131 lines
3.5 KiB
Plaintext
131 lines
3.5 KiB
Plaintext
---
|
|
title: Queue Status
|
|
description: Learn how to check the status of Honcho's reasoning
|
|
icon: "lines-leaning"
|
|
---
|
|
|
|
Whenever messages are stored in Honcho, a background process kicks off to [reason](/v2/documentation/core-concepts/reasoning) about the conversation and generate insights.
|
|
|
|
Reasoning is an asynchronous process and, depending on load, may not immediately
|
|
generate insights for the latest message you've sent. To help with this, Honcho
|
|
provides several utilities to check the status of the queue.
|
|
|
|
<CodeGroup>
|
|
```python Python
|
|
from honcho import Honcho
|
|
honcho = Honcho()
|
|
|
|
status = honcho.get_queue_status()
|
|
honcho.poll_queue_status()
|
|
```
|
|
|
|
```typescript typescript
|
|
import { Honcho } from '@honcho-ai/sdk';
|
|
|
|
const honcho = new Honcho({});
|
|
|
|
const status = await honcho.getQueueStatus();
|
|
await honcho.pollQueueStatus();
|
|
```
|
|
</CodeGroup>
|
|
|
|
Output types
|
|
|
|
<CodeGroup>
|
|
```python Python
|
|
class QueueStatus(BaseModel):
|
|
completed_work_units: int
|
|
"""Completed work units"""
|
|
|
|
in_progress_work_units: int
|
|
"""Work units currently being processed"""
|
|
|
|
pending_work_units: int
|
|
"""Work units waiting to be processed"""
|
|
|
|
total_work_units: int
|
|
"""Total work units"""
|
|
|
|
sessions: Optional[Dict[str, Sessions]] = None
|
|
"""Per-session status when not filtered by session"""
|
|
```
|
|
```typescript TypeScript
|
|
Promise<{
|
|
totalWorkUnits: number
|
|
completedWorkUnits: number
|
|
inProgressWorkUnits: number
|
|
pendingWorkUnits: number
|
|
sessions?: Record<string, QueueStatus.Sessions>
|
|
}>
|
|
|
|
```
|
|
</CodeGroup>
|
|
|
|
Whenever a message is sent it will generate several tasks. These could
|
|
be tasks such as generating insights, cleaning up a representation, summarizing
|
|
a conversation etc. These tasks are defined based on who is sending the
|
|
message, what session the message is in, and potentially who is observing the
|
|
message. We call the combination of these parameters a `work_unit`
|
|
|
|
This has a few different implications.
|
|
|
|
- tasks within the same work_unit are processed sequentially, but multiple
|
|
work_units will be processed in parallel
|
|
- If local representations are turned in a Session then a message will
|
|
generate an additional work unit for every peer that has `observe_others=True`
|
|
|
|
The `get_queue_status` and `poll_queue_status` methods can take additional
|
|
parameters to scope the status to a specific work unit
|
|
|
|
<CodeGroup>
|
|
```python Python
|
|
def get_queue_status(
|
|
self,
|
|
observer_id: str | None = None,
|
|
sender_id: str | None = None,
|
|
session_id: str | None = None,
|
|
) -> QueueStatus:
|
|
```
|
|
```typescript TypeScript
|
|
|
|
export const QueueStatusOptionsSchema = z.object({
|
|
observerId: z.string().optional(),
|
|
senderId: z.string().optional(),
|
|
sessionId: z.string().optional(),
|
|
timeoutMs: z
|
|
.number()
|
|
.positive('Timeout must be a positive number')
|
|
.optional(),
|
|
})
|
|
|
|
```
|
|
</CodeGroup>
|
|
|
|
Additionally, there are queue status and polling queue status methods
|
|
available on the session objects in each of the SDKs.
|
|
|
|
Below are the function signatures for the session level queue status method
|
|
|
|
<CodeGroup>
|
|
```python python
|
|
@validate_call
|
|
def get_queue_status(
|
|
self,
|
|
observer_id: str | None = None,
|
|
sender_id: str | None = None,
|
|
) -> QueueStatus:
|
|
```
|
|
|
|
```typescript TypeScript
|
|
async getQueueStatus(
|
|
options?: Omit<QueueStatusOptions, 'sessionId'>
|
|
): Promise<{
|
|
totalWorkUnits: number
|
|
completedWorkUnits: number
|
|
inProgressWorkUnits: number
|
|
pendingWorkUnits: number
|
|
sessions?: Record<string, QueueStatus.Sessions>
|
|
}>
|
|
```
|
|
</CodeGroup>
|