veryfront 0.1.516 → 0.1.518

package/esm/src/agent/ag-ui/run-control.d.ts

@@ -0,0 +1,39 @@
+import type { InferSchema } from "../../extensions/schema/index.js";
+import { RunResumeSessionManager } from "../runtime/resume-session.js";
+export declare const getAgUiResumeSignalSchema: () => import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"tool_result">;
+    toolCallId: import("../../internal-agents/schema.js").Schema<string>;
+    result: import("../../internal-agents/schema.js").Schema<unknown>;
+    isError: import("../../internal-agents/schema.js").Schema<boolean>;
+}>>;
+/** @deprecated Use getAgUiResumeSignalSchema() */
+export declare const AgUiResumeSignalSchema: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"tool_result">;
+    toolCallId: import("../../internal-agents/schema.js").Schema<string>;
+    result: import("../../internal-agents/schema.js").Schema<unknown>;
+    isError: import("../../internal-agents/schema.js").Schema<boolean>;
+}>>;
+export type AgUiResumeSignal = InferSchema<ReturnType<typeof getAgUiResumeSignalSchema>>;
+type ResumeValue = {
+    result: unknown;
+    isError: boolean;
+};
+export interface AgUiRunControlHandlerOptions {
+    resolveRunId?: ((input: {
+        request: Request;
+        requestOrCtx: unknown;
+    }) => string | null) | ((input: {
+        request: Request;
+        requestOrCtx: unknown;
+    }) => Promise<string | null>);
+}
+export interface AgUiResumeHandlerOptions extends AgUiRunControlHandlerOptions {
+    sessionManager: RunResumeSessionManager<ResumeValue>;
+}
+export interface AgUiCancelHandlerOptions<T = unknown> extends AgUiRunControlHandlerOptions {
+    sessionManager: RunResumeSessionManager<T>;
+}
+export declare function createAgUiResumeHandler(options: AgUiResumeHandlerOptions): (requestOrCtx: unknown) => Promise<Response>;
+export declare function createAgUiCancelHandler<T = unknown>(options: AgUiCancelHandlerOptions<T>): (requestOrCtx: unknown) => Promise<Response>;
+export {};
+//# sourceMappingURL=run-control.d.ts.map

package/esm/src/agent/ag-ui/run-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-control.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/run-control.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEpE,OAAO,EAEL,uBAAuB,EAGxB,MAAM,8BAA8B,CAAC;AAKtC,eAAO,MAAM,yBAAyB;;;;;GASrC,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,sBAAsB;;;;;GAA8B,CAAC;AAElE,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC;AAEzF,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAMF,MAAM,WAAW,4BAA4B;IAC3C,YAAY,CAAC,EACT,CAAC,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,KAAK,MAAM,GAAG,IAAI,CAAC,GACvE,CAAC,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;CACtF;AAED,MAAM,WAAW,wBAAyB,SAAQ,4BAA4B;IAC5E,cAAc,EAAE,uBAAuB,CAAC,WAAW,CAAC,CAAC;CACtD;AAED,MAAM,WAAW,wBAAwB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,4BAA4B;IACzF,cAAc,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;CAC5C;AAaD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,wBAAwB,GAChC,CAAC,YAAY,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA2D9C;AAED,wBAAgB,uBAAuB,CAAC,CAAC,GAAG,OAAO,EACjD,OAAO,EAAE,wBAAwB,CAAC,CAAC,CAAC,GACnC,CAAC,YAAY,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAgB9C"}

package/esm/src/agent/ag-ui/run-control.js

