veryfront 0.1.63 → 0.1.65

package/esm/src/internal-agents/ag-ui-sse.js

@@ -0,0 +1,263 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { serverLogger } from "../utils/index.js";
+import { z } from "zod";
+const encoder = new TextEncoder();
+const logger = serverLogger.component("internal-agents-ag-ui-sse");
+export function createStreamTransformState() {
+    return {
+        messageId: null,
+        textOpen: false,
+        stepIndex: 0,
+        sawTerminalError: false,
+        metadata: {},
+    };
+}
+const agUiEventPayloadSchemas = {
+    RunStarted: z.object({
+        runId: z.string().min(1),
+        threadId: z.string().min(1),
+        agentId: z.string().min(1),
+    }),
+    TextMessageStart: z.object({
+        messageId: z.string().min(1),
+        role: z.literal("assistant"),
+    }),
+    TextMessageContent: z.object({
+        messageId: z.string().min(1),
+        delta: z.string(),
+    }),
+    TextMessageEnd: z.object({
+        messageId: z.string().min(1),
+    }),
+    ToolCallStart: z.object({
+        toolCallId: z.string().min(1),
+        toolCallName: z.string().min(1),
+    }),
+    ToolCallArgs: z.object({
+        toolCallId: z.string().min(1),
+        delta: z.string(),
+    }),
+    ToolCallEnd: z.object({
+        toolCallId: z.string().min(1),
+    }),
+    ToolCallResult: z.object({
+        toolCallId: z.string().min(1),
+        result: z.unknown(),
+        isError: z.boolean().optional(),
+    }),
+    StepStarted: z.object({
+        stepIndex: z.number().int().positive(),
+    }),
+    StepFinished: z.object({
+        stepIndex: z.number().int().positive(),
+    }),
+    RunError: z.object({
+        code: z.string().min(1).optional(),
+        message: z.string().min(1),
+    }),
+    RunFinished: z.object({
+        metadata: z.object({
+            provider: z.string().optional(),
+            model: z.string().optional(),
+            inputTokens: z.number().int().nonnegative().optional(),
+            outputTokens: z.number().int().nonnegative().optional(),
+            totalTokens: z.number().int().nonnegative().optional(),
+            finishReason: z.string().optional(),
+        }),
+    }),
+};
+export function formatAgUiEvent(event, payload) {
+    const schema = agUiEventPayloadSchemas[event];
+    const validatedPayload = schema ? schema.parse(payload) : payload;
+    return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(validatedPayload)}\n\n`);
+}
+export function parseSseJsonEvents(chunk) {
+    const blocks = chunk.split("\n\n");
+    const remainder = blocks.pop() ?? "";
+    const events = blocks.flatMap((block) => {
+        const dataLines = block.split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trimStart());
+        if (!dataLines.length) {
+            return [];
+        }
+        try {
+            const payload = JSON.parse(dataLines.join("\n"));
+            return [payload];
+        }
+        catch (error) {
+            logger.warn("Skipping malformed runtime SSE event payload", {
+                error,
+                dataLength: dataLines.join("\n").length,
+            });
+            return [];
+        }
+    });
+    return { events, remainder };
+}
+function getMessageId(state, event) {
+    if (typeof event.messageId === "string") {
+        state.messageId = event.messageId;
+        return event.messageId;
+    }
+    if (!state.messageId && typeof event.id === "string") {
+        state.messageId = event.id;
+    }
+    if (!state.messageId) {
+        state.messageId = dntShim.crypto.randomUUID();
+    }
+    return state.messageId;
+}
+function applyDataMetadata(state, event) {
+    const data = event.data && typeof event.data === "object" && !Array.isArray(event.data)
+        ? event.data
+        : event;
+    if (typeof data.model === "string") {
+        state.metadata.model = data.model;
+        const provider = data.model.split("/")[0];
+        if (provider) {
+            state.metadata.provider = provider;
+        }
+    }
+}
+function applyResponseMetadata(state, response) {
+    if (!response)
+        return;
+    if (response.usage) {
+        state.metadata.inputTokens = response.usage.promptTokens;
+        state.metadata.outputTokens = response.usage.completionTokens;
+        state.metadata.totalTokens = response.usage.totalTokens;
+    }
+    const finishReason = response.metadata && typeof response.metadata === "object"
+        ? response.metadata.finishReason
+        : undefined;
+    if (typeof finishReason === "string") {
+        state.metadata.finishReason = finishReason;
+    }
+}
+export function mapRuntimeEventToAgUi(state, event) {
+    switch (event.type) {
+        case "message-start":
+            getMessageId(state, event);
+            return [];
+        case "text-start": {
+            if (state.textOpen)
+                return [];
+            const messageId = getMessageId(state, event);
+            state.textOpen = true;
+            return [{
+                    event: "TextMessageStart",
+                    payload: { messageId, role: "assistant" },
+                }];
+        }
+        case "text-delta": {
+            const messageId = getMessageId(state, event);
+            if (!state.textOpen) {
+                state.textOpen = true;
+                return [
+                    { event: "TextMessageStart", payload: { messageId, role: "assistant" } },
+                    {
+                        event: "TextMessageContent",
+                        payload: { messageId, delta: typeof event.delta === "string" ? event.delta : "" },
+                    },
+                ];
+            }
+            return [{
+                    event: "TextMessageContent",
+                    payload: { messageId, delta: typeof event.delta === "string" ? event.delta : "" },
+                }];
+        }
+        case "text-end": {
+            if (!state.textOpen)
+                return [];
+            state.textOpen = false;
+            return [{
+                    event: "TextMessageEnd",
+                    payload: { messageId: getMessageId(state, event) },
+                }];
+        }
+        case "tool-input-start":
+            return [{
+                    event: "ToolCallStart",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        toolCallName: event.toolName,
+                    },
+                }];
+        case "tool-input-delta":
+            return [{
+                    event: "ToolCallArgs",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        delta: typeof event.inputTextDelta === "string" ? event.inputTextDelta : "",
+                    },
+                }];
+        case "tool-input-available":
+            return [{
+                    event: "ToolCallEnd",
+                    payload: { toolCallId: event.toolCallId },
+                }];
+        case "tool-output-available":
+            return [{
+                    event: "ToolCallResult",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        result: event.output,
+                    },
+                }];
+        case "tool-output-error":
+            return [{
+                    event: "ToolCallResult",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        result: { error: event.errorText },
+                        isError: true,
+                    },
+                }];
+        case "step-start":
+            state.stepIndex += 1;
+            return [{
+                    event: "StepStarted",
+                    payload: { stepIndex: state.stepIndex },
+                }];
+        case "step-end":
+            return [{
+                    event: "StepFinished",
+                    payload: { stepIndex: state.stepIndex },
+                }];
+        case "data":
+            applyDataMetadata(state, event);
+            return [];
+        case "error":
+            state.sawTerminalError = true;
+            return [{
+                    event: "RunError",
+                    payload: {
+                        message: typeof event.error === "string" ? event.error : "Agent run failed",
+                    },
+                }];
+        default:
+            return [];
+    }
+}
+export function finalizeRunEvents(state, response) {
+    applyResponseMetadata(state, response);
+    if (state.sawTerminalError) {
+        return [];
+    }
+    const events = [];
+    if (state.textOpen) {
+        state.textOpen = false;
+        events.push({
+            event: "TextMessageEnd",
+            payload: { messageId: getMessageId(state, { type: "text-end" }) },
+        });
+    }
+    events.push({
+        event: "RunFinished",
+        payload: {
+            metadata: state.metadata,
+        },
+    });
+    return events;
+}

package/esm/src/internal-agents/control-plane-auth.d.ts

@@ -0,0 +1,20 @@
+import * as dntShim from "../../_dnt.shims.js";
+import type { HandlerContext } from "../types/index.js";
+export declare class ControlPlaneRequestError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function verifyControlPlaneRequest(req: dntShim.Request, ctx: HandlerContext, rawBody: string, options?: {
+    expectedSubject?: string;
+    expectedSurface?: "studio" | "channels" | "a2a" | "mcp";
+}): Promise<{
+    project_id: string;
+    sub: string;
+    surface: "mcp" | "studio" | "channels" | "a2a";
+    iss: string;
+    aud: string;
+    iat: number;
+    exp: number;
+    request_hash: string;
+}>;
+//# sourceMappingURL=control-plane-auth.d.ts.map

package/esm/src/internal-agents/control-plane-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-plane-auth.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/control-plane-auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAE/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAQxD,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK5C;AAED,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,CAAC;CACpD;;;;;;;;;GAsDP"}

package/esm/src/internal-agents/control-plane-auth.js

@@ -0,0 +1,56 @@
+import { verifyControlPlaneJws } from "../channels/control-plane.js";
+import { serverLogger } from "../utils/index.js";
+import { HTTP_INTERNAL_SERVER_ERROR } from "../utils/constants/index.js";
+const CONTROL_PLANE_JWS_HEADER = "x-veryfront-control-plane-jws";
+const MAX_CONTROL_PLANE_SIGNATURE_AGE_SECONDS = 60;
+const logger = serverLogger.component("internal-agents-auth");
+export class ControlPlaneRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ControlPlaneRequestError";
+    }
+}
+export async function verifyControlPlaneRequest(req, ctx, rawBody, options = {}) {
+    const publicKeyPem = ctx.adapter.env.get("CHANNEL_DISPATCH_SIGNING_PUBLIC_KEY");
+    if (!publicKeyPem) {
+        throw new ControlPlaneRequestError(HTTP_INTERNAL_SERVER_ERROR, "Control-plane verification is not configured");
+    }
+    const projectSlug = ctx.projectSlug;
+    if (!projectSlug) {
+        throw new ControlPlaneRequestError(400, "Project context is unavailable");
+    }
+    const controlPlaneJws = req.headers.get(CONTROL_PLANE_JWS_HEADER);
+    if (!controlPlaneJws) {
+        throw new ControlPlaneRequestError(401, "Missing control-plane signature");
+    }
+    try {
+        return await verifyControlPlaneJws(controlPlaneJws, rawBody, {
+            audience: projectSlug,
+            expectedProjectId: ctx.projectId,
+            expectedSubject: options.expectedSubject,
+            expectedSurface: options.expectedSurface,
+            publicKeyPem,
+            maxAgeSeconds: MAX_CONTROL_PLANE_SIGNATURE_AGE_SECONDS,
+        });
+    }
+    catch (error) {
+        const isAuthError = error instanceof Error && (error.message.includes("Control-plane") ||
+            error.message.includes("Unsupported"));
+        if (isAuthError) {
+            logger.warn("Invalid control-plane signature", {
+                error,
+                projectSlug,
+                expectedSubject: options.expectedSubject,
+                expectedSurface: options.expectedSurface,
+            });
+            throw new ControlPlaneRequestError(401, "Invalid control-plane signature");
+        }
+        logger.error("Unexpected error during control-plane verification", {
+            error,
+            projectSlug,
+        });
+        throw new ControlPlaneRequestError(HTTP_INTERNAL_SERVER_ERROR, "Internal error during request verification");
+    }
+}

package/esm/src/internal-agents/request-body.d.ts

@@ -0,0 +1,9 @@
+import * as dntShim from "../../_dnt.shims.js";
+export declare const INTERNAL_AGENT_STREAM_MAX_BODY_BYTES: number;
+export declare const INTERNAL_AGENT_CONTROL_PLANE_MAX_BODY_BYTES: number;
+export declare class InternalAgentRequestBodyTooLargeError extends Error {
+    readonly status = 413;
+    constructor(message?: string);
+}
+export declare function readInternalAgentRequestBody(request: dntShim.Request, maxBodyBytes?: number): Promise<string>;
+//# sourceMappingURL=request-body.d.ts.map

package/esm/src/internal-agents/request-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/request-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAQ/C,eAAO,MAAM,oCAAoC,QAA8B,CAAC;AAChF,eAAO,MAAM,2CAA2C,QAAa,CAAC;AAEtE,qBAAa,qCAAsC,SAAQ,KAAK;IAC9D,QAAQ,CAAC,MAAM,OAA0B;gBAE7B,OAAO,SAAsB;CAI1C;AAED,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,YAAY,SAAuC,GAClD,OAAO,CAAC,MAAM,CAAC,CAkBjB"}

package/esm/src/internal-agents/request-body.js

@@ -0,0 +1,28 @@
+import { VeryfrontError } from "../errors/types.js";
+import { readBodyWithLimit } from "../security/index.js";
+import { DEFAULT_MAX_BODY_SIZE_BYTES, HTTP_PAYLOAD_TOO_LARGE, } from "../utils/constants/index.js";
+export const INTERNAL_AGENT_STREAM_MAX_BODY_BYTES = DEFAULT_MAX_BODY_SIZE_BYTES;
+export const INTERNAL_AGENT_CONTROL_PLANE_MAX_BODY_BYTES = 128 * 1024;
+export class InternalAgentRequestBodyTooLargeError extends Error {
+    status = HTTP_PAYLOAD_TOO_LARGE;
+    constructor(message = "Payload too large") {
+        super(message);
+        this.name = "InternalAgentRequestBodyTooLargeError";
+    }
+}
+export async function readInternalAgentRequestBody(request, maxBodyBytes = INTERNAL_AGENT_STREAM_MAX_BODY_BYTES) {
+    if (!request.body) {
+        return "";
+    }
+    try {
+        return await readBodyWithLimit(request, maxBodyBytes);
+    }
+    catch (error) {
+        if (error instanceof VeryfrontError &&
+            error.slug === "input-validation-failed" &&
+            error.detail === "Request body exceeds size limit") {
+            throw new InternalAgentRequestBodyTooLargeError();
+        }
+        throw error;
+    }
+}

package/esm/src/internal-agents/run-stream.d.ts

@@ -0,0 +1,14 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { type Agent, type AgentMessage as Message, type AgentResponse } from "../agent/index.js";
+import { type AgentRunSessionManager } from "./session-manager.js";
+import type { RuntimeRunAgentInput } from "./schema.js";
+export interface RuntimeAgentStreamExecutionDeps {
+    sessionManager: AgentRunSessionManager;
+    createRuntime?: (agent: Agent, mergedTools: Agent["config"]["tools"]) => {
+        stream: (messages: Message[], context?: Record<string, unknown>, callbacks?: {
+            onFinish?: (response: AgentResponse) => void;
+        }) => Promise<ReadableStream<Uint8Array>>;
+    };
+}
+export declare function createRuntimeAgentStreamResponse(input: RuntimeRunAgentInput, agent: Agent, deps: RuntimeAgentStreamExecutionDeps): Promise<dntShim.Response>;
+//# sourceMappingURL=run-stream.d.ts.map

package/esm/src/internal-agents/run-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-stream.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/run-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EACL,KAAK,KAAK,EACV,KAAK,YAAY,IAAI,OAAO,EAC5B,KAAK,aAAa,EAEnB,MAAM,mBAAmB,CAAC;AAW3B,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD,MAAM,WAAW,+BAA+B;IAC9C,cAAc,EAAE,sBAAsB,CAAC;IACvC,aAAa,CAAC,EAAE,CACd,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,KAClC;QACH,MAAM,EAAE,CACN,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,SAAS,CAAC,EAAE;YACV,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;SAC9C,KACE,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;KAC1C,CAAC;CACH;AAsKD,wBAAsB,gCAAgC,CACpD,KAAK,EAAE,oBAAoB,EAC3B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,+BAA+B,GACpC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAmJ3B"}

package/esm/src/internal-agents/run-stream.js

@@ -0,0 +1,259 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { AgentRuntime, } from "../agent/index.js";
+import { SKILL_TOOL_IDS } from "../skill/types.js";
+import { toolRegistry } from "../tool/index.js";
+import { z } from "zod";
+import { createStreamTransformState, finalizeRunEvents, formatAgUiEvent, mapRuntimeEventToAgUi, parseSseJsonEvents, } from "./ag-ui-sse.js";
+import { AgentRunCancelledError } from "./session-manager.js";
+const anyObjectSchema = z.record(z.unknown());
+function createInjectedStudioTool(runId, toolName, description, parameters, sessionManager) {
+    return {
+        id: toolName,
+        type: "function",
+        description: description ?? toolName,
+        inputSchema: anyObjectSchema,
+        inputSchemaJson: (parameters ??
+            { type: "object", properties: {}, additionalProperties: true }),
+        execute: async (_input, context) => {
+            const toolCallId = typeof context?.toolCallId === "string" ? context.toolCallId : null;
+            if (!toolCallId) {
+                throw new Error(`Missing toolCallId for injected tool "${toolName}"`);
+            }
+            const waitResult = await sessionManager.waitForToolResult(runId, toolCallId);
+            if (waitResult.isError) {
+                throw new Error(typeof waitResult.result === "string"
+                    ? waitResult.result
+                    : JSON.stringify(waitResult.result));
+            }
+            return waitResult.result;
+        },
+    };
+}
+function buildMergedTools(agent, input, sessionManager) {
+    const injectedTools = Object.fromEntries(input.tools.map((tool) => [
+        tool.name,
+        createInjectedStudioTool(input.runId, tool.name, tool.description, tool.parameters, sessionManager),
+    ]));
+    if (!agent.config.tools) {
+        return Object.keys(injectedTools).length ? injectedTools : undefined;
+    }
+    if (agent.config.tools === true) {
+        const merged = {};
+        for (const [toolId] of toolRegistry.getAll()) {
+            if (!agent.config.skills && SKILL_TOOL_IDS.has(toolId)) {
+                continue;
+            }
+            merged[toolId] = true;
+        }
+        return { ...merged, ...injectedTools };
+    }
+    return { ...agent.config.tools, ...injectedTools };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeToolArgs(part) {
+    if (isRecord(part.args)) {
+        return part.args;
+    }
+    if (isRecord(part.input)) {
+        return part.input;
+    }
+    return {};
+}
+function normalizeMessagePart(part) {
+    if (part.type === "text" && typeof part.text === "string") {
+        return { type: "text", text: part.text };
+    }
+    if (part.type === "tool_call" &&
+        typeof part.id === "string" &&
+        typeof part.name === "string") {
+        return {
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: part.name,
+            args: normalizeToolArgs(part),
+        };
+    }
+    if (part.type === "tool-call" &&
+        typeof part.toolCallId === "string" &&
+        typeof part.toolName === "string") {
+        return {
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            args: normalizeToolArgs(part),
+        };
+    }
+    if (typeof part.type === "string" &&
+        part.type.startsWith("tool-") &&
+        part.type !== "tool-result" &&
+        typeof part.toolCallId === "string" &&
+        typeof part.toolName === "string") {
+        return {
+            type: part.type,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            args: normalizeToolArgs(part),
+        };
+    }
+    if (part.type === "tool_result" && typeof part.tool_call_id === "string") {
+        return {
+            type: "tool-result",
+            toolCallId: part.tool_call_id,
+            toolName: typeof part.tool_name === "string" ? part.tool_name : "unknown",
+            result: "output" in part ? part.output : undefined,
+        };
+    }
+    if (part.type === "tool-result" && typeof part.toolCallId === "string") {
+        return {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: typeof part.toolName === "string" ? part.toolName : "unknown",
+            result: "result" in part ? part.result : undefined,
+        };
+    }
+    return null;
+}
+function normalizeRuntimeMessages(messages) {
+    return messages.map((message) => ({
+        id: message.id,
+        role: message.role,
+        parts: message.parts
+            .map((part) => isRecord(part) ? normalizeMessagePart(part) : null)
+            .filter((part) => part !== null),
+        ...(message.createdAt ? { timestamp: Date.parse(message.createdAt) || undefined } : {}),
+        ...(message.metadata ? { metadata: message.metadata } : {}),
+    }));
+}
+export async function createRuntimeAgentStreamResponse(input, agent, deps) {
+    const abortSignal = deps.sessionManager.startRun({
+        runId: input.runId,
+        threadId: input.threadId,
+    });
+    const mergedTools = buildMergedTools(agent, input, deps.sessionManager);
+    const runtime = deps.createRuntime?.(agent, mergedTools) ?? new AgentRuntime(agent.id, {
+        ...agent.config,
+        tools: mergedTools,
+    });
+    let completedResponse = null;
+    const runtimeMessages = normalizeRuntimeMessages(input.messages);
+    let runtimeStream;
+    let clientAttached = true;
+    try {
+        runtimeStream = await runtime.stream(runtimeMessages, {
+            threadId: input.threadId,
+            runId: input.runId,
+            context: input.context,
+            forwardedProps: input.forwardedProps,
+        }, {
+            onFinish: (response) => {
+                completedResponse = response;
+            },
+        });
+    }
+    catch (error) {
+        deps.sessionManager.failRun(input.runId);
+        throw error;
+    }
+    const response = new ReadableStream({
+        start: async (controller) => {
+            const state = createStreamTransformState();
+            const reader = runtimeStream.getReader();
+            const decoder = new TextDecoder();
+            let remainder = "";
+            let aborted = false;
+            const enqueueIfAttached = (event, payload) => {
+                const encodedEvent = formatAgUiEvent(event, payload);
+                if (!clientAttached) {
+                    return;
+                }
+                try {
+                    controller.enqueue(encodedEvent);
+                }
+                catch {
+                    clientAttached = false;
+                }
+            };
+            const throwIfAborted = () => {
+                if (aborted || abortSignal.aborted) {
+                    throw new AgentRunCancelledError();
+                }
+            };
+            const abortHandler = () => {
+                aborted = true;
+                reader.cancel(new AgentRunCancelledError()).catch(() => { });
+            };
+            abortSignal.addEventListener("abort", abortHandler, { once: true });
+            enqueueIfAttached("RunStarted", {
+                runId: input.runId,
+                threadId: input.threadId,
+                agentId: input.agentId,
+            });
+            try {
+                while (true) {
+                    throwIfAborted();
+                    const { done, value } = await reader.read();
+                    throwIfAborted();
+                    if (done) {
+                        break;
+                    }
+                    remainder += decoder.decode(value, { stream: true });
+                    const parsed = parseSseJsonEvents(remainder);
+                    remainder = parsed.remainder;
+                    for (const event of parsed.events) {
+                        for (const mappedEvent of mapRuntimeEventToAgUi(state, event)) {
+                            enqueueIfAttached(mappedEvent.event, mappedEvent.payload);
+                        }
+                    }
+                }
+                throwIfAborted();
+                const trailingEvents = parseSseJsonEvents(`${remainder}\n\n`);
+                for (const event of trailingEvents.events) {
+                    for (const mappedEvent of mapRuntimeEventToAgUi(state, event)) {
+                        enqueueIfAttached(mappedEvent.event, mappedEvent.payload);
+                    }
+                }
+                throwIfAborted();
+                for (const mappedEvent of finalizeRunEvents(state, completedResponse)) {
+                    enqueueIfAttached(mappedEvent.event, mappedEvent.payload);
+                }
+                deps.sessionManager.completeRun(input.runId);
+            }
+            catch (error) {
+                if (error instanceof AgentRunCancelledError) {
+                    deps.sessionManager.cancelRun(input.runId);
+                    enqueueIfAttached("RunError", {
+                        code: "CANCELLED",
+                        message: error.message,
+                    });
+                }
+                else {
+                    deps.sessionManager.failRun(input.runId);
+                    enqueueIfAttached("RunError", {
+                        code: "RUNTIME_ERROR",
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            finally {
+                abortSignal.removeEventListener("abort", abortHandler);
+                if (clientAttached) {
+                    controller.close();
+                }
+            }
+        },
+        cancel() {
+            clientAttached = false;
+            return Promise.resolve();
+        },
+    });
+    return new dntShim.Response(response, {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}