deepagentsdk 0.12.0 → 0.13.0

package/dist/index.d.cts

@@ -1,357 +1,9 @@
-import { $ as createReadFileTool, A as TodosChangedEvent, At as InterruptData, B as InterruptOnConfig, C as HttpRequestStartEvent, Ct as GrepMatch, D as SubagentFinishEvent, Dt as BaseCheckpointSaver, E as StreamWithEventsOptions, Et as isSandboxBackend, F as AgentMemoryOptions, G as execute, H as CreateExecuteToolOptions, I as CreateDeepAgentParams, J as createEditFileTool, K as createTodosTool, L as SummarizationConfig, M as ToolResultEvent, Mt as ResumeOptions, N as WebSearchFinishEvent, O as SubagentStartEvent, Ot as Checkpoint, P as WebSearchStartEvent, Q as createLsTool, R as TodoItem, S as HttpRequestFinishEvent, St as FileInfo, T as StepStartEvent, Tt as WriteResult, U as createExecuteTool, V as SubAgent, W as createExecuteToolFromBackend, X as createGlobTool, Y as createFilesystemTools, Z as createGrepTool, _ as FetchUrlFinishEvent, _t as BackendProtocol, a as getStructuredOutput, at as read_file, b as FileWriteStartEvent, bt as ExecuteResponse, c as ApprovalResponseEvent, ct as createFetchUrlTool, d as DeepAgentEvent, dt as createWebTools, et as createWriteFileTool, f as DoneEvent, ft as fetch_url, g as ExecuteStartEvent, gt as BackendFactory, h as ExecuteFinishEvent, ht as web_search, i as getEventOutput, it as ls, j as ToolCallEvent, jt as ResumeDecision, k as TextEvent, kt as CheckpointSaverOptions, l as CheckpointLoadedEvent, lt as createHttpRequestTool, m as EventCallback, mt as http_request, n as StructuredAgentResult, nt as glob, o as hasStructuredOutput, ot as write_file, p as ErrorEvent, pt as htmlToMarkdown, q as write_todos, r as eventHasStructuredOutput, rt as grep, s as ApprovalRequestedEvent, st as CreateWebToolsOptions, t as ModelMessage$1, tt as edit_file, u as CheckpointSavedEvent, ut as createWebSearchTool, v as FetchUrlStartEvent, vt as DeepAgentState, w as StepFinishEvent, wt as SandboxBackendProtocol, x as FileWrittenEvent, xt as FileData, y as FileEditedEvent, yt as EditResult, z as DynamicApprovalConfig } from "./types-IulnvhFg.cjs";
-import * as ai0 from "ai";
-import { LanguageModel, LanguageModelMiddleware, LanguageModelMiddleware as LanguageModelMiddleware$1, ModelMessage, ToolLoopAgent, ToolLoopAgent as ToolLoopAgent$1, ToolSet, hasToolCall, stepCountIs, wrapLanguageModel } from "ai";
+import { $ as createLsTool, A as TextEvent, At as CheckpointSaverOptions, B as DynamicApprovalConfig, C as FileWrittenEvent, Ct as FileInfo, D as StepStartEvent, Dt as isSandboxBackend, E as StepFinishEvent, Et as WriteResult, F as WebSearchStartEvent, G as createExecuteToolFromBackend, H as SubAgent, I as AgentMemoryOptions, J as write_todos, K as execute, L as CreateDeepAgentParams, M as ToolCallEvent, Mt as ResumeDecision, N as ToolResultEvent, Nt as ResumeOptions, O as SubagentFinishEvent, Ot as BaseCheckpointSaver, P as WebSearchFinishEvent, Q as createGrepTool, R as SummarizationConfig, S as FileWriteStartEvent, St as FileData, T as HttpRequestStartEvent, Tt as SandboxBackendProtocol, U as CreateExecuteToolOptions, V as InterruptOnConfig, W as createExecuteTool, X as createFilesystemTools, Y as createEditFileTool, Z as createGlobTool, _ as ExecuteFinishEvent, _t as BackendFactory, a as eventHasStructuredOutput, at as ls, b as FetchUrlStartEvent, bt as EditResult, c as hasStructuredOutput, ct as CreateWebToolsOptions, d as CheckpointLoadedEvent, dt as createWebSearchTool, et as createReadFileTool, f as CheckpointSavedEvent, ft as createWebTools, g as EventCallback, gt as web_search, h as ErrorEvent, ht as http_request, i as StructuredAgentResult, it as grep, j as TodosChangedEvent, jt as InterruptData, k as SubagentStartEvent, kt as Checkpoint, l as ApprovalRequestedEvent, lt as createFetchUrlTool, m as DoneEvent, mt as htmlToMarkdown, n as createDeepAgent, nt as edit_file, o as getEventOutput, ot as read_file, p as DeepAgentEvent, pt as fetch_url, q as createTodosTool, r as ModelMessage$1, rt as glob, s as getStructuredOutput, st as write_file, t as DeepAgent, tt as createWriteFileTool, u as ApprovalResponseEvent, ut as createHttpRequestTool, v as ExecuteStartEvent, vt as BackendProtocol, w as HttpRequestFinishEvent, wt as GrepMatch, x as FileEditedEvent, xt as ExecuteResponse, y as FetchUrlFinishEvent, yt as DeepAgentState, z as TodoItem } from "./agent-DToEVxs-.cjs";
+import * as ai18 from "ai";
+import { LanguageModel, LanguageModelMiddleware, LanguageModelMiddleware as LanguageModelMiddleware$1, ModelMessage, ToolLoopAgent, ToolSet, hasToolCall, stepCountIs, wrapLanguageModel } from "ai";
 
