@agent-native/core 0.4.5 → 0.6.1

package/dist/agent/production-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"production-agent.d.ts","sourceRoot":"","sources":["../../src/agent/production-agent.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,IAAI,cAAc,EAAE,MAAM,IAAI,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAoC,MAAM,YAAY,CAAC;AAE/E,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AASD,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,sBAAsB,GAC9B,cAAc,CA4LhB"}
+{"version":3,"file":"production-agent.d.ts","sourceRoot":"","sources":["../../src/agent/production-agent.ts"],"names":[],"mappings":"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"}

package/dist/agent/production-agent.js

@@ -1,18 +1,231 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { defineEventHandler, readBody, setResponseHeader, setResponseStatus, getMethod, } from "h3";
-function sseEvent(event) {
-    return `data: ${JSON.stringify(event)}\n\n`;
+import { defineEventHandler, setResponseHeader, setResponseStatus, getMethod, } from "h3";
+import { resolveEngine, registerBuiltinEngines } from "./engine/index.js";
+import { ASSISTANT_CONTENT_KEY } from "./engine/anthropic-engine.js";
+import { readAppState } from "../application-state/script-helpers.js";
+import { startRun, subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, } from "./run-manager.js";
+import { readBody } from "../server/h3-helpers.js";
+// Register built-in engines on first import
+registerBuiltinEngines();
+const MAX_ITERATIONS = 40;
+const MAX_RETRIES = 3;
+const RETRY_BASE_DELAY_MS = 2000;
+function generateRunId() {
+    return `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
-const MAX_ITERATIONS = 20;
-const encoder = new TextEncoder();
-export function createProductionAgentHandler(options) {
-    const model = options.model ?? "claude-sonnet-4-6";
-    // Build Anthropic tool definitions from script registry
-    const tools = Object.entries(options.scripts).map(([name, entry]) => ({
+/** Check if an error is transient and should be retried */
+function isRetryableError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message.toLowerCase();
+    return (msg.includes("overloaded") ||
+        msg.includes("rate_limit") ||
+        msg.includes("529") ||
+        msg.includes("503") ||
+        msg.includes("too many requests"));
+}
+/** Wait with exponential backoff, respecting abort signal */
+function retryDelay(attempt, signal) {
+    const ms = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new Error("aborted"));
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(new Error("aborted"));
+        }, { once: true });
+    });
+}
+/** Build enriched message with file/skill/mention references */
+function enrichMessage(message, references) {
+    if (references.length === 0)
+        return message;
+    const fileRefs = references.filter((r) => r.type === "file");
+    const skillRefs = references.filter((r) => r.type === "skill");
+    const mentionRefs = references.filter((r) => r.type === "mention");
+    const parts = [];
+    if (fileRefs.length > 0) {
+        parts.push("Referenced files:\n" +
+            fileRefs
+                .map((r) => `- ${r.path}${r.source === "resource" ? " (resource)" : ""}`)
+                .join("\n"));
+    }
+    if (skillRefs.length > 0) {
+        parts.push("Applied skills:\n" +
+            skillRefs
+                .map((r) => `- ${r.name} (${r.path})${r.source === "resource" ? " — read with resource-read" : " — read with read-file"}`)
+                .join("\n"));
+    }
+    if (mentionRefs.length > 0) {
+        parts.push("Referenced items:\n" +
+            mentionRefs
+                .map((r) => `- [${r.refType || "item"}] ${r.name}${r.refId ? ` (id: ${r.refId})` : ""}${r.path ? ` (path: ${r.path})` : ""}`)
+                .join("\n"));
+    }
+    return `${parts.join("\n\n")}\n\n${message}`;
+}
+/**
+ * Convert ActionEntry registry to EngineTool array.
+ */
+export function actionsToEngineTools(actions) {
+    return Object.entries(actions).map(([name, entry]) => ({
         name,
         description: entry.tool.description,
-        input_schema: entry.tool.parameters,
+        inputSchema: (entry.tool.parameters ?? {
+            type: "object",
+            properties: {},
+        }),
     }));
+}
+/**
+ * The core agent loop — calls the engine iteratively until no more tool calls.
+ * Decoupled from HTTP transport so it can run in the background.
+ * Returns accumulated token usage for cost tracking.
+ */
+export async function runAgentLoop(opts) {
+    const { engine, model, systemPrompt, tools, messages, actions, send, signal, } = opts;
+    const usage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        model,
+    };
+    let iterations = 0;
+    while (true) {
+        if (signal.aborted)
+            break;
+        if (++iterations > MAX_ITERATIONS) {
+            send({ type: "loop_limit" });
+            break;
+        }
+        let assistantContent;
+        let hasToolCalls = false;
+        for (let retry = 0;; retry++) {
+            try {
+                const streamOpts = {
+                    model,
+                    systemPrompt,
+                    messages,
+                    tools,
+                    abortSignal: signal,
+                    providerOptions: opts.providerOptions,
+                };
+                const eventStream = engine.stream(streamOpts);
+                let thinkingBuffer = "";
+                for await (const event of eventStream) {
+                    if (event.type === "text-delta") {
+                        send({ type: "text", text: event.text });
+                    }
+                    else if (event.type === "thinking-delta") {
+                        thinkingBuffer += event.text;
+                        // Thinking deltas are not forwarded to the SSE client yet —
+                        // we accumulate them. In a future iteration, we can surface
+                        // them as a collapsible "reasoning" section in the UI.
+                    }
+                    else if (event.type === "tool-call") {
+                        hasToolCalls = true;
+                    }
+                    else if (event.type === "usage") {
+                        usage.inputTokens += event.inputTokens;
+                        usage.outputTokens += event.outputTokens;
+                        usage.cacheReadTokens += event.cacheReadTokens ?? 0;
+                        usage.cacheWriteTokens += event.cacheWriteTokens ?? 0;
+                    }
+                    else if (event.type === "stop" && event.reason === "error") {
+                        throw new Error(event.error ?? "Engine stream error");
+                    }
+                }
+                // Retrieve the assistant content blocks stored by the engine.
+                // AnthropicEngine sets streamOpts[ASSISTANT_CONTENT_KEY] after streaming.
+                assistantContent = streamOpts[ASSISTANT_CONTENT_KEY];
+                // If engine didn't populate assistant content (e.g. AI SDK engine),
+                // rebuild it from the messages state we tracked via tool-call events.
+                // The AI SDK engine stores it under AISDK_ASSISTANT_CONTENT_KEY.
+                if (!assistantContent) {
+                    const { AISDK_ASSISTANT_CONTENT_KEY } = await import("./engine/ai-sdk-engine.js");
+                    assistantContent = streamOpts[AISDK_ASSISTANT_CONTENT_KEY];
+                }
+                break;
+            }
+            catch (err) {
+                if (signal.aborted)
+                    throw err;
+                if (retry < MAX_RETRIES && isRetryableError(err)) {
+                    // Clear partial text from the failed attempt so the retry
+                    // doesn't produce garbled duplicate output
+                    send({ type: "clear" });
+                    send({
+                        type: "text",
+                        text: `*Retrying in ${(RETRY_BASE_DELAY_MS * Math.pow(2, retry)) / 1000}s...*\n\n`,
+                    });
+                    await retryDelay(retry, signal);
+                    continue;
+                }
+                throw err;
+            }
+        }
+        if (!assistantContent) {
+            // No content — done
+            break;
+        }
+        messages.push({ role: "assistant", content: assistantContent });
+        const toolCallParts = assistantContent.filter((p) => p.type === "tool-call");
+        if (toolCallParts.length === 0)
+            break;
+        // Run all tool calls in parallel — engines often return multiple tool-call
+        // blocks in one turn. Running them concurrently saves wall-clock time.
+        const toolResultParts = await Promise.all(toolCallParts.map(async (toolCall) => {
+            const actionEntry = actions[toolCall.name];
+            if (!actionEntry) {
+                const result = `Error: Unknown tool "${toolCall.name}"`;
+                send({
+                    type: "tool_start",
+                    tool: toolCall.name,
+                    input: toolCall.input,
+                });
+                send({ type: "tool_done", tool: toolCall.name, result });
+                return {
+                    type: "tool-result",
+                    toolCallId: toolCall.id,
+                    content: result,
+                    isError: true,
+                };
+            }
+            send({
+                type: "tool_start",
+                tool: toolCall.name,
+                input: toolCall.input,
+            });
+            let result;
+            let isError = false;
+            try {
+                const raw = await actionEntry.run(toolCall.input, { send });
+                result = typeof raw === "string" ? raw : JSON.stringify(raw, null, 2);
+            }
+            catch (err) {
+                result = `Error running ${toolCall.name}: ${err?.message ?? String(err)}`;
+                isError = true;
+            }
+            send({ type: "tool_done", tool: toolCall.name, result });
+            return {
+                type: "tool-result",
+                toolCallId: toolCall.id,
+                content: result,
+                ...(isError ? { isError } : {}),
+            };
+        }));
+        messages.push({ role: "user", content: toolResultParts });
+    }
+    send({ type: "done" });
+    return usage;
+}
+export function createProductionAgentHandler(options) {
+    const model = options.model ?? "claude-sonnet-4-6";
+    // Resolve actions — prefer `actions`, fall back to deprecated `scripts`
+    const resolvedActions = options.actions ?? options.scripts ?? {};
+    // Build engine tools from action registry
+    const engineTools = actionsToEngineTools(resolvedActions);
     return defineEventHandler(async (event) => {
         if (getMethod(event) !== "POST") {
             setResponseStatus(event, 405);
@@ -26,139 +239,279 @@ export function createProductionAgentHandler(options) {
             setResponseStatus(event, 400);
             return { error: "Invalid request body" };
         }
-        const { message, history = [] } = body;
+        const { message, history = [], references = [], threadId, attachments, } = body;
         if (!message) {
             setResponseStatus(event, 400);
             return { error: "message is required" };
         }
-        setResponseHeader(event, "Content-Type", "text/event-stream");
-        setResponseHeader(event, "Cache-Control", "no-cache");
-        setResponseHeader(event, "Connection", "keep-alive");
-        const abort = new AbortController();
-        // Use ReadableStream for cross-runtime compatibility (Node + CF Workers)
-        const stream = new ReadableStream({
-            async start(controller) {
-                const send = (ev) => {
-                    try {
-                        controller.enqueue(encoder.encode(sseEvent(ev)));
-                    }
-                    catch {
-                        // Stream already closed
+        // Resolve engine (async — reads settings if needed)
+        let engine;
+        try {
+            engine = await resolveEngine({
+                engineOption: options.engine,
+                apiKey: options.apiKey ?? process.env.ANTHROPIC_API_KEY,
+                model,
+            });
+        }
+        catch {
+            engine = await resolveEngine({
+                apiKey: options.apiKey ?? process.env.ANTHROPIC_API_KEY,
+            });
+        }
+        // Check for API key before starting a run (only for anthropic engine)
+        const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
+        if (engine.name === "anthropic" && !apiKey) {
+            setResponseHeader(event, "Content-Type", "text/event-stream");
+            setResponseHeader(event, "Cache-Control", "no-cache");
+            setResponseHeader(event, "Connection", "keep-alive");
+            const encoder = new TextEncoder();
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "missing_api_key" })}\n\n`));
+                    controller.close();
+                },
+            });
+        }
+        // Check usage limit before starting a run (production hosted mode)
+        if (options.trackUsage && options.resolveOwnerEmail) {
+            try {
+                const ownerEmail = await options.resolveOwnerEmail(event);
+                if (ownerEmail && ownerEmail !== "local@localhost") {
+                    const { checkUsageLimit } = await import("../usage/store.js");
+                    const result = await checkUsageLimit(ownerEmail, options.usageLimitCents);
+                    if (!result.allowed) {
+                        setResponseHeader(event, "Content-Type", "text/event-stream");
+                        setResponseHeader(event, "Cache-Control", "no-cache");
+                        setResponseHeader(event, "Connection", "keep-alive");
+                        const encoder = new TextEncoder();
+                        return new ReadableStream({
+                            start(controller) {
+                                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "usage_limit_reached", usageCents: result.usageCents, limitCents: result.limitCents })}\n\n`));
+                                controller.close();
+                            },
+                        });
                     }
-                };
-                // Check for API key before attempting any API calls
-                const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
-                if (!apiKey) {
-                    send({ type: "missing_api_key" });
+                }
+            }
+            catch {
+                // Usage check failed — allow the request to proceed
+            }
+        }
+        // Resolve system prompt before starting the run
+        let systemPrompt;
+        try {
+            systemPrompt =
+                typeof options.systemPrompt === "function"
+                    ? await options.systemPrompt(event)
+                    : options.systemPrompt;
+        }
+        catch (err) {
+            setResponseHeader(event, "Content-Type", "text/event-stream");
+            setResponseHeader(event, "Cache-Control", "no-cache");
+            const encoder = new TextEncoder();
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "error", error: `Failed to load system prompt: ${err?.message ?? String(err)}` })}\n\n`));
                     controller.close();
-                    return;
+                },
+            });
+        }
+        const enrichedMessage = enrichMessage(message, references);
+        // Auto-inject current screen context so the agent always knows what
+        // the user is looking at without needing to call view-screen first.
+        let screenContext = "";
+        try {
+            const viewScreenAction = resolvedActions["view-screen"];
+            if (viewScreenAction) {
+                const result = await viewScreenAction.run({});
+                if (result && result !== "(no output)") {
+                    screenContext = `\n\n<current-screen>\n${result}\n</current-screen>`;
                 }
-                const client = new Anthropic({ apiKey });
-                // Build messages for Anthropic API — skip empty-content history entries
-                // (assistant turns with only tool calls have content="" in the client history)
-                const messages = [
-                    ...history
-                        .filter((m) => m.content.trim())
-                        .map((m) => ({
-                        role: m.role,
-                        content: m.content,
-                    })),
-                    { role: "user", content: message },
-                ];
-                try {
-                    // Agentic loop — keep calling Claude until it stops using tools
-                    let iterations = 0;
-                    while (true) {
-                        if (abort.signal.aborted)
-                            break;
-                        if (++iterations > MAX_ITERATIONS) {
-                            send({
-                                type: "error",
-                                error: "Agent loop exceeded maximum iterations",
-                            });
-                            break;
-                        }
-                        const apiStream = client.messages.stream({
-                            model,
-                            max_tokens: 4096,
-                            system: options.systemPrompt,
-                            tools,
-                            messages,
-                        }, { signal: abort.signal });
-                        let assistantContent = [];
-                        let currentText = "";
-                        for await (const chunk of apiStream) {
-                            if (chunk.type === "content_block_delta" &&
-                                chunk.delta.type === "text_delta") {
-                                currentText += chunk.delta.text;
-                                send({ type: "text", text: chunk.delta.text });
+            }
+            else {
+                const navigation = await readAppState("navigation");
+                if (navigation) {
+                    screenContext = `\n\n<current-screen>\n${JSON.stringify(navigation, null, 2)}\n</current-screen>`;
+                }
+            }
+        }
+        catch {
+            // DB not ready or no navigation state — skip silently
+        }
+        // Pre-compute agent references for A2A resolution inside the run
+        const agentRefs = references.filter((r) => r.type === "agent");
+        // Build user content: text + any image attachments
+        const userContent = [];
+        if (attachments?.length) {
+            for (const att of attachments) {
+                if (att.type === "image" && att.data) {
+                    const match = att.data.match(/^data:(image\/[^;]+);base64,(.+)$/);
+                    if (match) {
+                        userContent.push({
+                            type: "image",
+                            data: match[2],
+                            mediaType: match[1],
+                        });
+                    }
+                }
+            }
+        }
+        userContent.push({
+            type: "text",
+            text: enrichedMessage + screenContext,
+        });
+        const messages = [
+            ...history
+                .filter((m) => m.content.trim())
+                .map((m) => ({
+                role: m.role,
+                content: [{ type: "text", text: m.content }],
+            })),
+            { role: "user", content: userContent },
+        ];
+        // Start agent loop in background via run-manager
+        const runId = generateRunId();
+        startRun(runId, threadId ?? runId, async (send, signal) => {
+            // Notify listeners that a run has started (used by agent teams)
+            if (options.onRunStart) {
+                options.onRunStart(send, threadId ?? runId);
+            }
+            // Resolve agent @-mentions via A2A calls (inside run so we can emit SSE events)
+            if (agentRefs.length > 0) {
+                const { A2AClient, callAgent } = await import("../a2a/client.js");
+                const agentResponses = [];
+                const results = await Promise.allSettled(agentRefs.map(async (ref) => {
+                    send({
+                        type: "agent_call",
+                        agent: ref.name,
+                        status: "start",
+                    });
+                    try {
+                        const a2aClient = new A2AClient(ref.path);
+                        const callerEmail = process.env.AGENT_USER_EMAIL;
+                        const a2aMetadata = {};
+                        if (callerEmail)
+                            a2aMetadata.userEmail = callerEmail;
+                        if (process.env.NODE_ENV === "production" && callerEmail) {
+                            try {
+                                const { listOAuthAccountsByOwner } = await import("../oauth-tokens/store.js");
+                                const accounts = await listOAuthAccountsByOwner("google", callerEmail);
+                                const tokens = accounts[0]?.tokens;
+                                if (tokens?.access_token) {
+                                    a2aMetadata.googleToken = tokens.access_token;
+                                }
                             }
+                            catch { }
                         }
-                        const finalMessage = await apiStream.finalMessage();
-                        assistantContent = finalMessage.content;
-                        // Add assistant turn to messages
-                        messages.push({ role: "assistant", content: assistantContent });
-                        // Check if we need to run tools
-                        const toolUseBlocks = assistantContent.filter((b) => b.type === "tool_use");
-                        if (toolUseBlocks.length === 0) {
-                            // No tool calls — we're done
-                            break;
-                        }
-                        // Execute each tool call
-                        const toolResults = [];
-                        for (const toolUse of toolUseBlocks) {
-                            const scriptEntry = options.scripts[toolUse.name];
-                            if (!scriptEntry) {
-                                const result = `Error: Unknown tool "${toolUse.name}"`;
-                                send({
-                                    type: "tool_start",
-                                    tool: toolUse.name,
-                                    input: toolUse.input,
-                                });
-                                send({ type: "tool_done", tool: toolUse.name, result });
-                                toolResults.push({
-                                    type: "tool_result",
-                                    tool_use_id: toolUse.id,
-                                    content: result,
-                                });
-                                continue;
+                        let responseText = "";
+                        let lastSentLength = 0;
+                        try {
+                            for await (const task of a2aClient.stream({
+                                role: "user",
+                                parts: [
+                                    {
+                                        type: "text",
+                                        text: enrichedMessage + screenContext,
+                                    },
+                                ],
+                            }, Object.keys(a2aMetadata).length > 0
+                                ? { metadata: a2aMetadata }
+                                : undefined)) {
+                                const newText = task.status?.message?.parts
+                                    ?.filter((p) => p.type === "text")
+                                    ?.map((p) => p.text)
+                                    ?.join("") ?? "";
+                                if (newText.length > lastSentLength) {
+                                    send({
+                                        type: "agent_call_text",
+                                        agent: ref.name,
+                                        text: newText.slice(lastSentLength),
+                                    });
+                                    lastSentLength = newText.length;
+                                }
+                                responseText = newText;
                             }
-                            send({
-                                type: "tool_start",
-                                tool: toolUse.name,
-                                input: toolUse.input,
-                            });
-                            let result;
-                            try {
-                                result = await scriptEntry.run(toolUse.input);
-                            }
-                            catch (err) {
-                                result = `Error running ${toolUse.name}: ${err?.message ?? String(err)}`;
+                        }
+                        catch {
+                            if (!responseText) {
+                                responseText = await callAgent(ref.path, enrichedMessage + screenContext);
                             }
-                            send({ type: "tool_done", tool: toolUse.name, result });
-                            toolResults.push({
-                                type: "tool_result",
-                                tool_use_id: toolUse.id,
-                                content: result,
-                            });
                         }
-                        // Add tool results turn
-                        messages.push({ role: "user", content: toolResults });
+                        send({
+                            type: "agent_call",
+                            agent: ref.name,
+                            status: "done",
+                        });
+                        return `<agent-response name="${ref.name}" id="${ref.refId}">\n${responseText}\n</agent-response>`;
+                    }
+                    catch (err) {
+                        send({
+                            type: "agent_call",
+                            agent: ref.name,
+                            status: "error",
+                        });
+                        return `<agent-response name="${ref.name}" id="${ref.refId}" error="true">\nFailed to reach ${ref.name}: ${err?.message}\n</agent-response>`;
+                    }
+                }));
+                const agentResponses_local = [];
+                for (const result of results) {
+                    if (result.status === "fulfilled") {
+                        agentResponses_local.push(result.value);
                     }
-                    send({ type: "done" });
                 }
-                catch (err) {
-                    if (!abort.signal.aborted) {
-                        send({ type: "error", error: err?.message ?? "Unknown error" });
+                if (agentResponses_local.length > 0) {
+                    const agentContext = "Responses from other agents:\n\n" +
+                        agentResponses_local.join("\n\n");
+                    const lastMsg = messages[messages.length - 1];
+                    if (lastMsg?.role === "user" && Array.isArray(lastMsg.content)) {
+                        const textPart = lastMsg.content.find((p) => p.type === "text");
+                        if (textPart) {
+                            textPart.text = agentContext + "\n\n" + textPart.text;
+                        }
                     }
                 }
-                controller.close();
-            },
-            cancel() {
-                abort.abort();
-            },
-        });
+            }
+            const loopUsage = await runAgentLoop({
+                engine,
+                model,
+                systemPrompt,
+                tools: engineTools,
+                messages,
+                actions: resolvedActions,
+                send,
+                signal,
+                providerOptions: options.providerOptions,
+            });
+            // Record token usage for cost tracking (production hosted mode)
+            if (options.trackUsage && options.resolveOwnerEmail) {
+                try {
+                    const ownerEmail = await options.resolveOwnerEmail(event);
+                    if (ownerEmail &&
+                        ownerEmail !== "local@localhost" &&
+                        (loopUsage.inputTokens > 0 || loopUsage.outputTokens > 0)) {
+                        const { recordUsage } = await import("../usage/store.js");
+                        await recordUsage(ownerEmail, loopUsage.inputTokens, loopUsage.outputTokens, loopUsage.model);
+                    }
+                }
+                catch {
+                    // Usage recording failed — don't break the run
+                }
+            }
+        }, options.onRunComplete
+            ? (run) => options.onRunComplete(run, threadId)
+            : undefined);
+        // Subscribe to the run and stream events to the client
+        const stream = subscribeToRun(runId, 0);
+        if (!stream) {
+            setResponseStatus(event, 500);
+            return { error: "Failed to start agent run" };
+        }
+        setResponseHeader(event, "Content-Type", "text/event-stream");
+        setResponseHeader(event, "Cache-Control", "no-cache");
+        setResponseHeader(event, "Connection", "keep-alive");
+        setResponseHeader(event, "X-Run-Id", runId);
         return stream;
     });
 }
+export { getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, subscribeToRun, };
 //# sourceMappingURL=production-agent.js.map