Agent Streaming

1
import { Recursiv } from '@recursiv/sdk';
2
3
const r = new Recursiv();
4
5
const stream = r.agents.chatStream('agent_123', {
6
  message: 'Explain how transformers work in machine learning.',
7
});
8
9
for await (const chunk of stream) {
10
  if (chunk.type === 'text_delta') {
11
    process.stdout.write(chunk.delta ?? '');
12
  }
13
}
14
15
console.log('\n--- Done ---');

1
interface StreamChunk {
2
  type: 'text_delta' | 'tool_use' | 'tool_result' | 'done' | 'error';
3
  delta?: string;
4
  tool_name?: string;
5
  content?: string;
6
  error?: string;
7
}

1
// First message
2
let conversationId: string | undefined;
3
let fullResponse = '';
4
5
for await (const chunk of r.agents.chatStream('agent_123', {
6
  message: 'What is Rust?',
7
})) {
8
  if (chunk.type === 'text_delta') {
9
    fullResponse += chunk.delta ?? '';
10
  }
11
}
12
13
// Use the conversation_id from the non-streaming chat to continue
14
const { data: initial } = await r.agents.chat('agent_123', {
15
  message: 'What is Rust?',
16
});
17
18
// Follow-up with streaming
19
for await (const chunk of r.agents.chatStream('agent_123', {
20
  message: 'How does its ownership model work?',
21
  conversation_id: initial.conversation_id,
22
})) {
23
  if (chunk.type === 'text_delta') {
24
    process.stdout.write(chunk.delta ?? '');
25
  }
26
}

1
let fullText = '';
2
3
for await (const chunk of r.agents.chatStream('agent_123', {
4
  message: 'Write a haiku about TypeScript.',
5
})) {
6
  switch (chunk.type) {
7
    case 'text_delta':
8
      fullText += chunk.delta ?? '';
9
      process.stdout.write(chunk.delta ?? '');
10
      break;
11
    case 'tool_use':
12
      console.log(`\n[Using tool: ${chunk.tool_name}]`);
13
      break;
14
    case 'tool_result':
15
      console.log(`[Tool result: ${chunk.content}]`);
16
      break;
17
    case 'error':
18
      console.error(`\nStream error: ${chunk.error}`);
19
      break;
20
    case 'done':
21
      break;
22
  }
23
}
24
25
console.log('\n\nFull response:', fullText);

1
import { AuthenticationError, NotFoundError } from '@recursiv/sdk';
2
3
try {
4
  for await (const chunk of r.agents.chatStream('bad_id', {
5
    message: 'Hello',
6
  })) {
7
    // ...
8
  }
9
} catch (err) {
10
  if (err instanceof NotFoundError) {
11
    console.error('Agent not found');
12
  } else if (err instanceof AuthenticationError) {
13
    console.error('Invalid API key');
14
  }
15
}

1
for await (const chunk of r.agents.chatStream('agent_123', {
2
  message: 'Hello',
3
})) {
4
  if (chunk.type === 'error') {
5
    console.error('Stream error:', chunk.error);
6
    break;
7
  }
8
  if (chunk.type === 'text_delta') {
9
    process.stdout.write(chunk.delta ?? '');
10
  }
11
}

1
import { Recursiv } from '@recursiv/sdk';
2
import { useState } from 'react';
3
4
function AgentChat({ agentId }: { agentId: string }) {
5
  const [response, setResponse] = useState('');
6
  const [isStreaming, setIsStreaming] = useState(false);
7
8
  async function sendMessage(message: string) {
9
    setResponse('');
10
    setIsStreaming(true);
11
12
    const r = new Recursiv({ apiKey: 'sk_live_...' });
13
14
    for await (const chunk of r.agents.chatStream(agentId, { message })) {
15
      if (chunk.type === 'text_delta') {
16
        setResponse((prev) => prev + (chunk.delta ?? ''));
17
      }
18
    }
19
20
    setIsStreaming(false);
21
  }
22
23
  return (
24
    <div>
25
      <button onClick={() => sendMessage('Hello!')}>
26
        {isStreaming ? 'Streaming...' : 'Send'}
27
      </button>
28
      <pre>{response}</pre>
29
    </div>
30
  );
31
}

1
import EventSource from 'react-native-sse';
2
3
function streamAgentChat(
4
  agentId: string,
5
  message: string,
6
  apiKey: string,
7
  onDelta: (text: string) => void,
8
  onDone: () => void,
9
  onError: (err: string) => void,
10
) {
11
  const baseUrl = 'https://api.recursiv.io/api/v1';
12
  const url = `${baseUrl}/agents/${agentId}/chat/stream`;
13
14
  const es = new EventSource(url, {
15
    method: 'POST',
16
    headers: {
17
      Authorization: `Bearer ${apiKey}`,
18
      'Content-Type': 'application/json',
19
    },
20
    body: JSON.stringify({ message }),
21
  });
22
23
  es.addEventListener('message', (event: any) => {
24
    if (event.data === '[DONE]') {
25
      es.close();
26
      onDone();
27
      return;
28
    }
29
30
    try {
31
      const chunk = JSON.parse(event.data);
32
      if (chunk.type === 'text_delta' && chunk.delta) {
33
        onDelta(chunk.delta);
34
      } else if (chunk.type === 'error') {
35
        onError(chunk.error ?? 'Unknown error');
36
        es.close();
37
      }
38
    } catch {
39
      // Skip malformed chunks
40
    }
41
  });
42
43
  es.addEventListener('error', (event: any) => {
44
    onError(event.message ?? 'Connection error');
45
    es.close();
46
  });
47
48
  return () => es.close();
49
}

1
import { parseSSE } from '@recursiv/sdk';