veryfront 0.1.63 → 0.1.65

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"}

package/esm/src/internal-agents/session-manager.js

@@ -0,0 +1,258 @@
+import * as dntShim from "../../_dnt.shims.js";
+function stableJsonStringify(value, depth = 0) {
+    if (depth > 64) {
+        return JSON.stringify(value);
+    }
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableJsonStringify(item, depth + 1)).join(",")}]`;
+    }
+    const entries = Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableJsonStringify(item, depth + 1)}`);
+    return `{${entries.join(",")}}`;
+}
+function createToolResultKey(result, isError) {
+    return `${isError ? "1" : "0"}:${stableJsonStringify(result)}`;
+}
+export class AgentRunCancelledError extends Error {
+    constructor(message = "Run cancelled") {
+        super(message);
+        this.name = "AgentRunCancelledError";
+    }
+}
+export class AgentRunAlreadyExistsError extends Error {
+    constructor(runId) {
+        super(`Run "${runId}" is already active`);
+        this.name = "AgentRunAlreadyExistsError";
+    }
+}
+export class RunNotActiveError extends Error {
+    constructor(runId) {
+        super(`Run "${runId}" is not active`);
+        this.name = "RunNotActiveError";
+    }
+}
+export class ToolResultNotWaitingError extends Error {
+    constructor(runId, toolCallId) {
+        super(`Run "${runId}" is not waiting for tool call "${toolCallId}"`);
+        this.name = "ToolResultNotWaitingError";
+    }
+}
+export class ToolResultConflictError extends Error {
+    constructor(runId, toolCallId) {
+        super(`Conflicting tool result for run "${runId}" and tool call "${toolCallId}"`);
+        this.name = "ToolResultConflictError";
+    }
+}
+const DEFAULT_WAITING_FOR_TOOL_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_SESSION_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_MAX_CONCURRENT_SESSIONS = 100;
+export class AgentRunSessionManager {
+    options;
+    sessions = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get waitingForToolTtlMs() {
+        return this.options.waitingForToolTtlMs ?? DEFAULT_WAITING_FOR_TOOL_TTL_MS;
+    }
+    get sessionTtlMs() {
+        return this.options.sessionTtlMs ?? null;
+    }
+    get setTimeoutFn() {
+        return this.options.setTimeoutFn ?? dntShim.dntGlobalThis.setTimeout.bind(dntShim.dntGlobalThis);
+    }
+    get clearTimeoutFn() {
+        return this.options.clearTimeoutFn ?? globalThis.clearTimeout.bind(dntShim.dntGlobalThis);
+    }
+    clearWaitingTimeout(session) {
+        if (session.waitingTimeoutId === null) {
+            return;
+        }
+        this.clearTimeoutFn(session.waitingTimeoutId);
+        session.waitingTimeoutId = null;
+    }
+    clearSessionTimeout(session) {
+        if (session.sessionTimeoutId === null) {
+            return;
+        }
+        this.clearTimeoutFn(session.sessionTimeoutId);
+        session.sessionTimeoutId = null;
+    }
+    scheduleSessionTimeout(session) {
+        if (this.sessionTtlMs === null) {
+            return;
+        }
+        this.clearSessionTimeout(session);
+        session.sessionTimeoutId = this.setTimeoutFn(() => {
+            this.cancelRun(session.runId);
+        }, this.sessionTtlMs);
+    }
+    scheduleWaitingTimeout(session) {
+        this.clearWaitingTimeout(session);
+        session.waitingTimeoutId = this.setTimeoutFn(() => {
+            this.cancelRun(session.runId);
+        }, this.waitingForToolTtlMs);
+    }
+    touchSession(session) {
+        if (session.status === "running" || session.status === "waiting") {
+            this.scheduleSessionTimeout(session);
+        }
+    }
+    get maxConcurrentSessions() {
+        return this.options.maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
+    }
+    startRun(input) {
+        const existing = this.sessions.get(input.runId);
+        if (existing && (existing.status === "running" || existing.status === "waiting")) {
+            throw new AgentRunAlreadyExistsError(input.runId);
+        }
+        if (this.sessions.size >= this.maxConcurrentSessions) {
+            throw new Error(`Maximum concurrent sessions (${this.maxConcurrentSessions}) reached`);
+        }
+        const session = {
+            runId: input.runId,
+            threadId: input.threadId,
+            status: "running",
+            abortController: new AbortController(),
+            waitingTool: null,
+            submittedResults: new Map(),
+            waitingTimeoutId: null,
+            sessionTimeoutId: null,
+        };
+        this.sessions.set(input.runId, session);
+        this.touchSession(session);
+        return session.abortController.signal;
+    }
+    async waitForToolResult(runId, toolCallId) {
+        const session = this.sessions.get(runId);
+        if (!session || session.status === "completed" || session.status === "failed") {
+            throw new RunNotActiveError(runId);
+        }
+        if (session.abortController.signal.aborted || session.status === "cancelled") {
+            throw new AgentRunCancelledError();
+        }
+        const existingResult = session.submittedResults.get(toolCallId);
+        if (existingResult) {
+            session.status = "running";
+            this.touchSession(session);
+            return { result: existingResult.result, isError: existingResult.isError };
+        }
+        if (session.waitingTool && session.waitingTool.toolCallId !== toolCallId) {
+            throw new ToolResultNotWaitingError(runId, toolCallId);
+        }
+        session.status = "waiting";
+        this.scheduleWaitingTimeout(session);
+        this.touchSession(session);
+        return await new Promise((resolve, reject) => {
+            const abortHandler = () => {
+                this.clearWaitingTimeout(session);
+                session.waitingTool = null;
+                session.status = "cancelled";
+                reject(new AgentRunCancelledError());
+            };
+            session.abortController.signal.addEventListener("abort", abortHandler, { once: true });
+            session.waitingTool = {
+                toolCallId,
+                resolve: (value) => {
+                    session.abortController.signal.removeEventListener("abort", abortHandler);
+                    this.clearWaitingTimeout(session);
+                    session.waitingTool = null;
+                    session.status = "running";
+                    this.touchSession(session);
+                    resolve({ result: value.result, isError: value.isError });
+                },
+                reject: (reason) => {
+                    session.abortController.signal.removeEventListener("abort", abortHandler);
+                    this.clearWaitingTimeout(session);
+                    session.waitingTool = null;
+                    reject(reason);
+                },
+            };
+        });
+    }
+    submitToolResult(runId, input) {
+        const session = this.sessions.get(runId);
+        if (!session) {
+            throw new RunNotActiveError(runId);
+        }
+        const normalized = {
+            toolCallId: input.toolCallId,
+            result: input.result,
+            isError: Boolean(input.isError),
+            key: createToolResultKey(input.result, Boolean(input.isError)),
+        };
+        const existingResult = session.submittedResults.get(input.toolCallId);
+        if (existingResult) {
+            if (existingResult.key === normalized.key) {
+                return { accepted: true, duplicate: true };
+            }
+            throw new ToolResultConflictError(runId, input.toolCallId);
+        }
+        if (session.status === "completed" || session.status === "failed" ||
+            session.status === "cancelled") {
+            throw new RunNotActiveError(runId);
+        }
+        if (!session.waitingTool || session.waitingTool.toolCallId !== input.toolCallId) {
+            throw new ToolResultNotWaitingError(runId, input.toolCallId);
+        }
+        session.submittedResults.set(input.toolCallId, normalized);
+        this.touchSession(session);
+        session.waitingTool.resolve(normalized);
+        return { accepted: true };
+    }
+    cancelRun(runId) {
+        const session = this.sessions.get(runId);
+        if (!session) {
+            return false;
+        }
+        if (session.status === "completed" || session.status === "failed" ||
+            session.status === "cancelled") {
+            return false;
+        }
+        session.status = "cancelled";
+        this.clearWaitingTimeout(session);
+        this.clearSessionTimeout(session);
+        session.abortController.abort(new AgentRunCancelledError());
+        session.waitingTool?.reject(new AgentRunCancelledError());
+        session.waitingTool = null;
+        this.sessions.delete(runId);
+        return true;
+    }
+    completeRun(runId) {
+        const session = this.sessions.get(runId);
+        if (!session)
+            return;
+        session.status = "completed";
+        this.clearWaitingTimeout(session);
+        this.clearSessionTimeout(session);
+        session.waitingTool = null;
+        this.sessions.delete(runId);
+    }
+    failRun(runId) {
+        const session = this.sessions.get(runId);
+        if (!session)
+            return;
+        session.status = "failed";
+        this.clearWaitingTimeout(session);
+        this.clearSessionTimeout(session);
+        session.waitingTool = null;
+        this.sessions.delete(runId);
+    }
+    getRunStatus(runId) {
+        return this.sessions.get(runId)?.status ?? null;
+    }
+    reset() {
+        for (const session of this.sessions.values()) {
+            this.clearWaitingTimeout(session);
+            this.clearSessionTimeout(session);
+        }
+        this.sessions.clear();
+    }
+}
+export const agentRunSessionManager = new AgentRunSessionManager({
+    sessionTtlMs: DEFAULT_SESSION_TTL_MS,
+});

