deepagentsdk 0.11.1 → 0.13.0

package/dist/agent-BDM-PIu8.d.mts

@@ -0,0 +1,1500 @@
+import * as ai2 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
+
+/**
+ * Data stored in a checkpoint.
+ * Contains everything needed to resume an agent session.
+ */
+interface Checkpoint {
+  /** Unique identifier for the conversation thread */
+  threadId: string;
+  /** Step number when this checkpoint was created */
+  step: number;
+  /** Conversation history (serialized messages) */
+  messages: ModelMessage$1[];
+  /** Agent state (todos and StateBackend files) */
+  state: DeepAgentState;
+  /**
+   * Interrupt data if the agent was paused mid-execution.
+   * Present when waiting for tool approval.
+   */
+  interrupt?: InterruptData;
+  /** ISO 8601 timestamp when checkpoint was created */
+  createdAt: string;
+  /** ISO 8601 timestamp when checkpoint was last updated */
+  updatedAt: string;
+}
+/**
+ * Data about an interrupted tool execution.
+ * Used to resume from approval requests.
+ */
+interface InterruptData {
+  /** The tool call that requires approval */
+  toolCall: {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+  };
+  /** Step number where interrupt occurred */
+  step: number;
+}
+/**
+ * Decision to resume from an interrupt.
+ */
+interface ResumeDecision {
+  /** Type of decision */
+  type: 'approve' | 'deny';
+  /** Optional modified arguments (for future "edit" feature) */
+  modifiedArgs?: unknown;
+}
+/**
+ * Options for resuming from a checkpoint.
+ */
+interface ResumeOptions {
+  /** Decisions for pending tool approvals */
+  decisions: ResumeDecision[];
+}
+/**
+ * Interface for checkpoint storage implementations.
+ *
+ * Implement this interface to use any storage backend (memory, files,
+ * Redis, database, etc.) for persisting checkpoints.
+ */
+interface BaseCheckpointSaver {
+  /**
+   * Save a checkpoint.
+   * If a checkpoint for the threadId already exists, it is overwritten.
+   *
+   * @param checkpoint - The checkpoint data to save
+   */
+  save(checkpoint: Checkpoint): Promise<void>;
+  /**
+   * Load the latest checkpoint for a thread.
+   *
+   * @param threadId - The thread identifier
+   * @returns The checkpoint, or undefined if not found
+   */
+  load(threadId: string): Promise<Checkpoint | undefined>;
+  /**
+   * List all thread IDs with saved checkpoints.
+   *
+   * @returns Array of thread IDs
+   */
+  list(): Promise<string[]>;
+  /**
+   * Delete a checkpoint.
+   *
+   * @param threadId - The thread identifier to delete
+   */
+  delete(threadId: string): Promise<void>;
+  /**
+   * Check if a checkpoint exists for a thread.
+   *
+   * @param threadId - The thread identifier
+   * @returns True if checkpoint exists
+   */
+  exists(threadId: string): Promise<boolean>;
+}
+/**
+ * Options for creating a checkpoint saver.
+ */
+interface CheckpointSaverOptions {
+  /** Optional namespace prefix for isolation */
+  namespace?: string;
+}
+//#endregion
+//#region src/types/backend.d.ts
+/**
+ * File data structure used by backends.
+ */
+interface FileData {
+  /** Lines of text content */
+  content: string[];
+  /** ISO format timestamp of creation */
+  created_at: string;
+  /** ISO format timestamp of last modification */
+  modified_at: string;
+}
+/**
+ * Structured file listing info.
+ */
+interface FileInfo {
+  /** File path */
+  path: string;
+  /** Whether this is a directory */
+  is_dir?: boolean;
+  /** File size in bytes (approximate) */
+  size?: number;
+  /** ISO 8601 timestamp of last modification */
+  modified_at?: string;
+}
+/**
+ * Structured grep match entry.
+ */
+interface GrepMatch {
+  /** File path where match was found */
+  path: string;
+  /** Line number (1-indexed) */
+  line: number;
+  /** The matching line text */
+  text: string;
+}
+/**
+ * Result from backend write operations.
+ */
+interface WriteResult {
+  /** Whether the write operation succeeded */
+  success: boolean;
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** File path of written file, undefined on failure */
+  path?: string;
+}
+/**
+ * Result from backend edit operations.
+ */
+interface EditResult {
+  /** Whether the edit operation succeeded */
+  success: boolean;
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** File path of edited file, undefined on failure */
+  path?: string;
+  /** Number of replacements made, undefined on failure */
+  occurrences?: number;
+}
+/**
+ * Shared state for deep agent operations.
+ * This is passed to tools and modified during execution.
+ */
+interface DeepAgentState {
+  /** Current todo list */
+  todos: TodoItem[];
+  /** Virtual filesystem (for StateBackend) */
+  files: Record<string, FileData>;
+}
+/**
+ * Protocol for pluggable memory backends.
+ */
+interface BackendProtocol {
+  /**
+   * Structured listing with file metadata.
+   */
+  lsInfo(path: string): FileInfo[] | Promise<FileInfo[]>;
+  /**
+   * Read file content with line numbers or an error string.
+   */
+  read(filePath: string, offset?: number, limit?: number): string | Promise<string>;
+  /**
+   * Read file content as raw FileData.
+   */
+  readRaw(filePath: string): FileData | Promise<FileData>;
+  /**
+   * Structured search results or error string for invalid input.
+   */
+  grepRaw(pattern: string, path?: string | null, glob?: string | null): GrepMatch[] | string | Promise<GrepMatch[] | string>;
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  globInfo(pattern: string, path?: string): FileInfo[] | Promise<FileInfo[]>;
+  /**
+   * Create a new file or overwrite existing file.
+   */
+  write(filePath: string, content: string): WriteResult | Promise<WriteResult>;
+  /**
+   * Edit a file by replacing string occurrences.
+   */
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): EditResult | Promise<EditResult>;
+}
+/**
+ * Factory function type for creating backend instances from agent state.
+ */
+type BackendFactory = (state: DeepAgentState) => BackendProtocol;
+/**
+ * Result of command execution in a sandbox.
+ */
+interface ExecuteResponse {
+  /** Combined stdout and stderr output of the executed command */
+  output: string;
+  /** Exit code (0 = success, non-zero = failure, null = unknown/timeout) */
+  exitCode: number | null;
+  /** Whether the output was truncated due to size limits */
+  truncated: boolean;
+}
+/**
+ * Protocol for sandbox backends with command execution capability.
+ */
+interface SandboxBackendProtocol extends BackendProtocol {
+  /**
+   * Execute a shell command in the sandbox.
+   */
+  execute(command: string): Promise<ExecuteResponse>;
+  /**
+   * Unique identifier for this sandbox instance.
+   */
+  readonly id: string;
+}
+/**
+ * Type guard to check if a backend is a SandboxBackendProtocol.
+ */
+declare function isSandboxBackend(backend: BackendProtocol): backend is SandboxBackendProtocol;
+//#endregion
+//#region src/tools/web.d.ts
+/**
+ * Convert HTML to Markdown with article extraction.
+ * Uses Mozilla Readability to extract main content, then converts to Markdown.
+ */
+declare function htmlToMarkdown(html: string, url: string): string;
+/**
+ * Create the web_search tool.
+ */
+declare function createWebSearchTool(state: DeepAgentState, options: {
+  backend?: BackendProtocol | BackendFactory;
+  onEvent?: EventCallback;
+  toolResultEvictionLimit?: number;
+  tavilyApiKey: string;
+}): ai2.Tool<{
+  query: string;
+  max_results: number;
+  topic: "general" | "news" | "finance";
+  include_raw_content: boolean;
+}, string>;
+/**
+ * Create the http_request tool.
+ */
+declare function createHttpRequestTool(state: DeepAgentState, options: {
+  backend?: BackendProtocol | BackendFactory;
+  onEvent?: EventCallback;
+  toolResultEvictionLimit?: number;
+  defaultTimeout: number;
+}): ai2.Tool<{
+  timeout: number;
+  url: string;
+  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  headers?: Record<string, string> | undefined;
+  params?: Record<string, string> | undefined;
+  body?: string | Record<string, any> | undefined;
+}, string>;
+/**
+ * Create the fetch_url tool.
+ */
+declare function createFetchUrlTool(state: DeepAgentState, options: {
+  backend?: BackendProtocol | BackendFactory;
+  onEvent?: EventCallback;
+  toolResultEvictionLimit?: number;
+  defaultTimeout: number;
+}): ai2.Tool<{
+  timeout: number;
+  url: string;
+  extract_article: boolean;
+}, string>;
+/**
+ * Options for creating web tools.
+ */
+interface CreateWebToolsOptions {
+  /** Backend for filesystem operations (for eviction) */
+  backend?: BackendProtocol | BackendFactory;
+  /** Callback for emitting events */
+  onEvent?: EventCallback;
+  /** Token limit before evicting large tool results (default: disabled) */
+  toolResultEvictionLimit?: number;
+  /** Tavily API key (defaults to process.env.TAVILY_API_KEY) */
+  tavilyApiKey?: string;
+  /** Default timeout for HTTP requests in seconds (default: 30) */
+  defaultTimeout?: number;
+}
+/**
+ * Create all web tools (web_search, http_request, fetch_url).
+ * Tools are only created if TAVILY_API_KEY is available.
+ */
+declare function createWebTools(state: DeepAgentState, options?: CreateWebToolsOptions): Record<string, any>;
+/**
+ * Individual builtin tool references for selective subagent configuration.
+ * These are references to the creator functions, not instances.
+ */
+declare const web_search: typeof createWebSearchTool;
+declare const http_request: typeof createHttpRequestTool;
+declare const fetch_url: typeof createFetchUrlTool;
+//#endregion
+//#region src/tools/filesystem.d.ts
+/**
+ * Create the ls tool.
+ */
+declare function createLsTool(state: DeepAgentState, backend: BackendProtocol | BackendFactory, onEvent?: EventCallback): ai2.Tool<{
+  path: string;
+}, string>;
+/**
+ * Create the read_file tool.
+ */
+declare function createReadFileTool(state: DeepAgentState, backend: BackendProtocol | BackendFactory, evictionLimit?: number, onEvent?: EventCallback): ai2.Tool<{
+  file_path: string;
+  offset: number;
+  limit: number;
+}, string>;
+/**
+ * Create the write_file tool.
+ */
+declare function createWriteFileTool(state: DeepAgentState, backend: BackendProtocol | BackendFactory, onEvent?: EventCallback): ai2.Tool<{
+  file_path: string;
+  content: string;
+}, string>;
+/**
+ * Create the edit_file tool.
+ */
+declare function createEditFileTool(state: DeepAgentState, backend: BackendProtocol | BackendFactory, onEvent?: EventCallback): ai2.Tool<{
+  file_path: string;
+  old_string: string;
+  new_string: string;
+  replace_all: boolean;
+}, string>;
+/**
+ * Create the glob tool.
+ */
+declare function createGlobTool(state: DeepAgentState, backend: BackendProtocol | BackendFactory, onEvent?: EventCallback): ai2.Tool<{
+  path: string;
+  pattern: string;
+}, string>;
+/**
+ * Create the grep tool.
+ */
+declare function createGrepTool(state: DeepAgentState, backend: BackendProtocol | BackendFactory, evictionLimit?: number, onEvent?: EventCallback): ai2.Tool<{
+  path: string;
+  pattern: string;
+  glob?: string | null | undefined;
+}, string>;
+/**
+ * Options for creating filesystem tools.
+ */
+interface CreateFilesystemToolsOptions {
+  /** Backend for filesystem operations */
+  backend?: BackendProtocol | BackendFactory;
+  /** Callback for emitting events */
+  onEvent?: EventCallback;
+  /** Token limit before evicting large tool results (default: disabled) */
+  toolResultEvictionLimit?: number;
+}
+/**
+ * Create all filesystem tools.
+ * @param state - The shared agent state
+ * @param backendOrOptions - Backend or options object
+ * @param onEvent - Optional callback for emitting events (deprecated, use options)
+ */
+declare function createFilesystemTools(state: DeepAgentState, backendOrOptions?: BackendProtocol | BackendFactory | CreateFilesystemToolsOptions, onEvent?: EventCallback): {
+  ls: ai2.Tool<{
+    path: string;
+  }, string>;
+  read_file: ai2.Tool<{
+    file_path: string;
+    offset: number;
+    limit: number;
+  }, string>;
+  write_file: ai2.Tool<{
+    file_path: string;
+    content: string;
+  }, string>;
+  edit_file: ai2.Tool<{
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all: boolean;
+  }, string>;
+  glob: ai2.Tool<{
+    path: string;
+    pattern: string;
+  }, string>;
+  grep: ai2.Tool<{
+    path: string;
+    pattern: string;
+    glob?: string | null | undefined;
+  }, string>;
+};
+/**
+ * Individual builtin tool references for selective subagent configuration.
+ * These are references to the creator functions, not instances.
+ */
+declare const ls: typeof createLsTool;
+declare const read_file: typeof createReadFileTool;
+declare const write_file: typeof createWriteFileTool;
+declare const edit_file: typeof createEditFileTool;
+declare const glob: typeof createGlobTool;
+declare const grep: typeof createGrepTool;
+//#endregion
+//#region src/tools/todos.d.ts
+/**
+ * Create the write_todos tool for task planning.
+ * @param state - The shared agent state
+ * @param onEvent - Optional callback for emitting events
+ */
+declare function createTodosTool(state: DeepAgentState, onEvent?: EventCallback): ai2.Tool<{
+  todos: {
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    id: string;
+    content: string;
+  }[];
+  merge: boolean;
+}, string>;
+/**
+ * Individual builtin tool reference for selective subagent configuration.
+ * This is a reference to the creator function, not an instance.
+ */
+declare const write_todos: typeof createTodosTool;
+//#endregion
+//#region src/tools/execute.d.ts
+/**
+ * Options for creating the execute tool.
+ */
+interface CreateExecuteToolOptions {
+  /** The sandbox backend to execute commands in */
+  backend: SandboxBackendProtocol;
+  /** Optional callback for emitting events */
+  onEvent?: EventCallback;
+  /** Optional custom description for the tool */
+  description?: string;
+}
+/**
+ * Create an execute tool for running shell commands.
+ *
+ * @param options - Options including the sandbox backend and optional event callback
+ * @returns An AI SDK tool that executes shell commands
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { LocalSandbox, createExecuteTool } from 'deepagentsdk';
+ *
+ * const sandbox = new LocalSandbox({ cwd: './workspace' });
+ * const executeTool = createExecuteTool({ backend: sandbox });
+ *
+ * // Use with agent
+ * const agent = createDeepAgent({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   backend: sandbox,
+ *   tools: { execute: executeTool },
+ * });
+ * ```
+ *
+ * @example With event streaming
+ * ```typescript
+ * const executeTool = createExecuteTool({
+ *   backend: sandbox,
+ *   onEvent: (event) => {
+ *     if (event.type === 'execute-start') {
+ *       console.log(`Running: ${event.command}`);
+ *     } else if (event.type === 'execute-finish') {
+ *       console.log(`Exit code: ${event.exitCode}`);
+ *     }
+ *   },
+ * });
+ * ```
+ */
+declare function createExecuteTool(options: CreateExecuteToolOptions): ai2.Tool<{
+  command: string;
+}, string>;
+/**
+ * Convenience function to create execute tool from just a backend.
+ * Useful for simple cases without event handling.
+ *
+ * @param backend - The sandbox backend
+ * @returns An AI SDK tool that executes shell commands
+ *
+ * @example
+ * ```typescript
+ * const sandbox = new LocalSandbox({ cwd: './workspace' });
+ * const tools = {
+ *   execute: createExecuteToolFromBackend(sandbox),
+ * };
+ * ```
+ */
+declare function createExecuteToolFromBackend(backend: SandboxBackendProtocol): ai2.Tool<{
+  command: string;
+}, string>;
+/**
+ * Individual builtin tool reference for selective subagent configuration.
+ * This is a reference to the creator function, not an instance.
+ */
+declare const execute: typeof createExecuteTool;
+//#endregion
+//#region src/types/subagent.d.ts
+/**
+ * Configuration for dynamic tool approval.
+ */
+interface DynamicApprovalConfig {
+  /**
+   * Function to determine if approval is needed based on tool arguments.
+   */
+  shouldApprove?: (args: unknown) => boolean | Promise<boolean>;
+}
+/**
+ * Configuration for human-in-the-loop tool approval.
+ */
+type InterruptOnConfig = Record<string, boolean | DynamicApprovalConfig>;
+/**
+ * Type for builtin tool creator functions.
+ */
+type BuiltinToolCreator = typeof createWebSearchTool | typeof createHttpRequestTool | typeof createFetchUrlTool | typeof createLsTool | typeof createReadFileTool | typeof createWriteFileTool | typeof createEditFileTool | typeof createGlobTool | typeof createGrepTool | typeof createTodosTool | typeof createExecuteTool;
+/**
+ * Union type for subagent tool configuration.
+ */
+type SubagentToolConfig = ToolSet | BuiltinToolCreator;
+/**
+ * SubAgent specification for task delegation.
+ */
+interface SubAgent {
+  /**
+   * Unique name identifier for the subagent.
+   */
+  name: string;
+  /**
+   * Description shown to the main agent when deciding which subagent to use.
+   */
+  description: string;
+  /**
+   * System prompt that defines the subagent's behavior and instructions.
+   */
+  systemPrompt: string;
+  /**
+   * Optional custom tools available only to this subagent.
+   */
+  tools?: ToolSet | SubagentToolConfig[];
+  /**
+   * Optional model override for this subagent.
+   */
+  model?: LanguageModel;
+  /**
+   * Optional interrupt configuration for this subagent.
+   */
+  interruptOn?: InterruptOnConfig;
+  /**
+   * Optional structured output configuration for this subagent.
+   */
+  output?: {
+    schema: z.ZodType<any>;
+    description?: string;
+  };
+  /**
+   * Advanced generation options for this subagent.
+   */
+  generationOptions?: GenerationOptions;
+  /**
+   * Advanced agent options for this subagent.
+   */
+  advancedOptions?: AdvancedAgentOptions;
+}
+//#endregion
+//#region src/types/core.d.ts
+/**
+ * Configuration options for agent memory middleware.
+ */
+interface AgentMemoryOptions {
+  /**
+   * Unique identifier for the agent (e.g., "code-architect", "research-agent").
+   * Used to locate agent-specific memory at ~/.deepagents/{agentId}/agent.md
+   */
+  agentId: string;
+  /**
+   * Optional working directory for project-level memory detection.
+   * Defaults to process.cwd().
+   */
+  workingDirectory?: string;
+  /**
+   * Optional custom path for user-level .deepagents directory.
+   * Defaults to os.homedir() + '/.deepagents'.
+   */
+  userDeepagentsDir?: string;
+  /**
+   * Optional callback to request user approval for creating project-level .deepagents/ directory.
+   */
+  requestProjectApproval?: (projectPath: string) => Promise<boolean>;
+}
+/**
+ * Todo item for task planning and tracking.
+ */
+interface TodoItem {
+  /** Unique identifier for the todo */
+  id: string;
+  /** Description of the task */
+  content: string;
+  /** Current status */
+  status: "pending" | "in_progress" | "completed" | "cancelled";
+}
+/**
+ * Tool choice type for prepareStep.
+ */
+type DeepAgentToolChoice = "auto" | "none" | "required" | {
+  type: "tool";
+  toolName: string;
+};
+/**
+ * Result from prepareStep callback.
+ */
+interface PrepareStepResult {
+  toolChoice?: DeepAgentToolChoice;
+  model?: LanguageModel$2;
+  [key: string]: unknown;
+}
+/**
+ * Arguments passed to prepareStep callback.
+ */
+interface PrepareStepArgs {
+  stepNumber: number;
+  steps: unknown[];
+  model: LanguageModel$2;
+  messages: ai2.ModelMessage[];
+  experimental_context?: unknown;
+}
+/**
+ * Prepare step function type with permissive tool choice typing.
+ */
+type PrepareStepFunction = (args: PrepareStepArgs) => PrepareStepResult | PromiseLike<PrepareStepResult>;
+/**
+ * Loop control callbacks for agent iteration.
+ */
+interface LoopControlOptions {
+  /**
+   * Called before each step to dynamically adjust settings.
+   */
+  prepareStep?: PrepareStepFunction;
+  /**
+   * Called after each step finishes.
+   */
+  onStepFinish?: ToolLoopAgentSettings["onStepFinish"];
+  /**
+   * Called when all steps are finished.
+   */
+  onFinish?: ToolLoopAgentSettings["onFinish"];
+  /**
+   * Custom stop conditions (composed with maxSteps safety limit).
+   */
+  stopWhen?: StopCondition<ToolSet> | StopCondition<ToolSet>[];
+}
+/**
+ * Sampling and generation parameters for model calls.
+ */
+interface GenerationOptions {
+  /** Sampling temperature (0-2). */
+  temperature?: number;
+  /** Nucleus sampling (0-1). */
+  topP?: number;
+  /** Top-K sampling. */
+  topK?: number;
+  /** Maximum number of tokens to generate per response. */
+  maxOutputTokens?: number;
+  /** Presence penalty (-1 to 1). */
+  presencePenalty?: number;
+  /** Frequency penalty (-1 to 1). */
+  frequencyPenalty?: number;
+  /** Random seed for deterministic generation. */
+  seed?: number;
+  /** Sequences that stop generation when encountered. */
+  stopSequences?: string[];
+  /** Maximum number of retries for failed API calls. */
+  maxRetries?: number;
+}
+/**
+ * Advanced options for power users.
+ */
+interface AdvancedAgentOptions {
+  /** OpenTelemetry configuration for observability. */
+  experimental_telemetry?: ToolLoopAgentSettings["experimental_telemetry"];
+  /** Provider-specific options passed through to the model provider. */
+  providerOptions?: ToolLoopAgentSettings["providerOptions"];
+  /** Custom context passed to tool executions. */
+  experimental_context?: ToolLoopAgentSettings["experimental_context"];
+  /** Control which tool the model should call. */
+  toolChoice?: ToolLoopAgentSettings["toolChoice"];
+  /** Limit which tools are available for the model to call. */
+  activeTools?: string[];
+}
+/**
+ * Summarization configuration options.
+ */
+interface SummarizationConfig {
+  /** Enable automatic summarization when approaching token limits. */
+  enabled: boolean;
+  /** Token threshold to trigger summarization (default: 170000). */
+  tokenThreshold?: number;
+  /** Number of recent messages to keep intact without summarization (default: 6). */
+  keepMessages?: number;
+  /** Model to use for summarization. */
+  model?: LanguageModel$2;
+}
+/**
+ * Configuration parameters for creating a Deep Agent.
+ */
+interface CreateDeepAgentParams {
+  /** The AI SDK LanguageModel instance to use. */
+  model: LanguageModel$2;
+  /** Optional middleware to wrap the model. */
+  middleware?: LanguageModelMiddleware | LanguageModelMiddleware[];
+  /** Optional custom tools the agent should have access to. */
+  tools?: ToolSet;
+  /** Optional custom system prompt for the agent. */
+  systemPrompt?: string;
+  /** Optional list of subagent specifications for task delegation. */
+  subagents?: SubAgent[];
+  /** Optional backend for filesystem operations. */
+  backend?: BackendProtocol | BackendFactory;
+  /** Optional maximum number of steps for the agent loop (default: 100). */
+  maxSteps?: number;
+  /** Optional flag to include the general-purpose subagent (default: true). */
+  includeGeneralPurposeAgent?: boolean;
+  /** Optional token limit before evicting large tool results to filesystem. */
+  toolResultEvictionLimit?: number;
+  /** Optional flag to enable prompt caching (Anthropic only). */
+  enablePromptCaching?: boolean;
+  /** Optional summarization configuration. */
+  summarization?: SummarizationConfig;
+  /** Configuration for human-in-the-loop tool approval. */
+  interruptOn?: InterruptOnConfig;
+  /** Optional checkpointer for persisting agent state. */
+  checkpointer?: BaseCheckpointSaver;
+  /** @deprecated Use `agentId` instead. */
+  skillsDir?: string;
+  /** Optional agent identifier for loading agent-specific memory and skills. */
+  agentId?: string;
+  /** Optional configuration for structured output parsing. */
+  output?: {
+    schema: z.ZodType<any>;
+    description?: string;
+  };
+  /** Advanced loop control options. */
+  loopControl?: LoopControlOptions;
+  /** Advanced generation options. */
+  generationOptions?: GenerationOptions;
+  /** Advanced agent options. */
+  advancedOptions?: AdvancedAgentOptions;
+}
+//#endregion
+//#region src/types/events.d.ts
+/**
+ * Event emitted when text is streamed from the agent.
+ */
+interface TextEvent {
+  type: "text";
+  text: string;
+}
+/**
+ * Event emitted when a step starts.
+ */
+interface StepStartEvent {
+  type: "step-start";
+  stepNumber: number;
+}
+/**
+ * Event emitted when a step finishes.
+ */
+interface StepFinishEvent {
+  type: "step-finish";
+  stepNumber: number;
+  toolCalls: Array<{
+    toolName: string;
+    args: unknown;
+    result: unknown;
+  }>;
+}
+/**
+ * Event emitted when a tool is called.
+ */
+interface ToolCallEvent {
+  type: "tool-call";
+  toolName: string;
+  toolCallId: string;
+  args: unknown;
+}
+/**
+ * Event emitted when a tool returns a result.
+ */
+interface ToolResultEvent {
+  type: "tool-result";
+  toolName: string;
+  toolCallId: string;
+  result: unknown;
+  isError?: boolean;
+}
+/**
+ * Event emitted when the todo list changes.
+ */
+interface TodosChangedEvent {
+  type: "todos-changed";
+  todos: TodoItem[];
+}
+/**
+ * Event emitted when a file write starts (for preview).
+ */
+interface FileWriteStartEvent {
+  type: "file-write-start";
+  path: string;
+  content: string;
+}
+/**
+ * Event emitted when a file is written.
+ */
+interface FileWrittenEvent {
+  type: "file-written";
+  path: string;
+  content: string;
+}
+/**
+ * Event emitted when a file is edited.
+ */
+interface FileEditedEvent {
+  type: "file-edited";
+  path: string;
+  occurrences: number;
+}
+/**
+ * Event emitted when a file is read.
+ */
+interface FileReadEvent {
+  type: "file-read";
+  path: string;
+  /** Number of lines read */
+  lines: number;
+}
+/**
+ * Event emitted when listing directory contents.
+ */
+interface LsEvent {
+  type: "ls";
+  path: string;
+  /** Number of items found */
+  count: number;
+}
+/**
+ * Event emitted when searching with glob pattern.
+ */
+interface GlobEvent {
+  type: "glob";
+  pattern: string;
+  /** Number of files found */
+  count: number;
+}
+/**
+ * Event emitted when searching with grep.
+ */
+interface GrepEvent {
+  type: "grep";
+  pattern: string;
+  /** Number of matches found */
+  count: number;
+}
+/**
+ * Event emitted when a command execution starts.
+ */
+interface ExecuteStartEvent {
+  type: "execute-start";
+  /** The command being executed */
+  command: string;
+  /** The sandbox ID where the command is running */
+  sandboxId: string;
+}
+/**
+ * Event emitted when a command execution finishes.
+ */
+interface ExecuteFinishEvent {
+  type: "execute-finish";
+  /** The command that was executed */
+  command: string;
+  /** Exit code (0 = success, non-zero = failure, null = unknown/timeout) */
+  exitCode: number | null;
+  /** Whether the output was truncated */
+  truncated: boolean;
+  /** The sandbox ID where the command ran */
+  sandboxId: string;
+}
+/**
+ * Event emitted when a web search starts.
+ */
+interface WebSearchStartEvent {
+  type: "web-search-start";
+  /** The search query */
+  query: string;
+}
+/**
+ * Event emitted when a web search finishes.
+ */
+interface WebSearchFinishEvent {
+  type: "web-search-finish";
+  /** The search query */
+  query: string;
+  /** Number of results returned */
+  resultCount: number;
+}
+/**
+ * Event emitted when an HTTP request starts.
+ */
+interface HttpRequestStartEvent {
+  type: "http-request-start";
+  /** The request URL */
+  url: string;
+  /** HTTP method (GET, POST, etc.) */
+  method: string;
+}
+/**
+ * Event emitted when an HTTP request finishes.
+ */
+interface HttpRequestFinishEvent {
+  type: "http-request-finish";
+  /** The request URL */
+  url: string;
+  /** HTTP status code */
+  statusCode: number;
+}
+/**
+ * Event emitted when a URL fetch starts.
+ */
+interface FetchUrlStartEvent {
+  type: "fetch-url-start";
+  /** The URL being fetched */
+  url: string;
+}
+/**
+ * Event emitted when a URL fetch finishes.
+ */
+interface FetchUrlFinishEvent {
+  type: "fetch-url-finish";
+  /** The URL that was fetched */
+  url: string;
+  /** Whether extraction was successful */
+  success: boolean;
+}
+/**
+ * Event emitted when a subagent starts.
+ */
+interface SubagentStartEvent {
+  type: "subagent-start";
+  name: string;
+  task: string;
+}
+/**
+ * Event emitted when a subagent finishes.
+ */
+interface SubagentFinishEvent {
+  type: "subagent-finish";
+  name: string;
+  result: string;
+}
+/**
+ * Event emitted when a subagent completes a step with tool calls.
+ */
+interface SubagentStepEvent {
+  type: "subagent-step";
+  stepIndex: number;
+  toolCalls: Array<{
+    toolName: string;
+    args: any;
+    result: any;
+  }>;
+}
+/**
+ * Event emitted for a segment of text (used for CLI display).
+ * Text segments are flushed before tool events to maintain chronological order.
+ */
+interface TextSegmentEvent {
+  type: "text-segment";
+  text: string;
+}
+/**
+ * Event emitted when a user sends a message (used for CLI history).
+ */
+interface UserMessageEvent {
+  type: "user-message";
+  content: string;
+}
+/**
+ * Event emitted when the agent is done.
+ */
+interface DoneEvent {
+  type: "done";
+  state: DeepAgentState;
+  text?: string;
+  /** Updated conversation history including the assistant's response */
+  messages?: ModelMessage[];
+  /** Structured output if schema was provided (validated by Zod) */
+  output?: unknown;
+}
+/**
+ * Event emitted when an error occurs.
+ */
+interface ErrorEvent {
+  type: "error";
+  error: Error;
+}
+/**
+ * Event emitted when a tool requires approval before execution.
+ */
+interface ApprovalRequestedEvent {
+  type: "approval-requested";
+  /** Unique ID for this approval request */
+  approvalId: string;
+  /** The tool call ID */
+  toolCallId: string;
+  /** Name of the tool requiring approval */
+  toolName: string;
+  /** Arguments that will be passed to the tool */
+  args: unknown;
+}
+/**
+ * Event emitted when user responds to an approval request.
+ */
+interface ApprovalResponseEvent {
+  type: "approval-response";
+  /** The approval ID being responded to */
+  approvalId: string;
+  /** Whether the tool was approved */
+  approved: boolean;
+}
+/**
+ * Event emitted when a checkpoint is saved.
+ */
+interface CheckpointSavedEvent {
+  type: "checkpoint-saved";
+  /** Thread ID */
+  threadId: string;
+  /** Step number */
+  step: number;
+}
+/**
+ * Event emitted when a checkpoint is loaded.
+ */
+interface CheckpointLoadedEvent {
+  type: "checkpoint-loaded";
+  /** Thread ID */
+  threadId: string;
+  /** Step number from loaded checkpoint */
+  step: number;
+  /** Number of messages restored */
+  messagesCount: number;
+}
+/**
+ * Union type of all possible Deep Agent events.
+ */
+type DeepAgentEvent = TextEvent | StepStartEvent | StepFinishEvent | ToolCallEvent | ToolResultEvent | TodosChangedEvent | FileWriteStartEvent | FileWrittenEvent | FileEditedEvent | FileReadEvent | LsEvent | GlobEvent | GrepEvent | ExecuteStartEvent | ExecuteFinishEvent | WebSearchStartEvent | WebSearchFinishEvent | HttpRequestStartEvent | HttpRequestFinishEvent | FetchUrlStartEvent | FetchUrlFinishEvent | SubagentStartEvent | SubagentFinishEvent | SubagentStepEvent | TextSegmentEvent | UserMessageEvent | ApprovalRequestedEvent | ApprovalResponseEvent | CheckpointSavedEvent | CheckpointLoadedEvent | DoneEvent | ErrorEvent;
+/**
+ * Callback function for handling Deep Agent events.
+ */
+type EventCallback = (event: DeepAgentEvent) => void;
+/**
+ * Options for streamWithEvents method.
+ */
+interface StreamWithEventsOptions {
+  /** @deprecated Use messages instead for better conversation context support */
+  /** The user's prompt/message */
+  prompt?: string;
+  /** Maximum number of steps for the agent loop */
+  maxSteps?: number;
+  /** Shared state for todos and files */
+  state?: DeepAgentState;
+  /** Conversation history for multi-turn conversations. Takes precedence over prompt. */
+  messages?: ModelMessage[];
+  /** Signal to abort the generation */
+  abortSignal?: AbortSignal;
+  /**
+   * Thread ID for checkpoint persistence.
+   * When provided with a checkpointer, enables:
+   * - Auto-saving checkpoints after each step
+   * - Loading previous conversation state on start
+   * - Resume from interrupts
+   */
+  threadId?: string;
+  /**
+   * Resume options for continuing from an interrupt.
+   * Use when resuming from a tool approval request.
+   */
+  resume?: ResumeOptions;
+  /**
+   * Callback to handle tool approval requests.
+   * Return true to approve, false to deny.
+   * If not provided, tools requiring approval will be auto-denied.
+   */
+  onApprovalRequest?: (request: {
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+  }) => Promise<boolean>;
+}
+//#endregion
+//#region src/types/structured-output.d.ts
+/**
+ * Interface for agent results that include structured output
+ */
+interface StructuredAgentResult<T = unknown> {
+  text: string;
+  output?: T;
+  state?: any;
+  messages?: any[];
+}
+/**
+ * Type guard for checking if a result has structured output
+ */
+declare function hasStructuredOutput<T>(result: any): result is StructuredAgentResult<T>;
+/**
+ * Type guard for checking if an event has structured output
+ */
+declare function eventHasStructuredOutput<T>(event: any): event is {
+  type: "done";
+  output: T;
+};
+/**
+ * Extract structured output from agent result with type safety
+ */
+declare function getStructuredOutput<T>(result: any): T | undefined;
+/**
+ * Extract structured output from event with type safety
+ */
+declare function getEventOutput<T>(event: any): T | undefined;
+//#endregion
+//#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<ai2.GenerateTextResult<{}, never> & {
+    state: DeepAgentState;
+  }>;
+  /**
+   * Stream a response.
+   */
+  stream(options: {
+    prompt: string;
+    maxSteps?: number;
+  }): Promise<ai2.StreamTextResult<{}, never> & {
+    state: DeepAgentState;
+  }>;
+  /**
+   * Generate with an existing state (for continuing conversations).
+   */
+  generateWithState(options: {
+    prompt: string;
+    state: DeepAgentState;
+    maxSteps?: number;
+  }): Promise<ai2.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-BDM-PIu8.d.mts.map