veryfront 0.1.64 → 0.1.65

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

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

package/esm/src/internal-agents/schema.d.ts

@@ -0,0 +1,268 @@
+import { z } from "zod";
+export declare const RunIdSchema: z.ZodString;
+export declare const AgentIdSchema: z.ZodString;
+export declare const StudioToolNameSchema: z.ZodString;
+export declare const RuntimeInjectedToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodEffects<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+    parameters?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    parameters?: Record<string, unknown> | undefined;
+}>;
+export declare const RuntimeContextItemSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    title: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    text: string;
+    title?: string | undefined;
+}, {
+    type: "text";
+    text: string;
+    title?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"json">;
+    title: z.ZodOptional<z.ZodString>;
+    data: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "json";
+    data: Record<string, unknown>;
+    title?: string | undefined;
+}, {
+    type: "json";
+    data: Record<string, unknown>;
+    title?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resource">;
+    title: z.ZodOptional<z.ZodString>;
+    uri: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "resource";
+    uri: string;
+    title?: string | undefined;
+    text?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "resource";
+    uri: string;
+    title?: string | undefined;
+    text?: string | undefined;
+    mimeType?: string | undefined;
+}>]>;
+export declare const RuntimeRunAgentInputSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    threadId: z.ZodString;
+    runId: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<["user", "assistant", "system", "tool"]>;
+        parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>, "many">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        role: "tool" | "user" | "assistant" | "system";
+        parts: z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+    }, {
+        id: string;
+        role: "tool" | "user" | "assistant" | "system";
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        parts?: z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[] | undefined;
+    }>, "many">;
+    tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodEffects<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    context: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        title: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+        title?: string | undefined;
+    }, {
+        type: "text";
+        text: string;
+        title?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        title: z.ZodOptional<z.ZodString>;
+        data: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "json";
+        data: Record<string, unknown>;
+        title?: string | undefined;
+    }, {
+        type: "json";
+        data: Record<string, unknown>;
+        title?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        title: z.ZodOptional<z.ZodString>;
+        uri: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "resource";
+        uri: string;
+        title?: string | undefined;
+        text?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        type: "resource";
+        uri: string;
+        title?: string | undefined;
+        text?: string | undefined;
+        mimeType?: string | undefined;
+    }>]>, "many">>, ({
+        type: "text";
+        text: string;
+        title?: string | undefined;
+    } | {
+        type: "json";
+        data: Record<string, unknown>;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        uri: string;
+        title?: string | undefined;
+        text?: string | undefined;
+        mimeType?: string | undefined;
+    })[], ({
+        type: "text";
+        text: string;
+        title?: string | undefined;
+    } | {
+        type: "json";
+        data: Record<string, unknown>;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        uri: string;
+        title?: string | undefined;
+        text?: string | undefined;
+        mimeType?: string | undefined;
+    })[] | undefined>;
+    forwardedProps: z.ZodEffects<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+}, "strip", z.ZodTypeAny, {
+    context: ({
+        type: "text";
+        text: string;
+        title?: string | undefined;
+    } | {
+        type: "json";
+        data: Record<string, unknown>;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        uri: string;
+        title?: string | undefined;
+        text?: string | undefined;
+        mimeType?: string | undefined;
+    })[];
+    tools: {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    }[];
+    agentId: string;
+    messages: {
+        id: string;
+        role: "tool" | "user" | "assistant" | "system";
+        parts: z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+    }[];
+    runId: string;
+    threadId: string;
+    forwardedProps?: Record<string, unknown> | undefined;
+}, {
+    agentId: string;
+    messages: {
+        id: string;
+        role: "tool" | "user" | "assistant" | "system";
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        parts?: z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[] | undefined;
+    }[];
+    runId: string;
+    threadId: string;
+    context?: ({
+        type: "text";
+        text: string;
+        title?: string | undefined;
+    } | {
+        type: "json";
+        data: Record<string, unknown>;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        uri: string;
+        title?: string | undefined;
+        text?: string | undefined;
+        mimeType?: string | undefined;
+    })[] | undefined;
+    tools?: {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    }[] | undefined;
+    forwardedProps?: Record<string, unknown> | undefined;
+}>;
+export declare const ResumeSignalSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    toolCallId: z.ZodString;
+    result: z.ZodEffects<z.ZodUnknown, unknown, unknown>;
+    isError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_result";
+    toolCallId: string;
+    isError: boolean;
+    result?: unknown;
+}, {
+    type: "tool_result";
+    toolCallId: string;
+    result?: unknown;
+    isError?: boolean | undefined;
+}>]>;
+export type RuntimeInjectedTool = z.infer<typeof RuntimeInjectedToolSchema>;
+export type RuntimeContextItem = z.infer<typeof RuntimeContextItemSchema>;
+export type RuntimeRunAgentInput = z.infer<typeof RuntimeRunAgentInputSchema>;
+export type ResumeSignal = z.infer<typeof ResumeSignalSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/esm/src/internal-agents/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,WAAW,aAAqD,CAAC;AAE9E,eAAO,MAAM,aAAa,aAAqD,CAAC;AAEhF,eAAO,MAAM,oBAAoB,aAI2C,CAAC;AAE7E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAOpC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBnC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBrC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;IAU7B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/esm/src/internal-agents/schema.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+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_TOOL_RESULT_BYTES = 65_536;
+const MAX_RUNTIME_MESSAGES = 100;
+const encoder = new TextEncoder();
+function isWithinJsonSizeLimit(value, maxBytes) {
+    try {
+        return encoder.encode(JSON.stringify(value)).byteLength <= maxBytes;
+    }
+    catch {
+        return false;
+    }
+}
+export const RunIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
+export const AgentIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
+export const StudioToolNameSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^studio_[a-zA-Z0-9_]+$/, "Tool names must use the studio_ prefix");
+export const RuntimeInjectedToolSchema = z.object({
+    name: StudioToolNameSchema,
+    description: z.string().max(1024).optional(),
+    parameters: z.record(z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES), { message: "Tool parameters must be less than 16 KB" }),
+});
+export const RuntimeContextItemSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        title: z.string().max(256).optional(),
+        text: z.string().max(MAX_CONTEXT_ITEM_BYTES),
+    }),
+    z.object({
+        type: z.literal("json"),
+        title: z.string().max(256).optional(),
+        data: z.record(z.unknown()).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES), { message: "JSON context item must be less than 16 KB" }),
+    }),
+    z.object({
+        type: z.literal("resource"),
+        title: z.string().max(256).optional(),
+        uri: z.string().max(2048),
+        mimeType: z.string().max(256).optional(),
+        text: z.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
+    }),
+]);
+export const RuntimeRunAgentInputSchema = z.object({
+    agentId: AgentIdSchema,
+    threadId: z.string().uuid(),
+    runId: RunIdSchema,
+    messages: z.array(z.object({
+        id: z.string().min(1),
+        role: z.enum(["user", "assistant", "system", "tool"]),
+        parts: z.array(z.object({ type: z.string().min(1) }).passthrough()).default([]),
+        metadata: z.record(z.unknown()).optional(),
+        createdAt: z.string().optional(),
+    })).max(MAX_RUNTIME_MESSAGES),
+    tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
+    context: z.array(RuntimeContextItemSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
+    forwardedProps: z.record(z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES), { message: "forwardedProps must be less than 64 KB" }),
+});
+export const ResumeSignalSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("tool_result"),
+        toolCallId: z.string().min(1).max(128),
+        result: z.unknown().refine((value) => isWithinJsonSizeLimit(value, MAX_TOOL_RESULT_BYTES), { message: "Tool result must be less than 64 KB" }),
+        isError: z.boolean().optional().default(false),
+    }),
+]);

