veryfront 0.1.516 → 0.1.518

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

@@ -0,0 +1,244 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { isResponseLike } from "../response-like.js";
+import { getAgent } from "../composition/index.js";
+import { AgentRuntime, RunAlreadyExistsError, } from "../runtime/index.js";
+import { createStreamTransformState, finalizeRunEvents, formatAgUiEvent, mapRuntimeEventToAgUi, } from "../../internal-agents/ag-ui-sse.js";
+import { streamDataStreamEvents } from "../data-stream.js";
+import { normalizeAgUiMessages, parseAgUiRequestOrError, } from "./host-support.js";
+import { extractRequest } from "./request-shared.js";
+import { buildMergedAgUiTools } from "./tool-shared.js";
+export { AgUiContextItemSchema, AgUiInjectedToolSchema, AgUiRequestSchema, } from "./host-support.js";
+const AG_UI_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+};
+function generateRunId() {
+    return `run_${dntShim.crypto.randomUUID().replaceAll("-", "")}`;
+}
+function buildStreamContext(request, baseContext, threadId, runId) {
+    return {
+        ...baseContext,
+        threadId,
+        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 createAgUiStreamResponse(options) {
+    const { agentId, request, runId, threadId, 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, threadId, agentId })) {
+                return;
+            }
+            if (!enqueueEvent(controller, "StateSnapshot", { snapshot: {} })) {
+                return;
+            }
+            if (!enqueueEvent(controller, "MessagesSnapshot", { messages: 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 createAgUiDirectStreamResponse(agent, request, baseContext) {
+    const threadId = request.threadId ?? dntShim.crypto.randomUUID();
+    const runId = request.runId ?? generateRunId();
+    await agent.clearMemory();
+    const result = await agent.stream({
+        messages: normalizeAgUiMessages(request.messages),
+        context: buildStreamContext(request, baseContext, threadId, runId),
+        ...(request.model ? { model: request.model } : {}),
+        ...(request.maxOutputTokens ? { maxOutputTokens: request.maxOutputTokens } : {}),
+    });
+    const upstream = result.toDataStreamResponse();
+    return await createAgUiStreamResponse({
+        agentId: agent.id,
+        request,
+        runId,
+        threadId,
+        upstreamBody: upstream.body,
+        upstreamStatus: upstream.status,
+        upstreamStatusText: upstream.statusText,
+    });
+}
+async function createAgUiInjectedToolsStreamResponse(agent, request, baseContext, sessionManager) {
+    const threadId = request.threadId ?? dntShim.crypto.randomUUID();
+    const runId = request.runId ?? generateRunId();
+    try {
+        sessionManager.startRun({ runId, 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: buildMergedAgUiTools(agent, runId, request.tools, sessionManager),
+    });
+    let upstreamBody;
+    try {
+        upstreamBody = await runtime.stream(normalizeAgUiMessages(request.messages), buildStreamContext(request, baseContext, threadId, runId), undefined, request.model, request.maxOutputTokens);
+    }
+    catch (error) {
+        sessionManager.failRun(runId);
+        throw error;
+    }
+    return await createAgUiStreamResponse({
+        agentId: agent.id,
+        request,
+        runId,
+        threadId,
+        upstreamBody,
+        upstreamStatus: 200,
+        onFinish: () => {
+            sessionManager.completeRun(runId);
+        },
+        onError: () => {
+            sessionManager.failRun(runId);
+        },
+        onToolCallSeen: (toolCallId) => {
+            sessionManager.prepareForSignal(runId, toolCallId);
+        },
+    });
+}
+function mergeConfig(config, options) {
+    if (!options)
+        return config;
+    return { ...options, ...config };
+}
+export function createAgUiHandler(agentIdOrConfig, options) {
+    return async function POST(requestOrCtx) {
+        const request = extractRequest(requestOrCtx);
+        let agent;
+        if (typeof agentIdOrConfig === "object" &&
+            agentIdOrConfig !== null &&
+            "agent" in agentIdOrConfig) {
+            const config = mergeConfig(agentIdOrConfig, options);
+            agent = config.agent;
+            options = config;
+        }
+        else {
+            const agentId = agentIdOrConfig;
+            try {
+                agent = getAgent(agentId);
+            }
+            catch {
+                return Response.json({ error: "Agent not found" }, { status: 404 });
+            }
+        }
+        if (!agent) {
+            return Response.json({ error: "Agent not found" }, { status: 404 });
+        }
+        try {
+            const parsed = await parseAgUiRequestOrError(request);
+            if (isResponseLike(parsed)) {
+                return parsed;
+            }
+            if (parsed.tools.length > 0) {
+                if (!options?.sessionManager) {
+                    return Response.json({
+                        error: "Injected AG-UI tools require a public RunResumeSessionManager on createAgUiHandler().",
+                    }, { status: 501 });
+                }
+                const context = typeof options?.context === "function"
+                    ? await options.context(request)
+                    : options?.context ?? {};
+                return await createAgUiInjectedToolsStreamResponse(agent, parsed, context, options.sessionManager);
+            }
+            const context = typeof options?.context === "function"
+                ? await options.context(request)
+                : options?.context ?? {};
+            return await createAgUiDirectStreamResponse(agent, parsed, context);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "issues" in error &&
+                Array.isArray(error.issues)) {
+                const issues = error.issues;
+                return Response.json({
+                    error: "Invalid AG-UI 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/host-support.d.ts

@@ -0,0 +1,131 @@
+import type { InferSchema } from "../../extensions/schema/index.js";
+import type { Message } from "../types.js";
+export interface AgUiSseEvent {
+    event: string;
+    payload: Record<string, unknown>;
+}
+export declare const getAgUiInjectedToolSchema: () => import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    name: import("../../internal-agents/schema.js").Schema<string>;
+    description: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    parameters: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+}>>;
+export declare const getAgUiContextItemSchema: () => import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"text">;
+    title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    text: import("../../internal-agents/schema.js").Schema<string>;
+}> | import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"json">;
+    title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    data: import("../../internal-agents/schema.js").Schema<Record<string, unknown>>;
+}> | import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"resource">;
+    title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    uri: import("../../internal-agents/schema.js").Schema<string>;
+    mimeType: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    text: import("../../internal-agents/schema.js").Schema<string | undefined>;
+}>>;
+export declare const getAgUiRequestSchema: () => import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    threadId: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    runId: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    messages: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+        id: import("../../internal-agents/schema.js").Schema<string>;
+        role: import("../../internal-agents/schema.js").Schema<string>;
+        parts: import("../../internal-agents/schema.js").Schema<({
+            type: string;
+        } & {} & Record<string, unknown>)[]>;
+        metadata: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+        createdAt: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    }>[]>;
+    tools: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+        name: import("../../internal-agents/schema.js").Schema<string>;
+        description: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        parameters: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+    }>[]>;
+    context: import("../../internal-agents/schema.js").Schema<(import("../../extensions/schema/schema-validator.js").InferShape<{
+        type: import("../../internal-agents/schema.js").Schema<"text">;
+        title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        text: import("../../internal-agents/schema.js").Schema<string>;
+    }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+        type: import("../../internal-agents/schema.js").Schema<"json">;
+        title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        data: import("../../internal-agents/schema.js").Schema<Record<string, unknown>>;
+    }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+        type: import("../../internal-agents/schema.js").Schema<"resource">;
+        title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        uri: import("../../internal-agents/schema.js").Schema<string>;
+        mimeType: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        text: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    }>)[]>;
+    forwardedProps: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+    model: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    maxOutputTokens: import("../../internal-agents/schema.js").Schema<number | undefined>;
+}>>;
+/** @deprecated Use getAgUiInjectedToolSchema() */
+export declare const AgUiInjectedToolSchema: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    name: import("../../internal-agents/schema.js").Schema<string>;
+    description: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    parameters: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+}>>;
+/** @deprecated Use getAgUiContextItemSchema() */
+export declare const AgUiContextItemSchema: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"text">;
+    title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    text: import("../../internal-agents/schema.js").Schema<string>;
+}> | import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"json">;
+    title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    data: import("../../internal-agents/schema.js").Schema<Record<string, unknown>>;
+}> | import("../../extensions/schema/schema-validator.js").InferShape<{
+    type: import("../../internal-agents/schema.js").Schema<"resource">;
+    title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    uri: import("../../internal-agents/schema.js").Schema<string>;
+    mimeType: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    text: import("../../internal-agents/schema.js").Schema<string | undefined>;
+}>>;
+/** @deprecated Use getAgUiRequestSchema() */
+export declare const AgUiRequestSchema: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+    threadId: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    runId: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    messages: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+        id: import("../../internal-agents/schema.js").Schema<string>;
+        role: import("../../internal-agents/schema.js").Schema<string>;
+        parts: import("../../internal-agents/schema.js").Schema<({
+            type: string;
+        } & {} & Record<string, unknown>)[]>;
+        metadata: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+        createdAt: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    }>[]>;
+    tools: import("../../internal-agents/schema.js").Schema<import("../../extensions/schema/schema-validator.js").InferShape<{
+        name: import("../../internal-agents/schema.js").Schema<string>;
+        description: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        parameters: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+    }>[]>;
+    context: import("../../internal-agents/schema.js").Schema<(import("../../extensions/schema/schema-validator.js").InferShape<{
+        type: import("../../internal-agents/schema.js").Schema<"text">;
+        title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        text: import("../../internal-agents/schema.js").Schema<string>;
+    }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+        type: import("../../internal-agents/schema.js").Schema<"json">;
+        title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        data: import("../../internal-agents/schema.js").Schema<Record<string, unknown>>;
+    }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+        type: import("../../internal-agents/schema.js").Schema<"resource">;
+        title: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        uri: import("../../internal-agents/schema.js").Schema<string>;
+        mimeType: import("../../internal-agents/schema.js").Schema<string | undefined>;
+        text: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    }>)[]>;
+    forwardedProps: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
+    model: import("../../internal-agents/schema.js").Schema<string | undefined>;
+    maxOutputTokens: import("../../internal-agents/schema.js").Schema<number | undefined>;
+}>>;
+export type AgUiInjectedTool = InferSchema<ReturnType<typeof getAgUiInjectedToolSchema>>;
+export type AgUiContextItem = InferSchema<ReturnType<typeof getAgUiContextItemSchema>>;
+export type AgUiRequest = InferSchema<ReturnType<typeof getAgUiRequestSchema>>;
+export declare function parseAgUiRequest(request: Request): Promise<AgUiRequest>;
+export declare function parseAgUiRequestOrError(request: Request): Promise<AgUiRequest | Response>;
+export declare function normalizeAgUiMessages(messages: AgUiRequest["messages"]): Message[];
+export declare function createAgUiRunErrorEvent(message: string, code?: string): AgUiSseEvent;
+export declare function createAgUiSseErrorResponse(event: AgUiSseEvent, status: number): Response;
+export declare function createAgUiSseResponse(stream: ReadableStream<Uint8Array>): Response;
+//# sourceMappingURL=host-support.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"host-support.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/host-support.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAa3C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAgBD,eAAO,MAAM,yBAAyB;;;;GASrC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;GAuBpC,CAAC;AAgBF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBhC,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,sBAAsB;;;;GAA8B,CAAC;AAClE,iDAAiD;AACjD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;GAA6B,CAAC;AAChE,6CAA6C;AAC7C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyB,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC;AACzF,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC;AACvF,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;AA0E/E,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAE7E;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,WAAW,GAAG,QAAQ,CAAC,CAKjC;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,OAAO,EAAE,CAUlF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,YAAY,CAQpF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAUxF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,QAAQ,CASlF"}

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

