veryfront 0.1.516 → 0.1.518

package/esm/src/agent/ag-ui/runtime-handler.js

@@ -0,0 +1,301 @@
+import { isResponseLike } from "../response-like.js";
+import { AgentRuntime, RunAlreadyExistsError, } from "../runtime/index.js";
+import { parseAgUiRuntimeRequestOrError, } from "../runtime/ag-ui-contract.js";
+import { extractRequest } from "./request-shared.js";
+import { buildMergedAgUiTools } from "./tool-shared.js";
+import { normalizeAgUiRuntimeMessages } from "./runtime-support.js";
+import { createStreamTransformState, finalizeRunEvents, formatAgUiEvent, mapRuntimeEventToAgUi, } from "../../internal-agents/ag-ui-sse.js";
+import { streamDataStreamEvents } from "../data-stream.js";
+const AG_UI_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+};
+function invokeLifecycleCallback(callback, context) {
+    if (!callback)
+        return;
+    try {
+        const result = callback(context);
+        void Promise.resolve(result).catch(() => undefined);
+    }
+    catch {
+        return;
+    }
+}
+async function invokeLifecycleCallbackAndWait(callback, context) {
+    if (!callback)
+        return;
+    try {
+        await callback(context);
+    }
+    catch {
+        return;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildStreamContext(request, baseContext) {
+    return {
+        ...baseContext,
+        threadId: request.threadId,
+        runId: request.runId,
+        agUi: {
+            context: request.context,
+            forwardedProps: request.forwardedProps,
+        },
+    };
+}
+function closeController(controller) {
+    try {
+        controller.close();
+    }
+    catch {
+        return;
+    }
+}
+function enqueueEvent(controller, event, payload) {
+    try {
+        controller.enqueue(formatAgUiEvent(event, payload));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function createAgUiRuntimeStreamResponse(options) {
+    const { agentId, request, upstreamBody, upstreamStatus, upstreamStatusText, onFinish, onError, onToolCallSeen, } = options;
+    const stream = new ReadableStream({
+        start: async (controller) => {
+            const state = createStreamTransformState();
+            const prepareToolResultIfNeeded = (event, payload) => {
+                if (event !== "ToolCallStart" && event !== "ToolCallArgs" &&
+                    event !== "ToolCallEnd") {
+                    return;
+                }
+                const toolCallId = typeof payload.toolCallId === "string" ? payload.toolCallId : null;
+                if (toolCallId) {
+                    onToolCallSeen?.(toolCallId);
+                }
+            };
+            if (!enqueueEvent(controller, "RunStarted", {
+                runId: request.runId,
+                threadId: request.threadId,
+                agentId,
+            })) {
+                return;
+            }
+            if (!enqueueEvent(controller, "StateSnapshot", {
+                snapshot: isRecord(request.state) ? request.state : {},
+            })) {
+                return;
+            }
+            if (!enqueueEvent(controller, "MessagesSnapshot", {
+                messages: normalizeAgUiRuntimeMessages(request.messages),
+            })) {
+                return;
+            }
+            try {
+                if (!upstreamBody) {
+                    for (const event of finalizeRunEvents(state, null)) {
+                        if (!enqueueEvent(controller, event.event, event.payload)) {
+                            return;
+                        }
+                    }
+                    onFinish?.();
+                    closeController(controller);
+                    return;
+                }
+                for await (const event of streamDataStreamEvents(upstreamBody)) {
+                    for (const mapped of mapRuntimeEventToAgUi(state, event)) {
+                        prepareToolResultIfNeeded(mapped.event, mapped.payload);
+                        if (!enqueueEvent(controller, mapped.event, mapped.payload)) {
+                            return;
+                        }
+                    }
+                }
+                for (const event of finalizeRunEvents(state, null)) {
+                    if (!enqueueEvent(controller, event.event, event.payload)) {
+                        return;
+                    }
+                }
+                onFinish?.();
+            }
+            catch (error) {
+                onError?.(error);
+                enqueueEvent(controller, "RunError", {
+                    message: error instanceof Error ? error.message : "Agent run failed",
+                });
+            }
+            finally {
+                closeController(controller);
+            }
+        },
+    });
+    return new Response(stream, {
+        status: upstreamStatus,
+        statusText: upstreamStatusText,
+        headers: { ...AG_UI_HEADERS },
+    });
+}
+async function createAgUiRuntimeDirectStreamResponse(agent, request, baseContext, lifecycle) {
+    await agent.clearMemory();
+    const result = await agent.stream({
+        messages: normalizeAgUiRuntimeMessages(request.messages),
+        context: buildStreamContext(request, baseContext),
+    });
+    const upstream = result.toDataStreamResponse();
+    return await createAgUiRuntimeStreamResponse({
+        agentId: agent.id,
+        request,
+        upstreamBody: upstream.body,
+        upstreamStatus: upstream.status,
+        upstreamStatusText: upstream.statusText,
+        onFinish: lifecycle?.onFinish,
+        onError: lifecycle?.onError,
+        onToolCallSeen: lifecycle?.onToolCallSeen,
+    });
+}
+function buildMergedTools(agent, request, sessionManager) {
+    return buildMergedAgUiTools(agent, request.runId, request.tools, sessionManager);
+}
+async function createAgUiRuntimeInjectedToolsStreamResponse(agent, request, baseContext, sessionManager, lifecycle) {
+    try {
+        sessionManager.startRun({ runId: request.runId, threadId: request.threadId });
+    }
+    catch (error) {
+        if (error instanceof RunAlreadyExistsError) {
+            return Response.json({ error: "Run already active" }, { status: 409 });
+        }
+        throw error;
+    }
+    const runtime = new AgentRuntime(agent.id, {
+        ...agent.config,
+        tools: buildMergedTools(agent, request, sessionManager),
+    });
+    let upstreamBody;
+    try {
+        upstreamBody = await runtime.stream(normalizeAgUiRuntimeMessages(request.messages), buildStreamContext(request, baseContext), undefined, undefined, undefined);
+    }
+    catch (error) {
+        sessionManager.failRun(request.runId);
+        throw error;
+    }
+    return await createAgUiRuntimeStreamResponse({
+        agentId: agent.id,
+        request,
+        upstreamBody,
+        upstreamStatus: 200,
+        onFinish: () => {
+            sessionManager.completeRun(request.runId);
+            void lifecycle?.onFinish?.();
+        },
+        onError: (error) => {
+            sessionManager.failRun(request.runId);
+            void lifecycle?.onError?.(error);
+        },
+        onToolCallSeen: (toolCallId) => {
+            sessionManager.prepareForSignal(request.runId, toolCallId);
+            void lifecycle?.onToolCallSeen?.(toolCallId);
+        },
+    });
+}
+export function createAgUiRuntimeHandler(config) {
+    if (!config.agent && !config.execute) {
+        throw new Error("createAgUiRuntimeHandler requires either an agent or an execute handler.");
+    }
+    return async function POST(requestOrCtx) {
+        const request = extractRequest(requestOrCtx);
+        try {
+            const gateResult = await config.beforeParse?.({ request });
+            if (isResponseLike(gateResult)) {
+                return gateResult;
+            }
+            const parsed = await parseAgUiRuntimeRequestOrError(request);
+            if (isResponseLike(parsed)) {
+                if (config.validationErrorResponse) {
+                    return await config.validationErrorResponse({ request, response: parsed });
+                }
+                return parsed;
+            }
+            const context = typeof config.context === "function"
+                ? await config.context(request)
+                : config.context ?? {};
+            const createDefaultResponse = config.agent
+                ? () => parsed.tools.length > 0
+                    ? config.sessionManager
+                        ? createAgUiRuntimeInjectedToolsStreamResponse(config.agent, parsed, context, config.sessionManager)
+                        : Promise.resolve(Response.json({
+                            error: "Injected AG-UI tools require a public RunResumeSessionManager on createAgUiRuntimeHandler().",
+                        }, { status: 501 }))
+                    : createAgUiRuntimeDirectStreamResponse(config.agent, parsed, context)
+                : undefined;
+            const invokeLifecycle = (type, extra = {}) => {
+                invokeLifecycleCallback(config[type], {
+                    request: parsed,
+                    ...extra,
+                });
+            };
+            const createDefaultResponseWithLifecycle = createDefaultResponse
+                ? async () => {
+                    try {
+                        if (!config.agent) {
+                            return await createDefaultResponse();
+                        }
+                        if (parsed.tools.length > 0) {
+                            if (!config.sessionManager) {
+                                return await createDefaultResponse();
+                            }
+                            return await createAgUiRuntimeInjectedToolsStreamResponse(config.agent, parsed, context, config.sessionManager, {
+                                onFinish: () => invokeLifecycle("onFinish"),
+                                onError: (error) => invokeLifecycle("onError", { error }),
+                                onToolCallSeen: (toolCallId) => invokeLifecycle("onToolCallSeen", { toolCallId }),
+                            });
+                        }
+                        return await createAgUiRuntimeDirectStreamResponse(config.agent, parsed, context, {
+                            onFinish: () => invokeLifecycle("onFinish"),
+                            onError: (error) => invokeLifecycle("onError", { error }),
+                            onToolCallSeen: (toolCallId) => invokeLifecycle("onToolCallSeen", { toolCallId }),
+                        });
+                    }
+                    catch (error) {
+                        await invokeLifecycleCallbackAndWait(config.onError, {
+                            request: parsed,
+                            error,
+                        });
+                        throw error;
+                    }
+                }
+                : undefined;
+            if (config.execute) {
+                return await config.execute({
+                    request,
+                    agUiInput: parsed,
+                    context,
+                    createDefaultResponse: createDefaultResponseWithLifecycle,
+                });
+            }
+            if (createDefaultResponseWithLifecycle) {
+                return await createDefaultResponseWithLifecycle();
+            }
+            throw new Error("createAgUiRuntimeHandler configuration became invalid during execution.");
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "issues" in error &&
+                Array.isArray(error.issues)) {
+                const issues = error.issues;
+                return Response.json({
+                    error: "Invalid AG-UI runtime request",
+                    details: issues.map((issue) => ({
+                        path: issue.path,
+                        message: issue.message,
+                    })),
+                }, { status: 400 });
+            }
+            return Response.json({
+                error: error instanceof Error ? error.message : "Internal server error",
+            }, { status: 500 });
+        }
+    };
+}

package/esm/src/agent/ag-ui/runtime-support.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from "../types.js";
+import type { AgUiRuntimeRequest } from "../runtime/ag-ui-contract.js";
+export declare function normalizeAgUiRuntimeMessages(messages: AgUiRuntimeRequest["messages"]): Message[];
+//# sourceMappingURL=runtime-support.d.ts.map

package/esm/src/agent/ag-ui/runtime-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-support.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/runtime-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAevE,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,GACvC,OAAO,EAAE,CA6CX"}

package/esm/src/agent/ag-ui/sse-parser.d.ts

@@ -0,0 +1,57 @@
+/** AG-UI runtime event type constants normalized from browser-wire SSE events. */
+export declare const agUiSseEventTypes: {
+    readonly custom: "CUSTOM";
+    readonly textMessageStart: "TEXT_MESSAGE_START";
+    readonly textMessageContent: "TEXT_MESSAGE_CONTENT";
+    readonly textMessageEnd: "TEXT_MESSAGE_END";
+    readonly reasoningMessageStart: "REASONING_MESSAGE_START";
+    readonly reasoningMessageContent: "REASONING_MESSAGE_CONTENT";
+    readonly reasoningMessageEnd: "REASONING_MESSAGE_END";
+    readonly toolCallStart: "TOOL_CALL_START";
+    readonly toolCallArgs: "TOOL_CALL_ARGS";
+    readonly toolCallEnd: "TOOL_CALL_END";
+    readonly toolCallResult: "TOOL_CALL_RESULT";
+    readonly runStarted: "RUN_STARTED";
+    readonly stateSnapshot: "STATE_SNAPSHOT";
+    readonly messagesSnapshot: "MESSAGES_SNAPSHOT";
+    readonly stepStarted: "STEP_STARTED";
+    readonly stepFinished: "STEP_FINISHED";
+    readonly runError: "RUN_ERROR";
+    readonly runFinished: "RUN_FINISHED";
+};
+/** Normalized AG-UI runtime event type value. */
+export type AgUiSseEventType = (typeof agUiSseEventTypes)[keyof typeof agUiSseEventTypes];
+/** Parsed AG-UI SSE response summary for evals, canaries, and host tests. */
+export interface ParsedAgUiSseRun {
+    responseStatus: number;
+    events: Array<Record<string, unknown>>;
+    eventTypes: string[];
+    toolStarts: string[];
+    toolArgs: string[];
+    text: string;
+    runError: string | null;
+}
+/** Progress snapshot emitted while parsing an AG-UI SSE response. */
+export interface AgUiSseProgressSnapshot {
+    eventCount: number;
+    lastEventType: string | null;
+    lastToolCallName: string | null;
+    toolStarts: string[];
+    textLength: number;
+}
+/** Options for `parseAgUiSseResponse()`. */
+export interface ParseAgUiSseResponseOptions {
+    onProgress?: (snapshot: AgUiSseProgressSnapshot) => void;
+    progressThrottleMs?: number;
+}
+/** Stringify an AG-UI SSE event or fallback value for diagnostics. */
+export declare function stringifyAgUiSseEvent(value: unknown): string;
+/** Return a string field from a parsed AG-UI SSE event record. */
+export declare function getAgUiSseStringField(record: Record<string, unknown>, key: string): string | null;
+/** Filter parsed AG-UI SSE events by normalized event type. */
+export declare function getAgUiSseEventsOfType(events: Array<Record<string, unknown>>, eventType: string): Array<Record<string, unknown>>;
+/** Build a compact ordered event-type signature for regression checks. */
+export declare function buildAgUiSseTraceSignature(eventTypes: string[]): string;
+/** Parse an AG-UI SSE `Response` into normalized events, text, tool starts, and terminal error state. */
+export declare function parseAgUiSseResponse(response: Response, options?: ParseAgUiSseResponseOptions): Promise<ParsedAgUiSseRun>;
+//# sourceMappingURL=sse-parser.d.ts.map

package/esm/src/agent/ag-ui/sse-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-parser.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/sse-parser.ts"],"names":[],"mappings":"AAGA,kFAAkF;AAClF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;CAmBpB,CAAC;AAEX,iDAAiD;AACjD,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC;AAE1F,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,qEAAqE;AACrE,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC1C,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IACzD,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,sEAAsE;AACtE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE5D;AAED,kEAAkE;AAClE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGjG;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACtC,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAEhC;AAED,0EAA0E;AAC1E,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAEvE;AAoLD,yGAAyG;AACzG,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CA6C3B"}

package/esm/src/agent/ag-ui/sse-parser.js

@@ -0,0 +1,227 @@
+import { isRecord } from "../../chat/conversation.js";
+import { safeJsonParse } from "../../chat/provider-errors.js";
+/** AG-UI runtime event type constants normalized from browser-wire SSE events. */
+export const agUiSseEventTypes = {
+    custom: "CUSTOM",
+    textMessageStart: "TEXT_MESSAGE_START",
+    textMessageContent: "TEXT_MESSAGE_CONTENT",
+    textMessageEnd: "TEXT_MESSAGE_END",
+    reasoningMessageStart: "REASONING_MESSAGE_START",
+    reasoningMessageContent: "REASONING_MESSAGE_CONTENT",
+    reasoningMessageEnd: "REASONING_MESSAGE_END",
+    toolCallStart: "TOOL_CALL_START",
+    toolCallArgs: "TOOL_CALL_ARGS",
+    toolCallEnd: "TOOL_CALL_END",
+    toolCallResult: "TOOL_CALL_RESULT",
+    runStarted: "RUN_STARTED",
+    stateSnapshot: "STATE_SNAPSHOT",
+    messagesSnapshot: "MESSAGES_SNAPSHOT",
+    stepStarted: "STEP_STARTED",
+    stepFinished: "STEP_FINISHED",
+    runError: "RUN_ERROR",
+    runFinished: "RUN_FINISHED",
+};
+/** Stringify an AG-UI SSE event or fallback value for diagnostics. */
+export function stringifyAgUiSseEvent(value) {
+    return JSON.stringify(value) ?? String(value);
+}
+/** Return a string field from a parsed AG-UI SSE event record. */
+export function getAgUiSseStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : null;
+}
+/** Filter parsed AG-UI SSE events by normalized event type. */
+export function getAgUiSseEventsOfType(events, eventType) {
+    return events.filter((event) => getAgUiSseStringField(event, "type") === eventType);
+}
+/** Build a compact ordered event-type signature for regression checks. */
+export function buildAgUiSseTraceSignature(eventTypes) {
+    return eventTypes.join(" > ");
+}
+function serializeToolResult(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value ?? null);
+    }
+    catch {
+        return String(value);
+    }
+}
+function createEmptyParsedRun(responseStatus) {
+    return {
+        responseStatus,
+        events: [],
+        eventTypes: [],
+        toolStarts: [],
+        toolArgs: [],
+        text: "",
+        runError: null,
+    };
+}
+function createProgressSnapshot(run) {
+    const lastEvent = run.events.at(-1);
+    const lastToolStart = [...run.events]
+        .reverse()
+        .find((event) => getAgUiSseStringField(event, "type") === agUiSseEventTypes.toolCallStart);
+    return {
+        eventCount: run.events.length,
+        lastEventType: lastEvent ? getAgUiSseStringField(lastEvent, "type") : null,
+        lastToolCallName: lastToolStart ? getAgUiSseStringField(lastToolStart, "toolCallName") : null,
+        toolStarts: [...run.toolStarts],
+        textLength: run.text.length,
+    };
+}
+function applyParsedEvent(run, event) {
+    run.events.push(event);
+    const type = getAgUiSseStringField(event, "type");
+    if (type) {
+        run.eventTypes.push(type);
+    }
+    if (type === agUiSseEventTypes.toolCallStart) {
+        const toolCallName = getAgUiSseStringField(event, "toolCallName");
+        if (toolCallName) {
+            run.toolStarts.push(toolCallName);
+        }
+    }
+    if (type === agUiSseEventTypes.toolCallArgs) {
+        const delta = getAgUiSseStringField(event, "delta");
+        if (delta) {
+            run.toolArgs.push(delta);
+        }
+    }
+    if (type === agUiSseEventTypes.textMessageContent) {
+        const delta = getAgUiSseStringField(event, "delta");
+        if (delta) {
+            run.text += delta;
+        }
+    }
+}
+function coerceBrowserWireEvent(eventName, payload) {
+    switch (eventName) {
+        case "RunStarted":
+            return { type: agUiSseEventTypes.runStarted, ...payload };
+        case "StateSnapshot":
+            return { type: agUiSseEventTypes.stateSnapshot, ...payload };
+        case "MessagesSnapshot":
+            return { type: agUiSseEventTypes.messagesSnapshot, ...payload };
+        case "TextMessageStart":
+            return { type: agUiSseEventTypes.textMessageStart, ...payload };
+        case "TextMessageContent":
+            return { type: agUiSseEventTypes.textMessageContent, ...payload };
+        case "TextMessageEnd":
+            return { type: agUiSseEventTypes.textMessageEnd, ...payload };
+        case "ReasoningMessageStart":
+            return { type: agUiSseEventTypes.reasoningMessageStart, ...payload };
+        case "ReasoningMessageContent":
+            return { type: agUiSseEventTypes.reasoningMessageContent, ...payload };
+        case "ReasoningMessageEnd":
+            return { type: agUiSseEventTypes.reasoningMessageEnd, ...payload };
+        case "StepStarted":
+            return { type: agUiSseEventTypes.stepStarted, ...payload };
+        case "StepFinished":
+            return { type: agUiSseEventTypes.stepFinished, ...payload };
+        case "ToolCallStart":
+            return { type: agUiSseEventTypes.toolCallStart, ...payload };
+        case "ToolCallArgs":
+            return { type: agUiSseEventTypes.toolCallArgs, ...payload };
+        case "ToolCallEnd":
+            return { type: agUiSseEventTypes.toolCallEnd, ...payload };
+        case "ToolCallResult":
+            return {
+                type: agUiSseEventTypes.toolCallResult,
+                ...payload,
+                ...(payload.result !== undefined ? { content: serializeToolResult(payload.result) } : {}),
+            };
+        case "Custom":
+            return { type: agUiSseEventTypes.custom, ...payload };
+        case "RunError":
+            return { type: agUiSseEventTypes.runError, ...payload };
+        case "RunFinished":
+            return { type: agUiSseEventTypes.runFinished, ...payload };
+        default:
+            return { type: eventName, ...payload };
+    }
+}
+function normalizeParsedEvent(payload, eventName) {
+    if (typeof payload.type === "string") {
+        return payload;
+    }
+    if (!eventName) {
+        return null;
+    }
+    return coerceBrowserWireEvent(eventName, payload);
+}
+function consumeSseBuffer(run, buffer, options, state) {
+    let nextBuffer = buffer;
+    let separatorIndex = nextBuffer.indexOf("\n\n");
+    while (separatorIndex !== -1) {
+        const entry = nextBuffer.slice(0, separatorIndex).trim();
+        nextBuffer = nextBuffer.slice(separatorIndex + 2);
+        const eventName = entry
+            .split("\n")
+            .flatMap((line) => line.startsWith("event:") ? [line.slice("event:".length).trimStart()] : [])[0] ?? null;
+        const data = entry
+            .split("\n")
+            .flatMap((line) => line.startsWith("data:") ? [line.slice("data:".length).trimStart()] : [])
+            .join("\n");
+        if (data.length > 0 && data !== "[DONE]") {
+            const parsed = safeJsonParse(data);
+            if (parsed.ok && isRecord(parsed.value)) {
+                const normalizedEvent = normalizeParsedEvent(parsed.value, eventName);
+                if (normalizedEvent) {
+                    applyParsedEvent(run, normalizedEvent);
+                    const now = Date.now();
+                    if (options.onProgress && now - state.lastProgressAt >= state.progressThrottleMs) {
+                        options.onProgress(createProgressSnapshot(run));
+                        state.lastProgressAt = now;
+                    }
+                }
+            }
+        }
+        separatorIndex = nextBuffer.indexOf("\n\n");
+    }
+    return nextBuffer;
+}
+/** Parse an AG-UI SSE `Response` into normalized events, text, tool starts, and terminal error state. */
+export async function parseAgUiSseResponse(response, options = {}) {
+    const run = createEmptyParsedRun(response.status);
+    const decoder = new TextDecoder();
+    const rawChunks = [];
+    const state = { lastProgressAt: 0, progressThrottleMs: options.progressThrottleMs ?? 15_000 };
+    if (!response.body) {
+        const body = await response.text();
+        rawChunks.push(body);
+    }
+    else {
+        const reader = response.body.getReader();
+        let buffer = "";
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                const tail = decoder.decode();
+                if (tail.length > 0) {
+                    rawChunks.push(tail);
+                    buffer += tail;
+                }
+                break;
+            }
+            const decoded = decoder.decode(result.value, { stream: true });
+            rawChunks.push(decoded);
+            buffer += decoded;
+            buffer = consumeSseBuffer(run, buffer, options, state);
+        }
+    }
+    if (options.onProgress) {
+        options.onProgress(createProgressSnapshot(run));
+    }
+    run.text = run.text.trim();
+    const runErrorEvent = getAgUiSseEventsOfType(run.events, agUiSseEventTypes.runError)[0];
+    run.runError = runErrorEvent && typeof runErrorEvent.message === "string"
+        ? runErrorEvent.message
+        : response.ok
+            ? null
+            : rawChunks.join("").trim() || `${response.status}`;
+    return run;
+}

