deepagentsdk 0.12.0 → 0.14.0

package/dist/{types-IulnvhFg.d.cts → agent-DwAj5emJ.d.cts}

@@ -1,5 +1,5 @@
 import * as ai18 from "ai";
-import { LanguageModel, LanguageModel as LanguageModel$2, LanguageModelMiddleware, ModelMessage, ModelMessage as ModelMessage$1, StopCondition, ToolLoopAgentSettings, ToolSet } from "ai";
+import { LanguageModel, LanguageModel as LanguageModel$2, LanguageModelMiddleware, ModelMessage, ModelMessage as ModelMessage$1, StopCondition, ToolLoopAgent, ToolLoopAgentSettings, ToolSet } from "ai";
 import { z } from "zod";
 
 //#region src/checkpointer/types.d.ts
@@ -1147,5 +1147,354 @@ declare function getStructuredOutput<T>(result: any): T | undefined;
  */
 declare function getEventOutput<T>(event: any): T | undefined;
 //#endregion
-export { createReadFileTool as $, TodosChangedEvent as A, InterruptData as At, InterruptOnConfig as B, HttpRequestStartEvent as C, GrepMatch as Ct, SubagentFinishEvent as D, BaseCheckpointSaver as Dt, StreamWithEventsOptions as E, isSandboxBackend as Et, AgentMemoryOptions as F, execute as G, CreateExecuteToolOptions as H, CreateDeepAgentParams as I, createEditFileTool as J, createTodosTool as K, SummarizationConfig as L, ToolResultEvent as M, ResumeOptions as Mt, WebSearchFinishEvent as N, SubagentStartEvent as O, Checkpoint as Ot, WebSearchStartEvent as P, createLsTool as Q, TodoItem as R, HttpRequestFinishEvent as S, FileInfo as St, StepStartEvent as T, WriteResult as Tt, createExecuteTool as U, SubAgent as V, createExecuteToolFromBackend as W, createGlobTool as X, createFilesystemTools as Y, createGrepTool as Z, FetchUrlFinishEvent as _, BackendProtocol as _t, getStructuredOutput as a, read_file as at, FileWriteStartEvent as b, ExecuteResponse as bt, ApprovalResponseEvent as c, createFetchUrlTool as ct, DeepAgentEvent as d, createWebTools as dt, createWriteFileTool as et, DoneEvent as f, fetch_url as ft, ExecuteStartEvent as g, BackendFactory as gt, ExecuteFinishEvent as h, web_search as ht, getEventOutput as i, ls as it, ToolCallEvent as j, ResumeDecision as jt, TextEvent as k, CheckpointSaverOptions as kt, CheckpointLoadedEvent as l, createHttpRequestTool as lt, EventCallback as m, http_request as mt, StructuredAgentResult as n, glob as nt, hasStructuredOutput as o, write_file as ot, ErrorEvent as p, htmlToMarkdown as pt, write_todos as q, eventHasStructuredOutput as r, grep as rt, ApprovalRequestedEvent as s, CreateWebToolsOptions as st, ModelMessage$1 as t, edit_file as tt, CheckpointSavedEvent as u, createWebSearchTool as ut, FetchUrlStartEvent as v, DeepAgentState as vt, StepFinishEvent as w, SandboxBackendProtocol as wt, FileWrittenEvent as x, FileData as xt, FileEditedEvent as y, EditResult as yt, DynamicApprovalConfig as z };
-//# sourceMappingURL=types-IulnvhFg.d.cts.map
+//#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.
+   * Uses dynamic import to avoid bundling Node.js dependencies in client builds.
+   * @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<ai18.GenerateTextResult<{}, never> & {
+    state: DeepAgentState;
+  }>;
+  /**
+   * Stream a response.
+   */
+  stream(options: {
+    prompt: string;
+    maxSteps?: number;
+  }): Promise<ai18.StreamTextResult<{}, never> & {
+    state: DeepAgentState;
+  }>;
+  /**
+   * Generate with an existing state (for continuing conversations).
+   */
+  generateWithState(options: {
+    prompt: string;
+    state: DeepAgentState;
+    maxSteps?: number;
+  }): Promise<ai18.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<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
+export { createLsTool as $, TextEvent as A, CheckpointSaverOptions as At, DynamicApprovalConfig as B, FileWrittenEvent as C, FileInfo as Ct, StepStartEvent as D, isSandboxBackend as Dt, StepFinishEvent as E, WriteResult as Et, WebSearchStartEvent as F, createExecuteToolFromBackend as G, SubAgent as H, AgentMemoryOptions as I, write_todos as J, execute as K, CreateDeepAgentParams as L, ToolCallEvent as M, ResumeDecision as Mt, ToolResultEvent as N, ResumeOptions as Nt, SubagentFinishEvent as O, BaseCheckpointSaver as Ot, WebSearchFinishEvent as P, createGrepTool as Q, SummarizationConfig as R, FileWriteStartEvent as S, FileData as St, HttpRequestStartEvent as T, SandboxBackendProtocol as Tt, CreateExecuteToolOptions as U, InterruptOnConfig as V, createExecuteTool as W, createFilesystemTools as X, createEditFileTool as Y, createGlobTool as Z, ExecuteFinishEvent as _, BackendFactory as _t, eventHasStructuredOutput as a, ls as at, FetchUrlStartEvent as b, EditResult as bt, hasStructuredOutput as c, CreateWebToolsOptions as ct, CheckpointLoadedEvent as d, createWebSearchTool as dt, createReadFileTool as et, CheckpointSavedEvent as f, createWebTools as ft, EventCallback as g, web_search as gt, ErrorEvent as h, http_request as ht, StructuredAgentResult as i, grep as it, TodosChangedEvent as j, InterruptData as jt, SubagentStartEvent as k, Checkpoint as kt, ApprovalRequestedEvent as l, createFetchUrlTool as lt, DoneEvent as m, htmlToMarkdown as mt, createDeepAgent as n, edit_file as nt, getEventOutput as o, read_file as ot, DeepAgentEvent as p, fetch_url as pt, createTodosTool as q, ModelMessage$1 as r, glob as rt, getStructuredOutput as s, write_file as st, DeepAgent as t, createWriteFileTool as tt, ApprovalResponseEvent as u, createHttpRequestTool as ut, ExecuteStartEvent as v, BackendProtocol as vt, HttpRequestFinishEvent as w, GrepMatch as wt, FileEditedEvent as x, ExecuteResponse as xt, FetchUrlFinishEvent as y, DeepAgentState as yt, TodoItem as z };
+//# sourceMappingURL=agent-DwAj5emJ.d.cts.map