package/esm/src/platform/adapters/runtime/deno/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/deno/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAGxD,OAAO,KAAK,EACV,QAAQ,EACR,kBAAkB,EAElB,QAAQ,EACR,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,YAAY,EACZ,MAAM,EACN,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAoHvB,cAAM,qBAAsB,YAAW,iBAAiB;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAKhD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWrC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC;IAY/C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYrC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKtE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKlD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,WAAW;CAuErE;AAED,cAAM,sBAAuB,YAAW,kBAAkB;IACxD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKpC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IASrC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAInC;AAED,cAAM,iBAAkB,YAAW,aAAa;IAC9C,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,gBAAgB;CAS7D;AAED,cAAM,gBAAiB,YAAW,YAAY;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE;IAejE,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAanC;AAwBD,qBAAa,WAAY,YAAW,cAAc;IAChD,QAAQ,CAAC,EAAE,EAAG,MAAM,CAAU;IAC9B,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,EAAE,wBAA+B;IAC1C,QAAQ,CAAC,GAAG,yBAAgC;IAC5C,QAAQ,CAAC,MAAM,oBAA2B;IAC1C,QAAQ,CAAC,KAAK,mBAA0B;IAExC,QAAQ,CAAC,YAAY;;;;;;;;;;MAUnB;IAEF,OAAO,CAAC,YAAY,CAA2B;IAE/C,KAAK,CACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,EACnF,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,MAAM,CAAC;IAuEZ,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC;AAED,eAAO,MAAM,WAAW,aAAoB,CAAC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/deno/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAGxD,OAAO,KAAK,EACV,QAAQ,EACR,kBAAkB,EAElB,QAAQ,EACR,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,YAAY,EACZ,MAAM,EACN,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAyHvB,cAAM,qBAAsB,YAAW,iBAAiB;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAKhD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWrC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC;IAY/C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYrC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKtE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKlD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,WAAW;CAuErE;AAED,cAAM,sBAAuB,YAAW,kBAAkB;IACxD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIrC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGnC;AAED,cAAM,iBAAkB,YAAW,aAAa;IAC9C,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,gBAAgB;CAS7D;AAED,cAAM,gBAAiB,YAAW,YAAY;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE;IAejE,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAanC;AAwBD,qBAAa,WAAY,YAAW,cAAc;IAChD,QAAQ,CAAC,EAAE,EAAG,MAAM,CAAU;IAC9B,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,EAAE,wBAA+B;IAC1C,QAAQ,CAAC,GAAG,yBAAgC;IAC5C,QAAQ,CAAC,MAAM,oBAA2B;IAC1C,QAAQ,CAAC,KAAK,mBAA0B;IAExC,QAAQ,CAAC,YAAY;;;;;;;;;;MAUnB;IAEF,OAAO,CAAC,YAAY,CAA2B;IAE/C,KAAK,CACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,EACnF,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,MAAM,CAAC;IAuEZ,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC;AAED,eAAO,MAAM,WAAW,aAAoB,CAAC"}