@samrahimi/smol-js 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -36,10 +36,23 @@ interface ToolInput {
     description: string;
     required?: boolean;
     default?: unknown;
+    enum?: string[];
 }
 interface ToolInputs {
     [key: string]: ToolInput;
 }
+interface OpenAIToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    };
+}
 interface CodeExecutionOutput {
     output: unknown;
     logs: string;
@@ -50,6 +63,7 @@ interface ActionOutput {
     output: unknown;
     isFinalAnswer: boolean;
 }
+type MemoryStrategy = 'truncate' | 'compact';
 interface AgentConfig$1 {
     model: Model$1;
     tools?: Tool$1[];
@@ -59,6 +73,12 @@ interface AgentConfig$1 {
     additionalAuthorizedImports?: string[];
     streamOutputs?: boolean;
     verboseLevel?: LogLevel;
+    persistent?: boolean;
+    maxContextLength?: number;
+    memoryStrategy?: MemoryStrategy;
+    customInstructions?: string;
+    maxTokens?: number;
+    temperature?: number;
 }
 interface ModelConfig {
     modelId?: string;
@@ -94,12 +114,20 @@ interface ActionStep extends MemoryStep {
     modelInputMessages: ChatMessage[];
     modelOutputMessage?: ChatMessage;
     codeAction?: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolCallResult[];
     observation?: string;
     actionOutput?: ActionOutput;
     tokenUsage?: TokenUsage;
     error?: Error;
     isFinalAnswer?: boolean;
 }
+interface ToolCallResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    error?: string;
+}
 interface FinalAnswerStep extends MemoryStep {
     type: 'final';
     answer: unknown;
@@ -121,6 +149,7 @@ interface Tool$1 {
     outputType: string;
     execute: (args: Record<string, unknown>) => Promise<unknown>;
     toCodePrompt: () => string;
+    toOpenAITool: () => OpenAIToolDefinition;
 }
 interface Model$1 {
     modelId: string;
@@ -132,6 +161,51 @@ interface GenerateOptions {
     maxTokens?: number;
     temperature?: number;
     tools?: Tool$1[];
+    toolDefinitions?: OpenAIToolDefinition[];
+}
+interface YAMLAgentDefinition {
+    name: string;
+    type: 'ToolUseAgent' | 'CodeAgent';
+    description?: string;
+    model?: YAMLModelDefinition;
+    tools?: string[];
+    agents?: string[];
+    maxSteps?: number;
+    maxTokens?: number;
+    temperature?: number;
+    persistent?: boolean;
+    maxContextLength?: number;
+    memoryStrategy?: MemoryStrategy;
+    customInstructions?: string;
+    systemPrompt?: string;
+}
+interface YAMLModelDefinition {
+    modelId?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    maxTokens?: number;
+    temperature?: number;
+    timeout?: number;
+}
+interface YAMLWorkflowDefinition {
+    name: string;
+    description?: string;
+    model?: YAMLModelDefinition;
+    tools?: Record<string, YAMLToolDefinition>;
+    agents?: Record<string, YAMLAgentDefinition>;
+    entrypoint: string;
+    globalMaxContextLength?: number;
+}
+interface YAMLToolDefinition {
+    type: string;
+    config?: Record<string, unknown>;
+}
+interface OrchestratorEvent {
+    type: 'agent_start' | 'agent_step' | 'agent_tool_call' | 'agent_observation' | 'agent_end' | 'agent_error';
+    agentName: string;
+    depth: number;
+    data: unknown;
+    timestamp: number;
 }
 
 /**
@@ -189,6 +263,14 @@ declare abstract class Tool {
      * Used in the CodeAgent system prompt.
      */
     toCodePrompt(): string;
+    /**
+     * Generate an OpenAI-compatible tool definition for function calling.
+     */
+    toOpenAITool(): OpenAIToolDefinition;
+    /**
+     * Convert tool input type to JSON Schema type.
+     */
+    protected typeToJsonSchemaType(type: ToolInputType): string;
     /**
      * Convert tool input type to JS/TS type string.
      */
@@ -246,61 +328,59 @@ declare abstract class Model {
 }
 
 /**
- * AgentMemory - Tracks agent execution history
- *
- * Stores all steps taken by the agent and converts them to messages
- * that can be sent to the LLM for context.
+ * AgentMemory - Tracks agent execution history with context management
  */
 
+interface MemoryConfig {
+    maxContextLength?: number;
+    memoryStrategy?: MemoryStrategy;
+    model?: Model$1;
+}
 declare class AgentMemory {
-    /**
-     * System prompt step (always first)
-     */
+    /** System prompt step (always first) */
     systemPrompt: SystemPromptStep;
-    /**
-     * All execution steps
-     */
+    /** All execution steps */
     steps: (TaskStep | ActionStep | FinalAnswerStep)[];
-    constructor(systemPrompt: string);
-    /**
-     * Reset memory, keeping only the system prompt.
-     */
+    private maxContextLength;
+    private memoryStrategy;
+    private model?;
+    constructor(systemPrompt: string, config?: MemoryConfig);
+    /** Reset memory, keeping only the system prompt */
     reset(): void;
-    /**
-     * Add a task step.
-     */
+    /** Add a task step */
     addTask(task: string): TaskStep;
-    /**
-     * Create a new action step.
-     */
+    /** Create a new action step */
     createActionStep(stepNumber: number): ActionStep;
-    /**
-     * Add a final answer step.
-     */
+    /** Add a final answer step */
     addFinalAnswer(answer: unknown): FinalAnswerStep;
-    /**
-     * Get the last step.
-     */
+    /** Get the last step */
     getLastStep(): MemoryStep | undefined;
-    /**
-     * Get all action steps.
-     */
+    /** Get all action steps */
     getActionSteps(): ActionStep[];
     /**
      * Convert memory to messages for LLM context.
+     * Handles both CodeAgent (observation-based) and ToolUseAgent (tool_call-based) patterns.
      */
     toMessages(): ChatMessage[];
     /**
-     * Get total token usage across all steps.
+     * Manage context length - truncate or compact if exceeded.
      */
-    getTotalTokenUsage(): TokenUsage;
+    manageContext(): Promise<void>;
     /**
-     * Get a summary of the memory for logging.
+     * Truncate older action steps to fit within context.
      */
-    getSummary(): string;
+    private truncateOlderMessages;
     /**
-     * Serialize memory to JSON.
+     * Compact older messages into a summary.
      */
+    private compactMessages;
+    /** Get total token usage across all steps */
+    getTotalTokenUsage(): TokenUsage;
+    /** Get current estimated token count */
+    getEstimatedTokenCount(): number;
+    /** Get a summary of the memory for logging */
+    getSummary(): string;
+    /** Serialize memory to JSON */
     toJSON(): Record<string, unknown>;
 }
 
@@ -414,68 +494,71 @@ declare class AgentLogger {
  */
 
 interface AgentConfig {
-    /**
-     * The LLM model to use for generation
-     */
+    /** The LLM model to use for generation */
     model: Model;
-    /**
-     * Tools available to the agent
-     */
+    /** Tools available to the agent */
     tools?: Tool[];
-    /**
-     * Maximum number of steps before stopping
-     * @default 20
-     */
+    /** Maximum number of steps before stopping (default: 20) */
     maxSteps?: number;
-    /**
-     * Delay in milliseconds before executing code (for user interruption)
-     * @default 5000
-     */
+    /** Delay in ms before executing code (default: 5000) */
     codeExecutionDelay?: number;
-    /**
-     * Custom system prompt (will be merged with generated prompt)
-     */
+    /** Custom instructions appended to system prompt */
     customInstructions?: string;
-    /**
-     * Log level for output
-     * @default LogLevel.INFO
-     */
+    /** Log level for output (default: INFO) */
     verboseLevel?: LogLevel;
-    /**
-     * Whether to stream model outputs
-     * @default true
-     */
+    /** Whether to stream model outputs (default: true) */
     streamOutputs?: boolean;
+    /** Whether the agent retains memory between run() calls (default: false) */
+    persistent?: boolean;
+    /** Max context length in tokens (default: 100000) */
+    maxContextLength?: number;
+    /** Memory management strategy when context is exceeded (default: 'truncate') */
+    memoryStrategy?: MemoryStrategy;
+    /** Max tokens for generation (passed to model if set) */
+    maxTokens?: number;
+    /** Temperature for generation (passed to model if set) */
+    temperature?: number;
+    /** Agent name for logging */
+    name?: string;
+    /** Callback for orchestration events */
+    onEvent?: (event: {
+        type: string;
+        data: unknown;
+    }) => void;
 }
 declare abstract class Agent {
-    /**
-     * The LLM model for generation
-     */
+    /** The LLM model for generation */
     protected model: Model;
-    /**
-     * Available tools mapped by name
-     */
+    /** Available tools mapped by name */
     protected tools: Map<string, Tool>;
-    /**
-     * Agent memory tracking all steps
-     */
+    /** Agent memory tracking all steps */
     protected memory: AgentMemory;
-    /**
-     * Logger for formatted output
-     */
+    /** Logger for formatted output */
     protected logger: AgentLogger;
-    /**
-     * Configuration options
-     */
-    protected config: Required<Omit<AgentConfig, 'model' | 'tools'>>;
-    /**
-     * Current step number
-     */
+    /** Configuration options */
+    protected config: {
+        maxSteps: number;
+        codeExecutionDelay: number;
+        customInstructions: string;
+        verboseLevel: LogLevel;
+        streamOutputs: boolean;
+        persistent: boolean;
+        maxContextLength: number;
+        memoryStrategy: MemoryStrategy;
+        maxTokens?: number;
+        temperature?: number;
+        name: string;
+        onEvent?: (event: {
+            type: string;
+            data: unknown;
+        }) => void;
+    };
+    /** Current step number */
     protected currentStep: number;
-    /**
-     * Whether the agent is currently running
-     */
+    /** Whether the agent is currently running */
     protected isRunning: boolean;
+    /** Whether the agent has been initialized at least once */
+    private initialized;
     constructor(config: AgentConfig);
     /**
      * Initialize the system prompt for the agent.
@@ -485,46 +568,31 @@ declare abstract class Agent {
     /**
      * Execute a single step in the agent loop.
      * Must be implemented by subclasses.
-     *
-     * @param memoryStep - The memory step to populate with execution results
-     * @returns The action output from this step
      */
     protected abstract executeStep(memoryStep: ActionStep): Promise<ActionOutput>;
     /**
      * Run the agent on a task.
-     *
-     * @param task - The task description
-     * @param reset - Whether to reset memory before running
-     * @returns The final result
      */
     run(task: string, reset?: boolean): Promise<RunResult>;
     /**
      * Generate a final answer when max steps is reached.
      */
     protected provideFinalAnswer(task: string): Promise<unknown>;
-    /**
-     * Stop the agent.
-     */
+    /** Emit an orchestration event */
+    protected emitEvent(type: string, data: unknown): void;
+    /** Stop the agent */
     stop(): void;
-    /**
-     * Get the current memory.
-     */
+    /** Get the current memory */
     getMemory(): AgentMemory;
-    /**
-     * Get registered tools.
-     */
+    /** Get registered tools */
     getTools(): Map<string, Tool>;
-    /**
-     * Add a tool to the agent.
-     */
+    /** Add a tool to the agent */
     addTool(tool: Tool): void;
-    /**
-     * Remove a tool from the agent.
-     */
+    /** Remove a tool from the agent */
     removeTool(name: string): boolean;
-    /**
-     * Sleep for a specified duration.
-     */
+    /** Get agent name */
+    getName(): string;
+    /** Sleep for a specified duration */
     protected sleep(ms: number): Promise<void>;
 }
 
@@ -681,6 +749,44 @@ declare class CodeAgent extends Agent {
     addTool(tool: Tool): void;
 }
 
+/**
+ * ToolUseAgent - Executes tasks using standard OpenAI-style tool calls
+ *
+ * Unlike CodeAgent which generates and executes JavaScript code,
+ * ToolUseAgent operates by making tool calls through the LLM's native
+ * function calling capabilities, following the ReACT pattern:
+ * Think -> Act (tool call) -> Observe (result) -> repeat
+ */
+
+interface ToolUseAgentConfig extends AgentConfig {
+    /** Whether to run independent tool calls in parallel (default: true) */
+    parallelToolCalls?: boolean;
+}
+declare class ToolUseAgent extends Agent {
+    private parallelToolCalls;
+    constructor(config: ToolUseAgentConfig);
+    /**
+     * Initialize the system prompt with tool descriptions.
+     */
+    protected initializeSystemPrompt(): string;
+    /**
+     * Execute a single step: send messages with tool definitions, process tool calls.
+     */
+    protected executeStep(memoryStep: ActionStep): Promise<ActionOutput>;
+    /**
+     * Process tool calls from the model response.
+     */
+    private processToolCalls;
+    /**
+     * Override provideFinalAnswer to use tool calling format.
+     */
+    protected provideFinalAnswer(task: string): Promise<unknown>;
+    /**
+     * Add a tool, which can also be an Agent instance (auto-wraps with AgentTool).
+     */
+    addTool(tool: Tool): void;
+}
+
 /**
  * OpenAI-compatible Model implementation
  *
@@ -703,11 +809,11 @@ interface OpenAIModelConfig {
      */
     baseUrl?: string;
     /**
-     * Maximum tokens to generate
+     * Maximum tokens to generate (omitted from requests by default)
      */
     maxTokens?: number;
     /**
-     * Temperature for generation (0-2)
+     * Temperature for generation (omitted from requests by default)
      */
     temperature?: number;
     /**
@@ -725,7 +831,7 @@ declare class OpenAIModel extends Model {
     private config;
     constructor(config?: OpenAIModelConfig);
     /**
-     * Generate a response from the model.
+     * Generate a response from the model (supports tool calling).
      */
     generate(messages: ChatMessage[], options?: GenerateOptions): Promise<ChatMessage>;
     /**
@@ -733,7 +839,7 @@ declare class OpenAIModel extends Model {
      */
     generateStream(messages: ChatMessage[], options?: GenerateOptions): AsyncGenerator<string, ChatMessage, undefined>;
     /**
-     * Format messages for the OpenAI API.
+     * Format messages for the OpenAI API, including tool call/response messages.
      */
     protected formatMessages(messages: ChatMessage[]): OpenAI.Chat.ChatCompletionMessageParam[];
 }
@@ -826,6 +932,115 @@ declare class AgentTool extends Tool {
  */
 declare function agentAsTool(agent: Agent, options?: Omit<AgentToolConfig, 'agent'>): AgentTool;
 
+/**
+ * ReadFileTool - Read contents from a file
+ */
+
+declare class ReadFileTool extends Tool {
+    readonly name = "read_file";
+    readonly description = "Read the contents of a file at the specified path. Returns the file content as a string.";
+    readonly inputs: ToolInputs;
+    readonly outputType = "string";
+    private workingDirectory;
+    constructor(config?: {
+        workingDirectory?: string;
+    });
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+
+/**
+ * WriteFileTool - Write content to a file
+ */
+
+declare class WriteFileTool extends Tool {
+    readonly name = "write_file";
+    readonly description = "Write content to a file at the specified path. Creates the file if it does not exist, and creates parent directories as needed. Overwrites existing content by default.";
+    readonly inputs: ToolInputs;
+    readonly outputType = "string";
+    private workingDirectory;
+    constructor(config?: {
+        workingDirectory?: string;
+    });
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+
+/**
+ * CurlTool - HTTP requests (GET/POST) using fetch
+ */
+
+declare class CurlTool extends Tool {
+    readonly name = "curl";
+    readonly description = "Make HTTP requests to any URL. Supports GET and POST methods with custom headers and body. Returns the response body as text.";
+    readonly inputs: ToolInputs;
+    readonly outputType = "string";
+    private timeout;
+    constructor(config?: {
+        timeout?: number;
+    });
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+
+/**
+ * ExaSearchTool - Web search using the Exa.ai API
+ *
+ * Uses Exa's embeddings-based search for semantically intelligent results.
+ */
+
+interface ExaSearchConfig {
+    apiKey?: string;
+}
+declare class ExaSearchTool extends Tool {
+    readonly name = "exa_search";
+    readonly description = "Search the web using Exa.ai semantic search. Returns relevant web pages with titles, URLs, and optionally content snippets. Use this for finding information, research, and fact-checking.";
+    readonly inputs: ToolInputs;
+    readonly outputType = "string";
+    private apiKey;
+    constructor(config?: ExaSearchConfig);
+    setup(): Promise<void>;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+
+/**
+ * ExaGetContentsTool - Get webpage contents using Exa.ai API
+ *
+ * Fetches and extracts clean text content from web pages.
+ */
+
+interface ExaGetContentsConfig {
+    apiKey?: string;
+}
+declare class ExaGetContentsTool extends Tool {
+    readonly name = "exa_get_contents";
+    readonly description = "Get the full text content of one or more web pages using Exa.ai. Returns cleaned, readable text extracted from the HTML. Use this to read articles, documentation, or any web page content.";
+    readonly inputs: ToolInputs;
+    readonly outputType = "string";
+    private apiKey;
+    constructor(config?: ExaGetContentsConfig);
+    setup(): Promise<void>;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+
+/**
+ * ExaResearchTool - Deep research on a topic using Exa.ai
+ *
+ * Performs multi-step research by combining search and content retrieval
+ * to produce comprehensive findings on a topic.
+ */
+
+interface ExaResearchConfig {
+    apiKey?: string;
+}
+declare class ExaResearchTool extends Tool {
+    readonly name = "exa_research";
+    readonly description = "Perform deep research on a single topic using Exa.ai. Searches for relevant sources, retrieves their content, and finds similar pages for comprehensive coverage. Returns a structured research summary with sources. Use this for thorough research on any topic.";
+    readonly inputs: ToolInputs;
+    readonly outputType = "string";
+    private apiKey;
+    constructor(config?: ExaResearchConfig);
+    setup(): Promise<void>;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+
 /**
  * System prompts for CodeAgent
  *
@@ -849,4 +1064,137 @@ declare const FINAL_ANSWER_PROMPT = "Based on the steps you've taken so far, pro
  */
 declare function getErrorRecoveryPrompt(error: string): string;
 
-export { type ActionOutput, type ActionStep, Agent, type AgentConfig, type AgentConfig$1 as AgentConfigType, AgentLogger, AgentMemory, AgentTool, type AgentToolConfig, type ChatMessage, CodeAgent, type CodeAgentConfig, type CodeExecutionOutput, type ExecutorConfig, FINAL_ANSWER_PROMPT, type FinalAnswerStep, FinalAnswerTool, type GenerateOptions, LocalExecutor, LogLevel, type MemoryStep, type MessageRole, Model, type ModelConfig, OpenAIModel, type OpenAIModelConfig, type PromptVariables, type RunResult, type StreamEvent, type SystemPromptStep, type TaskStep, type Timing, type TokenUsage, Tool, type ToolCall, type ToolInput, type ToolInputType, type ToolInputs, UserInputTool, agentAsTool, createTool, finalAnswerTool, generateSystemPrompt, getErrorRecoveryPrompt };
+/**
+ * System prompts for ToolUseAgent
+ */
+interface ToolUsePromptVariables {
+    tools: string;
+    customInstructions?: string;
+    /** Whether this agent has sub-agents (AgentTool instances) */
+    hasSubAgents?: boolean;
+    /** Whether this agent has file tools (read_file, write_file) */
+    hasFileTools?: boolean;
+}
+/**
+ * Generate the system prompt for ToolUseAgent.
+ */
+declare function generateToolUseSystemPrompt(variables: ToolUsePromptVariables): string;
+/**
+ * Format tool descriptions for the system prompt.
+ */
+declare function formatToolDescriptions(tools: Array<{
+    name: string;
+    description: string;
+    inputs: Record<string, {
+        type: string;
+        description: string;
+        required?: boolean;
+    }>;
+}>): string;
+
+/**
+ * YAMLLoader - Loads and parses YAML workflow definitions into runnable agents
+ */
+
+interface LoadedWorkflow {
+    name: string;
+    description?: string;
+    entrypointAgent: Agent;
+    agents: Map<string, Agent>;
+    tools: Map<string, Tool>;
+}
+declare class YAMLLoader {
+    private customTools;
+    /**
+     * Register a custom tool type for use in YAML definitions.
+     */
+    registerToolType(typeName: string, toolClass: new (config?: Record<string, unknown>) => Tool): void;
+    /**
+     * Load a workflow from a YAML file path.
+     */
+    loadFromFile(filePath: string): LoadedWorkflow;
+    /**
+     * Load a workflow from a YAML string.
+     */
+    loadFromString(yamlContent: string): LoadedWorkflow;
+    /**
+     * Build a runnable workflow from a parsed definition.
+     */
+    private buildWorkflow;
+    /**
+     * Build a tool instance from a type name and config.
+     */
+    private buildTool;
+    /**
+     * Build an agent instance from a YAML definition.
+     */
+    private buildAgent;
+}
+
+/**
+ * Orchestrator - Loads, runs, and provides real-time visibility into agent execution
+ */
+
+interface OrchestratorConfig {
+    /** Whether to display real-time output (default: true) */
+    verbose?: boolean;
+    /** Callback for orchestrator events */
+    onEvent?: (event: OrchestratorEvent) => void;
+}
+declare class Orchestrator {
+    private loader;
+    private config;
+    private activeAgents;
+    private eventLog;
+    constructor(config?: OrchestratorConfig);
+    /**
+     * Load a workflow from a YAML file.
+     */
+    loadWorkflow(filePath: string): LoadedWorkflow;
+    /**
+     * Load a workflow from YAML string.
+     */
+    loadWorkflowFromString(yamlContent: string): LoadedWorkflow;
+    /**
+     * Run a loaded workflow with a task.
+     */
+    runWorkflow(workflow: LoadedWorkflow, task: string): Promise<RunResult>;
+    /**
+     * Run a standalone agent with a task.
+     */
+    runAgent(agent: Agent, task: string): Promise<RunResult>;
+    /**
+     * Instrument an agent with orchestrator event tracking.
+     */
+    private instrumentAgent;
+    /**
+     * Display workflow info at startup.
+     */
+    private displayWorkflowInfo;
+    /**
+     * Display run start info.
+     */
+    private displayRunStart;
+    /**
+     * Display run completion info.
+     */
+    private displayRunEnd;
+    /**
+     * Display an error.
+     */
+    private displayError;
+    /**
+     * Log an orchestration event.
+     */
+    logEvent(event: OrchestratorEvent): void;
+    /**
+     * Get the event log.
+     */
+    getEventLog(): OrchestratorEvent[];
+    /**
+     * Get the YAML loader for registering custom tools.
+     */
+    getLoader(): YAMLLoader;
+}
+
+export { type ActionOutput, type ActionStep, Agent, type AgentConfig, type AgentConfig$1 as AgentConfigType, AgentLogger, AgentMemory, AgentTool, type AgentToolConfig, type ChatMessage, CodeAgent, type CodeAgentConfig, type CodeExecutionOutput, CurlTool, ExaGetContentsTool, ExaResearchTool, ExaSearchTool, type ExecutorConfig, FINAL_ANSWER_PROMPT, type FinalAnswerStep, FinalAnswerTool, type GenerateOptions, type LoadedWorkflow, LocalExecutor, LogLevel, type MemoryStep, type MemoryStrategy, type MessageRole, Model, type ModelConfig, OpenAIModel, type OpenAIModelConfig, type OpenAIToolDefinition, Orchestrator, type OrchestratorConfig, type OrchestratorEvent, type PromptVariables, ReadFileTool, type RunResult, type StreamEvent, type SystemPromptStep, type TaskStep, type Timing, type TokenUsage, Tool, type ToolCall, type ToolCallResult, type ToolInput, type ToolInputType, type ToolInputs, ToolUseAgent, type ToolUseAgentConfig, type ToolUsePromptVariables, UserInputTool, WriteFileTool, type YAMLAgentDefinition, YAMLLoader, type YAMLModelDefinition, type YAMLToolDefinition, type YAMLWorkflowDefinition, agentAsTool, createTool, finalAnswerTool, formatToolDescriptions, generateSystemPrompt, generateToolUseSystemPrompt, getErrorRecoveryPrompt };