@@ -0,0 +1,84 @@
+import { defineSchema } from "../../schemas/index.js";
+import { extractRequest } from "./request-shared.js";
+import { RunNotActiveError, WaitConflictError, WaitNotPendingError, } from "../runtime/resume-session.js";
+const RESUME_PATH_REGEX = /^\/api\/runs\/([^/]+)\/resume$/;
+const CANCEL_PATH_REGEX = /^\/api\/runs\/([^/]+)$/;
+export const getAgUiResumeSignalSchema = defineSchema((v) => v.discriminatedUnion("type", [
+    v.object({
+        type: v.literal("tool_result"),
+        toolCallId: v.string().min(1).max(128),
+        result: v.unknown(),
+        isError: v.boolean().optional().default(false),
+    }),
+]));
+/** @deprecated Use getAgUiResumeSignalSchema() */
+export const AgUiResumeSignalSchema = getAgUiResumeSignalSchema();
+function getRunId(pathname, regex) {
+    return regex.exec(pathname)?.[1] ?? null;
+}
+async function resolveRunId(requestOrCtx, request, options, regex) {
+    const explicit = await options?.resolveRunId?.({ request, requestOrCtx });
+    if (explicit)
+        return explicit;
+    return getRunId(new URL(request.url).pathname, regex);
+}
+export function createAgUiResumeHandler(options) {
+    return async function POST(requestOrCtx) {
+        const request = extractRequest(requestOrCtx);
+        const runId = await resolveRunId(requestOrCtx, request, options, RESUME_PATH_REGEX);
+        if (!runId) {
+            return Response.json({ error: "Run not found" }, { status: 404 });
+        }
+        try {
+            const parsed = getAgUiResumeSignalSchema().parse(await request.json());
+            const outcome = options.sessionManager.submitSignal(runId, {
+                waitKey: parsed.toolCallId,
+                value: {
+                    result: parsed.result,
+                    isError: parsed.isError,
+                },
+            });
+            return Response.json(outcome, { status: 200 });
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "issues" in error &&
+                Array.isArray(error.issues)) {
+                const issues = error.issues;
+                return Response.json({
+                    error: "Invalid AG-UI resume request",
+                    details: issues.map((issue) => ({
+                        path: issue.path,
+                        message: issue.message,
+                    })),
+                }, { status: 400 });
+            }
+            if (error instanceof WaitConflictError) {
+                return Response.json({ error: "TOOL_RESULT_CONFLICT" }, { status: 409 });
+            }
+            if (error instanceof WaitNotPendingError) {
+                return Response.json({ error: "TOOL_RESULT_NOT_WAITING" }, { status: 409 });
+            }
+            if (error instanceof RunNotActiveError) {
+                return Response.json({ error: "RUN_NOT_ACTIVE" }, { status: 410 });
+            }
+            return Response.json({
+                error: error instanceof Error ? error.message : "Internal resume failed",
+            }, { status: 500 });
+        }
+    };
+}
+export function createAgUiCancelHandler(options) {
+    return async function DELETE(requestOrCtx) {
+        const request = extractRequest(requestOrCtx);
+        const runId = await resolveRunId(requestOrCtx, request, options, CANCEL_PATH_REGEX);
+        if (!runId) {
+            return Response.json({ error: "Run not found" }, { status: 404 });
+        }
+        const accepted = options.sessionManager.cancelRun(runId);
+        if (accepted) {
+            return Response.json({ accepted: true }, { status: 202 });
+        }
+        return new Response(null, { status: 204 });
+    };
+}

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

@@ -0,0 +1,18 @@
+import { type AgUiBrowserResponseEncoder, type AgUiBrowserResponseExecution } from "./browser-response-stream.js";
+import { type AgUiRuntimeRequest } from "../runtime/ag-ui-contract.js";
+import type { AgentResponse } from "../types.js";
+export interface CreateAgUiRuntimeBrowserResponseInput<TChunk, TState> {
+    agUiInput: AgUiRuntimeRequest;
+    defaults?: {
+        threadId?: string;
+        runId?: string;
+    };
+    agentId: string;
+    execution: AgUiBrowserResponseExecution<TChunk>;
+    encoder: AgUiBrowserResponseEncoder<TChunk>;
+    initialState: TState;
+    onChunk?: (state: TState, chunk: TChunk) => void;
+    getFinalResponse?: (state: TState) => AgentResponse | null;
+}
+export declare function createAgUiRuntimeBrowserResponse<TChunk, TState>(input: CreateAgUiRuntimeBrowserResponseInput<TChunk, TState>): Response;
+//# sourceMappingURL=runtime-browser-response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-browser-response.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/runtime-browser-response.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EAElC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,WAAW,qCAAqC,CAAC,MAAM,EAAE,MAAM;IACnE,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,CAAC,EAAE;QACT,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,4BAA4B,CAAC,MAAM,CAAC,CAAC;IAChD,OAAO,EAAE,0BAA0B,CAAC,MAAM,CAAC,CAAC;IAC5C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,aAAa,GAAG,IAAI,CAAC;CAC5D;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,MAAM,EAC7D,KAAK,EAAE,qCAAqC,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3D,QAAQ,CAYV"}

