@rudderjs/ai 1.17.3 → 1.18.0

package/dist/agent.d.ts

@@ -1,508 +0,0 @@
-import { z } from 'zod';
-import { toolToSchema } from './tool.js';
-import type { ServerToolBuilder } from './tool.js';
-import { QueuedPromptBuilder } from './queue-job.js';
-import type { SubAgentPauseKind, SubAgentRunStore } from './sub-agent-run-store.js';
-import type { PendingHandoff } from './handoffs-driver.js';
-import type { AgentPromptOptions, AiMessage, AiMiddleware, AgentResponse, AgentStep, AgentStreamResponse, AnyTool, CacheableConfig, ConversationalSpec, ConversationStore, SubAgentUpdate, FinishReason, HasMiddleware, HasTools, MiddlewareContext, PrepareStepResult, RemembersSpec, StopCondition, StreamChunk, ToolCall, TokenUsage, UserMemory } from './types.js';
-/** Stop after N steps */
-export declare function stepCountIs(n: number): StopCondition;
-/** Stop when a specific tool is called in the latest step */
-export declare function hasToolCall(toolName: string): StopCondition;
-/** Options for {@link Agent.resumeAsTool}. */
-export interface SubAgentResumeOptions {
-    /** Shared run store the snapshot lives in. */
-    runStore: SubAgentRunStore;
-    /** The sub-agent instance to resume. */
-    agent: Agent;
-    /** Approved ids for an `approval` pause. */
-    approvedToolCallIds?: string[];
-    /** Rejected ids for an `approval` pause. */
-    rejectedToolCallIds?: string[];
-    /**
-     * Opt-in live progress during the resume. When set, the resumed inner loop
-     * runs via `stream()` instead of `prompt()` and each chunk is projected into
-     * a {@link SubAgentUpdate} forwarded to {@link onUpdate}. `true` uses
-     * {@link defaultSubAgentProjector} (emits `tool_call` / `agent_pending_approval`);
-     * a function is your own projector. Mirrors {@link Agent.asTool}'s `streaming`
-     * on the initial-dispatch path. Unset → the legacy non-streaming `prompt()`
-     * resume (no behavior change). The pause/completion partition is identical
-     * either way — this only adds a progress channel.
-     */
-    streaming?: AsToolStreamingOption;
-    /**
-     * Sink for projected updates. Only fires when {@link streaming} is set, once
-     * per non-null projection, in stream order. Awaited, so a slow sink applies
-     * backpressure to the resume.
-     */
-    onUpdate?: (update: SubAgentUpdate) => void | Promise<void>;
-}
-/**
- * One entry in a {@link Agent.resumeManyAsTool} batch — a single paused
- * sub-agent to resume. Mirrors the positional args of the singular
- * {@link Agent.resumeAsTool}, plus an optional host `key` echoed back on the
- * matching outcome so callers can correlate results without relying on array
- * order.
- */
-export interface SubAgentResumeRequest {
-    /** The paused run's id (the `subRunId` from its pause chunk/snapshot). */
-    subRunId: string;
-    /** The sub-agent instance to resume (each item may be a different agent). */
-    agent: Agent;
-    /** Client tool-results for a `client_tool` pause (one per pending id). */
-    clientToolResults?: ReadonlyArray<{
-        toolCallId: string;
-        result: unknown;
-    }>;
-    /** Approved ids for an `approval` pause. */
-    approvedToolCallIds?: string[];
-    /** Rejected ids for an `approval` pause. */
-    rejectedToolCallIds?: string[];
-    /** Opaque correlation key echoed back on this item's outcome. */
-    key?: string;
-}
-/** Outcome for a single item in a {@link Agent.resumeManyAsTool} batch. */
-export type SubAgentResumeOutcome = {
-    key?: string;
-    originalSubRunId: string;
-    kind: 'completed';
-    response: AgentResponse;
-} | {
-    key?: string;
-    originalSubRunId: string;
-    kind: 'paused';
-    subRunId: string;
-    pauseKind: SubAgentPauseKind;
-    pendingToolCallIds: string[];
-    toolCall?: ToolCall;
-    isClientTool?: boolean;
-} | {
-    key?: string;
-    originalSubRunId: string;
-    kind: 'error';
-    error: Error;
-};
-export interface SubAgentResumeManyOptions {
-    /** Shared run store all the snapshots live in. */
-    runStore: SubAgentRunStore;
-    /**
-     * What to do when one item fails (expired/forged `subRunId`, duplicate
-     * result id, inner error):
-     * - `'capture'` (default) — record it as a `{ kind: 'error' }` outcome and
-     *   let the rest of the batch resume; the aggregated round-trip still
-     *   returns.
-     * - `'throw'` — reject the whole call on the first failure, matching the
-     *   singular `resumeAsTool` strictness.
-     */
-    onError?: 'capture' | 'throw';
-    /**
-     * - `'parallel'` (default) — resume all snapshots concurrently. Snapshots
-     *   are independent and `consume()` is per-id atomic, so this is safe and
-     *   fastest.
-     * - `'serial'` — resume one at a time in array order, for deterministic
-     *   side-effect ordering when sub-agents touch shared state.
-     */
-    concurrency?: 'parallel' | 'serial';
-    /**
-     * Shared live-progress projector applied to every resumed item — same option
-     * as {@link SubAgentResumeOptions.streaming}. Unset → every item resumes
-     * non-streaming (legacy behavior). Set → each item streams and its projected
-     * updates flow to {@link onUpdate} tagged with the originating request.
-     */
-    streaming?: AsToolStreamingOption;
-    /**
-     * Sink for projected updates across the whole batch. Only fires when
-     * {@link streaming} is set. Each call carries the originating item's `key`
-     * (when supplied) and `originalSubRunId`, so a host can correlate a chunk
-     * back to its request and fan it out (e.g. to a per-sub-agent SSE channel).
-     */
-    onUpdate?: (update: SubAgentUpdate, ctx: {
-        key?: string;
-        originalSubRunId: string;
-    }) => void | Promise<void>;
-}
-/** Aggregated result of a {@link Agent.resumeManyAsTool} batch. */
-export interface SubAgentResumeManyResult {
-    /** Every item's outcome, in input order. */
-    results: SubAgentResumeOutcome[];
-    /** The items that paused again (need another client round-trip). */
-    paused: Extract<SubAgentResumeOutcome, {
-        kind: 'paused';
-    }>[];
-    /** The items that ran to completion. */
-    completed: Extract<SubAgentResumeOutcome, {
-        kind: 'completed';
-    }>[];
-    /** The items that failed (only populated under `onError: 'capture'`). */
-    errors: Extract<SubAgentResumeOutcome, {
-        kind: 'error';
-    }>[];
-    /**
-     * All pending tool-call ids across every paused item, flattened — the
-     * single set the host gathers client results / approvals for before the
-     * next `resumeManyAsTool`. Empty when nothing paused.
-     */
-    pendingToolCallIds: string[];
-    /**
-     * `true` when nothing is still paused and no item errored — i.e. there is
-     * no further round-trip to do. Loop `resumeManyAsTool` until this is `true`.
-     */
-    allCompleted: boolean;
-}
-export declare abstract class Agent {
-    /** System instructions for this agent */
-    abstract instructions(): string;
-    /** Model string (e.g. 'anthropic/claude-sonnet-4-5'). Defaults to registry default. */
-    model(): string | undefined;
-    /** Failover provider/model strings */
-    failover(): string[];
-    /** Maximum iterations for the tool loop (default: 20) */
-    maxSteps(): number;
-    /** Per-step control — override model, tools, messages per iteration */
-    prepareStep?(_ctx: {
-        stepNumber: number;
-        steps: AgentStep[];
-        messages: AiMessage[];
-    }): PrepareStepResult | Promise<PrepareStepResult>;
-    /** Stop conditions — combine with array (OR logic) */
-    stopWhen(): StopCondition | StopCondition[];
-    /** Temperature (0-1) */
-    temperature(): number | undefined;
-    /** Max tokens for response */
-    maxTokens(): number | undefined;
-    /**
-     * Declarative prompt-cache configuration.
-     *
-     * Override on a subclass to mark stable parts of the prompt as cacheable
-     * — provider adapters translate to native primitives (Anthropic
-     * `cache_control`, OpenAI `prompt_cache_key`, Google `cachedContent`)
-     * so cache hits can save 50–90% on input tokens for long system prompts,
-     * tool definitions, or stable conversation context.
-     *
-     * Returning `undefined` (the default) means no caching. Per-call override
-     * via `agent.prompt(input, { cache: false })` disables caching for that
-     * call; passing a {@link CacheableConfig} for `cache` replaces the agent
-     * default for that call.
-     *
-     * @example
-     * class SupportAgent extends Agent {
-     *   instructions() { return LONG_SYSTEM_PROMPT }
-     *   tools()        { return [tool1, tool2, tool3] }
-     *   cacheable() {
-     *     return { instructions: true, tools: true }
-     *   }
-     * }
-     */
-    cacheable(): CacheableConfig | undefined;
-    /**
-     * Opt into auto-persisted conversation behavior. Override on a subclass
-     * to declare *which* user owns the thread and (optionally) which
-     * specific thread, and the framework will load history before each
-     * `prompt()`/`stream()` call and append the new turn after it — without
-     * any caller having to remember `forUser()` / `continue()`.
-     *
-     * Returning `false` (the default) disables auto-persist; the agent runs
-     * stateless. Returning a {@link ConversationalSpec} opts in:
-     *
-     * @example
-     * class ChatAgent extends Agent {
-     *   conversational() {
-     *     return { user: Auth.user()?.id }   // null user → falsy → opt-out
-     *   }
-     * }
-     *
-     * await new ChatAgent().prompt('Hi')          // auto-loads + auto-saves
-     *
-     * **Precedence (high → low):**
-     * 1. Explicit `agent.forUser(id).prompt()` / `agent.continue(id).prompt()`
-     * 2. Per-call `prompt(input, { conversation: false | {...} })`
-     * 3. This method's return value
-     *
-     * Async returns are supported — useful when the user identity is fetched
-     * from an async DI binding.
-     */
-    conversational(): false | ConversationalSpec | Promise<false | ConversationalSpec>;
-    /**
-     * Opt this agent class into per-user memory beyond conversation history
-     * (#A4). Returns a {@link RemembersSpec} naming the user whose memory
-     * the agent reads/writes, and how injection / extraction should behave.
-     * Returning `false` (the default) leaves the agent memory-stateless.
-     *
-     * Phase 1 wires the declaration + the per-call precedence chain so
-     * apps and downstream phases (auto-inject middleware in Phase 2,
-     * auto-extract middleware in Phase 3) can read a consistent spec.
-     * Calling this method directly today produces no runtime behavior
-     * unless application code reads it via `resolveRemembersSpec()`.
-     *
-     * **Precedence (high → low):**
-     * 1. Per-call `prompt(input, { memory: false | {...} })`
-     * 2. This method's return value
-     *
-     * Async returns are supported — useful when the user identity is fetched
-     * from an async DI binding.
-     *
-     * @example
-     * class SupportAgent extends Agent {
-     *   remembers() { return { user: ctx.user.id, inject: 'auto', tags: ['support'] } }
-     * }
-     */
-    remembers(): false | RemembersSpec | Promise<false | RemembersSpec>;
-    /**
-     * Default for `AgentPromptOptions.parallelTools`. When `true` (default),
-     * multiple tool calls within a single step run their `execute()` functions
-     * concurrently. Override on a subclass to flip the default for an agent
-     * whose tools share non-idempotent state. Per-call options still win.
-     */
-    parallelTools(): boolean;
-    /** Run the agent with a prompt (non-streaming) */
-    prompt(input: string, options?: AgentPromptOptions): Promise<AgentResponse>;
-    /** Run the agent with a prompt (streaming) */
-    stream(input: string, options?: AgentPromptOptions): AgentStreamResponse;
-    /** Queue the prompt for background execution */
-    queue(input: string, options?: AgentPromptOptions): QueuedPromptBuilder;
-    /** Set the user scope for conversation persistence */
-    forUser(userId: string): ConversableAgent;
-    /** Continue an existing conversation */
-    continue(conversationId: string): ConversableAgent;
-    /**
-     * Wrap this agent as a tool another agent can call (the "subagents"
-     * pattern). The returned tool is fully-formed — pass it directly into the
-     * parent agent's `tools()` array. When the parent calls it, this agent
-     * runs its own loop end-to-end (its own model, tools, middleware) and
-     * returns a single result.
-     *
-     * Defaults are tuned for the zero-config case:
-     * - `inputSchema` defaults to `{ prompt: string }` and the agent is
-     *   invoked with `input.prompt`.
-     * - The parent model only sees `response.text` on its next step
-     *   (override with `modelOutput`); the UI still receives the full
-     *   `AgentResponse` via the `tool-result` chunk.
-     *
-     * @example  Zero-config
-     * const research = researchAgent.asTool({
-     *   name: 'research',
-     *   description: 'Research a topic in depth.',
-     * })
-     *
-     * @example  Custom schema + prompt mapper
-     * const research = researchAgent.asTool({
-     *   name: 'research',
-     *   description: 'Research a topic in depth.',
-     *   inputSchema: z.object({ topic: z.string(), depth: z.enum(['quick', 'deep']) }),
-     *   prompt:      ({ topic, depth }) => `Research ${topic} (${depth}).`,
-     * })
-     */
-    asTool<TInput extends z.ZodType>(options: {
-        name: string;
-        description: string;
-        inputSchema: TInput;
-        prompt: (input: z.infer<TInput>) => string;
-        modelOutput?: (response: AgentResponse) => string | Promise<string>;
-        streaming?: AsToolStreamingOption;
-        suspendable?: AsToolSuspendableOption;
-    }): ServerToolBuilder<z.infer<TInput>, AgentResponse>;
-    asTool(options: {
-        name: string;
-        description: string;
-        modelOutput?: (response: AgentResponse) => string | Promise<string>;
-        streaming?: AsToolStreamingOption;
-        suspendable?: AsToolSuspendableOption;
-    }): ServerToolBuilder<{
-        prompt: string;
-    }, AgentResponse>;
-    /**
-     * Resume a sub-agent run that previously paused with either
-     * `pauseForClientTools` (client-tool pause) or `pauseForApproval`
-     * (approval pause), typically from {@link Agent.asTool} with
-     * `suspendable: { runStore }` set. The snapshot's `pauseKind`
-     * (default `'client_tool'`) selects the resume contract:
-     *
-     * - **`client_tool`** — `clientToolResults` must carry one entry per
-     *   id in the snapshot's `pendingToolCallIds`. Results are appended
-     *   to the inner-agent message history and the loop re-runs.
-     * - **`approval`** — `approvedToolCallIds` and/or
-     *   `rejectedToolCallIds` must reference the single pending id.
-     *   `clientToolResults` must be empty; the loop re-runs with the
-     *   approval decision injected via `AgentPromptOptions`.
-     *
-     * Returns either a `'completed'` result (the inner agent finished),
-     * a `'paused'` continuation pointing at a fresh `subRunId` for the
-     * next round-trip, or stays `'paused'` if the inner loop hits another
-     * gate. The resume can pause on a different kind than it started on
-     * (e.g. an approval pause that, once approved, hits a client-tool
-     * pause on the next step).
-     *
-     * @example  Client-tool resume
-     * const r = await Agent.resumeAsTool(subRunId, browserResults, { runStore, agent: subAgent })
-     *
-     * @example  Approval resume
-     * const r = await Agent.resumeAsTool(subRunId, [], {
-     *   runStore, agent: subAgent,
-     *   approvedToolCallIds: ['inner-call-id'],
-     * })
-     */
-    static resumeAsTool(subRunId: string, clientToolResults: ReadonlyArray<{
-        toolCallId: string;
-        result: unknown;
-    }>, options: SubAgentResumeOptions): Promise<{
-        kind: 'completed';
-        response: AgentResponse;
-    } | {
-        kind: 'paused';
-        subRunId: string;
-        pauseKind: SubAgentPauseKind;
-        pendingToolCallIds: string[];
-        toolCall?: ToolCall;
-        isClientTool?: boolean;
-    }>;
-    /**
-     * Resume MANY paused sub-agents in one call and aggregate their pending
-     * tool calls into a single client round-trip.
-     *
-     * When an orchestrator dispatches several sub-agents in one parent turn
-     * and more than one pauses on a client tool (or approval gate), the host
-     * would otherwise loop over {@link Agent.resumeAsTool} by hand and stitch
-     * the pending sets back together. This does that: each request resumes its
-     * own `(subRunId, agent)` snapshot, and the result carries the combined
-     * `completed` / `paused` / `errors` partition plus the flattened
-     * `pendingToolCallIds` the host collects the next batch of results for.
-     *
-     * Re-entrant: feed the next round of `clientToolResults` / approvals back
-     * in as a fresh batch keyed off each paused item's NEW `subRunId` until
-     * `allCompleted` is `true`.
-     *
-     * @example
-     * let batch = await Agent.resumeManyAsTool(
-     *   paused.map(p => ({ subRunId: p.subRunId, agent: p.agent, clientToolResults: results[p.subRunId] })),
-     *   { runStore },
-     * )
-     * // batch.pendingToolCallIds → gather the next round from the browser, repeat.
-     */
-    static resumeManyAsTool(requests: ReadonlyArray<SubAgentResumeRequest>, options: SubAgentResumeManyOptions): Promise<SubAgentResumeManyResult>;
-}
-/**
- * Projects an inner-agent {@link StreamChunk} into a {@link SubAgentUpdate} the
- * host can render, or `null` to suppress it. Used by both {@link Agent.asTool}
- * (`streaming`) and the streaming resume path ({@link SubAgentResumeOptions.streaming}).
- *
- * On the resume paths the projector also receives a `ctx` 2nd arg carrying the
- * originating sub-run's `originalSubRunId` (and the host `key` when batched via
- * {@link Agent.resumeManyAsTool}), so a side-effect projector can fan a raw
- * chunk out to the correct per-sub-agent channel and return `null`:
- *
- * ```ts
- * streaming: (chunk, ctx) => { pumpToChannel(ctx!.originalSubRunId, chunk); return null }
- * ```
- *
- * `ctx` is optional — {@link Agent.asTool}'s initial-dispatch path omits it, and
- * existing projectors that ignore the arg are unaffected.
- */
-export type ChunkProjector = (chunk: StreamChunk, ctx?: {
-    originalSubRunId: string;
-    key?: string;
-}) => SubAgentUpdate | null;
-/**
- * Live-progress option shared by {@link Agent.asTool} and the streaming resume
- * surface: `true` uses {@link defaultSubAgentProjector}; a function is your own
- * {@link ChunkProjector}.
- */
-export type AsToolStreamingOption = boolean | ChunkProjector;
-type AsToolSuspendableOption = {
-    runStore: SubAgentRunStore;
-};
-/**
- * Wraps an Agent to add conversation memory.
- * Created via `agent.forUser(id)` or `agent.continue(id)`.
- */
-export declare class ConversableAgent {
-    private readonly agent;
-    private _userId;
-    private _conversationId;
-    constructor(agent: Agent);
-    forUser(userId: string): this;
-    continue(conversationId: string): this;
-    prompt(input: string, options?: AgentPromptOptions): Promise<AgentResponse>;
-    stream(input: string, options?: AgentPromptOptions): AgentStreamResponse;
-    /**
-     * Translate the wrapper's explicit-form state (`forUser` / `continue`)
-     * into a {@link ConversationalSpec}. The explicit chain bypasses the
-     * agent's `conversational()` declaration entirely — `forUser` always
-     * wins over class defaults.
-     */
-    private toSpec;
-}
-/**
- * Create an anonymous agent inline.
- *
- * @example
- * const response = await agent('You are helpful.').prompt('Hello')
- *
- * @example
- * const response = await agent({
- *   instructions: 'You are a search assistant.',
- *   tools: [searchTool],
- *   model: 'anthropic/claude-sonnet-4-5',
- * }).prompt('Find users named John')
- */
-export declare function agent(instructionsOrOptions: string | {
-    instructions: string;
-    tools?: AnyTool[] | undefined;
-    model?: string | undefined;
-    middleware?: AiMiddleware[] | undefined;
-}): Agent & HasTools & HasMiddleware;
-/** Set the global conversation store (called by service provider or manually) */
-export declare function setConversationStore(store: ConversationStore): void;
-/**
- * Set the global {@link UserMemory} (called by `AiProvider` from
- * `AiConfig.memory`, or manually for tests / standalone setups).
- * Phase 2/3 middleware reads it via `resolveUserMemory()` —
- * imported by the persistence layer the same way
- * `resolveConversationStore` is wired today.
- */
-export declare function setUserMemory(memory: UserMemory): void;
-export declare function resolveUserMemory(): UserMemory | undefined;
-/**
- * Mutable state shared between the non-streaming and streaming agent loops.
- * Helpers (`runFailover`, `emitObserverFailed`, `emitObserverCompleted`,
- * `buildAgentResponse`) read and write this struct so the same orchestration
- * logic serves both `prompt()` and `stream()` callers.
- */
-export interface LoopContext {
-    readonly agent: Agent;
-    readonly input: string;
-    readonly options: AgentPromptOptions | undefined;
-    readonly modelString: string;
-    readonly providerName: string;
-    readonly tools: AnyTool[];
-    readonly toolMap: Map<string, AnyTool>;
-    readonly toolSchemas: ReturnType<typeof toolToSchema>[];
-    readonly middlewares: AiMiddleware[];
-    readonly loopStart: number;
-    readonly ctx: MiddlewareContext & {
-        readonly _aborted: boolean;
-        readonly _abortReason: string;
-    };
-    readonly messages: AiMessage[];
-    readonly steps: AgentStep[];
-    readonly totalUsage: TokenUsage;
-    readonly pendingClientToolCalls: ToolCall[];
-    pendingApprovalToolCall: {
-        toolCall: ToolCall;
-        isClientTool: boolean;
-    } | undefined;
-    loopFinishReason: FinishReason | undefined;
-    stopForClientTools: boolean;
-    stopForApproval: boolean;
-    resumedToolMessages: AiMessage[];
-    failoverAttempts: number;
-    /**
-     * Set by the tool phase when the model called a {@link handoff} tool.
-     * Triggers the parent loop to break and the handoff wrapper to construct
-     * the child agent and continue with the carried message history.
-     */
-    pendingHandoff?: PendingHandoff;
-    stopForHandoff: boolean;
-}
-export type { PendingHandoff } from './handoffs-driver.js';
-export type { InvalidToolArgumentsError } from './tool-helpers.js';
-//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"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"}