experimental-agent 0.5.0 → 0.6.1

package/dist/client-B2ohNvwc.d.mts

@@ -0,0 +1,494 @@
+import * as _vercel_sandbox from '@vercel/sandbox';
+import { a as SandboxBinding, c as SandboxSetupFields, b as SandboxInstance, W as WithConfig, d as LoggingConfig, E as ExecResult, U as UploadableFile } from './steps-Mi3sjYbD.mjs';
+import { L as LocalBindingConfig, a as LocalBindingMetadata, V as VercelBindingConfig, b as VercelBindingMetadata, D as DockerBindingConfig, c as DockerBindingMetadata } from './entry-BUiucCNp.mjs';
+import { c as Session, G as GenerationOptions, j as StorageInput, f as Storage } from './adapter-txsF6hou.mjs';
+import * as ai from 'ai';
+import { UIMessage, InferToolInput, ModelMessage, ToolSet, InferUITools, GatewayModelId } from 'ai';
+import { z } from 'zod';
+import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
+
+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 InterruptOptions = {
+    lastPart?: {
+        index: number;
+        part: 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 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>, TState = Record<string, unknown>> = {
+    context: TContext;
+    state: TState;
+    sessionId: string;
+    sandbox: SandboxInstance;
+    messages: UIMessage[];
+};
+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; };
+
+/**
+ * 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: 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, TMessageMetadata = unknown> = UIMessage<TMessageMetadata> | {
+    role?: TypedUIMessage<unknown, Tools>["role"];
+    parts: TypedUIMessage<unknown, Tools>["parts"];
+    metadata?: TMessageMetadata | null;
+    id?: string;
+};
+type SendInput<Tools extends ToolSet, TMessageMetadata = unknown> = string | MessageData<Tools, TMessageMetadata> | {
+    type: "message";
+    message: MessageData<Tools, TMessageMetadata>;
+} | {
+    type: "approval";
+    approval: ApprovalData;
+};
+type SendOptions<TContext, TState = unknown> = {
+    interruptIfStreaming?: boolean | {
+        lastPart: {
+            index: number;
+            part: unknown;
+        };
+    };
+    context?: TContext;
+    initialState?: TState;
+    abortSignal?: AbortSignal;
+    sandboxId?: string;
+};
+type SendResult = {
+    assistantMessageId: string;
+    done: true | Promise<true>;
+};
+
+type UpdateOptions<TState extends Record<string, unknown> = Record<string, unknown>> = Partial<Omit<Session, "id" | "createdAt" | "updatedAt" | "state">> & {
+    state?: TState;
+};
+
+type ResolvableArgs<TContext = Record<string, unknown>, Tools extends ToolSet = ToolSet, TState = Record<string, unknown>> = {
+    context: TContext;
+    sessionId: string;
+    sandbox: SandboxInstance;
+    messages: UIMessage<unknown, AgentDataTypes, InferUITools<Tools>>[];
+    state: Readonly<TState>;
+};
+type Resolvable<T, TContext = Record<string, unknown>, Tools extends ToolSet = ToolSet, TState = Record<string, unknown>> = T | ((args: ResolvableArgs<TContext, Tools, TState>) => T | Promise<T>);
+type SessionDefaults<Tools extends ToolSet = ToolSet, TContext extends Record<string, unknown> = Record<string, unknown>, TState extends Record<string, unknown> = Record<string, unknown>> = {
+    model?: Resolvable<GatewayModelId | undefined, TContext, Tools, TState>;
+    system?: Resolvable<string | string[] | undefined, TContext, Tools, TState>;
+    generation?: Resolvable<GenerationOptions | undefined, TContext, Tools, TState>;
+    activeTools?: Resolvable<readonly (Extract<keyof Tools, string> | BuiltInToolName)[] | undefined, TContext, Tools, TState>;
+    skills?: Resolvable<SkillInput[] | undefined, TContext, Tools, TState>;
+};
+type AgentOptions<Tools extends ToolSet = any, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>, TState extends Record<string, unknown> = Record<string, unknown>, TMessageMetadata = unknown> = SessionDefaults<Tools, TContext, TState> & {
+    storage?: StorageInput;
+    sandbox?: TSandboxBindings;
+    tools?: Tools;
+    hooks?: AgentHooks;
+    needsApproval?: NeedsApprovalMap<Tools>;
+    contextSchema?: z.ZodType<TContext>;
+    stateSchema?: z.ZodType<TState>;
+    messageMetadataSchema?: z.ZodType<TMessageMetadata>;
+    logging?: Omit<LoggingConfig, "name">;
+};
+type AnyAgent = Agent<any, 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>, TState extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    options: AgentOptions<Tools, TSandboxBindings, TContext, TState, TMessageMetadata>;
+    constructor(name: string, options?: AgentOptions<Tools, TSandboxBindings, TContext, TState, TMessageMetadata>);
+    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, TMessageMetadata> | SendInput<Tools, TMessageMetadata>[], opts?: SendOptions<TContext, TState> | 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: UpdateOptions<TState>) => 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<Tools extends ToolSet = ToolSet, TSandboxBindings extends SandboxBinding | SandboxBinding[] = SandboxBinding, TContext extends Record<string, unknown> = Record<string, never>, TState extends Record<string, unknown> = Record<string, unknown>, TMessageMetadata = unknown>(name: string, options?: AgentOptions<Tools, TSandboxBindings, TContext, TState, TMessageMetadata>): Agent<TMessageMetadata, Tools, TSandboxBindings, TContext, TState>;
+
+export { type AnyAgent as A, type BuiltInToolName as B, type GitSkillEntry as G, type HostSkillEntry as H, type InferSession as I, type NeedsApprovalMap as N, type Resolvable as R, type SessionSendArgs as S, type ToolContext as T, type UsageSummary as U, type WorkflowRunLike as W, AgentStatus as a, type SendResult as b, type AgentDataTypes as c, type AgentHooks as d, type AgentOptions as e, type ApprovalData as f, type GitSkillInput as g, type HostSkillInput as h, type InferUIMessage as i, type InlineSkillEntry as j, type InlineSkillInput as k, type ResolvableArgs as l, type SandboxSkillEntry as m, type SandboxSkillInput as n, type SendInput as o, type SessionDefaults as p, type SkillEntry as q, type SkillInput as r, type SkillSourceType as s, type StepUsage as t, agent as u, builtinToolNames as v };