Streaming

Real-time event streaming with the AskVerdict SDK. Handle debate events, arguments, and verdicts as they happen.

1 min read
Share

The AskVerdict SDK provides first-class support for streaming debate events via Server-Sent Events (SSE).

Basic Usage

typescript
import { AskVerdictClient } from "@askverdict/sdk";
 
const client = new AskVerdictClient({ apiKey: "vrd_..." });
 
// Create a debate
const { debate } = await client.createVerdict({
  question: "Should we hire a CTO or promote internally?",
  mode: "thorough",
});
 
// Stream events
const stream = client.streamVerdict(debate.id);
 
for await (const event of stream) {
  switch (event.type) {
    case "debate.started":
      console.log("Debate started!");
      break;
    case "argument":
      console.log(`[${event.agent}] ${event.content}`);
      break;
    case "rebuttal":
      console.log(`[${event.agent} rebuts] ${event.content}`);
      break;
    case "verdict":
      console.log(`Verdict: ${event.recommendation}`);
      console.log(`Confidence: ${event.confidence}%`);
      break;
    case "debate.completed":
      console.log("Done!");
      break;
    case "debate.failed":
      console.error(`Error: ${event.error}`);
      break;
  }
}

Event Types

typescript
type DebateEvent =
  | { type: "debate.started"; debateId: string; mode: string }
  | { type: "argument"; agent: "pro" | "con"; round: number; content: string }
  | { type: "rebuttal"; agent: "pro" | "con"; round: number; content: string; targetAgent: string }
  | { type: "verdict"; recommendation: string; oneLiner: string; confidence: number; reasoning: string }
  | { type: "debate.completed"; debateId: string; status: "completed" }
  | { type: "debate.failed"; debateId: string; error: string };

React Usage

Use the streaming API in React with a custom hook pattern:

typescript
import { useState, useEffect } from "react";
import { AskVerdictClient } from "@askverdict/sdk";
 
function useDebateStream(debateId: string | null) {
  const [events, setEvents] = useState<DebateEvent[]>([]);
  const [status, setStatus] = useState<"idle" | "streaming" | "done" | "error">("idle");
 
  useEffect(() => {
    if (!debateId) return;
 
    const client = new AskVerdictClient({ apiKey: process.env.NEXT_PUBLIC_API_KEY! });
    let cancelled = false;
 
    async function stream() {
      setStatus("streaming");
      try {
        for await (const event of client.streamVerdict(debateId!)) {
          if (cancelled) break;
          setEvents((prev) => [...prev, event]);
          if (event.type === "debate.completed") setStatus("done");
          if (event.type === "debate.failed") setStatus("error");
        }
      } catch {
        if (!cancelled) setStatus("error");
      }
    }
 
    stream();
    return () => { cancelled = true; };
  }, [debateId]);
 
  return { events, status };
}

Error Handling

The stream automatically handles connection drops with reconnection. For explicit error handling:

typescript
try {
  for await (const event of client.streamVerdict(id)) {
    // Process events...
  }
} catch (error) {
  // Connection error or server error
  console.error("Stream failed:", error);
}

The for await...of loop naturally ends when the debate completes or fails. You don't need to manually close the connection.

Was this page helpful?

PreviousClient MethodsNextTypeScript Types