evoltagent 1.1.1 → 1.1.2

package/dist/index.d.ts

@@ -0,0 +1,1052 @@
+/**
+ * Post-run hooks for agent output processing
+ *
+ * PostProcessor allows transformation of agent output from raw string response
+ * to structured data (e.g., JSON parsing, data validation, formatting)
+ */
+/**
+ * PostProcessor function type
+ *
+ * Takes the raw string response from an agent and transforms it into
+ * any desired format. Commonly used for:
+ * - Parsing JSON responses
+ * - Extracting structured data
+ * - Validating and transforming output
+ * - Converting to domain-specific types
+ *
+ * @param response - Raw string response from agent
+ * @returns Transformed output (any type)
+ *
+ * @example
+ * ```typescript
+ * // JSON parser post-processor
+ * const jsonParser: PostProcessor = async (text) => {
+ *   const match = text.match(/```json\n([\s\S]+?)\n```/);
+ *   return match ? JSON.parse(match[1]) : JSON.parse(text);
+ * };
+ *
+ * const agent = new Agent({
+ *   name: "DataAgent",
+ *   post_processor: jsonParser
+ * });
+ *
+ * const data = await agent.run("Generate user data");
+ * // Returns: { name: "John", age: 30 }
+ * ```
+ */
+type PostProcessor = (response: string) => Promise<any>;
+
+/**
+ * Core type definitions for evoltagent
+ */
+
+interface Message$1 {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    images?: string | string[];
+    type?: string;
+}
+interface ToolCall {
+    type: 'system' | 'user';
+    extractedResult: () => string;
+}
+interface ModelResponse$1 {
+    type: 'system' | 'user' | 'TaskCompletion';
+    extractedResult: () => string | any[] | Record<string, any>;
+    rawContentFromLlm?: string;
+}
+interface ToolDescription {
+    desc: string;
+    execute: (...args: any[]) => Promise<any>;
+    argNames: string[];
+    serverName?: string;
+    inputSchema?: Record<string, any>;
+}
+interface ToolStore {
+    addTool: (name: string, desc: string, execute: (...args: any[]) => Promise<any>, argNames: string[], serverName?: string, inputSchema?: Record<string, any>) => void;
+    addMcpTools: (agentName: string, serverName: string, stack: any) => Promise<void>;
+    getMcpToolsSchemas: (agentName: string, serverName: string, provider: string) => any[];
+    getTool: (name: string) => ToolDescription | undefined;
+    hasTool: (name: string) => boolean;
+    listTools: () => string[];
+    toDict?: (provider?: string) => any[];
+    contains: (name: string) => boolean;
+    getItem: (name: string) => ToolDescription;
+    items: () => [string, ToolDescription][];
+    keys: () => string[];
+    readonly length: number;
+    toToolSchema: (name: string, tool: ToolDescription, provider?: string) => any;
+    getToolcallSchema: (toolName: string, provider?: string) => any;
+}
+interface ModelConfig {
+    provider: string;
+    model: string;
+    apiKey: string;
+    baseUrl: string;
+    contextWindowTokens: number;
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    stream?: boolean;
+    [key: string]: any;
+}
+interface AgentConfig {
+    name: string;
+    profile: string;
+    system?: string;
+    tools?: string[];
+    subAgents?: any[];
+    mcpServerNames?: string[];
+    modelConfig?: string | ModelConfig;
+    verbose?: boolean | number;
+    useFunctionCalling?: boolean;
+    postProcessor?: PostProcessor;
+    toolcallManagerPoolSize?: number;
+}
+interface EnvironmentConfig {
+    workspace?: string;
+    [key: string]: any;
+}
+declare class EvoltError extends Error {
+    constructor(message: string);
+}
+declare class ToolExecutionError extends EvoltError {
+    constructor(message: string);
+}
+declare class ModelError extends EvoltError {
+    constructor(message: string);
+}
+
+/**
+ * Tool storage and management
+ *
+ * Python Evolt v0.1.5 Parity - Unified ToolStore implementation
+ */
+
+declare const SystemToolStore: ToolStore;
+declare const FunctionCallingStore: ToolStore;
+/**
+ * @deprecated Use FunctionCallingStore instead. This alias will be removed in v2.0.0
+ */
+declare const UserToolStore: ToolStore;
+
+/**
+ * Tool configuration types
+ * TypeScript-native way to define tool descriptions
+ */
+/**
+ * Tool parameter configuration
+ */
+interface ToolParam {
+    name: string;
+    type: string;
+    description: string;
+    optional?: boolean;
+}
+/**
+ * Tool return configuration
+ */
+interface ToolReturn {
+    type: string;
+    description: string;
+}
+/**
+ * Tool method configuration
+ */
+interface ToolMethodConfig {
+    description: string;
+    params?: ToolParam[];
+    returns?: ToolReturn;
+    examples?: string[];
+}
+/**
+ * Complete tool configuration
+ * Key is the method name (e.g., 'execute')
+ */
+type ToolConfig = Record<string, ToolMethodConfig>;
+
+/**
+ * TypeScript-native tool registration system
+ * Uses configuration objects instead of docstring parsing
+ */
+
+/**
+ * Unified tool registration decorator (Python parity)
+ * Registers methods to BOTH SystemToolStore and FunctionCallingStore
+ *
+ * This simplifies tool registration compared to using separate decorators.
+ * The decorator automatically handles both XML (system) and OpenAI (user) formats.
+ *
+ * @param config - Tool configuration with method definitions
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @tools({
+ *   execute: {
+ *     description: "Tool description",
+ *     params: [{ name: "param1", type: "string", description: "..." }],
+ *     returns: { type: "string", description: "..." }
+ *   }
+ * })
+ * export class MyTool {
+ *   async execute(param1: string): Promise<string> { ... }
+ * }
+ * ```
+ */
+declare function tools(config: ToolConfig): ClassDecorator;
+/**
+ * Register Agent as tool to SystemToolStore
+ */
+declare function registerAgentAsTool(agents: any, verbose?: boolean): string[];
+
+/**
+ * ThinkTool - Tool for internal reasoning without executing external actions
+ *
+ * TypeScript-native version using configuration objects
+ */
+/**
+ * ThinkTool class for internal reasoning
+ */
+declare class ThinkTool {
+    execute(thought: string): Promise<string>;
+}
+
+/**
+ * CommandTool - Command line tool for executing bash commands in background
+ *
+ * Converts Python's cmd_tool.py to TypeScript
+ */
+/**
+ * CommandTool class for executing commands in background
+ */
+declare class CommandLineTool {
+    execute(command: string, cwd?: string, env?: Record<string, string>): Promise<string>;
+    /**
+     * List all background processes.
+     *
+     * Returns:
+     *     str: The natural language description of the background process list
+     */
+    list(): Promise<string>;
+    /**
+     * Stop the specified background process.
+     *
+     * Args:
+     *     process_id (str): The process ID to stop
+     *     force (bool): Whether to force kill the process (using SIGKILL)
+     *
+     * Returns:
+     *     str: Natural language description of the operation result
+     */
+    stop(processId: string, force?: boolean): Promise<string>;
+    /**
+     * Clean up all background processes.
+     *
+     * Returns:
+     *     str: The natural language description of the cleanup result
+     */
+    cleanup(): Promise<string>;
+}
+
+/**
+ * FileEditor - Async file reader and editor
+ *
+ * Converts Python's file_tool.py to TypeScript
+ */
+/**
+ * FileEditor class for async file operations
+ */
+declare class FileEditor {
+    read(path: string, lineRange?: string): Promise<string>;
+    write(path: string, content: string): Promise<string>;
+    find(path: string, pattern: string): Promise<string>;
+    findAndReplace(path: string, pattern: string, replacement: string): Promise<string>;
+    insert(path: string, content: string, line?: number): Promise<string>;
+}
+
+/**
+ * ExtendStateMachineTool - Tool for writing ESM content to YAML files
+ *
+ * Converts Python's esm_tool.py to TypeScript
+ */
+/**
+ * ExtendStateMachineTool class for writing ESM content
+ */
+declare class ExtendStateMachineTool {
+    writeEsm(esmContent: string, filepath: string): Promise<string>;
+}
+
+/**
+ * ApiTool - Tool for writing API files and generating Golang files
+ *
+ * Converts Python's api_tool.py to TypeScript
+ */
+/**
+ * ApiTool class for API file operations
+ */
+declare class ApiTool {
+    write(apiFilePath: string, apiContent: string): Promise<string>;
+    generateGolangFilesFromApi(apiFilePath: string, dir: string): Promise<string>;
+}
+
+/**
+ * Reply2HumanTool - Tool for sending final human-facing replies
+ *
+ * Converts Python's reply2human.py to TypeScript
+ */
+/**
+ * Reply2HumanTool class for sending human-facing replies
+ */
+declare class Reply2HumanTool {
+    reply(reply: string): Promise<string>;
+}
+
+/**
+ * TodoListTool - Tool for editing todo list file for project
+ *
+ * Converts Python's todo_list.py to TypeScript
+ */
+/**
+ * TodoListTool class for managing todo lists
+ */
+declare class TodoListTool {
+    write(projectName: string, todoList: string, projectDir: string): Promise<string>;
+}
+
+/**
+ * WriteUIDesignDocument - Tool for writing UI Design Document files
+ *
+ * Converts Python's design_ui.py to TypeScript
+ */
+/**
+ * WriteUIDesignDocument class for UI design document operations
+ */
+declare class WriteUIDesignDocument {
+    write(uiDesignDocumentFileDir: string, elements: Record<string, any>[], composites: Record<string, any>[], pages: Record<string, any>[], functions: Record<string, any>[], styles: Record<string, any>[]): Promise<string>;
+}
+
+/**
+ * ReflectTool - Tool for reflecting on the state
+ *
+ * Converts Python's reflect.py to TypeScript
+ */
+/**
+ * ReflectTool class for state reflection
+ */
+declare class ReflectTool {
+    reflect(state: string): Promise<string>;
+    /**
+     * Set the reflection for agent to see.
+     */
+    setReflection(reflection: string): string;
+}
+
+/**
+ * SkillsTool - Tool for managing skills
+ *
+ * Converts Python's tools/skills.py to TypeScript
+ */
+/**
+ * SkillsTool class for managing skills
+ */
+declare class SkillsTool {
+    /**
+     * Skills directory
+     */
+    skillsDir: string;
+    constructor(skillsDir?: string);
+    /**
+     * Read the content of the skill description file.
+     *
+     * Args:
+     *     name (str): The name of the skill
+     *
+     * Returns:
+     *     str: The content of the skill description file
+     */
+    readSkillDescription(name: string): Promise<string>;
+    /**
+     * List the skills in the skills root directory
+     */
+    listSkills(): Promise<string>;
+}
+
+declare class GitTool {
+    /**
+     * Helper method to execute git commands.
+     */
+    private _executeGitCommand;
+    /**
+     * Get current branch name.
+     */
+    private _getCurrentBranch;
+    init(cwd?: string, bare?: boolean, initialBranch?: string, config?: Record<string, string>): Promise<string>;
+    status(cwd?: string, config?: Record<string, string>): Promise<string>;
+    add(files: string, cwd?: string, config?: Record<string, string>): Promise<string>;
+    commit(message: string, cwd?: string, allowEmpty?: boolean, config?: Record<string, string>): Promise<string>;
+    push(remote?: string, branch?: string, cwd?: string, force?: boolean, config?: Record<string, string>): Promise<string>;
+    pull(remote?: string, branch?: string, cwd?: string, config?: Record<string, string>): Promise<string>;
+    checkout(target: string, cwd?: string, createBranch?: boolean, config?: Record<string, string>): Promise<string>;
+    branch(name?: string, cwd?: string, deleteBranch?: boolean, config?: Record<string, string>): Promise<string>;
+    log(cwd?: string, maxCount?: number, oneline?: boolean, filePath?: string, config?: Record<string, string>): Promise<string>;
+    diff(cwd?: string, staged?: boolean, filePath?: string, commit1?: string, commit2?: string, config?: Record<string, string>): Promise<string>;
+    remote(action?: string, name?: string, url?: string, cwd?: string, config?: Record<string, string>): Promise<string>;
+    clone(url: string, directory?: string, cwd?: string, config?: Record<string, string>): Promise<string>;
+    fetch(remote?: string, cwd?: string, config?: Record<string, string>): Promise<string>;
+    merge(branch: string, cwd?: string, config?: Record<string, string>): Promise<string>;
+    show(object?: string, cwd?: string, stat?: boolean, nameOnly?: boolean, format?: string, config?: Record<string, string>): Promise<string>;
+    tag(name?: string, cwd?: string, message?: string, deleteTag?: boolean, listAll?: boolean, annotate?: boolean, config?: Record<string, string>): Promise<string>;
+    revert(commit: string, cwd?: string, noCommit?: boolean, noEdit?: boolean, mainline?: number, config?: Record<string, string>): Promise<string>;
+}
+
+/**
+ * Main Agent class with tool use capabilities
+ *
+ * Converts Python's agent.py to TypeScript
+ */
+
+/**
+ * Main Agent class
+ */
+declare class Agent {
+    name: string;
+    private profile;
+    private system;
+    private tools;
+    private functionCallingTools;
+    private mcpServerNames;
+    private modelConfig;
+    private verbose;
+    private model;
+    private history;
+    private subAgents;
+    private toolcallManagerPoolSize;
+    private postProcessor;
+    private useFunctionCalling;
+    constructor(config: AgentConfig);
+    /**
+     * Get the current system prompt
+     */
+    get systemPrompt(): string;
+    /**
+     * Set the system prompt and update history
+     */
+    set systemPrompt(value: string);
+    /**
+     * Set the system prompt with system tools descriptions
+     * @private
+     */
+    private setSystem;
+    /**
+     * Set up function calling tools for OpenAI-style function calling
+     * @private
+     */
+    private setFunctionCallingTools;
+    /**
+     * Agent loop - processes user input and handles tool calls
+     * @private
+     */
+    private _agentLoop;
+    /**
+     * Run the agent with given instruction
+     */
+    run(instruction: string, images?: string | string[]): Promise<string | any>;
+    /**
+     * Get agent profile
+     */
+    getProfile(): string;
+    /**
+     * Get tools
+     */
+    getTools(): string[];
+    /**
+     * Get function calling tools schemas
+     */
+    getFunctionCallingTools(): any[];
+    /**
+     * Get MCP server names
+     */
+    getMcpServerNames(): string[];
+    /**
+     * Get model config (string or ModelConfig object)
+     */
+    getModelConfig(): string | ModelConfig;
+    /**
+     * Get model name (for backward compatibility)
+     */
+    getModelName(): string;
+    /**
+     * Get verbose setting
+     */
+    getVerbose(): boolean | number;
+    /**
+     * Get sub-agents
+     */
+    getSubAgents(): any[];
+}
+
+/**
+ * Model abstraction layer using official SDKs
+ *
+ * Provides a unified interface for multiple LLM providers:
+ * - OpenAI (and compatible APIs like DeepSeek)
+ * - Anthropic Claude
+ * - Google Gemini
+ */
+
+/**
+ * Model response interface
+ */
+interface ModelResponse {
+    type: 'system' | 'user' | 'TaskCompletion';
+    extractedResult: () => string | any[] | Record<string, any>;
+    rawContentFromLlm?: string;
+}
+/**
+ * Model class for interacting with LLM providers
+ * Uses official SDKs for better reliability and type safety
+ */
+declare class Model {
+    private modelName;
+    private config;
+    private openaiClient?;
+    private anthropicClient?;
+    private geminiClient?;
+    constructor(model?: string | ModelConfig);
+    /**
+     * Initialize the appropriate SDK client based on provider
+     */
+    private _initializeClient;
+    /**
+     * Asynchronous chat completion
+     */
+    achat(messages: any[], tools?: any[], stream?: boolean): Promise<ModelResponse[]>;
+    /**
+     * Call OpenAI-compatible API (OpenAI, DeepSeek, etc.)
+     */
+    private _callOpenAICompatible;
+    /**
+     * Call Anthropic API
+     */
+    private _callAnthropic;
+    /**
+     * Call Google Gemini API
+     */
+    private _callGemini;
+    /**
+     * Convert OpenAI format messages to Gemini format
+     */
+    private _convertMessagesToGeminiFormat;
+    /**
+     * Get model configuration
+     */
+    getConfig(): ModelConfig;
+    /**
+     * Get model name
+     */
+    getName(): string;
+    /**
+     * Check if model supports tool calling
+     */
+    supportsToolCalling(): boolean;
+}
+
+/**
+ * Message class for conversation history
+ *
+ * Converts Python's message.py to TypeScript
+ */
+
+/**
+ * Message class representing a single message in conversation
+ */
+declare class Message implements Message$1 {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    images?: string | string[];
+    type?: string;
+    constructor(role: 'system' | 'user' | 'assistant', content: string, images?: string | string[], type?: string);
+    /**
+     * Create message from user input
+     */
+    static fromUserMsg(content: string, images?: string | string[]): Message;
+    /**
+     * Create message from assistant response
+     */
+    static fromAssistantMsg(content: string): Message;
+    /**
+     * Create system message
+     */
+    static fromSystemMsg(content: string): Message;
+    /**
+     * Convert to plain object for API calls
+     */
+    toObject(): any;
+    /**
+     * Check if message contains images
+     */
+    hasImages(): boolean;
+    /**
+     * Get message content length
+     */
+    getContentLength(): number;
+    /**
+     * Convert to string representation
+     */
+    toString(): string;
+    /**
+     * Convert to OpenAI Vision API format with base64-encoded images
+     * This method handles:
+     * - HTTP/HTTPS URLs: Downloads and converts to base64
+     * - Local file paths: Reads file and converts to base64
+     * - Already base64 strings: Passes through
+     */
+    toChatMessage(): Promise<Record<string, any>>;
+    /**
+     * Get MIME type from file path or URL
+     */
+    private getMimeType;
+    /**
+     * Encode local file to base64
+     */
+    private encodeLocalFile;
+    /**
+     * Fetch and encode HTTP image to base64
+     */
+    private encodeHttpImage;
+}
+
+/**
+ * Toolcall class and types
+ *
+ * Extracted from src/utils/toolUtil.ts to mirror Python evolt/schemas/toolcall.py
+ */
+/**
+ * Toolcall execution state
+ */
+type ToolcallState = 'pending' | 'running' | 'success' | 'failed';
+/**
+ * Toolcall type
+ */
+type ToolcallType = 'system' | 'user' | 'TaskCompletion';
+/**
+ * Toolcall class representing a single tool call
+ */
+declare class Toolcall {
+    name: string;
+    input: Record<string, any>;
+    isExtractedSuccess: boolean;
+    failedExtractedReason?: string;
+    executedState: ToolcallState;
+    executedContent?: string;
+    toolCallId: string;
+    type: ToolcallType;
+    rawContentFromLlm?: string;
+    constructor(config: {
+        name: string;
+        input?: Record<string, any>;
+        isExtractedSuccess?: boolean;
+        failedExtractedReason?: string;
+        executedState?: ToolcallState;
+        executedContent?: string;
+        toolCallId?: string;
+        type?: ToolcallType;
+        rawContentFromLlm?: string;
+    });
+    /**
+     * Toolcall extraction result description
+     */
+    extractedResult(): string | Record<string, any> | Record<string, any>[];
+    /**
+     * Toolcall execution result: Feedback to LLM
+     */
+    executedResult(): string | Record<string, any>;
+}
+
+/**
+ * Message history management
+ *
+ * Converts Python's message_history.py to TypeScript
+ */
+
+/**
+ * Message history class for managing conversation context
+ */
+declare class MessageHistory {
+    private messages;
+    private systemPrompt;
+    private model;
+    private contextWindowTokens;
+    private currentTokens;
+    constructor(model: string, system: string, contextWindowTokens: number);
+    /**
+     * Add a message to history
+     */
+    addMessage(message: Message): void;
+    addMessage(role: 'system' | 'user' | 'assistant' | 'tool', content: string): void;
+    addMessage(messageObject: any): void;
+    /**
+     * Get all messages
+     */
+    getMessages(): (Message | Record<string, any>)[];
+    /**
+     * Get messages formatted for API calls
+     * Async version to handle base64 image encoding
+     */
+    formatForApi(): Promise<any[]>;
+    /**
+     * Update system prompt
+     */
+    updateSystem(system: string): void;
+    /**
+     * Truncate history to fit context window
+     * Preserves tool call chains: assistant(with tool_calls) → tool messages
+     */
+    truncate(): void;
+    /**
+     * Clear all messages except system
+     */
+    clear(): void;
+    /**
+     * Get the last message
+     */
+    getLastMessage(): Message | Record<string, any> | null;
+    /**
+     * Get message count
+     */
+    getMessageCount(): number;
+    /**
+     * Get formatted context usage information
+     */
+    get formattedContextUsage(): string;
+    /**
+     * Estimate tokens for text (simplified implementation)
+     */
+    private estimateTokens;
+    /**
+     * Get conversation as string
+     */
+    toString(): string;
+}
+
+/**
+ * Base environment for agent management
+ *
+ * Converts Python's environment/base.py to TypeScript
+ */
+
+/**
+ * Instruction type enumeration
+ */
+declare enum InstructionType {
+    VALID = "valid",
+    QUIT = "quit",
+    SEND_TO_ALL = "sendToAll",
+    NO_AGENT_NAME = "noAgentName",
+    NO_AVAILABLE_AGENT_NAME = "noAvailableAgentName"
+}
+/**
+ * Environment for the agent
+ */
+declare class BaseEnvironment {
+    /**
+     * List of agents in the environment
+     */
+    agents: Agent[];
+    /**
+     * Assign skills to agent with their names
+     */
+    agentSkills: Record<string, string[]>;
+    constructor(agents?: Agent[], agentSkills?: Record<string, string[]>);
+    /**
+     * Set agent skills after initialization
+     */
+    private setAgentSkills;
+    /**
+     * Check if instruction has agent name
+     */
+    hasAgentName(instruction: string): boolean;
+    /**
+     * Post process instruction
+     */
+    postProcessInstruction(instruction: string, agentNames: string[]): [InstructionType, string];
+    /**
+     * Run with a single goal until completion (non-interactive mode)
+     */
+    runGoal(goal: string): Promise<void>;
+    /**
+     * Run the environment (interactive mode)
+     */
+    run(): Promise<void>;
+}
+
+/**
+ * Coding environment for agent management
+ *
+ * Converts Python's environment/coding.py to TypeScript
+ */
+
+/**
+ * Environment for coding
+ */
+declare class CodingEnvironment extends BaseEnvironment {
+    /**
+     * Workspace directory
+     */
+    workspaceDir: string;
+    constructor(agents?: Agent[], agentSkills?: Record<string, string[]>, workspaceDir?: string);
+    /**
+     * Set workspace directory after initialization
+     */
+    private setWorkspaceDir;
+}
+
+/**
+ * Model configuration loader
+ *
+ * Converts Python's config_loader.py to TypeScript
+ */
+
+/**
+ * Load model configuration from YAML file
+ */
+declare function loadModelConfig(modelName?: string): ModelConfig;
+
+/**
+ * Application constants
+ *
+ * Converts Python's constants.py to TypeScript
+ */
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_CONFIG: {
+    MODEL: string;
+    PROVIDER: string;
+    CONTEXT_WINDOW: number;
+    MAX_OUTPUT_TOKENS: number;
+    TEMPERATURE: number;
+    TOP_P: number;
+};
+/**
+ * Tool-related constants
+ */
+declare const TOOL_CONSTANTS: {
+    SYSTEM_TOOL_PREFIX: string;
+    USER_TOOL_PREFIX: string;
+    AGENT_TOOL_PREFIX: string;
+    MCP_TOOL_PREFIX: string;
+};
+/**
+ * Message role constants
+ */
+declare const MESSAGE_ROLES: {
+    readonly SYSTEM: "system";
+    readonly USER: "user";
+    readonly ASSISTANT: "assistant";
+};
+/**
+ * Tool call types
+ */
+declare const TOOL_CALL_TYPES: {
+    readonly SYSTEM: "system";
+    readonly USER: "user";
+};
+/**
+ * Environment variables
+ */
+declare const ENV_VARS: {
+    EVOLT_CONFIG_PATH: string;
+    DEEPSEEK_API_KEY: string;
+    DEEPSEEK_BASE_URL: string;
+    OPENAI_API_KEY: string;
+    ANTHROPIC_API_KEY: string;
+};
+/**
+ * Error messages
+ */
+declare const ERROR_MESSAGES: {
+    CONFIG_LOAD_FAILED: string;
+    MODEL_NOT_FOUND: string;
+    TOOL_NOT_REGISTERED: string;
+    INVALID_MESSAGE_FORMAT: string;
+    TOOL_EXECUTION_FAILED: string;
+};
+/**
+ * Logging levels
+ */
+declare const LOG_LEVELS: {
+    readonly DEBUG: 0;
+    readonly INFO: 1;
+    readonly WARNING: 2;
+    readonly ERROR: 3;
+};
+
+/**
+ * Path configuration and utilities
+ *
+ * Converts Python's paths.py to TypeScript
+ */
+/**
+ * Get workspace directory
+ */
+declare function getWorkspaceDir(): string;
+/**
+ * Get configuration directory
+ */
+declare function getConfigDir(): string;
+/**
+ * Get logs directory
+ */
+declare function getLogsDir(): string;
+/**
+ * Get cache directory
+ */
+declare function getCacheDir(): string;
+/**
+ * Get skills directory
+ */
+declare function getSkillsDir(): string;
+/**
+ * Ensure directory exists
+ */
+declare function ensureDir(dirPath: string): void;
+/**
+ * Get absolute path relative to workspace
+ */
+declare function getWorkspacePath(relativePath: string): string;
+/**
+ * Get absolute path relative to config directory
+ */
+declare function getConfigPath(relativePath: string): string;
+/**
+ * Check if path is within workspace
+ */
+declare function isInWorkspace(filePath: string): boolean;
+/**
+ * Normalize path for cross-platform compatibility
+ */
+declare function normalizePath(filePath: string): string;
+/**
+ * Get file extension
+ */
+declare function getFileExtension(filePath: string): string;
+/**
+ * Check if file exists
+ */
+declare function fileExists(filePath: string): boolean;
+/**
+ * Create temporary file path
+ */
+declare function getTempFilePath(prefix?: string): string;
+declare const WORKSPACE_DIR: string;
+declare const SKILLS_DIR: string;
+
+/**
+ * Application settings and runtime configuration
+ *
+ * Converts Python's settings.py to TypeScript
+ */
+/**
+ * Application settings interface
+ */
+interface AppSettings {
+    logLevel: number;
+    verbose: boolean;
+    debug: boolean;
+    workspace: string;
+    maxRetries: number;
+    timeout: number;
+    enableCache: boolean;
+    enableTelemetry: boolean;
+}
+/**
+ * Default application settings
+ */
+declare const DEFAULT_SETTINGS: AppSettings;
+/**
+ * Global settings instance
+ */
+declare class SettingsManager {
+    private settings;
+    /**
+     * Update settings
+     */
+    update(newSettings: Partial<AppSettings>): void;
+    /**
+     * Get current settings
+     */
+    get(): AppSettings;
+    /**
+     * Reset to default settings
+     */
+    reset(): void;
+    /**
+     * Get specific setting value
+     */
+    getValue<K extends keyof AppSettings>(key: K): AppSettings[K];
+    /**
+     * Set specific setting value
+     */
+    setValue<K extends keyof AppSettings>(key: K, value: AppSettings[K]): void;
+}
+declare const settings: SettingsManager;
+/**
+ * Initialize settings from environment variables
+ */
+declare function initializeSettings(): void;
+/**
+ * Get current settings (convenience function)
+ */
+declare function getSettings(): AppSettings;
+/**
+ * Update settings (convenience function)
+ */
+declare function updateSettings(newSettings: Partial<AppSettings>): void;
+
+/**
+ * Winston logger configuration
+ *
+ * Provides a centralized logging solution to replace console calls
+ * Format inspired by loguru for better readability
+ */
+declare const _default: {
+    enhancedLogger: {
+        error: (message?: any, ...meta: any[]) => void;
+        warn: (message?: any, ...meta: any[]) => void;
+        info: (message?: any, ...meta: any[]) => void;
+        debug: (message?: any, ...meta: any[]) => void;
+        http: (message?: any, ...meta: any[]) => void;
+        verbose: (message?: any, ...meta: any[]) => void;
+        silly: (message?: any, ...meta: any[]) => void;
+    };
+    dummyLogger: {
+        error: () => void;
+        warn: () => void;
+        info: () => void;
+        debug: () => void;
+        http: () => void;
+        verbose: () => void;
+        silly: () => void;
+    };
+    streamLogger: {
+        /**
+         * Write content directly to stdout without formatting
+         * Used for streaming output where content comes in chunks
+         */
+        info: (message: string) => void;
+        /**
+         * Write error content to stderr
+         */
+        error: (message: string) => void;
+        /**
+         * Write content with newline
+         */
+        log: (message: string) => void;
+        debug: (message: string) => void;
+    };
+    getDisableLog: () => boolean;
+};
+
+export { Agent, type AgentConfig, ApiTool, type AppSettings, BaseEnvironment, CodingEnvironment, CommandLineTool, DEFAULT_CONFIG, DEFAULT_SETTINGS, ENV_VARS, ERROR_MESSAGES, type EnvironmentConfig, EvoltError, ExtendStateMachineTool, FileEditor, FunctionCallingStore, GitTool, LOG_LEVELS, MESSAGE_ROLES, Message, MessageHistory, Model, type ModelConfig, ModelError, type ModelResponse$1 as ModelResponse, type PostProcessor, ReflectTool, Reply2HumanTool, SKILLS_DIR, SkillsTool, SystemToolStore, TOOL_CALL_TYPES, TOOL_CONSTANTS, ThinkTool, TodoListTool, type ToolCall, type ToolDescription, ToolExecutionError, type ToolStore, Toolcall, type ToolcallState, type ToolcallType, UserToolStore, WORKSPACE_DIR, WriteUIDesignDocument, ensureDir, fileExists, getCacheDir, getConfigDir, getConfigPath, getFileExtension, getLogsDir, getSettings, getSkillsDir, getTempFilePath, getWorkspaceDir, getWorkspacePath, initializeSettings, isInWorkspace, loadModelConfig, _default as logger, normalizePath, registerAgentAsTool, settings, tools, updateSettings };