package/esm/src/agent/ag-ui/runtime-browser-response.js

@@ -0,0 +1,15 @@
+import { createAgUiBrowserResponseStream, } from "./browser-response-stream.js";
+import { createAgUiSseResponse } from "./host-support.js";
+import { normalizeAgUiBrowserRuntimeRequest, } from "../runtime/ag-ui-contract.js";
+export function createAgUiRuntimeBrowserResponse(input) {
+    const stream = createAgUiBrowserResponseStream({
+        agUiInput: normalizeAgUiBrowserRuntimeRequest(input.agUiInput, input.defaults),
+        agentId: input.agentId,
+        execution: input.execution,
+        encoder: input.encoder,
+        initialState: input.initialState,
+        ...(input.onChunk ? { onChunk: input.onChunk } : {}),
+        ...(input.getFinalResponse ? { getFinalResponse: input.getFinalResponse } : {}),
+    });
+    return createAgUiSseResponse(stream);
+}

package/esm/src/agent/ag-ui/runtime-chat-stream-encoder.d.ts

@@ -0,0 +1,17 @@
+import type { AgUiRuntimeStreamEvent } from "./browser-encoder.js";
+import type { ChatFinishReason, ChatStreamEvent } from "../../chat/protocol.js";
+export interface AgUiRuntimeChatStreamEncoderState {
+    isStepOpen: boolean;
+    finishReason: ChatFinishReason;
+}
+export interface AgUiRuntimeChatStreamEncoder {
+    state: AgUiRuntimeChatStreamEncoderState;
+    encode: (event: AgUiRuntimeStreamEvent) => ChatStreamEvent[];
+}
+export interface CreateAgUiRuntimeChatStreamEncoderOptions {
+    responseMessageId: string;
+    sendReasoning?: boolean;
+    onError?: (error: unknown) => string;
+}
+export declare function createAgUiRuntimeChatStreamEncoder(options: CreateAgUiRuntimeChatStreamEncoderOptions): AgUiRuntimeChatStreamEncoder;
+//# sourceMappingURL=runtime-chat-stream-encoder.d.ts.map

package/esm/src/agent/ag-ui/runtime-chat-stream-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-chat-stream-encoder.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/runtime-chat-stream-encoder.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEhF,MAAM,WAAW,iCAAiC;IAChD,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,gBAAgB,CAAC;CAChC;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,iCAAiC,CAAC;IACzC,MAAM,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,eAAe,EAAE,CAAC;CAC9D;AAED,MAAM,WAAW,yCAAyC;IACxD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CACtC;AAoDD,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,yCAAyC,GACjD,4BAA4B,CAyR9B"}

package/esm/src/agent/ag-ui/runtime-chat-stream-encoder.js

