experimental-agent 0.2.3 → 0.3.0

package/dist/index.d.mts

@@ -1,27 +1,424 @@
-import { M as MethodName, S as StorageMethods } from './client-CEeSFGva.mjs';
-export { A as AgentDataTypes, a as AgentOptions, b as AgentStatus, c as AgentStream, B as BuiltInToolName, E as ExecResult, G as GenerationOptions, I as InferUIMessage, L as ListResult, d as Message, e as MessageNotFoundError, f as MessageUsage, O as OnConfigChange, g as OnRestart, P as Part, R as ResolvedStorage, h as RpcPayload, i as RpcResult, j as Sandbox, k as SandboxConfig, l as SandboxError, m as SandboxNotFoundError, n as SandboxRecord, o as SandboxSetup, p as SendInput, q as Session, r as SessionNotFoundError, s as SessionOptions, t as SkillSummary, u as StepUsage, v as Storage, w as StorageConfig, x as StorageConflictError, y as StorageError, T as TagsSchema, z as ToolContext, C as TypedStorage, U as UploadableFile, D as UsageSummary, F as agent, H as builtinToolNames } from './client-CEeSFGva.mjs';
+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-u-mGDbP_.mjs';
+export { d as SandboxAgentRef } from './steps-u-mGDbP_.mjs';
+import { L as LocalBindingConfig, a as LocalBindingMetadata, V as VercelBindingConfig, b as VercelBindingMetadata, D as DockerBindingConfig, c as DockerBindingMetadata } from './entry-CZd9aAwn.mjs';
+import * as ai from 'ai';
+import { InferToolInput, ModelMessage, ToolSet, UIMessage, InferUITools, GatewayModelId } from 'ai';
+import { b as Session, e as Storage, i as StorageInput } from './adapter-BigchkkI.mjs';
 import { z } from 'zod';
-import 'errore';
-import 'ai';
-import '@vercel/sandbox';
+import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
+import * as errore from 'errore';
 
-type Handlers = {
-    [K in MethodName]: (params: z.infer<StorageMethods[K]["params"]>) => Promise<z.infer<StorageMethods[K]["result"]>>;
+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 RpcRequest = {
-    method: string;
-    params: unknown;
+
+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 RpcSuccessResponse<T = unknown> = {
-    result: T;
+type SessionUsage = {
+    total: UsageSummary & {
+        messageCount: number;
+    };
+    byMessageId: Record<string, UsageSummary | null>;
 };
-type RpcErrorResponse = {
-    error: {
+
+type StreamOptions = {
+    messageId?: string;
+    startIndex?: number;
+};
+type WorkflowRunLike = {
+    getReadable(options?: {
+        startIndex?: number;
+    }): ReadableStream;
+};
+
+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;
-        message: string;
+    }, any>;
+};
+type BuiltInToolName = keyof typeof builtInTools;
+declare const builtinToolNames: { [K in BuiltInToolName]: K; };
+
+/**
+ * Transient status indicators emitted over the stream during long-running phases.
+ * Delivered to the client as `data-status` chunks with `transient: true` — not persisted.
+ */
+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: {
+        toolCallId: string;
+        messages: ModelMessage[];
+        experimental_context: unknown;
+    }) => boolean | Promise<boolean>);
+};
+type InferUIMessage<A> = A extends {
+    tools: infer T extends ToolSet;
+} ? UIMessage<unknown, AgentDataTypes, InferUITools<T>> : UIMessage<unknown, AgentDataTypes>;
+type TypedUIMessage<Tools extends ToolSet = ToolSet> = UIMessage<unknown, AgentDataTypes, InferUITools<Tools>>;
+
+type UpdateOptions<Tools extends ToolSet> = Partial<Omit<Session, "id" | "activeTools" | "model"> & {
+    model?: GatewayModelId;
+    activeTools?: (Extract<keyof Tools, string> | BuiltInToolName)[];
+}>;
+
+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 RpcResponse<T = unknown> = RpcSuccessResponse<T> | RpcErrorResponse;
-declare function handleStorageRpc(body: RpcRequest, handlers: Handlers): Promise<RpcResponse>;
 