@@ -0,0 +1,179 @@
+import { defineSchema } from "../../schemas/index.js";
+import { formatAgUiEvent } from "../../internal-agents/ag-ui-sse.js";
+import { parseAgUiJsonRequestOrError } from "./request-shared.js";
+const AGENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const MAX_TOOL_PARAMETERS_BYTES = 16_384;
+const MAX_CONTEXT_ITEM_BYTES = 16_384;
+const MAX_CONTEXT_TOTAL_BYTES = 65_536;
+const MAX_FORWARDED_PROPS_BYTES = 65_536;
+const MAX_TEXT_PART_LENGTH = 10_000;
+const MAX_MESSAGES_PER_REQUEST = 100;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function isWithinJsonSizeLimit(value, maxBytes) {
+    try {
+        return encoder.encode(JSON.stringify(value)).byteLength <= maxBytes;
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const getAgUiRunIdSchema = defineSchema((v) => v.string().min(1).max(128).regex(AGENT_ID_PATTERN));
+export const getAgUiInjectedToolSchema = defineSchema((v) => v.object({
+    name: v.string().min(1).max(128),
+    description: v.string().max(1024).optional(),
+    parameters: v.record(v.string(), v.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES), { message: "Tool parameters must be less than 16 KB" }),
+}));
+export const getAgUiContextItemSchema = defineSchema((v) => v.discriminatedUnion("type", [
+    v.object({
+        type: v.literal("text"),
+        title: v.string().max(256).optional(),
+        text: v.string().max(MAX_CONTEXT_ITEM_BYTES),
+    }),
+    v.object({
+        type: v.literal("json"),
+        title: v.string().max(256).optional(),
+        data: v.record(v.string(), v.unknown()).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES), { message: "JSON context item must be less than 16 KB" }),
+    }),
+    v.object({
+        type: v.literal("resource"),
+        title: v.string().max(256).optional(),
+        uri: v.string().max(2048),
+        mimeType: v.string().max(256).optional(),
+        text: v.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
+    }),
+]));
+const getAgUiMessagePartSchema = defineSchema((v) => v.object({ type: v.string().min(1) }).passthrough());
+const getAgUiMessageSchema = defineSchema((v) => v.object({
+    id: v.string().min(1),
+    role: v.enum(["user", "assistant", "system", "tool"]),
+    parts: v.array(getAgUiMessagePartSchema()).default([]),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+    createdAt: v.string().optional(),
+}));
+export const getAgUiRequestSchema = defineSchema((v) => v.object({
+    threadId: v.string().uuid().optional(),
+    runId: getAgUiRunIdSchema().optional(),
+    messages: v.array(getAgUiMessageSchema()).min(1).max(MAX_MESSAGES_PER_REQUEST),
+    tools: v.array(getAgUiInjectedToolSchema()).max(50).default([]),
+    context: v.array(getAgUiContextItemSchema()).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
+    forwardedProps: v.record(v.string(), v.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES), { message: "forwardedProps must be less than 64 KB" }),
+    model: v.string().optional(),
+    maxOutputTokens: v.number().int().positive().optional(),
+}));
+/** @deprecated Use getAgUiInjectedToolSchema() */
+export const AgUiInjectedToolSchema = getAgUiInjectedToolSchema();
+/** @deprecated Use getAgUiContextItemSchema() */
+export const AgUiContextItemSchema = getAgUiContextItemSchema();
+/** @deprecated Use getAgUiRequestSchema() */
+export const AgUiRequestSchema = getAgUiRequestSchema();
+function normalizeToolArgs(part) {
+    if (isRecord(part.args))
+        return part.args;
+    if (isRecord(part.input))
+        return part.input;
+    return {};
+}
+function normalizeMessagePart(part) {
+    if (part.type === "text" && typeof part.text === "string" &&
+        part.text.length <= MAX_TEXT_PART_LENGTH) {
+        return { type: "text", text: part.text };
+    }
+    if (part.type === "tool_call" && typeof part.id === "string" && typeof part.name === "string") {
+        return {
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: part.name,
+            args: normalizeToolArgs(part),
+        };
+    }
+    if (part.type === "tool-call" &&
+        typeof part.toolCallId === "string" &&
+        typeof part.toolName === "string") {
+        return {
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            args: normalizeToolArgs(part),
+        };
+    }
+    if (typeof part.type === "string" &&
+        part.type.startsWith("tool-") &&
+        part.type !== "tool-result" &&
+        typeof part.toolCallId === "string" &&
+        typeof part.toolName === "string") {
+        return {
+            type: part.type,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            args: normalizeToolArgs(part),
+        };
+    }
+    if (part.type === "tool_result" && typeof part.tool_call_id === "string") {
+        return {
+            type: "tool-result",
+            toolCallId: part.tool_call_id,
+            toolName: typeof part.tool_name === "string" ? part.tool_name : "unknown",
+            result: "output" in part ? part.output : undefined,
+        };
+    }
+    if (part.type === "tool-result" && typeof part.toolCallId === "string") {
+        return {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: typeof part.toolName === "string" ? part.toolName : "unknown",
+            result: "result" in part ? part.result : undefined,
+        };
+    }
+    return null;
+}
+export async function parseAgUiRequest(request) {
+    return getAgUiRequestSchema().parse(await request.json());
+}
+export async function parseAgUiRequestOrError(request) {
+    return await parseAgUiJsonRequestOrError(() => parseAgUiRequest(request), "Invalid AG-UI request");
+}
+export function normalizeAgUiMessages(messages) {
+    return messages.map((message) => ({
+        id: message.id,
+        role: message.role,
+        parts: message.parts
+            .map((part) => normalizeMessagePart(part))
+            .filter((part) => part !== null),
+        ...(message.createdAt ? { timestamp: Date.parse(message.createdAt) || undefined } : {}),
+        ...(message.metadata ? { metadata: message.metadata } : {}),
+    }));
+}
+export function createAgUiRunErrorEvent(message, code) {
+    return {
+        event: "RunError",
+        payload: {
+            message,
+            ...(code ? { code } : {}),
+        },
+    };
+}
+export function createAgUiSseErrorResponse(event, status) {
+    return new Response(decoder.decode(formatAgUiEvent(event.event, event.payload)), {
+        status,
+        headers: {
+            "Content-Type": "text/event-stream; charset=utf-8",
+            "Cache-Control": "no-cache, no-transform",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    });
+}
+export function createAgUiSseResponse(stream) {
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "text/event-stream; charset=utf-8",
+            "Cache-Control": "no-cache, no-transform",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    });
+}

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