@@ -0,0 +1,304 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { mergeToolInputDelta, parseToolInputObject, stripLeadingEmptyObjectPlaceholder, } from "../data-stream.js";
+function getStringField(event, key) {
+    const value = event[key];
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getDataRecord(event) {
+    return isRecord(event.data) ? event.data : undefined;
+}
+function getToolInput(event) {
+    return parseToolInputObject(event.input);
+}
+function parseStreamedToolInput(inputText) {
+    const normalizedInputText = stripLeadingEmptyObjectPlaceholder(inputText).trim();
+    if (normalizedInputText.length === 0) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(normalizedInputText);
+        return isRecord(parsed) ? Object.fromEntries(Object.entries(parsed)) : {};
+    }
+    catch {
+        return null;
+    }
+}
+function isEmptyRecord(value) {
+    return Object.keys(value).length === 0;
+}
+function formatErrorText(error, onError) {
+    return onError ? onError(error) : error instanceof Error ? error.message : String(error);
+}
+export function createAgUiRuntimeChatStreamEncoder(options) {
+    const state = {
+        isStepOpen: false,
+        finishReason: "stop",
+    };
+    const startedTextBlockIds = new Set();
+    const seenTextBlockIds = new Set();
+    const emittedToolInputStartIds = new Set();
+    const toolParts = new Map();
+    const pendingToolDeltas = new Map();
+    const ensureStepStarted = (events) => {
+        if (state.isStepOpen) {
+            return;
+        }
+        state.isStepOpen = true;
+        events.push({ type: "start-step" });
+    };
+    const appendPendingToolDelta = (toolCallId, inputTextDelta) => {
+        const existing = pendingToolDeltas.get(toolCallId);
+        if (existing) {
+            existing.inputText = mergeToolInputDelta(existing.inputText, inputTextDelta);
+            existing.chunks.push(inputTextDelta);
+            return;
+        }
+        pendingToolDeltas.set(toolCallId, {
+            inputText: inputTextDelta,
+            chunks: [inputTextDelta],
+        });
+    };
+    const flushPendingToolDeltas = (toolCallId) => {
+        const pending = pendingToolDeltas.get(toolCallId);
+        if (!pending) {
+            return [];
+        }
+        pendingToolDeltas.delete(toolCallId);
+        return pending.chunks.map((inputTextDelta) => ({
+            type: "tool-input-delta",
+            toolCallId,
+            inputTextDelta,
+        }));
+    };
+    return {
+        state,
+        encode: (event) => {
+            const events = [];
+            switch (event.type) {
+                case "message-start":
+                case "message-finish":
+                    return events;
+                case "step-start":
+                    ensureStepStarted(events);
+                    return events;
+                case "step-end":
+                    if (state.isStepOpen) {
+                        state.isStepOpen = false;
+                        events.push({ type: "finish-step" });
+                    }
+                    return events;
+                case "text-start": {
+                    ensureStepStarted(events);
+                    const id = getStringField(event, "id") ?? options.responseMessageId;
+                    if (!seenTextBlockIds.has(id)) {
+                        seenTextBlockIds.add(id);
+                    }
+                    else if (startedTextBlockIds.has(id)) {
+                        events.push({ type: "text-start", id: options.responseMessageId });
+                    }
+                    return events;
+                }
+                case "text-delta": {
+                    ensureStepStarted(events);
+                    const id = getStringField(event, "id") ?? options.responseMessageId;
+                    const delta = getStringField(event, "delta") ?? "";
+                    if (delta.length === 0) {
+                        return events;
+                    }
+                    if (!startedTextBlockIds.has(id)) {
+                        startedTextBlockIds.add(id);
+                        seenTextBlockIds.add(id);
+                        events.push({ type: "text-start", id: options.responseMessageId });
+                    }
+                    events.push({ type: "text-delta", id: options.responseMessageId, delta });
+                    return events;
+                }
+                case "text-end": {
+                    const id = getStringField(event, "id") ?? options.responseMessageId;
+                    if (startedTextBlockIds.has(id)) {
+                        startedTextBlockIds.delete(id);
+                        events.push({ type: "text-end", id: options.responseMessageId });
+                    }
+                    return events;
+                }
+                case "reasoning-start": {
+                    ensureStepStarted(events);
+                    const id = getStringField(event, "id") ?? dntShim.crypto.randomUUID();
+                    events.push({ type: "reasoning-start", id });
+                    return events;
+                }
+                case "reasoning-delta": {
+                    ensureStepStarted(events);
+                    if (options.sendReasoning === false) {
+                        return events;
+                    }
+                    const id = getStringField(event, "id") ?? dntShim.crypto.randomUUID();
+                    const delta = getStringField(event, "delta") ?? "";
+                    if (delta.length > 0) {
+                        events.push({ type: "reasoning-delta", id, delta });
+                    }
+                    return events;
+                }
+                case "reasoning-end": {
+                    const id = getStringField(event, "id");
+                    if (id) {
+                        events.push({ type: "reasoning-end", id });
+                    }
+                    return events;
+                }
+                case "tool-input-start": {
+                    ensureStepStarted(events);
+                    const toolCallId = getStringField(event, "toolCallId");
+                    const toolName = getStringField(event, "toolName");
+                    if (!toolCallId || !toolName) {
+                        return events;
+                    }
+                    const toolPart = toolParts.get(toolCallId);
+                    if (!toolPart) {
+                        toolParts.set(toolCallId, {
+                            toolName,
+                            inputText: "",
+                            input: {},
+                        });
+                    }
+                    if (!emittedToolInputStartIds.has(toolCallId)) {
+                        emittedToolInputStartIds.add(toolCallId);
+                        events.push({ type: "tool-input-start", toolCallId, toolName });
+                    }
+                    const pendingEvents = flushPendingToolDeltas(toolCallId);
+                    const existingToolPart = toolParts.get(toolCallId);
+                    if (existingToolPart) {
+                        for (const pendingEvent of pendingEvents) {
+                            if (pendingEvent.type === "tool-input-delta") {
+                                existingToolPart.inputText = mergeToolInputDelta(existingToolPart.inputText, pendingEvent.inputTextDelta);
+                                const parsedInput = parseStreamedToolInput(existingToolPart.inputText);
+                                if (parsedInput) {
+                                    existingToolPart.input = parsedInput;
+                                }
+                            }
+                        }
+                    }
+                    events.push(...pendingEvents);
+                    return events;
+                }
+                case "tool-input-delta": {
+                    ensureStepStarted(events);
+                    const toolCallId = getStringField(event, "toolCallId");
+                    const inputTextDelta = getStringField(event, "inputTextDelta") ??
+                        getStringField(event, "delta") ?? "";
+                    if (!toolCallId || inputTextDelta.length === 0) {
+                        return events;
+                    }
+                    const toolPart = toolParts.get(toolCallId);
+                    if (!toolPart) {
+                        appendPendingToolDelta(toolCallId, inputTextDelta);
+                        return events;
+                    }
+                    toolPart.inputText = mergeToolInputDelta(toolPart.inputText, inputTextDelta);
+                    const parsedInput = parseStreamedToolInput(toolPart.inputText);
+                    if (parsedInput) {
+                        toolPart.input = parsedInput;
+                    }
+                    events.push({ type: "tool-input-delta", toolCallId, inputTextDelta });
+                    return events;
+                }
+                case "tool-input-available": {
+                    ensureStepStarted(events);
+                    const toolCallId = getStringField(event, "toolCallId");
+                    const toolName = getStringField(event, "toolName");
+                    if (!toolCallId || !toolName) {
+                        return events;
+                    }
+                    const inputRecord = getToolInput(event);
+                    const existingToolPart = toolParts.get(toolCallId);
+                    const pendingToolDelta = pendingToolDeltas.get(toolCallId);
+                    const pendingInputText = pendingToolDelta?.inputText ?? "";
+                    const parsedPendingInput = pendingInputText.length > 0
+                        ? parseStreamedToolInput(pendingInputText)
+                        : null;
+                    const resolvedInputRecord = isEmptyRecord(inputRecord)
+                        ? existingToolPart && !isEmptyRecord(existingToolPart.input)
+                            ? existingToolPart.input
+                            : parsedPendingInput && !isEmptyRecord(parsedPendingInput)
+                                ? parsedPendingInput
+                                : inputRecord
+                        : inputRecord;
+                    if (existingToolPart) {
+                        existingToolPart.toolName = toolName;
+                        existingToolPart.inputText = pendingInputText;
+                        existingToolPart.input = resolvedInputRecord;
+                    }
+                    else {
+                        toolParts.set(toolCallId, {
+                            toolName,
+                            inputText: pendingInputText,
+                            input: resolvedInputRecord,
+                        });
+                    }
+                    if (!emittedToolInputStartIds.has(toolCallId)) {
+                        emittedToolInputStartIds.add(toolCallId);
+                        events.push({ type: "tool-input-start", toolCallId, toolName });
+                    }
+                    events.push(...flushPendingToolDeltas(toolCallId));
+                    events.push({
+                        type: "tool-input-available",
+                        toolCallId,
+                        toolName,
+                        input: resolvedInputRecord,
+                    });
+                    return events;
+                }
+                case "tool-output-available": {
+                    ensureStepStarted(events);
+                    const toolCallId = getStringField(event, "toolCallId");
+                    if (!toolCallId) {
+                        return events;
+                    }
+                    events.push({ type: "tool-output-available", toolCallId, output: event.output });
+                    return events;
+                }
+                case "tool-output-error": {
+                    ensureStepStarted(events);
+                    const toolCallId = getStringField(event, "toolCallId");
+                    if (!toolCallId) {
+                        return events;
+                    }
+                    const errorText = getStringField(event, "errorText") ?? "Tool execution failed";
+                    events.push({ type: "tool-output-error", toolCallId, errorText });
+                    return events;
+                }
+                case "data": {
+                    const data = getDataRecord(event);
+                    const name = typeof data?.name === "string" && data.name.length > 0
+                        ? data.name
+                        : undefined;
+                    if (name) {
+                        const dataValue = data && Object.hasOwn(data, "value") ? data.value : undefined;
+                        events.push({
+                            type: `data-${name}`,
+                            data: dataValue,
+                        });
+                        return events;
+                    }
+                    if (data && typeof data.model === "string") {
+                        events.push({ type: "message-metadata", messageMetadata: { modelId: data.model } });
+                    }
+                    return events;
+                }
+                case "error": {
+                    state.finishReason = "error";
+                    events.push({
+                        type: "error",
+                        errorText: formatErrorText(getStringField(event, "error") ?? "Framework stream failed", options.onError),
+                    });
+                    return events;
+                }
+                default:
+                    return events;
+            }
+        },
+    };
+}

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

