Streaming agent responses

1
import { LettaClient } from '@letta-ai/letta-client';
2
3
const client = new LettaClient({ token: 'YOUR_API_KEY' });
4
5
// Step streaming (default) - returns complete messages
6
const stream = await client.agents.messages.createStream(
7
    agent.id, {
8
        messages: [{role: "user", content: "Hello!"}]
9
    }
10
);
11
for await (const chunk of stream) {
12
    console.log(chunk);  // Complete message objects
13
}
14
15
// Token streaming - returns partial chunks for real-time UX
16
const tokenStream = await client.agents.messages.createStream(
17
    agent.id, {
18
        messages: [{role: "user", content: "Hello!"}],
19
        streamTokens: true  // Enable token streaming
20
    }
21
);
22
for await (const chunk of tokenStream) {
23
    console.log(chunk);  // Partial content chunks
24
}

1
// With reasoning (default) - includes reasoning_message events
2
const agent = await client.agents.create({
3
    model: "openai/gpt-4o-mini",
4
    // reasoning: true is the default
5
});
6
7
// Without reasoning - no reasoning_message events
8
const agentNoReasoning = await client.agents.create({
9
    model: "openai/gpt-4o-mini",
10
    reasoning: false  // Disable reasoning messages
11
});

1
import { LettaClient } from '@letta-ai/letta-client';
2
import type { LettaMessage } from '@letta-ai/letta-client/api/types';
3
4
const client = new LettaClient({ token: 'YOUR_API_KEY' });
5
6
const stream = await client.agents.messages.createStream(
7
    agent.id, {
8
        messages: [{role: "user", content: "What's 2+2?"}]
9
    }
10
);
11
12
for await (const chunk of stream as AsyncIterable<LettaMessage>) {
13
    if (chunk.messageType === 'reasoning_message') {
14
        console.log(`Thinking: ${(chunk as any).reasoning}`);
15
    } else if (chunk.messageType === 'assistant_message') {
16
        console.log(`Response: ${(chunk as any).content}`);
17
    }
18
}

1
import { LettaClient } from '@letta-ai/letta-client';
2
import type { LettaMessage } from '@letta-ai/letta-client/api/types';
3
4
const client = new LettaClient({ token: 'YOUR_API_KEY' });
5
6
// Token streaming with reassembly
7
interface MessageAccumulator {
8
    type: string;
9
    content: string;
10
}
11
12
const messageAccumulators = new Map<string, MessageAccumulator>();
13
14
const stream = await client.agents.messages.createStream(
15
    agent.id, {
16
        messages: [{role: "user", content: "Tell me a joke"}],
17
        streamTokens: true  // Note: camelCase
18
    }
19
);
20
21
for await (const chunk of stream as AsyncIterable<LettaMessage>) {
22
    if (chunk.id && chunk.messageType) {
23
        const msgId = chunk.id;
24
        const msgType = chunk.messageType;
25
26
        // Initialize accumulator for new messages
27
        if (!messageAccumulators.has(msgId)) {
28
            messageAccumulators.set(msgId, {
29
                type: msgType,
30
                content: ''
31
            });
32
        }
33
34
        // Accumulate content based on message type
35
        const acc = messageAccumulators.get(msgId)!;
36
37
        // Only accumulate if the type matches (in case types share IDs)
38
        if (acc.type === msgType) {
39
            if (msgType === 'reasoning_message') {
40
                acc.content += (chunk as any).reasoning || '';
41
            } else if (msgType === 'assistant_message') {
42
                acc.content += (chunk as any).content || '';
43
            }
44
        }
45
46
        // Update UI with accumulated content
47
        process.stdout.write(acc.content);
48
    }
49
}