experimental-agent 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,392 +1,50 @@
-import * as _vercel_sandbox from '@vercel/sandbox';
-import { S as SandboxBinding, a as SandboxSetupFields, b as SandboxInstance, W as WithConfig, c as LoggingConfig, E as ExecResult, U as UploadableFile } from './steps-DShnXBLf.js';
-export { d as SandboxAgentRef } from './steps-DShnXBLf.js';
-import { L as LocalBindingConfig, a as LocalBindingMetadata, V as VercelBindingConfig, b as VercelBindingMetadata, D as DockerBindingConfig, c as DockerBindingMetadata } from './entry-BrWOmEK2.js';
+import { T as ToolContext, A as AnyAgent, S as SessionSendArgs, b as SendResult } from './client-Cd-79N5B.js';
+export { c as AgentDataTypes, d as AgentHooks, e as AgentOptions, a as AgentStatus, f as ApprovalData, B as BuiltInToolName, G as GitSkillEntry, g as GitSkillInput, H as HostSkillEntry, h as HostSkillInput, I as InferSession, i as InferUIMessage, j as InlineSkillEntry, k as InlineSkillInput, N as NeedsApprovalMap, R as Resolvable, l as ResolvableArgs, m as SandboxSkillEntry, n as SandboxSkillInput, o as SendInput, p as SessionDefaults, q as SkillEntry, r as SkillInput, s as SkillSourceType, t as StepUsage, U as UsageSummary, W as WorkflowRunLike, u as agent, v as builtinToolNames } from './client-Cd-79N5B.js';
+import * as errore from 'errore';
+import * as elysia from 'elysia';
+import elysia__default from 'elysia';
 import * as ai from 'ai';
-import { InferToolInput, ModelMessage, ToolSet, UIMessage, InferUITools, GatewayModelId } from 'ai';
+import { Tool } from 'ai';
+import z$1 from '../../node_modules/zod/v4/classic/external.cjs';
+export { E as ExecResult, S as SandboxAgentRef, a as SandboxBinding, b as SandboxInstance, c as SandboxSetupFields, U as UploadableFile } from './steps-DnvPkAtl.js';
 import { z } from 'zod';
