Stream the Assistant over SSE

# 1. Start the turn — returns chat_id, run_id, and stream_url.
curl -sN -X POST https://api.modulex.dev/assistant/chat \
  -H "Authorization: Bearer mx_live_your_api_key" \
  -H "X-Organization-ID: org_your_organization_id" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "List my GitHub repositories",
    "llm": { "integration_name": "openai", "provider_id": "openai", "model_id": "gpt-4o" }
  }'
# => {"status":"running","chat_id":"...","run_id":"...","thread_id":"...","stream_url":"/assistant/chat/.../listen/..."}

# 2. Open the stream (substitute the stream_url from step 1).
#    Each event arrives as a single `data:` line; the type is inside the JSON.
curl -sN https://api.modulex.dev/assistant/chat/{CHAT_ID}/listen/{RUN_ID} \
  -H "Authorization: Bearer mx_live_your_api_key" \
  -H "X-Organization-ID: org_your_organization_id" \
  -H "Accept: text/event-stream"

import asyncio
from modulex import Modulex

client = Modulex(api_key="mx_live_your_api_key", organization_id="org_your_organization_id")

async def main():
    # 1. Start the turn.
    started = await client.assistant.chat(
        "List my GitHub repositories",
        llm={"integration_name": "openai", "provider_id": "openai", "model_id": "gpt-4o"},
    )

    # 2. Open the stream. Heartbeats are filtered out by default.
    async with client.assistant.listen(started.chat_id, started.run_id) as stream:
        async for event in stream:
            if event.event == "response_chunk":
                print(event.data["data"]["chunk"], end="", flush=True)
            elif event.event == "tool_call":
                print(f"\n[calling {event.data['data']['tool']}]")
            elif event.event == "user_input_request":
                print("\n[paused — needs your input; answer with assistant.resume]")
                break
            if event.is_terminal:  # done, error, cancelled, interrupted
                break

asyncio.run(main())

import { Modulex } from "modulex-js";

const client = new Modulex({
  apiKey: "mx_live_your_api_key",
  organizationId: "org_your_organization_id",
});

// 1. Start the turn.
const started = await client.assistant.chat({
  message: "List my GitHub repositories",
  llm: { integration_name: "openai", provider_id: "openai", model_id: "gpt-4o" },
});

// 2. Open the stream. Frames are yielded already discriminated on `type`.
for await (const evt of client.assistant.listen(started.chat_id, started.run_id)) {
  switch (evt.type) {
    case "response_chunk":
      process.stdout.write(evt.data.chunk ?? "");
      break;
    case "tool_call":
      console.log(`\n[calling ${evt.data.tool}]`);
      break;
    case "user_input_request":
      console.log("\n[paused — answer with assistant.resume]");
      break; // stop reading; go answer it
    case "heartbeat":
      break; // ignore keepalives
    case "done":
    case "error":
    case "cancelled":
      break;
  }
}

curl -X POST https://api.modulex.dev/assistant/chat/{CHAT_ID}/cancel \
  -H "Authorization: Bearer mx_live_your_api_key" \
  -H "X-Organization-ID: org_your_organization_id"
# => {"status":"cancelled","chat_id":"...","run_id":"..."}

# Stop consuming locally (exit the `async with`), then cancel the turn server-side.
await client.assistant.cancel(chat_id)
# => AssistantCancelResponse(status="cancelled", chat_id=..., run_id=...)

// Abort the local stream...
const controller = new AbortController();
const stream = client.assistant.listen(chatId, runId, { signal: controller.signal });
setTimeout(() => controller.abort(), 5_000); // stop reading after 5s

// ...and cancel the turn on the server.
await client.assistant.cancel(chatId);
// => { status: "cancelled", chat_id: "...", run_id: "..." }