package/dist/{chunk-CbDLau6x.cjs → chunk-C5azi7Hr.cjs}

@@ -5,6 +5,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -23,9 +37,28 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 //#endregion
 
+Object.defineProperty(exports, '__esmMin', {
+  enumerable: true,
+  get: function () {
+    return __esmMin;
+  }
+});
+Object.defineProperty(exports, '__exportAll', {
+  enumerable: true,
+  get: function () {
+    return __exportAll;
+  }
+});
+Object.defineProperty(exports, '__toCommonJS', {
+  enumerable: true,
+  get: function () {
+    return __toCommonJS;
+  }
+});
 Object.defineProperty(exports, '__toESM', {
   enumerable: true,
   get: function () {

package/dist/cli/index.cjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
-const require_chunk = require('../chunk-CbDLau6x.cjs');
-const require_agent = require('../agent-Cuks-Idh.cjs');
-const require_file_saver = require('../file-saver-C6O2LAvg.cjs');
+const require_chunk = require('../chunk-C5azi7Hr.cjs');
+const require_file_saver = require('../file-saver-BYPKakT4.cjs');
 let react = require("react");
 react = require_chunk.__toESM(react);
 let ink = require("ink");
@@ -9,6 +8,7 @@ let react_jsx_runtime = require("react/jsx-runtime");
 let _inkjs_ui = require("@inkjs/ui");
 
 //#region src/cli/hooks/useAgent.ts
+require_file_saver.init_limits();
 /**
 * Hook for managing agent streaming and events.
 */
@@ -72,7 +72,7 @@ function useAgent(options) {
 		eviction: evictionLimit > 0,
 		summarization: summarizationEnabled
 	};
-	const agentRef = (0, react.useRef)(require_agent.createDeepAgent({
+	const agentRef = (0, react.useRef)(require_file_saver.createDeepAgent({
 		model: require_file_saver.parseModelString(currentModel),
 		maxSteps: options.maxSteps,
 		systemPrompt: options.systemPrompt,
@@ -497,7 +497,7 @@ function useAgent(options) {
 		if (overrides.interruptOn === null) newInterruptOn = void 0;
 		else if (overrides.interruptOn !== void 0) newInterruptOn = overrides.interruptOn;
 		else newInterruptOn = autoApproveEnabled ? void 0 : options.interruptOn ?? DEFAULT_CLI_INTERRUPT_ON;
-		agentRef.current = require_agent.createDeepAgent({
+		agentRef.current = require_file_saver.createDeepAgent({
 			model: require_file_saver.parseModelString(newModel),
 			maxSteps: options.maxSteps,
 			systemPrompt: options.systemPrompt,
@@ -2396,10 +2396,10 @@ function ToolApproval({ toolName, args, onApprove, onDeny, onApproveAll }) {
 *   ANTHROPIC_API_KEY=xxx bunx deep-agent-ink --model anthropic/claude-sonnet-4-20250514
 */
 const DEFAULT_PROMPT_CACHING = true;
-const DEFAULT_EVICTION_LIMIT = require_agent.DEFAULT_EVICTION_TOKEN_LIMIT$1;
+const DEFAULT_EVICTION_LIMIT = require_file_saver.DEFAULT_EVICTION_TOKEN_LIMIT$1;
 const DEFAULT_SUMMARIZATION = true;
-const DEFAULT_SUMMARIZATION_THRESHOLD_VALUE = require_agent.DEFAULT_SUMMARIZATION_THRESHOLD$1;
-const DEFAULT_SUMMARIZATION_KEEP = require_agent.DEFAULT_KEEP_MESSAGES$1;
+const DEFAULT_SUMMARIZATION_THRESHOLD_VALUE = require_file_saver.DEFAULT_SUMMARIZATION_THRESHOLD$1;
+const DEFAULT_SUMMARIZATION_KEEP = require_file_saver.DEFAULT_KEEP_MESSAGES$1;
 function parseArgs() {
 	const args = process.argv.slice(2);
 	const options = {
@@ -2610,7 +2610,7 @@ function App({ options, backend }) {
 			case "tok":
 				setPanel({
 					view: "tokens",
-					tokenCount: require_agent.estimateMessagesTokens(agent.messages)
+					tokenCount: require_file_saver.estimateMessagesTokens(agent.messages)
 				});
 				break;
 			case "sessions":
@@ -3029,9 +3029,9 @@ function FeaturesPanel({ features, options }) {
 					color: colors.success,
 					children: [
 						"enabled (",
-						options.summarizationThreshold || require_agent.DEFAULT_SUMMARIZATION_THRESHOLD$1,
+						options.summarizationThreshold || require_file_saver.DEFAULT_SUMMARIZATION_THRESHOLD$1,
 						" tokens, keep ",
-						options.summarizationKeepMessages || require_agent.DEFAULT_KEEP_MESSAGES$1,
+						options.summarizationKeepMessages || require_file_saver.DEFAULT_KEEP_MESSAGES$1,
 						" msgs)"
 					]
 				})
@@ -3060,7 +3060,7 @@ function FeaturesPanel({ features, options }) {
 }
 function TokensPanel({ tokenCount, messageCount }) {
 	const formatNumber = (n) => n.toLocaleString();
-	const percentage = Math.round(tokenCount / require_agent.CONTEXT_WINDOW * 100);
+	const percentage = Math.round(tokenCount / require_file_saver.CONTEXT_WINDOW * 100);
 	let usageColor = colors.success;
 	if (percentage > 80) usageColor = colors.error;
 	else if (percentage > 50) usageColor = colors.warning;