@@ -0,0 +1,11 @@
+import { type AgentResponse, type AgUiBrowserEncodedEvent, type AgUiBrowserEncoderState, type AgUiBrowserRunFinishedMetadata, type AgUiRuntimeStreamEvent } from "../index.js";
+export interface AgUiRuntimeEventEncoder {
+    state: AgUiBrowserEncoderState;
+    encode: (event: AgUiRuntimeStreamEvent) => AgUiBrowserEncodedEvent[];
+    finalize: (response: AgentResponse | null) => AgUiBrowserEncodedEvent[];
+}
+export interface CreateAgUiRuntimeEventEncoderOptions {
+    initialMetadata?: Partial<AgUiBrowserRunFinishedMetadata>;
+}
+export declare function createAgUiRuntimeEventEncoder(options?: CreateAgUiRuntimeEventEncoderOptions): AgUiRuntimeEventEncoder;
+//# sourceMappingURL=runtime-event-encoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-event-encoder.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/runtime-event-encoder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,8BAA8B,EACnC,KAAK,sBAAsB,EAI5B,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,uBAAuB,CAAC;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,uBAAuB,EAAE,CAAC;IACrE,QAAQ,EAAE,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,KAAK,uBAAuB,EAAE,CAAC;CACzE;AAED,MAAM,WAAW,oCAAoC;IACnD,eAAe,CAAC,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC;CAC3D;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,GAAE,oCAAyC,GACjD,uBAAuB,CA+CzB"}

