experimental-agent 0.0.4 → 0.1.1

package/dist/{client-6g79J0s3.d.mts → types-DuTc4UQW.d.mts}

@@ -1,7 +1,6 @@
-import * as errore from 'errore';
-import * as ai from 'ai';
-import { UIMessage, JSONSchema7, ToolSet, InferToolInput, ModelMessage, GatewayModelId, UIDataTypes, InferUITools, UIMessageChunk } from 'ai';
+import { UIMessage } from 'ai';
 import { z } from 'zod';
+import * as errore from 'errore';
 
 declare const SessionNotFoundError_base: errore.FactoryTaggedErrorClass<"SessionNotFoundError", "Session $id not found", Error>;
 declare class SessionNotFoundError extends SessionNotFoundError_base {
@@ -22,6 +21,14 @@ declare const MessageNotFoundError_base: errore.FactoryTaggedErrorClass<"Message
 declare class MessageNotFoundError extends MessageNotFoundError_base {
 }
 
+declare const NetworkPolicySchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subnets: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>>;
+type NetworkPolicy = z.infer<typeof NetworkPolicySchema>;
 declare const SandboxConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"vercel">;
     resources: z.ZodOptional<z.ZodObject<{
@@ -35,6 +42,13 @@ declare const SandboxConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         snapshotId: z.ZodOptional<z.ZodString>;
         autoStart: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        subnets: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"local">;
     path: z.ZodOptional<z.ZodString>;
@@ -175,6 +189,13 @@ declare const SandboxRecordSchema: z.ZodObject<{
             snapshotId: z.ZodOptional<z.ZodString>;
             autoStart: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
+        networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            subnets: z.ZodOptional<z.ZodObject<{
+                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"local">;
         path: z.ZodOptional<z.ZodString>;
@@ -241,6 +262,14 @@ declare const CommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         completedAt: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>], "status">;
+declare const SetupSnapshotSchema: z.ZodObject<{
+    key: z.ZodString;
+    snapshotId: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNumber;
+    lastUsedAt: z.ZodNullable<z.ZodNumber>;
+    acquiringLockId: z.ZodNullable<z.ZodString>;
+    acquiringLockAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
 declare const methods: {
     readonly "session.get": {
         readonly params: z.ZodObject<{
@@ -664,6 +693,13 @@ declare const methods: {
                     snapshotId: z.ZodOptional<z.ZodString>;
                     autoStart: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>;
+                networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    subnets: z.ZodOptional<z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"local">;
                 path: z.ZodOptional<z.ZodString>;
@@ -703,6 +739,13 @@ declare const methods: {
                     snapshotId: z.ZodOptional<z.ZodString>;
                     autoStart: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>;
+                networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    subnets: z.ZodOptional<z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"local">;
                 path: z.ZodOptional<z.ZodString>;
@@ -739,6 +782,13 @@ declare const methods: {
                     snapshotId: z.ZodOptional<z.ZodString>;
                     autoStart: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>;
+                networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    subnets: z.ZodOptional<z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"local">;
                 path: z.ZodOptional<z.ZodString>;
@@ -788,6 +838,13 @@ declare const methods: {
                         snapshotId: z.ZodOptional<z.ZodString>;
                         autoStart: z.ZodOptional<z.ZodBoolean>;
                     }, z.core.$strip>>;
+                    networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        subnets: z.ZodOptional<z.ZodObject<{
+                            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
                 }, z.core.$strip>, z.ZodObject<{
                     type: z.ZodLiteral<"local">;
                     path: z.ZodOptional<z.ZodString>;
@@ -830,6 +887,13 @@ declare const methods: {
                     snapshotId: z.ZodOptional<z.ZodString>;
                     autoStart: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>;
+                networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    subnets: z.ZodOptional<z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"local">;
                 path: z.ZodOptional<z.ZodString>;
@@ -1056,6 +1120,132 @@ declare const methods: {
             nextCursor: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>;
     };
+    readonly "setup.get": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodNullable<z.ZodObject<{
+            key: z.ZodString;
+            snapshotId: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodNumber;
+            lastUsedAt: z.ZodNullable<z.ZodNumber>;
+            acquiringLockId: z.ZodNullable<z.ZodString>;
+            acquiringLockAt: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    };
+    readonly "setup.set": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            snapshotId: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodNumber;
+            lastUsedAt: z.ZodNullable<z.ZodNumber>;
+            acquiringLockId: z.ZodNullable<z.ZodString>;
+            acquiringLockAt: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly result: z.ZodVoid;
+    };
+    readonly "setup.acquireLock": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            lockId: z.ZodString;
+            lockTimeoutMs: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly result: z.ZodNullable<z.ZodObject<{
+            key: z.ZodString;
+            snapshotId: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodNumber;
+            lastUsedAt: z.ZodNullable<z.ZodNumber>;
+            acquiringLockId: z.ZodNullable<z.ZodString>;
+            acquiringLockAt: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    };
+    readonly "sandbox.acquireLock": {
+        readonly params: z.ZodObject<{
+            record: z.ZodObject<{
+                id: z.ZodString;
+                config: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"vercel">;
+                    resources: z.ZodOptional<z.ZodObject<{
+                        vcpus: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    ports: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    lifecycle: z.ZodOptional<z.ZodObject<{
+                        pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+                        stopAfterInactiveMs: z.ZodOptional<z.ZodNumber>;
+                        snapshotBeforeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                        snapshotId: z.ZodOptional<z.ZodString>;
+                        autoStart: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        subnets: z.ZodOptional<z.ZodObject<{
+                            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"local">;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"custom">;
+                    url: z.ZodString;
+                    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strip>], "type">;
+                tags: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                createdAt: z.ZodNullable<z.ZodNumber>;
+                lastActivityAt: z.ZodNullable<z.ZodNumber>;
+                acquiringLockId: z.ZodNullable<z.ZodString>;
+                acquiringLockAt: z.ZodNullable<z.ZodNumber>;
+                providerMetadata: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    provider: z.ZodLiteral<"vercel">;
+                    sandboxId: z.ZodNullable<z.ZodString>;
+                    snapshotId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strip>], "provider">>;
+            }, z.core.$strip>;
+            lockTimeoutMs: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly result: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            config: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"vercel">;
+                resources: z.ZodOptional<z.ZodObject<{
+                    vcpus: z.ZodNumber;
+                }, z.core.$strip>>;
+                ports: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                lifecycle: z.ZodOptional<z.ZodObject<{
+                    pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+                    stopAfterInactiveMs: z.ZodOptional<z.ZodNumber>;
+                    snapshotBeforeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                    snapshotId: z.ZodOptional<z.ZodString>;
+                    autoStart: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                networkPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow-all">, z.ZodLiteral<"deny-all">, z.ZodObject<{
+                    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    subnets: z.ZodOptional<z.ZodObject<{
+                        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"local">;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"custom">;
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>], "type">;
+            tags: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            createdAt: z.ZodNullable<z.ZodNumber>;
+            lastActivityAt: z.ZodNullable<z.ZodNumber>;
+            acquiringLockId: z.ZodNullable<z.ZodString>;
+            acquiringLockAt: z.ZodNullable<z.ZodNumber>;
+            providerMetadata: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                provider: z.ZodLiteral<"vercel">;
+                sandboxId: z.ZodNullable<z.ZodString>;
+                snapshotId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>], "provider">>;
+        }, z.core.$strip>>;
+    };
 };
 
 type StorageMethods = typeof methods;
@@ -1065,6 +1255,7 @@ type Session = z.infer<typeof SessionSchema>;
 type Message = z.infer<typeof MessageSchema>;
 type Command = z.infer<typeof CommandSchema>;
 type SandboxRecord = z.infer<typeof SandboxRecordSchema>;
+type SetupSnapshot = z.infer<typeof SetupSnapshotSchema>;
 type PartBase = z.infer<typeof PartSchema>;
 type Part = Omit<PartBase, "part"> & {
     part: UIMessage["parts"][number];
@@ -1073,6 +1264,34 @@ type ListResult<T> = {
     items: T[];
     nextCursor: string | null;
 };
+/**
+ * Session with tags narrowed to a specific schema.
+ */
+type TypedSession<TTags extends Record<string, unknown>> = Omit<Session, "tags"> & {
+    tags: Partial<TTags> | null;
+};
+/**
+ * Storage interface with session tags narrowed to the agent's tagsSchema.
+ * Used by the agent's `storage` getter so callers get typed tags on sessions.
+ */
+type TypedStorage<TTags extends Record<string, unknown>> = Omit<Storage, "session"> & {
+    session: Omit<Storage["session"], "get" | "set" | "list" | "tag"> & {
+        get: (id: string) => Promise<SessionNotFoundError | StorageError | TypedSession<TTags>>;
+        set: (session: TypedSession<TTags>) => Promise<StorageError | TypedSession<TTags>>;
+        list: (opts?: {
+            tags?: Partial<TTags>;
+            order?: "createdAt_asc" | "createdAt_desc" | "updatedAt_asc" | "updatedAt_desc";
+            cursor?: string;
+            limit?: number;
+        }) => Promise<StorageError | ListResult<TypedSession<TTags>>>;
+        tag: {
+            set: (opts: {
+                sessionId: string;
+                tags: Partial<TTags>;
+            }) => Promise<StorageError | TypedSession<TTags>>;
+        };
+    };
+};
 interface Storage {
     session: {
         get: (id: string) => Promise<SessionNotFoundError | StorageError | Session>;
@@ -1126,6 +1345,7 @@ interface Storage {
                 tags: Record<string, unknown>;
             }) => Promise<StorageError | SandboxRecord>;
         };
+        acquireLock: (record: SandboxRecord, lockTimeoutMs: number) => Promise<StorageError | SandboxRecord | null>;
     };
     command: {
         get: (id: string) => Promise<StorageError | Command | null>;
@@ -1136,6 +1356,11 @@ interface Storage {
             limit?: number;
         }) => Promise<StorageError | ListResult<Command>>;
     };
+    setup: {
+        get: (key: string) => Promise<StorageError | SetupSnapshot | null>;
+        set: (snapshot: SetupSnapshot) => Promise<StorageError | SetupSnapshot>;
+        acquireLock: (key: string, lockId: string, lockTimeoutMs: number) => Promise<StorageError | SetupSnapshot | null>;
+    };
 }
 type BaseStorageConfig = {
     name?: string;
@@ -1160,590 +1385,4 @@ type ResolvedStorage = {
     headers?: Record<string, string>;
 };
 
-type RpcResponse<T> = {
-    result: T;
-} | {
-    error: {
-        code: string;
-        message: string;
-    };
-};
-type RpcFn = (params: {
-    name?: string;
-    method: string;
-    params: unknown;
-}) => Promise<RpcResponse<unknown>>;
-
-/**
- * Summary of a discovered skill, used in the system prompt
- * to inform the LLM about available skills.
- */
-type SkillSummary = {
-    name: string;
-    description: string;
-    /** Full path to the SKILL.md file inside the sandbox */
-    skillMdPath: string;
-};
-/**
- * A file ready to be uploaded to the sandbox.
- * Content can be text (string) or binary (Buffer).
- */
-type UploadableFile = {
-    /** Relative path within the upload destination */
-    path: string;
-    content: string | Buffer;
-};
-/**
- * Path or paths to skills directories inside the sandbox.
- */
-type SkillsDir = string | string[];
-
-type SandboxLifecycleInput = {
-    id: string;
-    vercelSandboxId: string;
-    storageConfig: StorageConfig;
-    rpc: RpcFn;
-};
-type LogEntry = {
-    stream: "stdout" | "stderr";
-    data: string;
-};
-type ExecResult = {
-    commandId: string;
-    logs: () => AsyncIterable<LogEntry>;
-    result: Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-};
-type SandboxStatus = "pending" | "running" | "stopping" | "stopped" | "failed";
-interface SandboxLifecycle {
-    start: () => Promise<SandboxError | SandboxStatus>;
-    snapshot: () => Promise<SandboxError | {
-        snapshotId: string;
-    }>;
-    stop: () => Promise<SandboxError | undefined>;
-    getStatus: () => Promise<SandboxError | SandboxStatus>;
-    getCreatedAt: () => Promise<SandboxError | Date>;
-    getRemainingTimeout: () => Promise<SandboxError | number>;
-}
-interface Sandbox<TTags extends TagsSchema = TagsSchema> {
-    id: SandboxRecord["id"];
-    config: SandboxRecord["config"];
-    exec: (opts: {
-        command: string;
-        args?: string[];
-        signal?: AbortSignal;
-    }) => Promise<SandboxError | ExecResult>;
-    /**
-     * Get the public domain URL for an exposed port.
-     * Only available for Vercel sandboxes with exposed ports.
-     */
-    getDomain: (port: number) => Promise<SandboxError | string>;
-    kill: (opts: {
-        commandId: string;
-        storage: Storage;
-    }) => Promise<SandboxError | undefined>;
-    writeFiles: (opts: {
-        files: UploadableFile[];
-        destPath: string;
-    }) => Promise<void>;
-    lifecycle?: SandboxLifecycle;
-    tag: {
-        list: () => Promise<SandboxNotFoundError | StorageError | TTags>;
-        get: (key: string) => Promise<SandboxNotFoundError | StorageError | TTags[typeof key] | undefined>;
-        set: (key: string, value: unknown) => Promise<StorageError | undefined>;
-        setMany: (tags: Record<string, unknown>) => Promise<StorageError | undefined>;
-    };
-}
-
-type GenerationOptions = {
-    /** Max tool-use steps per assistant response. Default: unlimited. */
-    maxSteps?: number;
-    temperature?: number;
-    topK?: number;
-    topP?: number;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
-    maxOutputTokens?: number;
-    /** Provider-specific HTTP headers. */
-    headers?: Record<string, string>;
-};
-
-type ToolContext<TContext = Record<string, unknown>> = {
-    session: Session;
-    sandbox: Sandbox;
-    storage: Storage;
-    context: TContext;
-};
-declare const builtInTools: {
-    Read: ai.Tool<{
-        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<{
-        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<{
-        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<{
-        path: string;
-        content: string;
-    }, {
-        success: boolean;
-        path: string;
-        bytesWritten: number;
-        error?: string | undefined;
-    }>;
-    Edit: ai.Tool<{
-        path: string;
-        old_string: string;
-        new_string: string;
-    }, {
-        success: boolean;
-        path: string;
-        error?: string | undefined;
-    }>;
-    Bash: ai.Tool<{
-        command: string;
-        waitUntil?: number | undefined;
-    }, {
-        pid: number;
-        output: string;
-        exitCode: number;
-        status: "running" | "completed" | "failed";
-        cwd: string;
-        outputFile: string;
-    }>;
-    JavaScript: ai.Tool<{
-        code: string;
-    }, any>;
-};
-type BuiltInToolName = keyof typeof builtInTools;
-declare const builtinToolNames: { [K in BuiltInToolName]: K; };
-
-type ToolMetadata = {
-    name: string;
-    description?: string;
-    inputSchema?: JSONSchema7;
-};
-type ToolsExecuteParams = {
-    name: string;
-    input: unknown;
-    session: Session;
-    sandboxRecord: SandboxRecord;
-    context: Record<string, unknown>;
-};
-type HookToolBeforeParams = {
-    name: string;
-    input: unknown;
-    context: ToolContext;
-};
-type HookToolBeforeResult = {
-    input?: unknown;
-    stop?: boolean;
-};
-type HookToolAfterParams = {
-    name: string;
-    input: unknown;
-    result: unknown;
-    context: ToolContext;
-};
-type HookToolAfterResult = {
-    result?: unknown;
-    stop?: boolean;
-};
-type ToolsNeedsApprovalParams = {
-    toolName: string;
-    input: unknown;
-    toolCallId: string;
-    messages: unknown[];
-};
-type ToolsNeedsApprovalResult = boolean;
-
-type SessionUsage = {
-    total: UsageSummary & {
-        messageCount: number;
-    };
-    byMessageId: Record<string, UsageSummary | null>;
-};
-
-type SendInput = string | {
-    role?: UIMessage["role"];
-    parts: UIMessage["parts"];
-    id?: string;
-};
-/**
- * Infer a typed UIMessage from an agent instance.
- * Tool parts are discriminated by `type: "tool-${name}"` with typed input/output.
- *
- * @example
- * ```ts
- * const myAgent = agent({ tools: { myTool: tool({...}) } });
- * type MyMessage = InferUIMessage<typeof myAgent>;
- * // MyMessage.parts includes { type: "tool-myTool"; input: MyInput; output: MyOutput; ... }
- * ```
- */
-type InferUIMessage<A> = A extends {
-    tools: infer T extends ToolSet;
-} ? UIMessage<unknown, UIDataTypes, InferUITools<T>> : UIMessage;
-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: {
-        toolCallId: string;
-        messages: ModelMessage[];
-        experimental_context: unknown;
-    }) => boolean | Promise<boolean>);
-};
-/**
- * Options that can be set per-session, overriding agent-level defaults.
- */
-type SessionOptions<Tools extends ToolSet, TTags extends Record<string, unknown> = Record<string, never>> = {
-    /** The AI model to use. */
-    model?: GatewayModelId;
-    /** System prompt for the AI model. */
-    system?: string;
-    /** Sandbox configuration or ID. If string, uses as sandbox ID with its config. */
-    sandbox?: SandboxConfig | string;
-    /** Key-value metadata tags for the session. */
-    tags?: TTags;
-    /** Directory containing skill definitions for the agent. */
-    skillsDir?: SkillsDir;
-    /**
-     * Names of tools to activate for this session.
-     * If not specified, all agent-level tools are active.
-     * Use this to restrict which tools are available per-session.
-     */
-    activeTools?: (Extract<keyof Tools, string> | BuiltInToolName)[];
-    /** Generation options (temperature, maxSteps, etc.). Overrides agent-level defaults. */
-    generation?: GenerationOptions;
-};
-/**
- * Configuration options for creating an agent instance.
- *
- * @example
- * ```ts
- * const myAgent = agent({
- *   model: "anthropic/claude-opus-4.5",
- *   system: "You are a helpful assistant...",
- *   tagsSchema: z.object({ userId: z.string() }),
- *   contextSchema: z.object({ authToken: z.string() }),
- * });
- * ```
- */
-type AgentOptions<Tools extends ToolSet, TTags extends Record<string, unknown> = Record<string, never>, TContext extends Record<string, unknown> = Record<string, never>> = {
-    /**
-     * Agent name. Used to isolate storage data - different names have separate data.
-     * @default "default"
-     */
-    name?: string;
-    /**
-     * Storage backend configuration.
-     * - `{ type: "local" }` - filesystem storage (dev)
-     * - `{ type: "vercel" }` - Vercel managed storage (prod)
-     * - `{ type: "custom", url: "..." }` - custom HTTP backend
-     * @default { type: "vercel" }
-     */
-    storage?: StorageConfig;
-    /**
-     * Custom tools available to the agent.
-     * These are exposed via the RPC handler and called over HTTP.
-     */
-    tools?: Tools;
-    /**
-     * Hooks for intercepting agent operations.
-     */
-    hooks?: AgentHooks;
-    /**
-     * Schema for session tags. All sessions share this schema.
-     * Tags are persisted in storage and survive across requests.
-     */
-    tagsSchema?: z.ZodType<TTags>;
-    /**
-     * Schema for transient tool context. Passed per-request via send().
-     * NOT persisted - use for secrets like auth tokens.
-     */
-    contextSchema?: z.ZodType<TContext>;
-    /**
-     * Approval rules for tools you don't own (built-in or third-party).
-     * Maps tool names to a boolean or a function that decides whether to ask.
-     *
-     * @example
-     * ```ts
-     * needsApproval: {
-     *   Bash: (input) => input.command.startsWith("rm"),
-     *   Write: true,
-     * }
-     * ```
-     */
-    needsApproval?: NeedsApprovalMap<Tools>;
-} & Omit<SessionOptions<Tools, TTags>, "tags">;
-/**
- * Base type for session/sandbox tags. Used for generic constraints.
- * For agent-level tag validation, use `tagsSchema` option with a zod schema.
- */
-type TagsSchema = Record<string, unknown>;
-/**
- * Hooks for intercepting agent operations.
- */
-type AgentHooks = {
-    /** Called before a tool is executed. Can modify input or throw to block. */
-    "tool.before"?: (opts: {
-        name: string;
-        input: unknown;
-        context: ToolContext;
-    }) => Promise<undefined | {
-        input: unknown;
-    }>;
-    /** Called after a tool is executed. Can modify result. */
-    "tool.after"?: (opts: {
-        name: string;
-        input: unknown;
-        result: unknown;
-        context: ToolContext;
-    }) => Promise<undefined | {
-        result: unknown;
-    }>;
-};
-/**
- * RPC response type for dispatch.
- */
-type RpcResult<T = unknown> = {
-    result: T;
-} | {
-    error: {
-        code: string;
-        message: string;
-    };
-    status?: number;
-};
-/**
- * Direct RPC payload for step function calls (no HTTP).
- */
-type RpcPayload = {
-    name?: string;
-    method: string;
-    params: unknown;
-};
-/**
- * All RPC methods available on the agent handler.
- * Combines tools methods, hooks, and storage methods.
- */
-type AgentRpcMethods = {
-    "tools.list": {
-        params: Record<string, never>;
-        result: ToolMetadata[];
-    };
-    "tools.execute": {
-        params: ToolsExecuteParams;
-        result: unknown;
-    };
-    "tools.needsApproval": {
-        params: ToolsNeedsApprovalParams;
-        result: ToolsNeedsApprovalResult;
-    };
-    "hook.tool.before": {
-        params: HookToolBeforeParams;
-        result: HookToolBeforeResult;
-    };
-    "hook.tool.after": {
-        params: HookToolAfterParams;
-        result: HookToolAfterResult;
-    };
-} & StorageMethods;
-type AgentRpcMethodName = keyof AgentRpcMethods;
-/**
- * Result type for RPC override handlers.
- * - `{ ok: true; result: T }` - return this result
- * - `{ ok: false; error: string }` - return this error
- * - `null` - use default handler
- */
-type AgentRpcResult<T> = {
-    ok: true;
-    result: T;
-} | {
-    ok: false;
-    error: string;
-} | null;
-/**
- * Override handlers for agent RPC methods.
- * Each method can be individually overridden.
- * Return `null` to fall back to the default handler.
- */
-type AgentRpcOverrides = {
-    [K in AgentRpcMethodName]?: (params: AgentRpcMethods[K]["params"]) => Promise<AgentRpcResult<AgentRpcMethods[K]["result"]>>;
-};
-declare const agent: <Tools extends {}, TTags extends Record<string, unknown> = Record<string, never>, TContext extends Record<string, unknown> = Record<string, never>>(options: AgentOptions<Tools, TTags, TContext>) => {
-    session: (sessionId: string, sessionOptions?: SessionOptions<Tools, TTags>) => Promise<{
-        send: ({ input, interruptIfStreaming, context, }: {
-            input: SendInput | SendInput[];
-            interruptIfStreaming?: boolean;
-            context?: TContext;
-        }) => Promise<void | SessionError | StorageError>;
-        stream: (opts?: {
-            messageId?: string;
-        }) => Promise<SessionNotFoundError | SessionError | StorageError | ReadableStream<UIMessageChunk>>;
-        ui: () => Promise<StorageError | {
-            messages: UIMessage<unknown, UIDataTypes, InferUITools<{
-                Read: ai.Tool<{
-                    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<{
-                    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<{
-                    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<{
-                    path: string;
-                    content: string;
-                }, {
-                    success: boolean;
-                    path: string;
-                    bytesWritten: number;
-                    error?: string | undefined;
-                }>;
-                Edit: ai.Tool<{
-                    path: string;
-                    old_string: string;
-                    new_string: string;
-                }, {
-                    success: boolean;
-                    path: string;
-                    error?: string | undefined;
-                }>;
-                Bash: ai.Tool<{
-                    command: string;
-                    waitUntil?: number | undefined;
-                }, {
-                    pid: number;
-                    output: string;
-                    exitCode: number;
-                    status: "running" | "completed" | "failed";
-                    cwd: string;
-                    outputFile: string;
-                }>;
-                JavaScript: ai.Tool<{
-                    code: string;
-                }, any>;
-            } & Tools>>[];
-            streamingMessageId: string | null;
-            usage: SessionUsage;
-        }>;
-        tag: {
-            list: () => Promise<SessionNotFoundError | StorageError | TTags>;
-            get: <K extends keyof TTags & string>(key: K) => Promise<TTags[K] | undefined | Error>;
-            set: <K extends keyof TTags & string>(key: K, value: TTags[K]) => Promise<undefined | Error>;
-            setMany: (tags: Partial<TTags>) => Promise<undefined | Error>;
-        };
-        sandbox: Sandbox<TTags>;
-        interrupt: () => Promise<StorageError | undefined>;
-        resolveApproval: ({ approvalId, approved, reason, }: {
-            approvalId: string;
-            approved: boolean;
-            reason?: string;
-        }) => Promise<undefined | Error>;
-        usage: () => Promise<SessionUsage | Error>;
-    }>;
-    sandbox: (sandboxId: string, opts?: {
-        config?: SandboxConfig;
-        tags?: TTags;
-    }) => Promise<Sandbox<TTags>>;
-    readonly storage: Storage;
-    /**
-     * RPC handler for agent operations.
-     * Handles tools.list, tools.execute, storage RPC, and hooks.
-     *
-     * Called internally by the `rpc` step function during workflow execution.
-     * Can also be exposed via HTTP for external access if needed.
-     */
-    handler: (input: Request | RpcPayload, overrides?: AgentRpcOverrides) => Promise<Response | RpcResult>;
-    tools: typeof builtInTools & Tools;
-    rpc: (params: RpcPayload) => Promise<RpcResult>;
-};
-
-export { type AgentOptions as A, type BuiltInToolName as B, type ExecResult as E, type GenerationOptions as G, type InferUIMessage as I, type ListResult as L, type MethodName as M, type Part as P, type ResolvedStorage as R, type StorageMethods as S, type TagsSchema as T, type UploadableFile as U, type Message as a, MessageNotFoundError as b, type MessageUsage as c, type RpcPayload as d, type RpcResult as e, type Sandbox as f, type SandboxConfig as g, SandboxError as h, SandboxNotFoundError as i, type SandboxRecord as j, type SendInput as k, type Session as l, SessionNotFoundError as m, type SessionOptions as n, type SkillSummary as o, type StepUsage as p, type StorageConfig as q, StorageError as r, type ToolContext as s, type UsageSummary as t, agent as u, builtinToolNames as v, type SandboxLifecycleInput as w };
+export { type ListResult as L, type MethodName as M, type NetworkPolicy as N, type Part as P, type ResolvedStorage as R, type StorageMethods as S, type TypedStorage as T, type UsageSummary as U, type Message as a, MessageNotFoundError as b, type MessageUsage as c, type SandboxConfig as d, SandboxError as e, SandboxNotFoundError as f, type SandboxRecord as g, type Session as h, SessionNotFoundError as i, type StepUsage as j, type StorageConfig as k, StorageError as l, type Storage as m, SessionError as n };