veryfront 0.1.222 → 0.1.224

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.222",
+    "version": "0.1.224",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "workspace": [

package/esm/src/agent/ag-ui-detached-start.d.ts

@@ -55,6 +55,12 @@ export declare const AgUiDetachedStartAcceptedSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AgUiDetachedStartRequest = z.infer<typeof AgUiDetachedStartRequestSchema>;
 export type AgUiDetachedStartAccepted = z.infer<typeof AgUiDetachedStartAcceptedSchema>;
+export interface ExecuteAgUiDetachedStartInput {
+    request: AgUiDetachedStartRequest;
+    rawRequest?: Request;
+    requestOrCtx?: unknown;
+    context?: Record<string, unknown>;
+}
 interface AgUiDetachedStartExecutionInput {
     request: AgUiDetachedStartRequest;
     requestOrCtx: unknown;
@@ -93,6 +99,7 @@ export type AgUiDetachedStartHandlerOptions = (AgUiDetachedStartHandlerOptionsBa
     agent?: undefined;
     startDetachedExecution: AgUiDetachedExecutionStarter;
 });
+export declare function executeAgUiDetachedStart(options: AgUiDetachedStartHandlerOptions, input: ExecuteAgUiDetachedStartInput): Promise<Response>;
 export declare function createAgUiDetachedStartHandler(options: AgUiDetachedStartHandlerOptions): (requestOrCtx: unknown) => Promise<Response>;
 export {};
 //# sourceMappingURL=ag-ui-detached-start.d.ts.map

package/esm/src/agent/ag-ui-detached-start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ag-ui-detached-start.d.ts","sourceRoot":"","sources":["../../../src/src/agent/ag-ui-detached-start.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAIxC,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,gBAAgB,GACjB,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;AA8IvF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGzC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,UAAU,+BAA+B;IACvC,OAAO,EAAE,wBAAwB,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,KAAK,4BAA4B,GAAG,CAClC,KAAK,EAAE,+BAA+B,KACnC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B,UAAU,mCAAmC;IAC3C,cAAc,EAAE,uBAAuB,CAAC,eAAe,CAAC,CAAC;IACzD,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,sBAAsB,CAAC,EAAE,4BAA4B,CAAC;IACtD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE;QACnB,OAAO,EAAE,wBAAwB,CAAC;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3B,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE;QACpB,OAAO,EAAE,wBAAwB,CAAC;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAChG;AAED,MAAM,MAAM,+BAA+B,GACvC,CAAC,mCAAmC,GAAG;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,GACxD,CAAC,mCAAmC,GAAG;IACvC,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,sBAAsB,EAAE,4BAA4B,CAAC;CACtD,CAAC,CAAC;AA0BL,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,CAAC,YAAY,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAwH9C"}
+{"version":3,"file":"ag-ui-detached-start.d.ts","sourceRoot":"","sources":["../../../src/src/agent/ag-ui-detached-start.ts"],"names":[],"mappings":"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"}

package/esm/src/agent/ag-ui-detached-start.js

@@ -84,12 +84,6 @@ function buildMergedTools(agent, request, sessionManager) {
     }
     return { ...agent.config.tools, ...injectedTools };
 }