@@ -0,0 +1,4 @@
+export declare function isRequest(value: unknown): value is Request;
+export declare function extractRequest(requestOrCtx: unknown): Request;
+export declare function parseAgUiJsonRequestOrError<T>(parseRequest: () => Promise<T>, errorLabel: string): Promise<T | Response>;
+//# sourceMappingURL=request-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request-shared.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/ag-ui/request-shared.ts"],"names":[],"mappings":"AAiBA,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAW1D;AAED,wBAAgB,cAAc,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAW7D;AAED,wBAAsB,2BAA2B,CAAC,CAAC,EACjD,YAAY,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC9B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,GAAG,QAAQ,CAAC,CA6BvB"}

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

@@ -0,0 +1,56 @@
+import { INVALID_ARGUMENT } from "../../errors/index.js";
+/**
+ * Detects a validation error thrown by a `Schema.parse()` call. Works with
+ * both the contract-DSL adapter (ext-zod wraps `ZodError` and sets `issues`)
+ * and raw zod errors.
+ */
+function isSchemaValidationError(error) {
+    return (error instanceof Error &&
+        "issues" in error &&
+        Array.isArray(error.issues));
+}
+export function isRequest(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "json" in value &&
+        typeof value.json === "function" &&
+        "url" in value &&
+        typeof value.url === "string" &&
+        "method" in value &&
+        typeof value.method === "string");
+}
+export 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",
+    });
+}
+export async function parseAgUiJsonRequestOrError(parseRequest, errorLabel) {
+    try {
+        return await parseRequest();
+    }
+    catch (error) {
+        if (isSchemaValidationError(error)) {
+            return Response.json({
+                error: errorLabel,
+                details: error.issues.map((issue) => ({
+                    path: issue.path,
+                    message: issue.message,
+                })),
+            }, { status: 400 });
+        }
+        if (error instanceof SyntaxError || error instanceof TypeError) {
+            return Response.json({
+                error: errorLabel,
+                details: [{ path: [], message: "Malformed JSON request body" }],
+            }, { status: 400 });
+        }
+        throw error;
+    }
+}