-import { c as Session, f as Storage, j as SkillInput, k as StorageInput } from './adapter-zgOel4wW.js';
-export { l as GitSkillEntry, m as GitSkillInput, H as HostSkillEntry, n as HostSkillInput, I as InlineSkillEntry, o as InlineSkillInput, p as SandboxSkillEntry, q as SandboxSkillInput, r as SkillEntry, s as SkillSourceType } from './adapter-zgOel4wW.js';
-import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
-import * as errore from 'errore';
-
-type BuiltInBindings = SandboxBinding<"local", LocalBindingConfig, LocalBindingMetadata> | SandboxBinding<"vercel", VercelBindingConfig, VercelBindingMetadata> | SandboxBinding<"docker", DockerBindingConfig, DockerBindingMetadata>;
-
-type SandboxOptions = {
-    id?: string;
-};
-
-type SetupCommonFields = Partial<SandboxSetupFields> & {
-    cwd?: string;
-    run?: (sandbox: SandboxInstance) => Promise<void>;
-    signal?: AbortSignal;
-};
-type ToBindingUnion<T extends SandboxBinding | SandboxBinding[]> = T extends SandboxBinding[] ? T[number] : T;
-type SetupOptsForBinding<B extends SandboxBinding> = B extends SandboxBinding<infer T, infer C, any> ? {
-    type: T;
-} & SetupCommonFields & WithConfig<C> : never;
-type IsDefault<T extends SandboxBinding | SandboxBinding[]> = SandboxBinding extends T ? true : false;
-type SetupOpts<TSandboxBindings extends SandboxBinding | SandboxBinding[]> = SetupOptsForBinding<IsDefault<TSandboxBindings> extends true ? BuiltInBindings : ToBindingUnion<TSandboxBindings>> | (SetupCommonFields & {
-    type?: never;
-});
-type SetupResult = {
-    done: Promise<SandboxInstance>;
-};
-
-type StepUsage = {
-    stepIndex: number;
-    model: string;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    reasoningTokens: number;
-};
-type UsageSummary = {
-    model: string;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    reasoningTokens: number;
-    stepCount: number;
-};
-type SessionUsage = {
-    total: UsageSummary & {
-        messageCount: number;
-    };
-    byMessageId: Record<string, UsageSummary | null>;
-};
-
-type ToolContext<TContext = Record<string, unknown>> = {
-    session: Session;
-    sandbox: SandboxInstance;
-    storage: Storage;
-    context: TContext;
-};
-declare const builtInTools: {
-    Read: ai.Tool<{
-        label: string;
-        path: string;
-        startLine?: number | undefined;
-        endLine?: number | undefined;
-    }, {
-        content: string;
-        metadata: {
-            totalLines: number;
-            linesShown: number;
-            startLine: number;
-            endLine: number;
-            isPaginated: boolean;
-            fileSize: string;
-            path: string;
-        };
-    }>;
-    Grep: ai.Tool<{
-        label: string;
-        pattern: string;
-        caseSensitive: boolean;
-        filesWithMatches: boolean;
-        path?: string | undefined;
-        fileType?: string | undefined;
-        glob?: string | undefined;
-        contextLines?: number | undefined;
-        maxCount?: number | undefined;
-    }, {
-        matches: string;
-        summary: {
-            matchCount: number;
-            fileCount: number;
-            searchPath: string;
-            pattern: string;
-        };
-    }>;
-    List: ai.Tool<{
-        label: string;
-        includeHidden: boolean;
-        filesOnly: boolean;
-        path?: string | undefined;
-        depth?: number | undefined;
-        pattern?: string | undefined;
-    }, {
-        listing: string;
-        summary: {
-            totalItems: number;
-            totalFiles: number;
-            totalDirs: number;
-            searchPath: string;
-            depth?: number | undefined;
-        };
-    }>;
-    Write: ai.Tool<{
-        label: string;
-        path: string;
-        content: string;
-    }, {
-        success: boolean;
-        path: string;
-        bytesWritten: number;
-        error?: string | undefined;
-    }>;
-    Edit: ai.Tool<{
-        label: string;
-        path: string;
-        old_string: string;
-        new_string: string;
-    }, {
-        success: boolean;
-        path: string;
-        error?: string | undefined;
-    }>;
-    Bash: ai.Tool<{
-        label: string;
-        command: string;
-        waitUntil?: number | undefined;
-    }, {
-        commandId: string;
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-        status: "running" | "failed" | "completed";
-        outputDir: string;
-    }>;
-    Skill: ai.Tool<{
-        label: string;
-        name: string;
-    }, {
-        name: string;
-        description: string;
-        content: string;
-        path: string;
-    }>;
-    JavaScript: ai.Tool<{
-        label: string;
-        code: string;
-    }, any>;
-};
-type BuiltInToolName = keyof typeof builtInTools;
-declare const builtinToolNames: { [K in BuiltInToolName]: K; };
+import '@vercel/sandbox';
+import './entry-MCzvxs7U.js';
+import './adapter-DmlMKodR.js';
+import '@workflow/serde';
 
 /**
- * Transient status indicators emitted over the stream during long-running phases.
- * Delivered to the client as `data-status` chunks with `transient: true` — not persisted.
+ * Define an agent tool with typed context and state.
+ *
+ * Pass the same `contextSchema` and/or `stateSchema` (Zod objects) used in
+ * your agent definition to get typed `context` and `state` inside `execute`.
+ *
+ * ```ts
+ * import { tool } from "experimental-agent";
+ * import { contextSchema, stateSchema } from "./context";
+ *
+ * export const MyTool = tool({
+ *   contextSchema,
+ *   stateSchema,
+ *   inputSchema: z.object({ query: z.string() }),
+ *   execute: async ({ query }, { context, state, sandbox }) => {
+ *     context.channelId // ✓ typed from contextSchema
+ *     state.counter++   // ✓ typed from stateSchema, mutable
+ *   },
+ * });
+ * ```
  */