package/esm/src/agent/ag-ui/runtime-event-encoder.js

@@ -0,0 +1,37 @@
+import { createAgUiBrowserEncoderState, finalizeAgUiBrowserEvents, mapRuntimeStreamEventToAgUiBrowserEvents, } from "../index.js";
+export function createAgUiRuntimeEventEncoder(options = {}) {
+    const state = createAgUiBrowserEncoderState();
+    const toolInputs = new Map();
+    Object.assign(state.metadata, options.initialMetadata ?? {});
+    return {
+        state,
+        encode: (event) => {
+            if ((event.type === "tool-input-available" || event.type === "tool-input-error") &&
+                typeof event.toolCallId === "string") {
+                toolInputs.set(event.toolCallId, event.input);
+            }
+            const encodedEvents = mapRuntimeStreamEventToAgUiBrowserEvents(state, event).map((next) => {
+                if (next.event !== "ToolCallResult" ||
+                    typeof next.payload.toolCallId !== "string" ||
+                    !toolInputs.has(next.payload.toolCallId)) {
+                    return next;
+                }
+                return {
+                    ...next,
+                    payload: {
+                        ...next.payload,
+                        input: toolInputs.get(next.payload.toolCallId),
+                    },
+                };
+            });
+            if ((event.type === "tool-output-available" ||
+                event.type === "tool-output-error" ||
+                event.type === "tool-output-denied") &&
+                typeof event.toolCallId === "string") {
+                toolInputs.delete(event.toolCallId);
+            }
+            return encodedEvents;
+        },
+        finalize: (response) => finalizeAgUiBrowserEvents(state, response),
+    };
+}

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