package/esm/src/agent/ag-ui/tool-shared.d.ts

@@ -0,0 +1,15 @@
+import type { Tool } from "../../tool/types.js";
+import type { RunResumeSessionManager } from "../runtime/index.js";
+import type { Agent } from "../types.js";
+export type AgUiResumeValue = {
+    result: unknown;
+    isError: boolean;
+};
+export interface AgUiInjectedToolLike {
+    name: string;
+    description?: string;
+    parameters?: unknown;
+}
+export declare function createInjectedAgUiTool(runId: string, tool: AgUiInjectedToolLike, sessionManager: RunResumeSessionManager<AgUiResumeValue>): Tool;
+export declare function buildMergedAgUiTools(agent: Agent, runId: string, tools: AgUiInjectedToolLike[], sessionManager: RunResumeSessionManager<AgUiResumeValue>): Agent["config"]["tools"];
+//# sourceMappingURL=tool-shared.d.ts.map

package/esm/src/agent/ag-ui/tool-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-shared.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/tool-shared.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,MAAM,eAAe,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAIpE,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,oBAAoB,EAC1B,cAAc,EAAE,uBAAuB,CAAC,eAAe,CAAC,GACvD,IAAI,CA0BN;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,oBAAoB,EAAE,EAC7B,cAAc,EAAE,uBAAuB,CAAC,eAAe,CAAC,GACvD,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAwB1B"}

