experimental-agent 0.5.0 → 0.6.1

package/dist/index.d.mts

@@ -1,483 +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-eTytqxQb.mjs';
-export { d as SandboxAgentRef } from './steps-eTytqxQb.mjs';
-import { L as LocalBindingConfig, a as LocalBindingMetadata, V as VercelBindingConfig, b as VercelBindingMetadata, D as DockerBindingConfig, c as DockerBindingMetadata } from './entry-Bs17QEiq.mjs';
-import { G as GenerationOptions, j as StorageInput, f as Storage, c as Session } from './adapter-Cl735Kp4.mjs';
+import { T as ToolContext, A as AnyAgent, S as SessionSendArgs, b as SendResult } from './client-B2ohNvwc.mjs';
+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-B2ohNvwc.mjs';
+import * as errore from 'errore';
+import * as elysia from 'elysia';
+import elysia__default from 'elysia';
 import * as ai from 'ai';
-import { ToolSet, InferToolInput, ModelMessage, 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-Mi3sjYbD.mjs';
 import { z } from 'zod';
-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 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 SandboxOptions = {
-    id?: string;
-};
-
-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 SkillSourceType = "sandbox" | "host" | "git" | "inline";
-type SandboxSkillInput = {
-    type: "sandbox";
-    path: string;
-};
-type HostSkillInput = {
-    type: "host";
-    path: string;
-};
-type GitSkillInput = {
-    type: "git";
-    repo: string;
-    ref?: string;
-    path?: string;
-    /**
-     * Skill directory name under `path`.
-     */
-    name?: string;
-};
-type InlineSkillInput = {
-    type: "inline";
-    name: string;
-    description: string;
-    instructions: string;
-};
-type SkillInput = SandboxSkillInput | HostSkillInput | GitSkillInput | InlineSkillInput;
-type SandboxSkillEntry = {
-    type: "sandbox";
-    path: string;
-};
-type HostSkillEntry = {
-    type: "host";
-    path: string;
-};
-type GitSkillEntry = {
-    type: "git";
-    repo: string;
-    ref?: string;
-    path?: string;
-    /**
-     * Skill directory name under `path`.
-     */
-    name?: string;
-};
-type InlineSkillEntry = {
-    type: "inline";
-    name: string;
-    description: string;
-    instructions: string;
-};
-type SkillEntry = SandboxSkillEntry | HostSkillEntry | GitSkillEntry | InlineSkillEntry;
-
-type ToolContext<TContext = Record<string, unknown>, Tools extends ToolSet = ToolSet> = ResolvableArgs<TContext, Tools>;
-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-BUiucCNp.mjs';
+import './adapter-txsF6hou.mjs';
+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 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<TContext> = {
-    interruptIfStreaming?: boolean | {
-        lastPart: {
-            index: number;
-            part: unknown;
-        };
-    };
-    context?: TContext;
-    abortSignal?: AbortSignal;
-    sandboxId?: string;
-};
-type SendResult = {
-    assistantMessageId: string;
-    done: true | Promise<true>;
-};
-
-type InterruptOptions = {
-    lastPart?: {
-        index: number;
-        part: unknown;
-    };
-};
-
-type ResolvableArgs<TContext = Record<string, unknown>, Tools extends ToolSet = ToolSet> = {
-    context: TContext;
-    sessionId: string;
-    sandbox: SandboxInstance;
-    messages: UIMessage<unknown, AgentDataTypes, InferUITools<Tools>>[];
-};
-type Resolvable<T, TContext = Record<string, unknown>, Tools extends ToolSet = ToolSet> = T | ((args: ResolvableArgs<TContext, Tools>) => T | Promise<T>);
-type SessionDefaults<Tools extends ToolSet = ToolSet, TContext extends Record<string, unknown> = Record<string, unknown>> = {
-    model?: Resolvable<GatewayModelId | undefined, TContext, Tools>;
-    system?: Resolvable<string | string[] | undefined, TContext, Tools>;
-    generation?: Resolvable<GenerationOptions | undefined, TContext, Tools>;
-    activeTools?: Resolvable<readonly (Extract<keyof Tools, string> | BuiltInToolName)[] | undefined, TContext, Tools>;
-    skills?: Resolvable<SkillInput[] | undefined, TContext, Tools>;
-};
-type AgentOptions<Tools extends ToolSet = any, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>> = SessionDefaults<Tools, TContext> & {
-    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 hooks(): AgentHooks;
-    readonly session: (id?: string | {
-        id?: string;
-    } | undefined) => {
-        id: string;
-        send: (input: SendInput<Tools> | SendInput<Tools>[], opts?: SendOptions<TContext> | undefined) => Promise<SendResult>;
-        stream: (runOrOpts?: StreamOptions | WorkflowRunLike | 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" | "createdAt" | "updatedAt">>) => Promise<void>;
-        sandbox: {
-            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>;
-            stop: (opts?: {
-                signal?: AbortSignal;
-            } | undefined) => Promise<void>;
-            snapshot: (opts?: {
-                signal?: AbortSignal;
-            } | undefined) => Promise<{
-                snapshotId: string;
-            }>;
-            getDomain: (opts: {
-                port: number;
-                signal?: AbortSignal;
-            }) => Promise<string>;
-            getStatus: (opts?: {
-                signal?: AbortSignal;
-            } | undefined) => Promise<"pending" | "running" | "stopping" | "stopped" | "failed">;
-            kill: (opts: {
-                commandId: string;
-                signal?: AbortSignal;
-            }) => Promise<void>;
-            readFile: (opts: {
-                path: string;
-                signal?: AbortSignal;
-            }) => Promise<Buffer | null>;
-            start: (opts?: {
-                signal?: AbortSignal;
-            } | undefined) => Promise<void>;
-            updateNetworkPolicy: (opts: {
-                policy: _vercel_sandbox.NetworkPolicy;
-                signal?: AbortSignal;
-            }) => Promise<_vercel_sandbox.NetworkPolicy>;
-            writeFiles: (opts: {
-                files: UploadableFile[];
-                destPath: string;
-                signal?: AbortSignal;
-            }) => 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 {
@@ -498,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 GitSkillEntry, type GitSkillInput, type HostSkillEntry, type HostSkillInput, type InferSession, type InferUIMessage, type InlineSkillEntry, type InlineSkillInput, MessageNotFoundError, type NeedsApprovalMap, type Resolvable, type ResolvableArgs, SandboxBinding, SandboxError, SandboxInstance, SandboxNotFoundError, SandboxSetupFields, type SandboxSkillEntry, type SandboxSkillInput, type SendInput, type SessionDefaults, SessionNotFoundError, type SessionSendArgs, type SkillEntry, type SkillInput, type SkillSourceType, 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 };