-async function resolveContextValue(value, request) {
-    if (typeof value === "function") {
-        return await value(request);
-    }
-    return value ?? {};
-}
 function scheduleDetachedTask(requestOrCtx, task) {
     if (typeof requestOrCtx === "object" &&
         requestOrCtx !== null &&
@@ -123,6 +117,111 @@ async function startDefaultDetachedExecution(input) {
     const runtimeStream = await runtime.stream(normalizeAgUiMessages(input.request.messages), buildStreamContext(input.request, input.context, input.request.threadId, input.request.runId), undefined, input.request.model, input.request.maxOutputTokens, input.abortSignal);
     await drainRuntimeStream(runtimeStream);
 }
+async function resolveDetachedStartContext(options, input) {
+    if (input.context) {
+        return input.context;
+    }
+    if (!options.context) {
+        return {};
+    }
+    if (typeof options.context === "function") {
+        if (!input.rawRequest) {
+            throw INVALID_ARGUMENT.create({
+                detail: "executeAgUiDetachedStart requires rawRequest when options.context is a function.",
+            });
+        }
+        return await options.context(input.rawRequest);
+    }
+    return options.context;
+}
+function assertDetachedStartRawRequest(options, input) {
+    if (!options.startDetachedExecution) {
+        return input.rawRequest;
+    }
+    if (input.rawRequest) {
+        return input.rawRequest;
+    }
+    throw INVALID_ARGUMENT.create({
+        detail: "executeAgUiDetachedStart requires rawRequest when options.startDetachedExecution is used.",
+    });
+}
+export async function executeAgUiDetachedStart(options, input) {
+    const rawRequest = assertDetachedStartRawRequest(options, input);
+    const context = await resolveDetachedStartContext(options, input);
+    try {
+        const abortSignal = options.sessionManager.startRun({
+            runId: input.request.runId,
+            threadId: input.request.threadId,
+        });
+        await options.onAccepted?.({
+            request: input.request,
+            runId: input.request.runId,
+            threadId: input.request.threadId,
+        });
+        const detachedTask = (async () => {
+            try {
+                if (options.startDetachedExecution) {
+                    await options.startDetachedExecution({
+                        request: input.request,
+                        requestOrCtx: input.requestOrCtx,
+                        rawRequest: rawRequest,
+                        context,
+                        abortSignal,
+                    });
+                }
+                else if (options.agent) {
+                    await startDefaultDetachedExecution({
+                        agent: options.agent,
+                        request: input.request,
+                        context,
+                        abortSignal,
+                        sessionManager: options.sessionManager,
+                    });
+                }
+                else {
+                    throw new Error("Detached AG-UI start configuration became invalid during execution.");
+                }
+                options.sessionManager.completeRun(input.request.runId);
+                await options.onFinish?.({
+                    runId: input.request.runId,
+                    threadId: input.request.threadId,
+                });
+            }
+            catch (error) {
+                options.sessionManager.failRun(input.request.runId);
+                await options.onError?.({
+                    runId: input.request.runId,
+                    threadId: input.request.threadId,
+                    error,
+                });
+            }
+        })().catch(() => undefined);
+        scheduleDetachedTask(input.requestOrCtx, detachedTask);
+        return Response.json({
+            accepted: true,
+            duplicate: false,
+            runId: input.request.runId,
+            threadId: input.request.threadId,
+        }, { status: 202 });
+    }
+    catch (error) {
+        if (error instanceof RunAlreadyExistsError) {
+            await options.onDuplicate?.({
+                request: input.request,
+                runId: input.request.runId,
+                threadId: input.request.threadId,
+            });
+            return Response.json({
+                accepted: true,
+                duplicate: true,
+                runId: input.request.runId,
+                threadId: input.request.threadId,
+            }, { status: 202 });
+        }
+        options.sessionManager.failRun(input.request.runId);
+        throw error;
+    }
+}
 export function createAgUiDetachedStartHandler(options) {
     if (!options.agent && !options.startDetachedExecution) {
         throw new Error("Detached AG-UI start requires either an agent or startDetachedExecution handler.");
@@ -131,80 +230,11 @@ export function createAgUiDetachedStartHandler(options) {
         const request = extractRequest(requestOrCtx);
         try {
             const parsed = AgUiDetachedStartRequestSchema.parse(await request.json());
-            const context = await resolveContextValue(options.context, request);
-            try {
-                const abortSignal = options.sessionManager.startRun({
-                    runId: parsed.runId,
-                    threadId: parsed.threadId,
-                });
-                await options.onAccepted?.({
-                    request: parsed,
-                    runId: parsed.runId,
-                    threadId: parsed.threadId,
-                });
-                const detachedTask = (async () => {
-                    try {
-                        if (options.startDetachedExecution) {
-                            await options.startDetachedExecution({
-                                request: parsed,
-                                requestOrCtx,
-                                rawRequest: request,
-                                context,
-                                abortSignal,
-                            });
-                        }
-                        else if (options.agent) {
-                            await startDefaultDetachedExecution({
-                                agent: options.agent,
-                                request: parsed,
-                                context,
-                                abortSignal,
-                                sessionManager: options.sessionManager,
-                            });
-                        }
-                        else {
-                            throw new Error("Detached AG-UI start configuration became invalid during execution.");
-                        }
-                        options.sessionManager.completeRun(parsed.runId);
-                        await options.onFinish?.({
-                            runId: parsed.runId,
-                            threadId: parsed.threadId,
-                        });
-                    }
-                    catch (error) {
-                        options.sessionManager.failRun(parsed.runId);
-                        await options.onError?.({
-                            runId: parsed.runId,
-                            threadId: parsed.threadId,
-                            error,
-                        });
-                    }
-                })().catch(() => undefined);
-                scheduleDetachedTask(requestOrCtx, detachedTask);
-                return Response.json({
-                    accepted: true,
-                    duplicate: false,
-                    runId: parsed.runId,
-                    threadId: parsed.threadId,
-                }, { status: 202 });
-            }
-            catch (error) {
-                if (error instanceof RunAlreadyExistsError) {
-                    await options.onDuplicate?.({
-                        request: parsed,
-                        runId: parsed.runId,
-                        threadId: parsed.threadId,
-                    });
-                    return Response.json({
-                        accepted: true,
-                        duplicate: true,
-                        runId: parsed.runId,
-                        threadId: parsed.threadId,
-                    }, { status: 202 });
-                }
-                options.sessionManager.failRun(parsed.runId);
-                throw error;
-            }
+            return await executeAgUiDetachedStart(options, {
+                request: parsed,
+                rawRequest: request,
+                requestOrCtx,
+            });
         }
         catch (error) {
             if (error instanceof z.ZodError) {

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

@@ -0,0 +1,29 @@
+import { type RunResumeSessionManager } from "./runtime/index.js";
+import type { Agent } from "./types.js";
+import { type AgUiRuntimeRequest } from "./runtime-ag-ui-contract.js";
+type AgUiResumeValue = {
+    result: unknown;
+    isError: boolean;
+};
+export interface AgUiRuntimeHandlerExecuteInput {
+    request: Request;
+    agUiInput: AgUiRuntimeRequest;
+    context: Record<string, unknown>;
+    createDefaultResponse?: () => Promise<Response>;
+}
+export type AgUiRuntimeHandlerExecute = (input: AgUiRuntimeHandlerExecuteInput) => Promise<Response> | Response;
+export interface AgUiRuntimeHandlerOptions {
+    context?: Record<string, unknown> | ((request: Request) => Record<string, unknown> | Promise<Record<string, unknown>>);
+    sessionManager?: RunResumeSessionManager<AgUiResumeValue>;
+    execute?: AgUiRuntimeHandlerExecute;
+}
+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>;
+export {};
+//# sourceMappingURL=ag-ui-runtime-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ag-ui-runtime-handler.d.ts","sourceRoot":"","sources":["../../../src/src/agent/ag-ui-runtime-handler.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAEL,KAAK,kBAAkB,EAExB,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,eAAe,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AA2T7D,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,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,cAAc,CAAC,EAAE,uBAAuB,CAAC,eAAe,CAAC,CAAC;IAC1D,OAAO,CAAC,EAAE,yBAAyB,CAAC;CACrC;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,CA8E9C"}

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

@@ -0,0 +1,291 @@
+import { z } from "zod";
+import { INVALID_ARGUMENT } from "../errors/index.js";
+import { SKILL_TOOL_IDS } from "../skill/types.js";
+import { toolRegistry } from "../tool/index.js";
+import { AgentRuntime, RunAlreadyExistsError, } from "./runtime/index.js";
+import { parseAgUiRuntimeRequestOrError, } from "./runtime-ag-ui-contract.js";
+import { normalizeAgUiRuntimeMessages } from "./ag-ui-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 isRequest(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        "json" in obj &&
+        typeof obj.json === "function" &&
+        "url" in obj &&
+        typeof obj.url === "string" &&
+        "method" in obj &&
+        typeof obj.method === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractRequest(requestOrCtx) {
+    if (isRequest(requestOrCtx))
+        return requestOrCtx;
+    if (typeof requestOrCtx === "object" && requestOrCtx !== null && "request" in requestOrCtx) {
+        const candidate = requestOrCtx.request;
+        if (isRequest(candidate))
+            return candidate;
+    }
+    throw INVALID_ARGUMENT.create({
+        detail: "Invalid handler argument: expected Request or APIContext",
+    });
+}
+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) {
+    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,
+    });
+}
+function createInjectedAgUiTool(runId, tool, sessionManager) {
+    return {
+        id: tool.name,
+        type: "function",
+        description: tool.description ?? tool.name,
+        inputSchema: z.record(z.string(), z.unknown()),
+        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;
+        },
+    };
+}
+function buildMergedTools(agent, request, sessionManager) {
+    const injectedTools = Object.fromEntries(request.tools.map((tool) => [
+        tool.name,
+        createInjectedAgUiTool(request.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 };
+}
+async function createAgUiRuntimeInjectedToolsStreamResponse(agent, request, baseContext, sessionManager) {
+    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);
+        },
+        onError: () => {
+            sessionManager.failRun(request.runId);
+        },
+        onToolCallSeen: (toolCallId) => {
+            sessionManager.prepareForSignal(request.runId, 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 parsed = await parseAgUiRuntimeRequestOrError(request);
+            if (parsed instanceof Response) {
+                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;
+            if (config.execute) {
+                return await config.execute({
+                    request,
+                    agUiInput: parsed,
+                    context,
+                    createDefaultResponse,
+                });
+            }
+            if (createDefaultResponse) {
+                return await createDefaultResponse();
+            }
+            throw new Error("createAgUiRuntimeHandler configuration became invalid during execution.");
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return Response.json({
+                    error: "Invalid AG-UI runtime request",
+                    details: error.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=ag-ui-runtime-support.d.ts.map

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

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

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

@@ -0,0 +1,56 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseToolArguments(serializedArguments) {
+    try {
+        const parsed = JSON.parse(serializedArguments);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function normalizeAgUiRuntimeMessages(messages) {
+    return messages.map((message) => {
+        const parts = [];
+        switch (message.role) {
+            case "system":
+            case "user":
+                parts.push({ type: "text", text: message.content });
+                break;
+            case "assistant":
+                if (typeof message.content === "string" && message.content.length > 0) {
+                    parts.push({ type: "text", text: message.content });
+                }
+                for (const toolCall of message.toolCalls ?? []) {
+                    parts.push({
+                        type: "tool-call",
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.function.name,
+                        args: parseToolArguments(toolCall.function.arguments),
+                    });
+                }
+                break;
+            case "tool":
+                parts.push({
+                    type: "tool-result",
+                    toolCallId: message.toolCallId,
+                    toolName: "unknown",
+                    result: message.error
+                        ? {
+                            content: message.content,
+                            error: message.error,
+                        }
+                        : message.content,
+                });
+                break;
+        }
+        return {
+            id: message.id,
+            role: message.role,
+            parts,
+            ...(message.createdAt ? { timestamp: Date.parse(message.createdAt) || undefined } : {}),
+            ...(message.metadata ? { metadata: message.metadata } : {}),
+        };
+    });
+}

package/esm/src/agent/index.d.ts

@@ -84,11 +84,13 @@ export { getTextFromParts, getToolArguments, hasArgs, hasInput } from "./types.j
 export { BufferMemory, ConversationMemory, createMemory, createRedisMemory, type Memory, type MemoryPersistence, type MemoryStats, type RedisClient, RedisMemory, type RedisMemoryConfig, SummaryMemory, } from "./memory/index.js";
 export { agentAsTool, createWorkflow, getAgent, getAgentsAsTools, getAllAgentIds, registerAgent, type WorkflowConfig, type WorkflowResult, type WorkflowStep, } from "./composition/index.js";
 export { agent } from "./factory.js";
+export { type AgUiRuntimeHandlerConfig, type AgUiRuntimeHandlerConfigWithAgent, type AgUiRuntimeHandlerExecute, type AgUiRuntimeHandlerExecuteInput, type AgUiRuntimeHandlerOptions, createAgUiRuntimeHandler, } from "./ag-ui-runtime-handler.js";
 export { type AgUiRuntimeContextItem, AgUiRuntimeContextItemSchema, type AgUiRuntimeInjectedTool, AgUiRuntimeInjectedToolSchema, type AgUiRuntimeMessage, AgUiRuntimeMessageSchema, type AgUiRuntimeRequest, AgUiRuntimeRequestSchema, parseAgUiRuntimeRequest, parseAgUiRuntimeRequestOrError, } from "./runtime-ag-ui-contract.js";
+export { normalizeAgUiRuntimeMessages } from "./ag-ui-runtime-support.js";
 export { type AgUiBrowserEncodedEvent, type AgUiBrowserEncoderState, type AgUiBrowserRunFinishedMetadata, type AgUiRuntimeStreamEvent, createAgUiBrowserEncoderState, finalizeAgUiBrowserEvents, mapRuntimeStreamEventToAgUiBrowserEvents, } from "./ag-ui-browser-encoder.js";
 export { mergeToolCallInput, mergeToolInputDelta, parseDataStreamSseEvents, parseToolInputObject, streamDataStreamEvents, stripLeadingEmptyObjectPlaceholder, } from "./data-stream.js";
 export { expandAllowedRemoteToolNames, getProviderNativeToolNames, type ProviderNativeToolInventoryOptions, } from "./provider-native-tool-inventory.js";
-export { type AgUiDetachedStartAccepted, AgUiDetachedStartAcceptedSchema, type AgUiDetachedStartHandlerOptions, type AgUiDetachedStartRequest, AgUiDetachedStartRequestSchema, createAgUiDetachedStartHandler, } from "./ag-ui-detached-start.js";
+export { type AgUiDetachedStartAccepted, AgUiDetachedStartAcceptedSchema, type AgUiDetachedStartHandlerOptions, type AgUiDetachedStartRequest, AgUiDetachedStartRequestSchema, createAgUiDetachedStartHandler, executeAgUiDetachedStart, type ExecuteAgUiDetachedStartInput, } from "./ag-ui-detached-start.js";
 export { type AgUiCancelHandlerOptions, type AgUiResumeHandlerOptions, type AgUiResumeSignal, AgUiResumeSignalSchema, createAgUiCancelHandler, createAgUiResumeHandler, } from "./ag-ui-run-control.js";
 export { type AgUiSseEvent, createAgUiRunErrorEvent, createAgUiSseErrorResponse, normalizeAgUiMessages, parseAgUiRequest, parseAgUiRequestOrError, } from "./ag-ui-host-support.js";
 export { type AgUiContextItem, type AgUiHandlerConfigWithAgent, type AgUiHandlerOptions, type AgUiInjectedTool, type AgUiRequest, AgUiRequestSchema, createAgUiHandler, } from "./ag-ui-handler.js";