-//#region src/agent.d.ts
-
-/**
- * Deep Agent wrapper class that provides generate() and stream() methods.
- * Uses ToolLoopAgent from AI SDK v6 for the agent loop.
- */
-declare class DeepAgent {
-  private model;
-  private systemPrompt;
-  private userTools;
-  private maxSteps;
-  private backend;
-  private subagentOptions;
-  private toolResultEvictionLimit?;
-  private enablePromptCaching;
-  private summarizationConfig?;
-  private hasSandboxBackend;
-  private interruptOn?;
-  private checkpointer?;
-  private skillsMetadata;
-  private outputConfig?;
-  private loopControl?;
-  private generationOptions?;
-  private advancedOptions?;
-  constructor(params: CreateDeepAgentParams);
-  /**
-   * Create core tools (todos and filesystem).
-   * @private
-   */
-  private createCoreTools;
-  /**
-   * Create web tools if TAVILY_API_KEY is available.
-   * @private
-   */
-  private createWebToolSet;
-  /**
-   * Create execute tool if backend is a sandbox.
-   * @private
-   */
-  private createExecuteToolSet;
-  /**
-   * Create subagent tool if configured.
-   * @private
-   */
-  private createSubagentToolSet;
-  /**
-   * Create all tools for the agent, combining core, web, execute, and subagent tools.
-   * @private
-   */
-  private createTools;
-  /**
-   * Build stop conditions with maxSteps safety limit.
-   * Combines user-provided stop conditions with the maxSteps limit.
-   */
-  private buildStopConditions;
-  /**
-   * Build agent settings by combining passthrough options with defaults.
-   */
-  private buildAgentSettings;
-  /**
-   * Create a ToolLoopAgent for a given state.
-   * @param state - The shared agent state
-   * @param maxSteps - Optional max steps override
-   * @param onEvent - Optional callback for emitting events
-   */
-  private createAgent;
-  /**
-   * Load skills from directory asynchronously.
-   * Supports both legacy skillsDir and new agentId modes.
-   */
-  private loadSkills;
-  /**
-   * Generate a response (non-streaming).
-   */
-  generate(options: {
-    prompt: string;
-    maxSteps?: number;
-  }): Promise<ai0.GenerateTextResult<{}, never> & {
-    state: DeepAgentState;
-  }>;
-  /**
-   * Stream a response.
-   */
-  stream(options: {
-    prompt: string;
-    maxSteps?: number;
-  }): Promise<ai0.StreamTextResult<{}, never> & {
-    state: DeepAgentState;
-  }>;
-  /**
-   * Generate with an existing state (for continuing conversations).
-   */
-  generateWithState(options: {
-    prompt: string;
-    state: DeepAgentState;
-    maxSteps?: number;
-  }): Promise<ai0.GenerateTextResult<{}, never> & {
-    state: DeepAgentState;
-  }>;
-  /**
-   * Get the underlying ToolLoopAgent for advanced usage.
-   * This allows using AI SDK's createAgentUIStream and other utilities.
-   */
-  getAgent(state?: DeepAgentState): ToolLoopAgent$1<never, {}, never>;
-  /**
-   * Stream a response with real-time events.
-   * This is an async generator that yields DeepAgentEvent objects.
-   *
-   * Supports conversation history via the `messages` option for multi-turn conversations.
-   *
-   * @example
-   * ```typescript
-   * // Single turn
-   * for await (const event of agent.streamWithEvents({ prompt: "..." })) {
-   *   switch (event.type) {
-   *     case 'text':
-   *       process.stdout.write(event.text);
-   *       break;
-   *     case 'done':
-   *       // event.messages contains the updated conversation history
-   *       console.log('Messages:', event.messages);
-   *       break;
-   *   }
-   * }
-   *
-   * // Multi-turn conversation
-   * let messages = [];
-   * for await (const event of agent.streamWithEvents({ prompt: "Hello", messages })) {
-   *   if (event.type === 'done') {
-   *     messages = event.messages; // Save for next turn
-   *   }
-   * }
-   * for await (const event of agent.streamWithEvents({ prompt: "Follow up", messages })) {
-   *   // Agent now has context from previous turn
-   * }
-   * ```
-   */
-  /**
-   * Compose user's onStepFinish callback with DeepAgent's internal checkpointing logic.
-   * User callback executes first, errors are caught to prevent breaking checkpointing.
-   */
-  private composeOnStepFinish;
-  /**
-   * Compose user's onFinish callback with DeepAgent's internal cleanup logic.
-   */
-  private composeOnFinish;
-  /**
-   * Compose user's prepareStep callback with DeepAgent's internal step preparation.
-   * Returns a function typed as `any` to avoid AI SDK's strict toolName inference.
-   */
-  private composePrepareStep;
-  /**
-   * Build streamText options with callbacks for step tracking and checkpointing.
-   *
-   * @private
-   */
-  private buildStreamTextOptions;
-  /**
-   * Build message array from options, handling validation and priority logic.
-   * Priority: explicit messages > prompt > checkpoint history.
-   *
-   * @private
-   */
-  private buildMessageArray;
-  /**
-   * Load checkpoint context if threadId is provided.
-   * Handles checkpoint restoration and resume from interrupt.
-   *
-   * @private
-   */
-  private loadCheckpointContext;
-  streamWithEvents(options: StreamWithEventsOptions): AsyncGenerator<DeepAgentEvent, void, unknown>;
-  /**
-   * Stream with a simple callback interface.
-   * This is a convenience wrapper around streamWithEvents.
-   */
-  streamWithCallback(options: StreamWithEventsOptions, onEvent: EventCallback): Promise<{
-    state: DeepAgentState;
-    text?: string;
-    messages?: ModelMessage$1[];
-  }>;
-}
-/**
- * Create a Deep Agent with planning, filesystem, and subagent capabilities.
- *
- * @param params - Configuration object for the Deep Agent
- * @param params.model - **Required.** AI SDK LanguageModel instance (e.g., `anthropic('claude-sonnet-4-20250514')`, `openai('gpt-4o')`)
- * @param params.systemPrompt - Optional custom system prompt for the agent
- * @param params.tools - Optional custom tools to add to the agent (AI SDK ToolSet)
- * @param params.subagents - Optional array of specialized subagent configurations for task delegation
- * @param params.backend - Optional backend for filesystem operations (default: StateBackend for in-memory storage)
- * @param params.maxSteps - Optional maximum number of steps for the agent loop (default: 100)
- * @param params.includeGeneralPurposeAgent - Optional flag to include general-purpose subagent (default: true)
- * @param params.toolResultEvictionLimit - Optional token limit before evicting large tool results to filesystem (default: disabled)
- * @param params.enablePromptCaching - Optional flag to enable prompt caching for improved performance (Anthropic only, default: false)
- * @param params.summarization - Optional summarization configuration for automatic conversation summarization
- * @returns A configured DeepAgent instance
- *
- * @see {@link CreateDeepAgentParams} for detailed parameter types
- *
- * @example Basic usage
- * ```typescript
- * import { createDeepAgent } from 'deepagentsdk';
- * import { anthropic } from '@ai-sdk/anthropic';
- *
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   systemPrompt: 'You are a research assistant...',
- * });
- *
- * const result = await agent.generate({
- *   prompt: 'Research the topic and write a report',
- * });
- * ```
- *
- * @example With custom tools
- * ```typescript
- * import { tool } from 'ai';
- * import { z } from 'zod';
- *
- * const customTool = tool({
- *   description: 'Get current time',
- *   inputSchema: z.object({}),
- *   execute: async () => new Date().toISOString(),
- * });
- *
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   tools: { get_time: customTool },
- * });
- * ```
- *
- * @example With subagents
- * ```typescript
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   subagents: [{
- *     name: 'research-agent',
- *     description: 'Specialized for research tasks',
- *     systemPrompt: 'You are a research specialist...',
- *   }],
- * });
- * ```
- *
- * @example With StateBackend (default, explicit)
- * ```typescript
- * import { StateBackend } from 'deepagentsdk';
- *
- * const state = { todos: [], files: {} };
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   backend: new StateBackend(state), // Ephemeral in-memory storage
- * });
- * ```
- *
- * @example With FilesystemBackend
- * ```typescript
- * import { FilesystemBackend } from 'deepagentsdk';
- *
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   backend: new FilesystemBackend({ rootDir: './workspace' }), // Persist to disk
- * });
- * ```
- *
- * @example With PersistentBackend
- * ```typescript
- * import { PersistentBackend, InMemoryStore } from 'deepagentsdk';
- *
- * const store = new InMemoryStore();
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   backend: new PersistentBackend({ store, namespace: 'project-1' }), // Cross-session persistence
- * });
- * ```
- *
- * @example With CompositeBackend
- * ```typescript
- * import { CompositeBackend, FilesystemBackend, StateBackend } from 'deepagentsdk';
- *
- * const state = { todos: [], files: {} };
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   backend: new CompositeBackend(
- *     new StateBackend(state),
- *     { '/persistent/': new FilesystemBackend({ rootDir: './persistent' }) }
- *   ), // Route files by path prefix
- * });
- * ```
- *
- * @example With middleware for logging and caching
- * ```typescript
- * import { createDeepAgent } from 'deepagentsdk';
- * import { anthropic } from '@ai-sdk/anthropic';
- *
- * const loggingMiddleware = {
- *   wrapGenerate: async ({ doGenerate, params }) => {
- *     console.log('Model called with:', params.prompt);
- *     const result = await doGenerate();
- *     console.log('Model returned:', result.text);
- *     return result;
- *   },
- * };
- *
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   middleware: [loggingMiddleware],
- * });
- * ```
- *
- * @example With middleware factory for context access
- * ```typescript
- * import { FilesystemBackend } from 'deepagentsdk';
- *
- * function createContextMiddleware(backend: BackendProtocol) {
- *   return {
- *     wrapGenerate: async ({ doGenerate }) => {
- *       const state = await backend.read('state');
- *       const result = await doGenerate();
- *       await backend.write('state', { ...state, lastCall: result });
- *       return result;
- *     },
- *   };
- * }
- *
- * const backend = new FilesystemBackend({ rootDir: './workspace' });
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   backend,
- *   middleware: createContextMiddleware(backend),
- * });
- * ```
- *
- * @example With performance optimizations
- * ```typescript
- * const agent = createDeepAgent({
- *   model: anthropic('claude-sonnet-4-20250514'),
- *   enablePromptCaching: true,
- *   toolResultEvictionLimit: 20000,
- *   summarization: {
- *     enabled: true,
- *     tokenThreshold: 170000,
- *     keepMessages: 6,
- *   },
- * });
- * ```
- */
-declare function createDeepAgent(params: CreateDeepAgentParams): DeepAgent;
-//#endregion
 //#region src/backends/state.d.ts
+
 /**
  * Backend that stores files in shared state (ephemeral).
  *
@@ -1085,7 +737,7 @@ interface CreateSubagentToolOptions {
 /**
  * Create the task tool for spawning subagents using ToolLoopAgent.
  */
-declare function createSubagentTool(state: DeepAgentState, options: CreateSubagentToolOptions): ai0.Tool<{
+declare function createSubagentTool(state: DeepAgentState, options: CreateSubagentToolOptions): ai18.Tool<{
   description: string;
   subagent_type: string;
 }, string>;