-export { type Handlers, type RpcRequest, type RpcResponse, handleStorageRpc };
+type SessionDefaults<Tools extends ToolSet = ToolSet> = {
+    model?: GatewayModelId;
+    system?: string;
+    generation?: Session["generation"];
+    activeTools?: (Extract<keyof Tools, string> | BuiltInToolName)[];
+    skillsDir?: string | string[];
+};
+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>;
+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<Tools extends 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 _storageWarned;
+    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: (string | {
+            type: "approval";
+            approval: {
+                approvalId: string;
+                approved: boolean;
+                reason?: string;
+            };
+        } | (UIMessage<unknown, ai.UIDataTypes, ai.UITools> | {
+            role?: TypedUIMessage<Tools_1>["role"];
+            parts: ai.UIMessagePart<AgentDataTypes, InferUITools<Tools>>[];
+            id?: string;
+        }) | {
+            type: "message";
+            message: UIMessage<unknown, ai.UIDataTypes, ai.UITools> | {
+                role?: TypedUIMessage<Tools_1>["role"];
+                parts: ai.UIMessagePart<AgentDataTypes, InferUITools<Tools>>[];
+                id?: string;
+            };
+        }) | (string | {
+            type: "approval";
+            approval: {
+                approvalId: string;
+                approved: boolean;
+                reason?: string;
+            };
+        } | (UIMessage<unknown, ai.UIDataTypes, ai.UITools> | {
+            role?: TypedUIMessage<Tools_1>["role"];
+            parts: ai.UIMessagePart<AgentDataTypes, InferUITools<Tools>>[];
+            id?: string;
+        }) | {
+            type: "message";
+            message: UIMessage<unknown, ai.UIDataTypes, ai.UITools> | {
+                role?: TypedUIMessage<Tools_1>["role"];
+                parts: ai.UIMessagePart<AgentDataTypes, InferUITools<Tools>>[];
+                id?: string;
+            };
+        })[], 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<unknown, AgentDataTypes, InferUITools<typeof builtInTools & Tools>>;
+}
+declare function agent<Tools extends ToolSet, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>>(name: string, options?: AgentOptions<Tools, TSandboxBindings, TContext>): Agent<Tools, TSandboxBindings, TContext>;
+
+declare const SessionNotFoundError_base: errore.FactoryTaggedErrorClass<"SessionNotFoundError", "Session $id not found", Error>;
+declare class SessionNotFoundError extends SessionNotFoundError_base {
+}
+declare const SandboxNotFoundError_base: errore.FactoryTaggedErrorClass<"SandboxNotFoundError", "Sandbox $id not found", Error>;
+declare class SandboxNotFoundError extends SandboxNotFoundError_base {
+}
+declare const StorageError_base: errore.FactoryTaggedErrorClass<"StorageError", "$reason", Error>;
+declare class StorageError extends StorageError_base {
+}
+declare const StorageConflictError_base: errore.FactoryTaggedErrorClass<"StorageConflictError", "$reason", Error>;
+declare class StorageConflictError extends StorageConflictError_base {
+}
+declare const SandboxError_base: errore.FactoryTaggedErrorClass<"SandboxError", "$reason", Error>;
+declare class SandboxError extends SandboxError_base {
+}
+declare const MessageNotFoundError_base: errore.FactoryTaggedErrorClass<"MessageNotFoundError", "Message $id not found", Error>;
+declare class MessageNotFoundError extends MessageNotFoundError_base {
+}
+
+export { type AgentDataTypes, type AgentHooks, type AgentOptions, AgentStatus, type AnyAgent, type BuiltInToolName, ExecResult, type InferSession, type InferUIMessage, MessageNotFoundError, type NeedsApprovalMap, SandboxBinding, SandboxError, SandboxInstance, SandboxNotFoundError, SandboxSetupFields, type SessionDefaults, SessionNotFoundError, type SessionSendArgs, type StepUsage, StorageConflictError, StorageError, type ToolContext, UploadableFile, type UsageSummary, type WorkflowRunLike, agent, builtinToolNames };