@@ -0,0 +1,44 @@
+import { type RunResumeSessionManager } from "../runtime/index.js";
+import type { Agent } from "../types.js";
+import { type AgUiRuntimeRequest } from "../runtime/ag-ui-contract.js";
+import { type AgUiResumeValue } from "./tool-shared.js";
+export interface AgUiRuntimeLifecycleContext {
+    request: AgUiRuntimeRequest;
+    toolCallId?: string;
+    error?: unknown;
+}
+export interface AgUiRuntimeHandlerExecuteInput {
+    request: Request;
+    agUiInput: AgUiRuntimeRequest;
+    context: Record<string, unknown>;
+    createDefaultResponse?: () => Promise<Response>;
+}
+export type AgUiRuntimeHandlerExecute = (input: AgUiRuntimeHandlerExecuteInput) => Promise<Response> | Response;
+export interface AgUiRuntimeRequestGateInput {
+    request: Request;
+}
+export type AgUiRuntimeRequestGate = (input: AgUiRuntimeRequestGateInput) => Promise<Response | undefined | void> | Response | undefined | void;
+export interface AgUiRuntimeValidationErrorInput {
+    request: Request;
+    response: Response;
+}
+export type AgUiRuntimeValidationErrorResponse = (input: AgUiRuntimeValidationErrorInput) => Promise<Response> | Response;
+export interface AgUiRuntimeHandlerOptions {
+    context?: Record<string, unknown> | ((request: Request) => Record<string, unknown> | Promise<Record<string, unknown>>);
+    beforeParse?: AgUiRuntimeRequestGate;
+    validationErrorResponse?: AgUiRuntimeValidationErrorResponse;
+    sessionManager?: RunResumeSessionManager<AgUiResumeValue>;
+    execute?: AgUiRuntimeHandlerExecute;
+    onToolCallSeen?: (context: AgUiRuntimeLifecycleContext) => Promise<void> | void;
+    onFinish?: (context: AgUiRuntimeLifecycleContext) => Promise<void> | void;
+    onError?: (context: AgUiRuntimeLifecycleContext) => Promise<void> | void;
+}
+export interface AgUiRuntimeHandlerConfigWithAgent extends AgUiRuntimeHandlerOptions {
+    agent: Agent;
+}
+export type AgUiRuntimeHandlerConfig = AgUiRuntimeHandlerConfigWithAgent | (AgUiRuntimeHandlerOptions & {
+    agent?: undefined;
+    execute: AgUiRuntimeHandlerExecute;
+});
+export declare function createAgUiRuntimeHandler(config: AgUiRuntimeHandlerConfig): (requestOrCtx: unknown) => Promise<Response>;
+//# sourceMappingURL=runtime-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-handler.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/runtime-handler.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,kBAAkB,CAAC;AAkB9E,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,kBAAkB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAqRD,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,qBAAqB,CAAC,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;CACjD;AAED,MAAM,MAAM,yBAAyB,GAAG,CACtC,KAAK,EAAE,8BAA8B,KAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;AAElC,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,sBAAsB,GAAG,CACnC,KAAK,EAAE,2BAA2B,KAC/B,OAAO,CAAC,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC;AAExE,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,MAAM,MAAM,kCAAkC,GAAG,CAC/C,KAAK,EAAE,+BAA+B,KACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;AAElC,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,EACJ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACvF,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,uBAAuB,CAAC,EAAE,kCAAkC,CAAC;IAC7D,cAAc,CAAC,EAAE,uBAAuB,CAAC,eAAe,CAAC,CAAC;IAC1D,OAAO,CAAC,EAAE,yBAAyB,CAAC;IACpC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChF,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1E,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC1E;AAED,MAAM,WAAW,iCAAkC,SAAQ,yBAAyB;IAClF,KAAK,EAAE,KAAK,CAAC;CACd;AAED,MAAM,MAAM,wBAAwB,GAChC,iCAAiC,GACjC,CAAC,yBAAyB,GAAG;IAAE,KAAK,CAAC,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,yBAAyB,CAAA;CAAE,CAAC,CAAC;AAE5F,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,CAAC,YAAY,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAmJ9C"}