package/esm/src/internal-agents/session-manager.d.ts

@@ -0,0 +1,63 @@
+import * as dntShim from "../../_dnt.shims.js";
+export declare class AgentRunCancelledError extends Error {
+    constructor(message?: string);
+}
+export declare class AgentRunAlreadyExistsError extends Error {
+    constructor(runId: string);
+}
+export declare class RunNotActiveError extends Error {
+    constructor(runId: string);
+}
+export declare class ToolResultNotWaitingError extends Error {
+    constructor(runId: string, toolCallId: string);
+}
+export declare class ToolResultConflictError extends Error {
+    constructor(runId: string, toolCallId: string);
+}
+type SessionStatus = "running" | "waiting" | "completed" | "cancelled" | "failed";
+export interface SubmitToolResultOutcome {
+    accepted: true;
+    duplicate?: true;
+}
+export declare class AgentRunSessionManager {
+    private readonly options;
+    private readonly sessions;
+    constructor(options?: {
+        waitingForToolTtlMs?: number;
+        sessionTtlMs?: number | null;
+        maxConcurrentSessions?: number;
+        setTimeoutFn?: typeof dntShim.setTimeout;
+        clearTimeoutFn?: typeof clearTimeout;
+    });
+    private get waitingForToolTtlMs();
+    private get sessionTtlMs();
+    private get setTimeoutFn();
+    private get clearTimeoutFn();
+    private clearWaitingTimeout;
+    private clearSessionTimeout;
+    private scheduleSessionTimeout;
+    private scheduleWaitingTimeout;
+    private touchSession;
+    private get maxConcurrentSessions();
+    startRun(input: {
+        runId: string;
+        threadId: string;
+    }): AbortSignal;
+    waitForToolResult(runId: string, toolCallId: string): Promise<{
+        result: unknown;
+        isError: boolean;
+    }>;
+    submitToolResult(runId: string, input: {
+        toolCallId: string;
+        result: unknown;
+        isError?: boolean;
+    }): SubmitToolResultOutcome;
+    cancelRun(runId: string): boolean;
+    completeRun(runId: string): void;
+    failRun(runId: string): void;
+    getRunStatus(runId: string): SessionStatus | null;
+    reset(): void;
+}
+export declare const agentRunSessionManager: AgentRunSessionManager;
+export {};
+//# sourceMappingURL=session-manager.d.ts.map

package/esm/src/internal-agents/session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/session-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAyB/C,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,SAAkB;CAItC;AAED,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,KAAK,EAAE,MAAM;CAI1B;AAED,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,KAAK,EAAE,MAAM;CAI1B;AAED,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI9C;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI9C;AAMD,KAAK,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,QAAQ,CAAC;AA0BlF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,IAAI,CAAC;IACf,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;gBAG5C,OAAO,GAAE;QACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC7B,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,YAAY,CAAC,EAAE,OAAO,OAAO,CAAC,UAAU,CAAC;QACzC,cAAc,CAAC,EAAE,OAAO,YAAY,CAAC;KACjC;IAGR,OAAO,KAAK,mBAAmB,GAE9B;IAED,OAAO,KAAK,YAAY,GAEvB;IAED,OAAO,KAAK,YAAY,GAEvB;IAED,OAAO,KAAK,cAAc,GAEzB;IAED,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,YAAY;IAQpB,OAAO,KAAK,qBAAqB,GAEhC;IAED,QAAQ,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW;IA4B3D,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;QAClE,MAAM,EAAE,OAAO,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;IAsDF,gBAAgB,CACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAChE,uBAAuB;IAuC1B,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAuBjC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAUhC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAU5B,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAIjD,KAAK,IAAI,IAAI;CAOd;AAED,eAAO,MAAM,sBAAsB,wBAEjC,CAAC"}