package/esm/src/agent/ag-ui/tool-shared.js

@@ -0,0 +1,48 @@
+import { defineSchema } from "../../schemas/index.js";
+import { SKILL_TOOL_IDS } from "../../skill/types.js";
+import { toolRegistry } from "../../tool/registry.js";
+const getAnyObjectSchema = defineSchema((v) => v.record(v.string(), v.unknown()));
+export function createInjectedAgUiTool(runId, tool, sessionManager) {
+    return {
+        id: tool.name,
+        type: "function",
+        description: tool.description ?? tool.name,
+        inputSchema: getAnyObjectSchema(),
+        inputSchemaJson: (tool.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 "${tool.name}"`);
+            }
+            sessionManager.prepareForSignal(runId, toolCallId);
+            const submitted = await sessionManager.waitForSignal(runId, toolCallId);
+            if (submitted.isError) {
+                throw new Error(typeof submitted.result === "string"
+                    ? submitted.result
+                    : JSON.stringify(submitted.result));
+            }
+            return submitted.result;
+        },
+    };
+}
+export function buildMergedAgUiTools(agent, runId, tools, sessionManager) {
+    const injectedTools = Object.fromEntries(tools.map((tool) => [
+        tool.name,
+        createInjectedAgUiTool(runId, tool, sessionManager),
+    ]));
+    if (!agent.config.tools) {
+        return Object.keys(injectedTools).length > 0 ? 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 };
+}

package/esm/src/agent/ag-ui/tracked-browser-response.d.ts

@@ -0,0 +1,9 @@
+import type { AgUiBrowserFinalizeTracker } from "./browser-finalize-tracker.js";
+import type { AgUiChunkEncoderBridge } from "./chunk-encoder-bridge.js";
+import { type CreateAgUiRuntimeBrowserResponseInput } from "./runtime-browser-response.js";
+export interface CreateAgUiTrackedBrowserResponseInput<TChunk> extends Omit<CreateAgUiRuntimeBrowserResponseInput<TChunk, null>, "encoder" | "initialState" | "onChunk" | "getFinalResponse"> {
+    chunkEncoder: Pick<AgUiChunkEncoderBridge<TChunk>, "encode" | "finalize">;
+    finalizeTracker: Pick<AgUiBrowserFinalizeTracker<TChunk>, "observeChunk" | "observeEncodedEvents" | "getFinalResponse">;
+}
+export declare function createAgUiTrackedBrowserResponse<TChunk>(input: CreateAgUiTrackedBrowserResponseInput<TChunk>): Response;
+//# sourceMappingURL=tracked-browser-response.d.ts.map