@nuvin/nuvin-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1452 @@
+import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+/**
+ * Agent Template - defines a pre-configured specialist agent
+ * Only systemPrompt is required; all other fields have sensible defaults
+ */
+type AgentTemplate = {
+    systemPrompt: string;
+    id?: string;
+    name?: string;
+    description?: string;
+    tools?: string[];
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    timeoutMs?: number;
+    shareContext?: boolean;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Specialist Agent Configuration (Internal - used by AgentManager)
+ */
+type SpecialistAgentConfig = {
+    agentId: string;
+    agentName: string;
+    taskDescription: string;
+    systemPrompt: string;
+    tools: string[];
+    provider?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    timeoutMs?: number;
+    shareContext?: boolean;
+    delegatingMemory?: Message[];
+    delegationDepth: number;
+    conversationId?: string;
+    messageId?: string;
+    toolCallId?: string;
+};
+/**
+ * Specialist Agent Result
+ */
+type SpecialistAgentResult = {
+    status: 'success' | 'error' | 'timeout';
+    result: string;
+    metadata: {
+        agentId: string;
+        tokensUsed?: number;
+        toolCallsExecuted: number;
+        executionTimeMs: number;
+        conversationHistory?: Message[];
+        events?: AgentEvent[];
+        errorMessage?: string;
+    };
+};
+/**
+ * AssignTool Parameters (what LLM provides)
+ */
+type AssignParams = {
+    agent: string;
+    task: string;
+};
+
+interface AgentFilePersistenceOptions {
+    agentsDir: string;
+}
+/**
+ * AgentFilePersistence - handles loading and saving agents to YAML files
+ */
+declare class AgentFilePersistence {
+    private agentsDir;
+    constructor(options: AgentFilePersistenceOptions);
+    /**
+     * Ensure agents directory exists
+     */
+    private ensureAgentsDir;
+    /**
+     * Load all agents from the agents directory
+     */
+    loadAll(): Promise<AgentTemplate[]>;
+    /**
+     * Load a single agent from a YAML file
+     */
+    load(filename: string): Promise<AgentTemplate | null>;
+    /**
+     * Save an agent to a YAML file
+     */
+    save(agent: AgentTemplate): Promise<void>;
+    /**
+     * Delete an agent file
+     */
+    delete(agentId: string): Promise<void>;
+    /**
+     * Check if an agent file exists
+     */
+    exists(agentId: string): boolean;
+    /**
+     * Sanitize filename to kebab-case and remove invalid characters
+     */
+    private sanitizeFilename;
+    /**
+     * Get the agents directory path
+     */
+    getAgentsDir(): string;
+}
+
+/**
+ * AgentRegistry - manages registered specialist agent configurations
+ */
+declare class AgentRegistry {
+    private agents;
+    private defaultAgentIds;
+    private persistence?;
+    private filePersistence?;
+    private loadingPromise?;
+    constructor(options?: {
+        persistence?: MemoryPort<AgentTemplate>;
+        filePersistence?: AgentFilePersistence;
+    });
+    /**
+     * Load agents from both persistence and files
+     */
+    private loadAgents;
+    /**
+     * Wait for all agents to finish loading
+     */
+    waitForLoad(): Promise<void>;
+    /**
+     * Apply defaults to a partial agent template
+     * Only systemPrompt is required; all other fields get defaults
+     */
+    applyDefaults(partial: Partial<AgentTemplate> & {
+        systemPrompt: string;
+    }): AgentTemplate;
+    /**
+     * Load agents from memory persistence
+     */
+    private loadFromPersistence;
+    /**
+     * Load agents from file system
+     */
+    private loadFromFiles;
+    /**
+     * Save current agents to persistence
+     */
+    private saveToPersistence;
+    /**
+     * Validate agent template (only systemPrompt required)
+     */
+    private validateTemplate;
+    /**
+     * Register a new agent template
+     */
+    register(agent: Partial<AgentTemplate> & {
+        systemPrompt: string;
+    }): void;
+    /**
+     * Save agent to file
+     */
+    saveToFile(agent: AgentTemplate): Promise<void>;
+    /**
+     * Delete agent from file
+     */
+    deleteFromFile(agentId: string): Promise<void>;
+    /**
+     * Check if an agent is a default agent
+     */
+    isDefault(agentId: string): boolean;
+    /**
+     * Unregister an agent template
+     */
+    unregister(agentId: string): void;
+    /**
+     * Get an agent template by ID
+     */
+    get(agentId: string): AgentTemplate | undefined;
+    /**
+     * List all registered agent templates
+     */
+    list(): AgentTemplate[];
+    /**
+     * Check if an agent exists
+     */
+    exists(agentId: string): boolean;
+}
+
+type ToolCall = {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+type TextContentPart = {
+    type: 'text';
+    text: string;
+};
+type ImageContentPart = {
+    type: 'image';
+    mimeType: string;
+    data: string;
+    altText?: string;
+    source?: string;
+    name?: string;
+};
+type MessageContentPart = TextContentPart | ImageContentPart;
+type MessageContent = string | null | {
+    type: 'parts';
+    parts: MessageContentPart[];
+};
+type ProviderContentPart = {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high';
+    };
+};
+type ChatMessage = {
+    role: typeof MessageRoles.System | typeof MessageRoles.User | typeof MessageRoles.Assistant | typeof MessageRoles.Tool;
+    content: string | null | ProviderContentPart[];
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+};
+type CompletionParams = {
+    messages: ChatMessage[];
+    model: string;
+    temperature: number;
+    topP: number;
+    maxTokens?: number;
+    tools?: Array<{
+        type: 'function';
+        function: {
+            name: string;
+            description: string;
+            parameters: object;
+        };
+    }>;
+    tool_choice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    reasoning?: {
+        effort: string;
+    };
+    usage?: {
+        include?: boolean;
+    };
+};
+type UsageData = {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    reasoning_tokens?: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+        audio_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+    cost?: number;
+    cost_details?: {
+        upstream_inference_cost?: number;
+    };
+};
+type CompletionResult = {
+    content: string;
+    tool_calls?: ToolCall[];
+    usage?: UsageData;
+};
+type Message = {
+    id: string;
+    role: typeof MessageRoles.User | typeof MessageRoles.Assistant | typeof MessageRoles.Tool;
+    content: MessageContent;
+    timestamp?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+};
+type MessageResponse = {
+    id: string;
+    content: string;
+    role: typeof MessageRoles.Assistant | typeof MessageRoles.Tool;
+    timestamp: string;
+    metadata?: {
+        model?: string;
+        provider?: string;
+        agentId?: string;
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+        estimatedCost?: number;
+        responseTime?: number;
+        toolCalls?: number;
+    };
+};
+type SendMessageOptions = {
+    conversationId?: string;
+    stream?: boolean;
+    signal?: AbortSignal;
+    retry?: boolean;
+};
+type UserAttachment = ImageContentPart & {
+    token?: string;
+};
+type UserMessagePayload = string | {
+    text: string;
+    displayText?: string;
+    attachments?: UserAttachment[];
+};
+interface LLMPort {
+    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
+    streamCompletion?(params: CompletionParams, handlers?: {
+        onChunk?: (delta: string, usage?: UsageData) => void;
+        onToolCallDelta?: (tc: ToolCall) => void;
+        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
+    }, signal?: AbortSignal): Promise<CompletionResult>;
+}
+type ToolDefinition = {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: object;
+    };
+};
+type ToolInvocation = {
+    id: string;
+    name: string;
+    parameters: Record<string, any>;
+};
+type ToolExecutionResult = {
+    id: string;
+    name: string;
+    status: 'success' | 'error';
+    type: 'text' | 'json';
+    result: string | object;
+    metadata?: Record<string, unknown>;
+    durationMs?: number;
+};
+interface ToolPort {
+    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
+    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
+    setEnabledAgents?(enabledAgents: Record<string, boolean>): void;
+    getAgentRegistry?(): AgentRegistry | undefined;
+    setOrchestrator?(config: AgentConfig, llm: LLMPort, tools: ToolPort): void;
+}
+type MemorySnapshot<T = unknown> = Record<string, T[]>;
+interface MemoryPersistence<T = unknown> {
+    load(): Promise<MemorySnapshot<T>>;
+    save(snapshot: MemorySnapshot<T>): Promise<void>;
+}
+interface MemoryPort<T = unknown> {
+    get(key: string): Promise<T[]>;
+    set(key: string, items: T[]): Promise<void>;
+    append(key: string, items: T[]): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    exportSnapshot(): Promise<MemorySnapshot<T>>;
+    importSnapshot(snapshot: MemorySnapshot<T>): Promise<void>;
+}
+interface MetadataPort<T> {
+    get(key: string): Promise<T | null>;
+    set(key: string, metadata: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    exportSnapshot(): Promise<Record<string, T>>;
+    importSnapshot(snapshot: Record<string, T>): Promise<void>;
+}
+interface ContextBuilder {
+    toProviderMessages(history: Message[], systemPrompt: string, newUserContent: MessageContent[]): ChatMessage[];
+}
+interface RemindersPort {
+    enhance(content: string, opts: {
+        conversationId?: string;
+    }): string[];
+}
+interface IdGenerator$1 {
+    uuid(): string;
+}
+interface Clock {
+    now(): number;
+    iso(dateMs?: number): string;
+}
+interface CostCalculator {
+    estimate(model: string, usage?: UsageData): number | undefined;
+}
+type AgentConfig = {
+    id: string;
+    systemPrompt: string;
+    topP: number;
+    model: string;
+    temperature: number;
+    maxTokens?: number;
+    enabledTools?: string[];
+    maxToolConcurrency?: number;
+    requireToolApproval?: boolean;
+    reasoningEffort?: string;
+};
+declare const MessageRoles: {
+    readonly System: "system";
+    readonly User: "user";
+    readonly Assistant: "assistant";
+    readonly Tool: "tool";
+};
+declare const AgentEventTypes: {
+    readonly MessageStarted: "message_started";
+    readonly ToolCalls: "tool_calls";
+    readonly ToolApprovalRequired: "tool_approval_required";
+    readonly ToolApprovalResponse: "tool_approval_response";
+    readonly ToolResult: "tool_result";
+    readonly AssistantChunk: "assistant_chunk";
+    readonly AssistantMessage: "assistant_message";
+    readonly StreamFinish: "stream_finish";
+    readonly MemoryAppended: "memory_appended";
+    readonly Done: "done";
+    readonly Error: "error";
+    readonly MCPStderr: "mcp_stderr";
+    readonly SubAgentStarted: "sub_agent_started";
+    readonly SubAgentToolCall: "sub_agent_tool_call";
+    readonly SubAgentToolResult: "sub_agent_tool_result";
+    readonly SubAgentCompleted: "sub_agent_completed";
+};
+type ToolApprovalDecision = 'approve' | 'deny' | 'approve_all';
+type AgentEvent = {
+    type: typeof AgentEventTypes.MessageStarted;
+    conversationId: string;
+    messageId: string;
+    userContent: string;
+    enhanced: string[];
+    toolNames: string[];
+} | {
+    type: typeof AgentEventTypes.ToolCalls;
+    conversationId: string;
+    messageId: string;
+    toolCalls: ToolCall[];
+} | {
+    type: typeof AgentEventTypes.ToolApprovalRequired;
+    conversationId: string;
+    messageId: string;
+    toolCalls: ToolCall[];
+    approvalId: string;
+} | {
+    type: typeof AgentEventTypes.ToolApprovalResponse;
+    conversationId: string;
+    messageId: string;
+    approvalId: string;
+    decision: ToolApprovalDecision;
+    approvedCalls?: ToolCall[];
+} | {
+    type: typeof AgentEventTypes.ToolResult;
+    conversationId: string;
+    messageId: string;
+    result: ToolExecutionResult;
+} | {
+    type: typeof AgentEventTypes.AssistantChunk;
+    conversationId: string;
+    messageId: string;
+    delta: string;
+    usage?: UsageData;
+} | {
+    type: typeof AgentEventTypes.AssistantMessage;
+    conversationId: string;
+    messageId: string;
+    content: string | null;
+    usage?: UsageData;
+} | {
+    type: typeof AgentEventTypes.StreamFinish;
+    conversationId: string;
+    messageId: string;
+    finishReason?: string;
+    usage?: UsageData;
+} | {
+    type: typeof AgentEventTypes.MemoryAppended;
+    conversationId: string;
+    delta: Message[];
+} | {
+    type: typeof AgentEventTypes.Done;
+    conversationId: string;
+    messageId: string;
+    responseTimeMs: number;
+    usage?: UsageData;
+} | {
+    type: typeof AgentEventTypes.Error;
+    conversationId: string;
+    messageId?: string;
+    error: string;
+} | {
+    type: typeof AgentEventTypes.MCPStderr;
+    conversationId: string;
+    serverId: string;
+    serverName?: string;
+    data: string;
+    timestamp: string;
+} | {
+    type: typeof AgentEventTypes.SubAgentStarted;
+    conversationId: string;
+    messageId: string;
+    agentId: string;
+    agentName: string;
+    toolCallId: string;
+} | {
+    type: typeof AgentEventTypes.SubAgentToolCall;
+    conversationId: string;
+    messageId: string;
+    agentId: string;
+    toolCallId: string;
+    toolName: string;
+    toolArguments?: string;
+} | {
+    type: typeof AgentEventTypes.SubAgentToolResult;
+    conversationId: string;
+    messageId: string;
+    agentId: string;
+    toolCallId: string;
+    toolName: string;
+    durationMs: number;
+    status: 'success' | 'error';
+} | {
+    type: typeof AgentEventTypes.SubAgentCompleted;
+    conversationId: string;
+    messageId: string;
+    agentId: string;
+    agentName: string;
+    status: 'success' | 'error' | 'timeout';
+    resultMessage: string;
+    totalDurationMs: number;
+};
+interface EventPort {
+    emit(event: AgentEvent): void | Promise<void>;
+}
+
+declare class AgentOrchestrator {
+    private cfg;
+    private deps;
+    private pendingApprovals;
+    constructor(cfg: AgentConfig, deps: {
+        memory: MemoryPort<Message>;
+        llm: LLMPort;
+        tools: ToolPort;
+        context: ContextBuilder;
+        ids: IdGenerator$1;
+        clock: Clock;
+        cost: CostCalculator;
+        reminders: RemindersPort;
+        events?: EventPort;
+    });
+    /**
+     * Updates the agent configuration dynamically after initialization.
+     * This allows for runtime changes to model, provider, and other settings.
+     */
+    updateConfig(newConfig: Partial<AgentConfig>): void;
+    /**
+     * Updates the LLM provider without reinitializing the entire orchestrator.
+     * This preserves conversation history, MCP connections, and other state.
+     */
+    setLLM(newLLM: LLMPort): void;
+    /**
+     * Updates the tool port without reinitializing the entire orchestrator.
+     * This preserves conversation history and other state while adding/removing tools.
+     */
+    setTools(newTools: ToolPort): void;
+    /**
+     * Gets the current tool port.
+     */
+    getTools(): ToolPort;
+    /**
+     * Gets the current LLM port.
+     */
+    getLLM(): LLMPort;
+    /**
+     * Gets the current agent configuration.
+     */
+    getConfig(): AgentConfig;
+    /**
+     * Updates the memory port without reinitializing the entire orchestrator.
+     * This allows starting a new conversation session while preserving LLM connections,
+     * MCP servers, and other state.
+     */
+    setMemory(newMemory: MemoryPort<Message>): void;
+    /**
+     * Updates the event port without reinitializing the entire orchestrator.
+     * This is useful when switching to a new session with a different event log file.
+     */
+    setEvents(newEvents: EventPort): void;
+    /**
+     * Determines if a tool should bypass approval requirements.
+     * Read-only tools and todo management tools are auto-approved.
+     */
+    private shouldBypassApproval;
+    private handleToolDenial;
+    private processToolApproval;
+    send(content: UserMessagePayload, opts?: SendMessageOptions): Promise<MessageResponse>;
+    private waitForToolApproval;
+    handleToolApproval(approvalId: string, decision: ToolApprovalDecision, approvedCalls?: ToolCall[]): void;
+    private toInvocations;
+}
+
+declare class SimpleContextBuilder implements ContextBuilder {
+    toProviderMessages(history: Message[], systemPrompt: string, newUserContent: MessageContent[]): ChatMessage[];
+}
+
+type RuntimeEnvInfo = {
+    cwd: string;
+    platform: string;
+    arch: string;
+    today: string;
+    tempDir: string;
+    workspaceDir: string;
+};
+type RuntimeEnvOptions = {
+    appName?: string;
+};
+declare class RuntimeEnv {
+    private appName;
+    private _workspaceDir;
+    constructor(opts?: RuntimeEnvOptions);
+    get workspaceDir(): string;
+    init(sessionId?: string): void;
+    info(): RuntimeEnvInfo;
+    resolveInWorkspace(...segments: string[]): string;
+}
+
+type TemplateVars = Record<string, string | number | boolean | null | undefined>;
+declare function renderTemplate(template: string, vars: TemplateVars): string;
+type InjectedSystemParams = {
+    today: string;
+    platform: string;
+    arch: string;
+    tempDir: string;
+    workspaceDir: string;
+    availableAgents?: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    folderTree?: string;
+};
+declare function buildInjectedSystem(p: InjectedSystemParams, { withSubAgent }?: {
+    withSubAgent?: boolean;
+}): string;
+
+/**
+ * System prompt for the agent creation LLM
+ * This prompt guides the LLM to generate specialist agent configurations
+ */
+declare const AGENT_CREATOR_SYSTEM_PROMPT = "You are an elite AI agent architect. Your job is to translate user requirements into a precise, reliable agent specification and final system prompt that downstream systems can use directly.\n\n### Context you may receive\n- Project materials (e.g., CLAUDE.md), coding standards, project structure, and custom requirements. Inherit these patterns explicitly in your design.\n\n### Your high-level objective\n- Produce a complete, self-sufficient agent spec that includes: a concise identifier, a clear \"when to use\" description with examples, and a robust system prompt that governs behavior.\n\n### Operating principles (follow in order)\n1) **Extract Core Intent**\n   - Identify purpose, scope, users, inputs, outputs, success criteria, constraints, and any implicit needs.\n   - If code-review is requested, default scope to *recently written or changed code* unless the user explicitly requests a full-repo review.\n2) **Design Expert Persona**\n   - Define a domain-specific role (e.g., senior code reviewer, API docs writer), decision style, and domain heuristics.\n   - Assume the role of a recognized domain expert with deep mastery of relevant concepts, methodologies, and best practices. Let this expertise guide your decision-making through nuanced understanding, authoritative judgment, and strategic thinking that anticipates challenges and recognizes proven patterns.\n   - Communicate with professional confidence while acknowledging uncertainty when appropriate.\n1) **Decompose the Task**\n   - Lay out a short pipeline (PLAN \u2192 EXECUTE \u2192 VERIFY \u2192 OUTPUT). Keep steps concrete and checklist-driven. (Structured, decomposed prompts improve reliability.)\n2) **Specify Inputs, Tools, and Boundaries**\n   - Name required inputs; state assumptions if missing.\n   - List allowed tools/APIs and how to invoke them; define fallback behavior if tools fail.\n   - Include stop conditions and escalation rules (when to ask the user for clarification, when to return partial results).\n3) **Quality & Reliability**\n   - Build in self-checks: requirement coverage, constraint adherence, formatting validation.\n   - Where applicable, instruct the agent to generate and verify reasoning internally, then present only the final, concise result.\n   - Encourage evidence/verification for factual claims when sources are available.\n4) **Output Contract**\n   - Define exact output formats (schemas, sections, or bullet checklists) so downstream consumers are deterministic.\n\n### System-prompt structure you must generate (use this template)\n\n# Role\nYou are <expert-persona>. You optimize for correctness, clarity, and adherence to project standards.\n\n# Goals\n- <bullet list of concrete goals>\n\n# Inputs\n- <required inputs>\n- Assumptions if missing: <rules to infer or request>\n\n# Process\n- PLAN: <brief checklist>\n- EXECUTE: <methods, frameworks, heuristics>\n- VERIFY: <self-checks, requirement coverage, constraint audit>\n- OUTPUT: <exact sections / schema>\n\n# Policies & Boundaries\n- Follow project coding standards from CLAUDE.md if provided.\n- Review only recent changes unless told otherwise.\n- If information is insufficient, ask precisely targeted questions (max 3) before proceeding; otherwise proceed with clearly stated assumptions.\n- Stop and escalate if safety, legal, or data-governance risks are detected.\n\n# Quality Bar\n- Ensure: correctness > completeness > speed.\n- Run a final \"Spec QA\" checklist before responding:\n  1) All user requirements mapped to sections?\n  2) Output format matches the contract exactly?\n  3) Edge cases addressed?\n  4) Examples included when helpful?\n\"\"\"\n\n### What to return\n- A **JSON object** with exactly these fields:\n  - 'id': short, kebab-case, descriptive (2\u20134 words), no generic terms like 'helper' or 'assistant'.\n  - 'description': starts with \"Use this agent when...\" and includes at least two concrete examples showing tool invocation (not direct replies). Include proactive triggers if implied.\n  - 'systemPrompt': the final second-person system prompt built from the template above.\n\n### Additional guidance\n- Prefer explicit instructions over prohibitions; say what to do. (Specific, structured prompts improve outcomes.)\n- Use few-shot examples when they clarify behavior.\n- Be concise but complete\u2014every line should add execution value.\n- If constraints conflict, state the trade-off and your resolution.\n- Only include optional advanced reasoning guidance when beneficial; keep the final user-visible output clean.\n\n\n### REQUIRED OUTPUT: You MUST return a JSON object with at least the 'systemPrompt' field.\n\n**OPTIONAL FIELDS**: You may also include any of these fields (they have defaults if omitted):\n- 'id': A kebab-case identifier (e.g., \"security-auditor\", \"data-analyzer\")\n- 'name': A human-readable name (e.g., \"Security Auditor\", \"Data Analyzer\")\n- 'description': A brief description of when to use this agent\n- 'tools': An array of tool names the agent should have access to\n- 'temperature': A number between 0 and 1 (default: 0.7)\n\nExample outputs:\n\n{\n  \"id\": \"security-auditor\",\n  \"name\": \"Security Auditor\",\n  \"description\": \"Use this agent when you need to perform a security audit on a codebase or application. For example, you might invoke this agent when you want to check for vulnerabilities in a web application or when you need to ensure compliance with security best practices.\",\n  \"systemPrompt\": \"\n      You are a security auditing specialist. Your role is to analyze code for security vulnerabilities, including SQL injection, XSS, CSRF, authentication issues, and insecure dependencies.\n\n      Approach:\n      1. Read and analyze the codebase systematically\n      2. Check for common vulnerability patterns\n      3. Review dependencies for known CVEs\n      4. Provide specific, actionable remediation steps\n\n      Always prioritize critical security issues and explain the potential impact.\",\n  \"tools\": [\"file_read\", \"web_search\", \"bash_tool\"],\n  \"temperature\": 0.3\n}\n\n{\n  \"systemPrompt\": \"You are a helpful specialist agent that assists with general programming tasks. You can read files, search for information, and provide clear explanations.\"\n}\n\nRemember: 'systemPrompt' is REQUIRED. All other fields are optional and will have defaults applied if omitted.\nIMPORTANT: Return ONLY the JSON object as your response. Do NOT include any additional text or explanation.\n";
+/**
+ * Generate a user prompt for agent creation
+ */
+declare function buildAgentCreationPrompt(userDescription: string): string;
+
+type FolderTreeOptions = {
+    maxDepth?: number;
+    maxFiles?: number;
+    includeHidden?: boolean;
+};
+declare function generateFolderTree(rootDir: string, options?: FolderTreeOptions): Promise<string>;
+
+declare class InMemoryMemory<T = unknown> implements MemoryPort<T> {
+    private store;
+    get(key: string): Promise<T[]>;
+    set(key: string, items: T[]): Promise<void>;
+    append(key: string, items: T[]): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    exportSnapshot(): Promise<MemorySnapshot<T>>;
+    importSnapshot(snapshot: MemorySnapshot<T>): Promise<void>;
+}
+declare class JsonFileMemoryPersistence<T = unknown> implements MemoryPersistence<T> {
+    private filename;
+    constructor(filename?: string);
+    load(): Promise<MemorySnapshot<T>>;
+    save(snapshot: MemorySnapshot<T>): Promise<void>;
+}
+declare class PersistedMemory<T = unknown> implements MemoryPort<T> {
+    private persistence;
+    private inner;
+    private initialized;
+    constructor(persistence: MemoryPersistence<T>);
+    private ensureInitialized;
+    private save;
+    get(key: string): Promise<T[]>;
+    set(key: string, items: T[]): Promise<void>;
+    append(key: string, items: T[]): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    exportSnapshot(): Promise<MemorySnapshot<T>>;
+    importSnapshot(snapshot: MemorySnapshot<T>): Promise<void>;
+}
+
+declare class MemoryPortMetadataAdapter<T> implements MetadataPort<T> {
+    private memory;
+    private prefix;
+    constructor(memory: MemoryPort<unknown>, prefix?: string);
+    private getKey;
+    get(key: string): Promise<T | null>;
+    set(key: string, metadata: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    exportSnapshot(): Promise<Record<string, T>>;
+    importSnapshot(snapshot: Record<string, T>): Promise<void>;
+}
+declare class InMemoryMetadata<T> implements MetadataPort<T> {
+    private store;
+    get(key: string): Promise<T | null>;
+    set(key: string, metadata: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    exportSnapshot(): Promise<Record<string, T>>;
+    importSnapshot(snapshot: Record<string, T>): Promise<void>;
+}
+
+type TokenUsage = {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+};
+type ConversationMetadata = {
+    topic?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    messageCount?: number;
+    totalTokens?: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    contextWindow?: TokenUsage;
+};
+type Conversation = {
+    messages: Message[];
+    metadata: ConversationMetadata;
+};
+type ConversationSnapshot = Record<string, Conversation>;
+declare class ConversationStore {
+    private memory;
+    private metadataMemory;
+    constructor(memory: MemoryPort<Message>, metadataMemory?: MetadataPort<ConversationMetadata>);
+    getConversation(conversationId: string): Promise<Conversation>;
+    setConversation(conversationId: string, conversation: Conversation): Promise<void>;
+    appendMessages(conversationId: string, messages: Message[]): Promise<void>;
+    updateMetadata(conversationId: string, updates: Partial<ConversationMetadata>): Promise<void>;
+    incrementTokens(conversationId: string, tokenUsage: TokenUsage): Promise<void>;
+    updateTopic(conversationId: string, topic: string): Promise<void>;
+    deleteConversation(conversationId: string): Promise<void>;
+    listConversations(): Promise<{
+        id: string;
+        metadata: ConversationMetadata;
+    }[]>;
+    exportSnapshot(): Promise<ConversationSnapshot>;
+    importSnapshot(snapshot: ConversationSnapshot): Promise<void>;
+}
+
+declare class ConversationContext {
+    private activeConversationId;
+    getActiveConversationId(): string;
+    setActiveConversationId(id: string): void;
+    createConversationId(topic?: string): string;
+    private slugify;
+}
+
+declare class SimpleId implements IdGenerator$1 {
+    uuid(): string;
+}
+
+declare class SystemClock implements Clock {
+    now(): number;
+    iso(dateMs?: number): string;
+}
+
+declare class SimpleCost implements CostCalculator {
+    estimate(_model: string, _usage?: UsageData): number | undefined;
+}
+
+declare class NoopReminders implements RemindersPort {
+    enhance(content: string, _opts: {
+        conversationId?: string;
+    }): string[];
+}
+
+type TodoStatus = 'pending' | 'in_progress' | 'completed';
+type TodoPriority = 'high' | 'medium' | 'low';
+type TodoItem = {
+    id: string;
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+    conversationId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+};
+
+declare class ToolRegistry implements ToolPort {
+    private tools;
+    private toolsMemory?;
+    private agentRegistry;
+    private assignTool?;
+    private enabledAgentsConfig;
+    constructor(opts?: {
+        todoMemory?: MemoryPort<TodoItem>;
+        toolsMemory?: MemoryPort<string>;
+        agentRegistry?: AgentRegistry;
+    });
+    private persistToolNames;
+    listRegisteredTools(): Promise<string[]>;
+    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
+    /**
+     * Initialize AssignTool with orchestrator dependencies (lazy initialization)
+     */
+    setOrchestrator(config: AgentConfig, llm: LLMPort, tools: ToolPort): void;
+    /**
+     * Get the agent registry
+     */
+    getAgentRegistry(): AgentRegistry;
+    /**
+     * Update the enabled agents configuration for AssignTool
+     */
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
+}
+
+declare class CompositeToolPort implements ToolPort {
+    private ports;
+    constructor(ports: ToolPort[]);
+    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
+    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    getAgentRegistry(): AgentRegistry | undefined;
+    listRegisteredTools(): Promise<string[]>;
+}
+
+type ExecResult = Omit<ToolExecutionResult, 'id' | 'name'>;
+type ToolExecutionContext = {
+    conversationId?: string;
+    agentId?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    delegationDepth?: number;
+    messageId?: string;
+    eventPort?: EventPort;
+    signal?: AbortSignal;
+} & Record<string, unknown>;
+interface FunctionTool<P = Record<string, unknown>, C = ToolExecutionContext> {
+    name: string;
+    parameters: object;
+    definition(): ToolDefinition['function'];
+    execute(params: P, context?: C): Promise<ExecResult> | ExecResult;
+}
+
+type BashParams = {
+    cmd: string;
+    cwd?: string;
+    timeoutMs?: number;
+};
+declare class BashTool implements FunctionTool<BashParams, ToolExecutionContext> {
+    name: "bash_tool";
+    parameters: {
+        readonly type: "object";
+        readonly properties: {
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Explanation of what this command will do (e.g., \"Get git commit log\")";
+            };
+            readonly cmd: {
+                readonly type: "string";
+                readonly description: "Shell command to run.";
+            };
+            readonly cwd: {
+                readonly type: "string";
+                readonly description: "Working directory.";
+            };
+            readonly timeoutMs: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly description: "Timeout in ms. Default: 30000.";
+            };
+        };
+        readonly required: readonly ["cmd"];
+    };
+    definition(): ToolDefinition['function'];
+    execute(p: BashParams, ctx?: ToolExecutionContext): Promise<ExecResult>;
+    private execOnce;
+    private defaultShell;
+    private shellExists;
+    private shellArgs;
+}
+
+/**
+ * AgentManager - coordinates specialist agent execution for task delegation
+ */
+declare class AgentManager {
+    private delegatingConfig;
+    private delegatingLLM;
+    private delegatingTools;
+    private eventCallback?;
+    private activeAgents;
+    private eventCollectors;
+    constructor(delegatingConfig: AgentConfig, delegatingLLM: LLMPort, delegatingTools: ToolPort, eventCallback?: (event: AgentEvent) => void);
+    /**
+     * Create and execute a specialist agent for a specific task
+     */
+    executeTask(config: SpecialistAgentConfig, signal?: AbortSignal): Promise<SpecialistAgentResult>;
+    /**
+     * Resolve which LLM to use (reuse delegating LLM or create new one)
+     */
+    private resolveLLM;
+    /**
+     * Execute agent task with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Get active specialist agent count
+     */
+    getActiveAgentCount(): number;
+    /**
+     * Get events for a specific specialist agent
+     */
+    getAgentEvents(agentId: string): AgentEvent[] | undefined;
+    /**
+     * Cleanup all active agents (emergency stop)
+     */
+    cleanup(): void;
+}
+
+interface AgentCatalog {
+    list(): AgentTemplate[];
+    get(agentId: string): AgentTemplate | undefined;
+}
+interface DelegationPolicyInput {
+    agent: AgentTemplate;
+    enabledAgents: Record<string, boolean>;
+    params: AssignParams;
+    context?: ToolExecutionContext;
+}
+interface PolicyDecision {
+    allowed: boolean;
+    reason?: string;
+}
+interface DelegationPolicy {
+    evaluate(input: DelegationPolicyInput): PolicyDecision;
+}
+interface SpecialistAgentFactoryInput {
+    template: AgentTemplate;
+    params: AssignParams;
+    context?: ToolExecutionContext;
+    currentDepth: number;
+}
+interface SpecialistAgentFactory {
+    create(input: SpecialistAgentFactoryInput): SpecialistAgentConfig;
+}
+interface AgentCommandRunner {
+    run(config: SpecialistAgentConfig, context?: ToolExecutionContext): Promise<SpecialistAgentResult>;
+}
+interface DelegationResult {
+    success: boolean;
+    summary?: string;
+    metadata?: Record<string, unknown>;
+    error?: string;
+}
+interface DelegationResultFormatter {
+    formatSuccess(agentId: string, result: SpecialistAgentResult): Pick<DelegationResult, 'summary' | 'metadata'>;
+    formatError(error: unknown): string;
+}
+interface DelegationService {
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    listEnabledAgents(): AgentTemplate[];
+    delegate(params: AssignParams, context?: ToolExecutionContext): Promise<DelegationResult>;
+}
+
+/**
+ * Default policy checks whether the agent is enabled (if explicitly configured).
+ */
+declare class DefaultDelegationPolicy implements DelegationPolicy {
+    evaluate(input: DelegationPolicyInput): PolicyDecision;
+}
+
+type SystemContext = {
+    timeISO: string;
+    platform: NodeJS.Platform;
+    arch: string;
+    tempDir: string;
+    workspaceDir: string;
+};
+type AgentInfo = {
+    id: string;
+    name: string;
+    description: string;
+};
+type SystemContextProvider = () => SystemContext;
+type AgentListProvider = () => AgentInfo[];
+type IdGenerator = (baseId: string) => string;
+declare class DefaultSpecialistAgentFactory implements SpecialistAgentFactory {
+    private readonly options?;
+    constructor(options?: {
+        systemContextProvider?: SystemContextProvider;
+        agentListProvider?: AgentListProvider;
+        idGenerator?: IdGenerator;
+    });
+    create(input: SpecialistAgentFactoryInput): SpecialistAgentConfig;
+}
+
+declare class AgentManagerCommandRunner implements AgentCommandRunner {
+    private readonly delegatingConfig;
+    private readonly delegatingLLM;
+    private readonly delegatingTools;
+    constructor(delegatingConfig: AgentConfig, delegatingLLM: LLMPort, delegatingTools: ToolPort);
+    run(config: Parameters<AgentManager['executeTask']>[0], context?: ToolExecutionContext): Promise<SpecialistAgentResult>;
+}
+
+declare class DefaultDelegationService implements DelegationService {
+    private readonly catalog;
+    private readonly policy;
+    private readonly factory;
+    private readonly runner;
+    private readonly formatter;
+    private enabledAgents;
+    constructor(catalog: AgentCatalog, policy: DelegationPolicy, factory: SpecialistAgentFactory, runner: AgentCommandRunner, formatter: DelegationResultFormatter);
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    listEnabledAgents(): AgentTemplate[];
+    delegate(params: AssignParams, context?: ToolExecutionContext): Promise<DelegationResult>;
+}
+
+declare class DefaultDelegationResultFormatter implements DelegationResultFormatter {
+    formatSuccess(agentId: string, result: SpecialistAgentResult): {
+        summary: string;
+        metadata: {
+            agentId: string;
+            status: "success" | "error" | "timeout";
+            executionTimeMs: number;
+            toolCallsExecuted: number;
+            tokensUsed: number;
+        };
+    };
+    formatError(error: unknown): string;
+}
+
+declare class EchoLLM implements LLMPort {
+    generateCompletion(params: CompletionParams): Promise<CompletionResult>;
+    private hasTool;
+    private id;
+}
+
+type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+type LogFormat = 'json' | 'structured';
+type PersistOptions = {
+    persistFile?: string;
+    logLevel?: LogLevel;
+    logFormat?: LogFormat;
+    maxFileSize?: number;
+    enableConsoleLog?: boolean;
+    captureResponseBody?: boolean;
+};
+
+type HttpHeaders = Record<string, string>;
+interface TransportResponse {
+    ok: boolean;
+    status: number;
+    json<T>(): Promise<T>;
+    text(): Promise<string>;
+}
+interface HttpTransport {
+    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
+}
+declare class FetchTransport implements HttpTransport {
+    private opts;
+    private logger;
+    constructor(opts?: PersistOptions);
+    private getRequestSize;
+    private getResponseSize;
+    private headersToRecord;
+    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
+}
+
+declare class GithubAuthTransport implements HttpTransport {
+    private apiKey?;
+    private accessToken?;
+    private dynamicApiUrl?;
+    private readonly baseUrl;
+    private readonly inner;
+    constructor(inner: FetchTransport, opts: {
+        apiKey?: string;
+        accessToken?: string;
+        baseUrl?: string;
+    });
+    private exchangeToken;
+    private buildFullUrl;
+    private hasVisionPayload;
+    private makeAuthHeaders;
+    private determineInitiator;
+    private generateRequestId;
+    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
+}
+
+declare class OpenRouterAuthTransport implements HttpTransport {
+    private readonly inner;
+    private readonly apiKey?;
+    private readonly baseUrl;
+    constructor(inner: FetchTransport, apiKey?: string, baseUrl?: string);
+    private buildFullUrl;
+    private makeAuthHeaders;
+    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
+}
+
+declare class DeepInfraAuthTransport implements HttpTransport {
+    private readonly inner;
+    private readonly apiKey?;
+    private readonly baseUrl;
+    constructor(inner: FetchTransport, apiKey?: string, baseUrl?: string);
+    private buildFullUrl;
+    private makeAuthHeaders;
+    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
+}
+
+declare class ZAIAuthTransport implements HttpTransport {
+    private readonly inner;
+    private readonly apiKey?;
+    private readonly baseUrl;
+    constructor(inner: FetchTransport, apiKey?: string, baseUrl?: string);
+    private buildFullUrl;
+    private makeAuthHeaders;
+    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
+    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
+}
+
+declare class LLMError extends Error {
+    readonly statusCode?: number;
+    readonly isRetryable: boolean;
+    constructor(message: string, statusCode?: number, isRetryable?: boolean, cause?: unknown);
+}
+declare abstract class BaseLLM implements LLMPort {
+    protected transport: HttpTransport | null;
+    protected apiUrl: string;
+    protected enablePromptCaching: boolean;
+    constructor(apiUrl: string, options?: {
+        enablePromptCaching?: boolean;
+    });
+    protected abstract createTransport(): HttpTransport;
+    private getTransport;
+    protected applyCacheControl(params: CompletionParams): CompletionParams;
+    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
+    streamCompletion(params: CompletionParams, handlers?: {
+        onChunk?: (delta: string, usage?: UsageData) => void;
+        onToolCallDelta?: (tc: ToolCall) => void;
+        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
+    }, signal?: AbortSignal): Promise<CompletionResult>;
+}
+
+type GithubOptions = {
+    apiKey?: string;
+    accessToken?: string;
+    apiUrl?: string;
+    httpLogFile?: string;
+};
+declare class GithubLLM extends BaseLLM implements LLMPort {
+    private readonly opts;
+    constructor(opts?: GithubOptions);
+    protected createTransport(): GithubAuthTransport;
+}
+
+type OpenRouterOptions = {
+    apiKey?: string;
+    apiUrl?: string;
+    httpLogFile?: string;
+    enablePromptCaching?: boolean;
+    includeUsage?: boolean;
+};
+type OpenRouterModel = {
+    id: string;
+    canonical_slug: string;
+    hugging_face_id: string;
+    name: string;
+    created: number;
+    description: string;
+    context_length: number;
+    architecture: {
+        modality: string;
+        input_modalities: string[];
+        output_modalities: string[];
+        tokenizer: string;
+        instruct_type: string | null;
+    };
+    pricing: {
+        prompt: string;
+        completion: string;
+        request: string;
+        image: string;
+        web_search: string;
+        internal_reasoning: string;
+        input_cache_read: string;
+    };
+    top_provider: {
+        context_length: number;
+        max_completion_tokens: number | null;
+        is_moderated: boolean;
+    };
+    per_request_limits: {
+        prompt_tokens: string;
+        completion_tokens: string;
+    } | null;
+    supported_parameters: string[];
+    default_parameters: {
+        temperature: number | null;
+        top_p: number | null;
+        frequency_penalty: number | null;
+    };
+};
+declare class OpenRouterLLM extends BaseLLM implements LLMPort {
+    private readonly includeUsage;
+    constructor(opts?: OpenRouterOptions);
+    private readonly opts;
+    protected createTransport(): OpenRouterAuthTransport;
+    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
+    streamCompletion(params: CompletionParams, handlers?: {
+        onChunk?: (delta: string, usage?: UsageData) => void;
+        onToolCallDelta?: (tc: ToolCall) => void;
+        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
+    }, signal?: AbortSignal): Promise<CompletionResult>;
+    getModels(signal?: AbortSignal): Promise<OpenRouterModel[]>;
+}
+
+type DeepInfraOptions = {
+    apiKey?: string;
+    apiUrl?: string;
+    httpLogFile?: string;
+};
+type DeepInfraModel = {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+    root: string;
+    parent: string | null;
+    metadata: {
+        description: string;
+        context_length: number;
+        max_tokens: number;
+        pricing: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_read_tokens?: number;
+        };
+        tags: string[];
+    };
+};
+declare class DeepInfraLLM extends BaseLLM implements LLMPort {
+    private readonly opts;
+    constructor(opts?: DeepInfraOptions);
+    protected createTransport(): DeepInfraAuthTransport;
+    getModels(signal?: AbortSignal): Promise<DeepInfraModel[]>;
+}
+
+type ZaiOptions = {
+    apiKey?: string;
+    apiUrl?: string;
+    httpLogFile?: string;
+};
+declare class ZaiLLM extends BaseLLM implements LLMPort {
+    private readonly opts;
+    constructor(opts?: ZaiOptions);
+    protected createTransport(): ZAIAuthTransport;
+}
+
+type AnthropicOptions = {
+    apiKey?: string;
+    oauth?: {
+        type: 'oauth';
+        access: string;
+        refresh: string;
+        expires: number;
+    };
+    apiUrl?: string;
+    httpLogFile?: string;
+};
+declare class AnthropicLLM {
+    private transport;
+    private readonly opts;
+    private readonly apiUrl;
+    constructor(opts?: AnthropicOptions);
+    private getTransport;
+    private transformToAnthropicMessages;
+    private transformTools;
+    private transformToolChoice;
+    private transformResponse;
+    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
+    streamCompletion(params: CompletionParams, handlers?: {
+        onChunk?: (delta: string, usage?: UsageData) => void;
+        onToolCallDelta?: (tc: ToolCall) => void;
+        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
+    }, signal?: AbortSignal): Promise<CompletionResult>;
+}
+
+type AnthropicAISDKOptions = {
+    apiKey?: string;
+    oauth?: {
+        type: 'oauth';
+        access: string;
+        refresh: string;
+        expires: number;
+    };
+    apiUrl?: string;
+    baseURL?: string;
+    httpLogFile?: string;
+    onTokenUpdate?: (newCredentials: {
+        access: string;
+        refresh: string;
+        expires: number;
+    }) => void;
+};
+declare class AnthropicAISDKLLM {
+    private readonly opts;
+    private provider?;
+    private refreshPromise;
+    constructor(opts?: AnthropicAISDKOptions);
+    private refreshAccessToken;
+    private updateCredentials;
+    private ensureValidToken;
+    private createFetchWithRetry;
+    private getProvider;
+    private getModel;
+    private transformMessages;
+    private transformTools;
+    private transformToolChoice;
+    private handleError;
+    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
+    streamCompletion(params: CompletionParams, handlers?: {
+        onChunk?: (delta: string, usage?: UsageData) => void;
+        onToolCallDelta?: (tc: ToolCall) => void;
+        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
+    }, signal?: AbortSignal): Promise<CompletionResult>;
+}
+
+type MCPHttpOptions = {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+};
+type MCPStdioOptions = {
+    type: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    stderr?: StdioServerParameters['stderr'];
+    cwd?: string;
+};
+type MCPOptions = MCPHttpOptions | MCPStdioOptions;
+type MCPToolSchema = {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+};
+type MCPToolCall = {
+    name: string;
+    arguments?: Record<string, any>;
+};
+type MCPCallResult = {
+    content?: Array<unknown>;
+    isError?: boolean;
+};
+declare class CoreMCPClient {
+    private opts;
+    private timeoutMs;
+    private client;
+    private transport;
+    private connected;
+    private tools;
+    constructor(opts: MCPOptions, timeoutMs?: number);
+    connect(): Promise<void>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+    refreshTools(): Promise<MCPToolSchema[]>;
+    getTools(): MCPToolSchema[];
+    callTool(call: MCPToolCall): Promise<MCPCallResult>;
+}
+
+declare class MCPToolPort implements ToolPort {
+    private client;
+    private map;
+    private toolSchemas;
+    private prefix;
+    constructor(client: CoreMCPClient, opts?: {
+        prefix?: string;
+    });
+    init(): Promise<void>;
+    getExposedToolNames(): string[];
+    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
+    executeToolCalls(calls: ToolInvocation[], _context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
+}
+
+type MCPServerConfig = {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    transport?: 'stdio' | 'http';
+    url?: string;
+    headers?: Record<string, string>;
+    prefix?: string;
+    timeoutMs?: number;
+};
+type MCPConfig = {
+    mcpServers: Record<string, MCPServerConfig>;
+};
+declare function loadMCPConfig(filePath?: string): Promise<MCPConfig | null>;
+
+declare class PersistingConsoleEventPort implements EventPort {
+    private memory;
+    private maxPerConversation;
+    constructor(opts?: {
+        memory?: MemoryPort<AgentEvent>;
+        filename?: string;
+        maxPerConversation?: number;
+    });
+    emit(event: AgentEvent): Promise<void>;
+}
+
+declare function normalizeNewlines(s: string): string;
+declare function resolveCarriageReturns(s: string): string;
+declare function resolveBackspaces(s: string): string;
+declare function stripAnsiAndControls(s: string): string;
+declare function canonicalizeTerminalPaste(raw: string): string;
+
+export { AGENT_CREATOR_SYSTEM_PROMPT, type AgentCatalog, type AgentConfig, type AgentEvent, AgentEventTypes, AgentFilePersistence, AgentManager, AgentManagerCommandRunner, AgentOrchestrator, AgentRegistry, type AgentTemplate, AnthropicAISDKLLM, AnthropicLLM, type AssignParams, BashTool, CompositeToolPort, type Conversation, ConversationContext, type ConversationMetadata, type ConversationSnapshot, ConversationStore, CoreMCPClient, DeepInfraLLM, type DeepInfraModel, DefaultDelegationPolicy, DefaultDelegationResultFormatter, DefaultDelegationService, DefaultSpecialistAgentFactory, type DelegationService, EchoLLM, type FolderTreeOptions, GithubLLM, InMemoryMemory, InMemoryMetadata, JsonFileMemoryPersistence, LLMError, type LLMPort, type MCPConfig, type MCPServerConfig, MCPToolPort, type MemoryPort, MemoryPortMetadataAdapter, type Message, type MessageContent, type MessageContentPart, type MetadataPort, NoopReminders, OpenRouterLLM, type OpenRouterModel, PersistedMemory, PersistingConsoleEventPort, RuntimeEnv, type SendMessageOptions, SimpleContextBuilder, SimpleCost, SimpleId, type SpecialistAgentConfig, type SpecialistAgentResult, SystemClock, type ToolApprovalDecision, type ToolCall, type ToolExecutionResult, type ToolPort, ToolRegistry, type UserAttachment, type UserMessagePayload, ZaiLLM, buildAgentCreationPrompt, buildInjectedSystem, canonicalizeTerminalPaste, generateFolderTree, loadMCPConfig, normalizeNewlines, renderTemplate, resolveBackspaces, resolveCarriageReturns, stripAnsiAndControls };