-declare const AgentStatus: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"sandbox-setup">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"sandbox-setup-cold">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"loading-skills">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"processing-approvals">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"needs-approval">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"thinking">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"custom">;
-    status: z.ZodString;
-}, z.core.$strip>], "type">;
-type AgentStatus = z.infer<typeof AgentStatus>;
-type AgentDataTypes = {
-    status: AgentStatus;
-};
-type AgentHooks = {
-    "tool.before"?: (opts: {
-        name: string;
-        input: unknown;
-        context: ToolContext;
-    }) => Promise<undefined | {
-        input: unknown;
-    }>;
-    "tool.after"?: (opts: {
-        name: string;
-        input: unknown;
-        result: unknown;
-        context: ToolContext;
-    }) => Promise<undefined | {
-        result: unknown;
-    }>;
-    status?: (status: AgentStatus) => void | Promise<void>;
-};
-type ToolName<Tools> = Extract<keyof Tools, string> | BuiltInToolName;
-type ToolInput<Tools, K> = K extends BuiltInToolName ? InferToolInput<(typeof builtInTools)[K]> : K extends keyof Tools ? Tools[K] extends ai.Tool ? InferToolInput<Tools[K]> : unknown : unknown;
-type NeedsApprovalMap<Tools> = {
-    [K in ToolName<Tools>]?: boolean | ((input: ToolInput<Tools, K>, options: {
+declare function tool<TInputSchema extends z.ZodType, TContextSchema extends z.ZodType = z.ZodType<Record<string, unknown>>, TStateSchema extends z.ZodType = z.ZodType<Record<string, unknown>>, TOutputSchema extends z.ZodType = z.ZodType<any>>(def: {
+    description?: string;
+    inputSchema: TInputSchema;
+    outputSchema?: TOutputSchema;
+    contextSchema?: TContextSchema;
+    stateSchema?: TStateSchema;
+    execute?: (input: z.infer<TInputSchema>, options: ToolContext<z.infer<TContextSchema>, z.infer<TStateSchema>> & {
         toolCallId: string;
-        messages: ModelMessage[];
-        experimental_context: unknown;
-    }) => boolean | Promise<boolean>);
-};
-type InferUIMessage<A> = A extends {
-    tools: infer T extends ToolSet;
-    $UIMessage: UIMessage<infer M>;
-} ? UIMessage<M, AgentDataTypes, InferUITools<T>> : A extends {
-    tools: infer T extends ToolSet;
-} ? UIMessage<unknown, AgentDataTypes, InferUITools<T>> : UIMessage<unknown, AgentDataTypes>;
-type TypedUIMessage<TMessageMetadata = unknown, Tools extends ToolSet = ToolSet> = UIMessage<TMessageMetadata, AgentDataTypes, InferUITools<Tools>>;
-
-type StreamOptions = {
-    messageId?: string;
-    startIndex?: number;
-};
-type WorkflowRunLike = {
-    getReadable(options?: {
-        startIndex?: number;
-    }): ReadableStream;
-};
-
-type UpdateOptions<Tools extends ToolSet> = Partial<Omit<Session, "id" | "activeTools" | "model"> & {
-    model?: GatewayModelId;
-    activeTools?: (Extract<keyof Tools, string> | BuiltInToolName)[];
-}>;
-
-type ApprovalData = {
-    approvalId: string;
-    approved: boolean;
-    reason?: string;
-};
-type MessageData<Tools extends ToolSet> = UIMessage | {
-    role?: TypedUIMessage<unknown, Tools>["role"];
-    parts: TypedUIMessage<unknown, Tools>["parts"];
-    metadata?: Record<string, unknown> | null;
-    id?: string;
-};
-type SendInput<Tools extends ToolSet> = string | MessageData<Tools> | {
-    type: "message";
-    message: MessageData<Tools>;
-} | {
-    type: "approval";
-    approval: ApprovalData;
-};
-type SendOptions<Tools extends ToolSet, TContext> = {
-    interruptIfStreaming?: boolean | {
-        lastPart: {
-            index: number;
-            part: unknown;
-        };
-    };
-    context?: TContext;
-    abortSignal?: AbortSignal;
-} & UpdateOptions<Tools>;
-type SendResult = {
-    assistantMessageId: string;
-    done: true | Promise<true>;
-};
-
-type InterruptOptions = {
-    lastPart?: {
-        index: number;
-        part: unknown;
-    };
-};
-
-type SessionDefaults<Tools extends ToolSet = ToolSet> = {
-    model?: GatewayModelId;
-    system?: string;
-    generation?: Session["generation"];
-    activeTools?: (Extract<keyof Tools, string> | BuiltInToolName)[];
-    skills?: SkillInput[];
-};
-type AgentOptions<Tools extends ToolSet = any, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>> = SessionDefaults<Tools> & {
-    storage?: StorageInput;
-    sandbox?: TSandboxBindings;
-    tools?: Tools;
-    hooks?: AgentHooks;
-    needsApproval?: NeedsApprovalMap<Tools>;
-    contextSchema?: z.ZodType<TContext>;
-    logging?: Omit<LoggingConfig, "name">;
-};
-type AnyAgent = Agent<any, any, any, any>;
-type InferSession<Agent extends AnyAgent = AnyAgent> = ReturnType<Agent["session"]>;
-type SessionSendArgs<Agent extends AnyAgent, Session extends InferSession<Agent> = InferSession<Agent>> = Parameters<Session["send"]>;
-declare class Agent<TMessageMetadata = unknown, Tools extends ToolSet = ToolSet, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>> {
-    readonly name: string;
-    options: AgentOptions<Tools, TSandboxBindings, TContext>;
-    constructor(name: string, options?: AgentOptions<Tools, TSandboxBindings, TContext>);
-    static [WORKFLOW_SERIALIZE](instance: AnyAgent): {
-        name: string;
-    };
-    static [WORKFLOW_DESERIALIZE](data: {
-        name: string;
-    }): AnyAgent;
-    private _resolvedStorage;
-    get storage(): Storage;
-    get tools(): typeof builtInTools & Tools;
-    get sessionDefaults(): SessionDefaults;
-    get hooks(): AgentHooks;
-    readonly session: (id?: string | {
-        id?: string;
-    } | undefined) => {
-        id: string;
-        send: (input: SendInput<Tools> | SendInput<Tools>[], opts?: SendOptions<Tools, TContext> | undefined) => Promise<SendResult>;
-        stream: (runOrOpts?: WorkflowRunLike | StreamOptions | undefined) => Promise<ReadableStream<ai.UIMessageChunk>>;
-        history: () => Promise<{
-            messages: UIMessage<unknown, AgentDataTypes, InferUITools<Tools>>[];
-            streamingMessageId: string | null;
-            usage: SessionUsage;
-        }>;
-        interrupt: (opts?: InterruptOptions | undefined) => Promise<void>;
-        usage: () => Promise<SessionUsage>;
-        update: (opts: Partial<Omit<Session, "id" | "model" | "activeTools"> & {
-            model?: GatewayModelId;
-            activeTools?: ("Read" | "Grep" | "List" | "Write" | "Edit" | "Bash" | "Skill" | "JavaScript" | Extract<keyof Tools, string>)[] | undefined;
-        }>) => Promise<void>;
-    };
-    readonly sandbox: (id?: string | SandboxOptions | undefined) => {
-        id: string;
-        readonly cwd: string;
-        setup: (opts?: SetupOpts<TSandboxBindings> | undefined) => Promise<SetupResult>;
-        exec: (opts: {
-            command: string;
-            args?: string[];
-            cwd?: string;
-            env?: Record<string, string>;
-            sudo?: boolean;
-            signal?: AbortSignal;
-        }) => Promise<ExecResult>;
-        readFile: (opts: {
-            path: string;
-            signal?: AbortSignal;
-        }) => Promise<Buffer | null>;
-        writeFiles: (opts: {
-            files: UploadableFile[];
-            destPath: string;
-            signal?: AbortSignal;
-        }) => Promise<void>;
-        getDomain: (opts: {
-            port: number;
-            signal?: AbortSignal;
-        }) => Promise<string>;
-        updateNetworkPolicy: (opts: {
-            policy: _vercel_sandbox.NetworkPolicy;
-            signal?: AbortSignal;
-        }) => Promise<_vercel_sandbox.NetworkPolicy>;
-        start: (opts?: {
-            signal?: AbortSignal;
-        } | undefined) => Promise<void>;
-        stop: (opts?: {
-            signal?: AbortSignal;
-        } | undefined) => Promise<void>;
-        kill: (opts: {
-            commandId: string;
-            signal?: AbortSignal;
-        }) => Promise<void>;
-        snapshot: (opts?: {
-            signal?: AbortSignal;
-        } | undefined) => Promise<{
-            snapshotId: string;
-        }>;
-        getStatus: (opts?: {
-            signal?: AbortSignal;
-        } | undefined) => Promise<"pending" | "running" | "stopping" | "stopped" | "failed">;
-    };
-    /** Phantom property for type inference. Use `typeof myAgent.$UIMessage` to get the typed UIMessage. */
-    readonly $UIMessage: UIMessage<TMessageMetadata, AgentDataTypes, InferUITools<typeof builtInTools & Tools>>;
-}
-declare function agent<TMessageMetadata = unknown, Tools extends ToolSet = ToolSet, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>>(name: string, options?: AgentOptions<Tools, TSandboxBindings, TContext>): Agent<TMessageMetadata, Tools, TSandboxBindings, TContext>;
+        abortSignal: AbortSignal;
+    }) => any;
+}): Tool<any, any>;
 
 declare const SessionNotFoundError_base: errore.FactoryTaggedErrorClass<"SessionNotFoundError", "Session $id not found", Error>;
 declare class SessionNotFoundError extends SessionNotFoundError_base {
@@ -407,4 +65,437 @@ declare const MessageNotFoundError_base: errore.FactoryTaggedErrorClass<"Message
 declare class MessageNotFoundError extends MessageNotFoundError_base {
 }
 
-export { type AgentDataTypes, type AgentHooks, type AgentOptions, AgentStatus, type AnyAgent, type ApprovalData, type BuiltInToolName, ExecResult, type InferSession, type InferUIMessage, MessageNotFoundError, type NeedsApprovalMap, SandboxBinding, SandboxError, SandboxInstance, SandboxNotFoundError, SandboxSetupFields, type SendInput, type SessionDefaults, SessionNotFoundError, type SessionSendArgs, SkillInput, type StepUsage, StorageConflictError, StorageError, type ToolContext, UploadableFile, type UsageSummary, type WorkflowRunLike, agent, builtinToolNames };
+declare function agentContract<Agent extends AnyAgent>(agent: Agent): {
+    "session.get": {
+        params: z$1.ZodObject<{
+            sessionId: z$1.ZodString;
+        }, z$1.core.$strip>;
+        response: z$1.ZodObject<{
+            messages: z$1.ZodArray<z$1.ZodObject<{
+                id: z$1.ZodString;
+                role: z$1.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                    system: "system";
+                }>;
+                parts: z$1.ZodArray<z$1.ZodType<ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                    type: `tool-${string}`;
+                } & ai.UIToolInvocation<ai.InferUITool<any>>), unknown, z$1.core.$ZodTypeInternals<ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                    type: `tool-${string}`;
+                } & ai.UIToolInvocation<ai.InferUITool<any>>), unknown>>>;
+            }, z$1.core.$strip>>;
+            streamingMessageId: z$1.ZodNullable<z$1.ZodString>;
+            usage: z$1.ZodObject<{
+                total: z$1.ZodObject<{
+                    model: z$1.ZodString;
+                    inputTokens: z$1.ZodNumber;
+                    outputTokens: z$1.ZodNumber;
+                    totalTokens: z$1.ZodNumber;
+                    cacheReadTokens: z$1.ZodNumber;
+                    cacheWriteTokens: z$1.ZodNumber;
+                    reasoningTokens: z$1.ZodNumber;
+                    stepCount: z$1.ZodNumber;
+                    messageCount: z$1.ZodNumber;
+                }, z$1.core.$strip>;
+                byMessageId: z$1.ZodRecord<z$1.ZodString, z$1.ZodNullable<z$1.ZodObject<{
+                    model: z$1.ZodString;
+                    inputTokens: z$1.ZodNumber;
+                    outputTokens: z$1.ZodNumber;
+                    totalTokens: z$1.ZodNumber;
+                    cacheReadTokens: z$1.ZodNumber;
+                    cacheWriteTokens: z$1.ZodNumber;
+                    reasoningTokens: z$1.ZodNumber;
+                    stepCount: z$1.ZodNumber;
+                }, z$1.core.$strip>>>;
+            }, z$1.core.$strip>;
+        }, z$1.core.$strip>;
+    };
+    "session.post": {
+        params: z$1.ZodObject<{
+            sessionId: z$1.ZodString;
+        }, z$1.core.$strip>;
+        body: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodObject<{
+            id: z$1.ZodString;
+            role: z$1.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+            }>;
+            parts: z$1.ZodArray<z$1.ZodType<ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                type: `tool-${string}`;
+            } & ai.UIToolInvocation<ai.InferUITool<any>>), unknown, z$1.core.$ZodTypeInternals<ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                type: `tool-${string}`;
+            } & ai.UIToolInvocation<ai.InferUITool<any>>), unknown>>>;
+        }, z$1.core.$strip>]>;
+        response: z$1.ZodAny;
+    };
+    "reconnect.get": {
+        params: z$1.ZodObject<{
+            sessionId: z$1.ZodString;
+        }, z$1.core.$strip>;
+        response: z$1.ZodAny;
+    };
+    "interrupt.post": {
+        params: z$1.ZodObject<{
+            sessionId: z$1.ZodString;
+        }, z$1.core.$strip>;
+        body: z$1.ZodOptional<z$1.ZodObject<{
+            lastPart: z$1.ZodOptional<z$1.ZodObject<{
+                index: z$1.ZodNumber;
+                part: z$1.ZodType<ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                    type: `tool-${string}`;
+                } & ai.UIToolInvocation<ai.InferUITool<any>>), unknown, z$1.core.$ZodTypeInternals<ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                    type: `tool-${string}`;
+                } & ai.UIToolInvocation<ai.InferUITool<any>>), unknown>>;
+            }, z$1.core.$strip>>;
+        }, z$1.core.$strip>>;
+        response: z$1.ZodObject<{
+            success: z$1.ZodBoolean;
+        }, z$1.core.$strip>;
+    };
+};
+type AgentContract<Agent extends AnyAgent> = ReturnType<typeof agentContract<Agent>>;
+type InferContract<Agent extends AnyAgent> = {
+    [K in keyof AgentContract<Agent>]: {
+        [K2 in keyof AgentContract<Agent>[K]]: z$1.infer<AgentContract<Agent>[K][K2]>;
+    };
+};
+type InferResponse<Agent extends AnyAgent, Key extends keyof AgentContract<Agent>> = InferContract<Agent>[Key]["response"];
+
+type BasePath = `/api/agents/[agent]`;
+
+type Without<O, K extends keyof O> = Omit<O, K>;
+declare function handleRequest<Agent extends AnyAgent, AgentBasePath extends string = BasePath>(agent: Agent, options?: {
+    basePath?: AgentBasePath;
+    workflow?: (sessionId: string, ...args: SessionSendArgs<AnyAgent>) => Promise<SendResult>;
+    overrides?: {
+        [K in keyof AgentContract<Agent>]?: (contract: Without<InferContract<Agent>[K], "response">, next: () => Promise<InferResponse<Agent, K> | Response>) => Promise<InferResponse<Agent, K> | Response>;
+    };
+}): elysia__default<`/api/agents/${string}` | AgentBasePath, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, ((({
+    api: {
+        agents: {
+            [x: string]: {
+                ":sessionId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            sessionId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                            200: {
+                                messages: {
+                                    id: string;
+                                    role: "user" | "assistant" | "system";
+                                    parts: (ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                                        type: `tool-${string}`;
+                                    } & ai.UIToolInvocation<ai.InferUITool<any>>))[];
+                                }[];
+                                streamingMessageId: string | null;
+                                usage: {
+                                    total: {
+                                        model: string;
+                                        inputTokens: number;
+                                        outputTokens: number;
+                                        totalTokens: number;
+                                        cacheReadTokens: number;
+                                        cacheWriteTokens: number;
+                                        reasoningTokens: number;
+                                        stepCount: number;
+                                        messageCount: number;
+                                    };
+                                    byMessageId: Record<string, {
+                                        model: string;
+                                        inputTokens: number;
+                                        outputTokens: number;
+                                        totalTokens: number;
+                                        cacheReadTokens: number;
+                                        cacheWriteTokens: number;
+                                        reasoningTokens: number;
+                                        stepCount: number;
+                                    } | null>;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} | ({} & elysia.CreateEden<`${AgentBasePath}/:sessionId`, {
+    get: {
+        body: unknown;
+        params: {
+            sessionId: string;
+        };
+        query: unknown;
+        headers: unknown;
+        response: {
+            422: {
+                type: "validation";
+                on: string;
+                summary?: string;
+                message?: string;
+                found?: unknown;
+                property?: string;
+                expected?: string;
+            };
+            200: {
+                messages: {
+                    id: string;
+                    role: "user" | "assistant" | "system";
+                    parts: (ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                        type: `tool-${string}`;
+                    } & ai.UIToolInvocation<ai.InferUITool<any>>))[];
+                }[];
+                streamingMessageId: string | null;
+                usage: {
+                    total: {
+                        model: string;
+                        inputTokens: number;
+                        outputTokens: number;
+                        totalTokens: number;
+                        cacheReadTokens: number;
+                        cacheWriteTokens: number;
+                        reasoningTokens: number;
+                        stepCount: number;
+                        messageCount: number;
+                    };
+                    byMessageId: Record<string, {
+                        model: string;
+                        inputTokens: number;
+                        outputTokens: number;
+                        totalTokens: number;
+                        cacheReadTokens: number;
+                        cacheWriteTokens: number;
+                        reasoningTokens: number;
+                        stepCount: number;
+                    } | null>;
+                };
+            };
+        };
+    };
+}>)) & ({
+    api: {
+        agents: {
+            [x: string]: {
+                ":sessionId": {
+                    post: {
+                        body: string | {
+                            id: string;
+                            role: "user" | "assistant" | "system";
+                            parts: (ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                                type: `tool-${string}`;
+                            } & ai.UIToolInvocation<ai.InferUITool<any>>))[];
+                        };
+                        params: {
+                            sessionId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                            200: any;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} | elysia.CreateEden<`${AgentBasePath}/:sessionId`, {
+    post: {
+        body: string | {
+            id: string;
+            role: "user" | "assistant" | "system";
+            parts: (ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                type: `tool-${string}`;
+            } & ai.UIToolInvocation<ai.InferUITool<any>>))[];
+        };
+        params: {
+            sessionId: string;
+        };
+        query: unknown;
+        headers: unknown;
+        response: {
+            422: {
+                type: "validation";
+                on: string;
+                summary?: string;
+                message?: string;
+                found?: unknown;
+                property?: string;
+                expected?: string;
+            };
+            200: any;
+        };
+    };
+}>)) & ({
+    api: {
+        agents: {
+            [x: string]: {
+                ":sessionId": {
+                    reconnect: {
+                        get: {
+                            body: unknown;
+                            params: {
+                                sessionId: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                                200: any;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} | elysia.CreateEden<`${AgentBasePath}/:sessionId/reconnect`, {
+    get: {
+        body: unknown;
+        params: {
+            sessionId: string;
+        };
+        query: unknown;
+        headers: unknown;
+        response: {
+            422: {
+                type: "validation";
+                on: string;
+                summary?: string;
+                message?: string;
+                found?: unknown;
+                property?: string;
+                expected?: string;
+            };
+            200: any;
+        };
+    };
+}>)) & ({
+    api: {
+        agents: {
+            [x: string]: {
+                ":sessionId": {
+                    interrupt: {
+                        post: {
+                            body: {
+                                lastPart?: {
+                                    index: number;
+                                    part: ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                                        type: `tool-${string}`;
+                                    } & ai.UIToolInvocation<ai.InferUITool<any>>);
+                                } | undefined;
+                            } | undefined;
+                            params: {
+                                sessionId: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                                200: {
+                                    success: boolean;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} | elysia.CreateEden<`${AgentBasePath}/:sessionId/interrupt`, {
+    post: {
+        body: {
+            lastPart?: {
+                index: number;
+                part: ai.TextUIPart | ai.ReasoningUIPart | ai.SourceUrlUIPart | ai.FileUIPart | ai.StepStartUIPart | ({
+                    type: `tool-${string}`;
+                } & ai.UIToolInvocation<ai.InferUITool<any>>);
+            } | undefined;
+        } | undefined;
+        params: {
+            sessionId: string;
+        };
+        query: unknown;
+        headers: unknown;
+        response: {
+            422: {
+                type: "validation";
+                on: string;
+                summary?: string;
+                message?: string;
+                found?: unknown;
+                property?: string;
+                expected?: string;
+            };
+            200: {
+                success: boolean;
+            };
+        };
+    };
+}>), {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+
+export { AnyAgent, MessageNotFoundError, SandboxError, SandboxNotFoundError, SessionNotFoundError, SessionSendArgs, StorageConflictError, StorageError, ToolContext, handleRequest, tool };