@geoffai/coder 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1019 @@
+import { ChildProcess } from 'child_process';
+import OpenAI from 'openai';
+
+interface Message {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ContentPart[];
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+interface ContentPart {
+    type: "text" | "image_url";
+    text?: string;
+    image_url?: {
+        url: string;
+    };
+}
+interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, PropertyDefinition>;
+            required: string[];
+        };
+    };
+}
+interface PropertyDefinition {
+    type: string;
+    description: string;
+    enum?: string[];
+}
+interface CompletionRequest {
+    model: string;
+    messages: Message[];
+    tools?: ToolDefinition[];
+    tool_choice?: "auto" | "none" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    stream?: boolean;
+    max_tokens?: number;
+    temperature?: number;
+}
+interface CompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Choice[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface Choice {
+    index: number;
+    message: Message;
+    finish_reason: "stop" | "tool_calls" | "length" | "content_filter" | null;
+}
+interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: StreamChoice[];
+}
+interface StreamChoice {
+    index: number;
+    delta: Partial<Message> & {
+        tool_calls?: Partial<ToolCall>[];
+    };
+    finish_reason: string | null;
+}
+interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+type AgentEventType = 'iteration_start' | 'llm_call' | 'llm_response' | 'tool_call' | 'tool_result' | 'file_written' | 'file_modified' | 'command_executed' | 'task_complete' | 'error' | 'thinking';
+interface AgentEvent {
+    type: AgentEventType;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+type AgentEventCallback = (event: AgentEvent) => void;
+interface AgentConfig {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    maxIterations: number;
+    maxTokens: number;
+    temperature: number;
+    workingDirectory: string;
+    autoApprove: boolean;
+    verbose: boolean;
+    onEvent?: AgentEventCallback;
+    sandboxId?: string;
+}
+interface AgentState {
+    messages: Message[];
+    iteration: number;
+    isRunning: boolean;
+    lastToolCalls: ToolCall[];
+    tokensUsed: number;
+    metrics: AgentMetrics;
+}
+interface AgentMetrics {
+    tokensUsed: number;
+    promptTokens: number;
+    completionTokens: number;
+    contextSize: number;
+    filesCreated: number;
+    filesModified: number;
+    linesAdded: number;
+    linesRemoved: number;
+    commandsExecuted: number;
+    toolCallsTotal: number;
+    apiCalls: number;
+    startTime: number;
+    modifiedFiles: Set<string>;
+    createdFiles: Set<string>;
+}
+type ToolHandler = (args: Record<string, unknown>) => Promise<ToolResult>;
+interface ToolRegistry {
+    definitions: ToolDefinition[];
+    handlers: Map<string, ToolHandler>;
+}
+
+declare class AgentLoop {
+    private client;
+    private config;
+    private state;
+    private tools;
+    private logger;
+    private aborted;
+    constructor(config: AgentConfig);
+    /**
+     * Emit an event to the callback if configured
+     */
+    private emit;
+    private createInitialMetrics;
+    private createInitialState;
+    private getSystemMessage;
+    private estimateContextSize;
+    private manageContextWindow;
+    private checkContextLimits;
+    run(userPrompt: string): Promise<string>;
+    private callLLM;
+    /**
+     * Process XML-style tool calls from LLM response
+     *
+     * This method checks if the response contains XML-style tool calls
+     * (e.g., <function=name><parameter=...>...</parameter></function>)
+     * and converts them to OpenAI-compatible JSON format.
+     *
+     * If regex parsing fails and content contains XML patterns,
+     * it optionally uses an AI inference to convert them.
+     */
+    private processXmlToolCalls;
+    /**
+     * AI-assisted tool call parsing
+     *
+     * Uses a lightweight LLM call to convert XML tool calls to JSON format.
+     * This is a fallback when regex parsing fails.
+     */
+    private aiAssistedToolParsing;
+    private handleToolCalls;
+    private trackToolMetrics;
+    private addToolResultMessage;
+    private looksLikeCompletion;
+    /**
+     * Check if we should stop the loop based on state
+     * Returns true if we should stop
+     */
+    private shouldStopLoop;
+    abort(): void;
+    getState(): Readonly<AgentState>;
+    getMetrics(): Readonly<AgentMetrics>;
+    getTokensUsed(): number;
+}
+
+/**
+ * ContentGenerator interface for GeoffNet Qwen integration
+ * Simplified from qwen-code to focus on OpenAI-compatible generation
+ */
+/**
+ * Gemini-compatible types for internal use
+ * These mirror the @google/genai types but are simplified for our use case
+ */
+interface Part {
+    text?: string;
+    thought?: boolean;
+    functionCall?: FunctionCall;
+    functionResponse?: FunctionResponse;
+    inlineData?: {
+        data: string;
+        mimeType: string;
+    };
+    fileData?: {
+        fileUri: string;
+        mimeType: string;
+    };
+}
+interface Content {
+    role: 'user' | 'model';
+    parts: Part[];
+}
+interface FunctionCall {
+    id?: string;
+    name?: string;
+    args?: Record<string, unknown>;
+}
+interface FunctionResponse {
+    id?: string;
+    name?: string;
+    response?: unknown;
+}
+interface FunctionDeclaration {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+    parametersJsonSchema?: Record<string, unknown>;
+}
+interface Tool {
+    functionDeclarations?: FunctionDeclaration[];
+}
+type ToolListUnion = (Tool | CallableTool)[];
+interface CallableTool {
+    tool: () => Promise<Tool>;
+}
+interface UsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+    cachedContentTokenCount?: number;
+    thoughtsTokenCount?: number;
+}
+interface Candidate {
+    content: Content;
+    finishReason?: FinishReason;
+    index: number;
+    safetyRatings?: unknown[];
+}
+declare enum FinishReason {
+    FINISH_REASON_UNSPECIFIED = 0,
+    STOP = 1,
+    MAX_TOKENS = 2,
+    SAFETY = 3,
+    RECITATION = 4,
+    OTHER = 5
+}
+/**
+ * Gemini-style response wrapper
+ */
+declare class GenerateContentResponse {
+    candidates?: Candidate[];
+    usageMetadata?: UsageMetadata;
+    responseId?: string;
+    createTime?: string;
+    modelVersion?: string;
+    promptFeedback?: {
+        safetyRatings: unknown[];
+    };
+}
+interface GenerateContentParameters {
+    contents: Content[] | string;
+    config?: {
+        systemInstruction?: string | Content;
+        tools?: ToolListUnion;
+        temperature?: number;
+        topP?: number;
+        maxOutputTokens?: number;
+        abortSignal?: AbortSignal;
+    };
+}
+interface CountTokensParameters {
+    contents: Content[] | string;
+}
+interface CountTokensResponse {
+    totalTokens: number;
+}
+interface EmbedContentParameters {
+    contents: Content[] | string;
+}
+interface EmbedContentResponse {
+    embeddings: {
+        values: number[];
+    }[];
+}
+/**
+ * Authentication types supported
+ */
+declare enum AuthType {
+    USE_OPENAI = "openai",
+    USE_OLLAMA = "ollama"
+}
+/**
+ * Configuration for content generation
+ */
+interface ContentGeneratorConfig {
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    authType?: AuthType;
+    enableOpenAILogging?: boolean;
+    openAILoggingDir?: string;
+    timeout?: number;
+    maxRetries?: number;
+    enableTextToolCallParsing?: boolean;
+    samplingParams?: {
+        top_p?: number;
+        top_k?: number;
+        repetition_penalty?: number;
+        presence_penalty?: number;
+        frequency_penalty?: number;
+        temperature?: number;
+        max_tokens?: number;
+    };
+}
+/**
+ * Interface for content generation implementations
+ */
+interface ContentGenerator {
+    generateContent(request: GenerateContentParameters, userPromptId: string): Promise<GenerateContentResponse>;
+    generateContentStream(request: GenerateContentParameters, userPromptId: string): Promise<AsyncGenerator<GenerateContentResponse>>;
+    countTokens(request: CountTokensParameters): Promise<CountTokensResponse>;
+    embedContent(request: EmbedContentParameters): Promise<EmbedContentResponse>;
+    setAvailableTools?(toolNames: string[]): void;
+}
+declare const DEFAULT_QWEN_MODEL = "qwen3-coder:30b";
+
+/**
+ * Interface for OpenAI-compatible providers
+ */
+interface OpenAICompatibleProvider {
+    buildHeaders(): Record<string, string | undefined>;
+    buildClient(): OpenAI;
+    buildRequest(request: OpenAI.Chat.ChatCompletionCreateParams, userPromptId: string): OpenAI.Chat.ChatCompletionCreateParams;
+}
+
+/**
+ * Content Generation Pipeline
+ * Handles the complete request/response flow for OpenAI-compatible APIs
+ */
+
+interface PipelineConfig {
+    provider: OpenAICompatibleProvider;
+    contentGeneratorConfig: ContentGeneratorConfig;
+}
+declare class ContentGenerationPipeline {
+    private config;
+    client: OpenAI;
+    private converter;
+    private contentGeneratorConfig;
+    constructor(config: PipelineConfig);
+    /**
+     * Set available tool names for text-based tool call parsing
+     */
+    setAvailableTools(toolNames: string[]): void;
+    /**
+     * Execute a non-streaming request
+     */
+    execute(request: GenerateContentParameters, userPromptId: string): Promise<GenerateContentResponse>;
+    /**
+     * Execute a streaming request
+     */
+    executeStream(request: GenerateContentParameters, userPromptId: string): Promise<AsyncGenerator<GenerateContentResponse>>;
+    /**
+     * Process the OpenAI stream and convert to Gemini format
+     */
+    private processStream;
+    private buildRequest;
+    private buildSamplingParameters;
+    private handleError;
+}
+
+/**
+ * OpenAI Content Generator
+ * Main implementation of ContentGenerator for OpenAI-compatible APIs
+ */
+
+declare class OpenAIContentGenerator implements ContentGenerator {
+    protected pipeline: ContentGenerationPipeline;
+    constructor(contentGeneratorConfig: ContentGeneratorConfig, provider: OpenAICompatibleProvider);
+    /**
+     * Set available tool names for text-based tool call parsing
+     */
+    setAvailableTools(toolNames: string[]): void;
+    generateContent(request: GenerateContentParameters, userPromptId: string): Promise<GenerateContentResponse>;
+    generateContentStream(request: GenerateContentParameters, userPromptId: string): Promise<AsyncGenerator<GenerateContentResponse>>;
+    countTokens(request: CountTokensParameters): Promise<CountTokensResponse>;
+    embedContent(request: EmbedContentParameters): Promise<EmbedContentResponse>;
+}
+
+/**
+ * OpenAI <-> Gemini format converter
+ * Handles bidirectional conversion between OpenAI Chat Completion format
+ * and internal Gemini-style format, including streaming tool call parsing.
+ */
+
+/**
+ * Converter class for transforming data between Gemini and OpenAI formats
+ */
+declare class OpenAIContentConverter {
+    private model;
+    private streamingToolCallParser;
+    private textToolCallParser;
+    private enableTextToolCallParsing;
+    private streamingTextAccumulator;
+    private streamingHasNativeToolCalls;
+    constructor(model: string, enableTextToolCallParsing?: boolean);
+    /**
+     * Set available tool names for text-based tool call parsing
+     */
+    setAvailableTools(toolNames: string[]): void;
+    /**
+     * Enable or disable text-based tool call parsing
+     */
+    setTextToolCallParsing(enabled: boolean): void;
+    /**
+     * Reset streaming state for new stream processing
+     */
+    resetStreamingToolCalls(): void;
+    /**
+     * Convert Gemini tools to OpenAI format
+     */
+    convertGeminiToolsToOpenAI(geminiTools: ToolListUnion): Promise<OpenAI.Chat.ChatCompletionTool[]>;
+    /**
+     * Convert Gemini tool parameters to OpenAI JSON Schema format
+     */
+    convertGeminiToolParametersToOpenAI(parameters: Record<string, unknown>): Record<string, unknown> | undefined;
+    /**
+     * Convert Gemini request to OpenAI message format
+     */
+    convertGeminiRequestToOpenAI(request: GenerateContentParameters): OpenAI.Chat.ChatCompletionMessageParam[];
+    private addSystemInstructionMessage;
+    private processContents;
+    private processContent;
+    private parseParts;
+    private extractFunctionResponseContent;
+    private getMediaType;
+    private createMultimodalMessage;
+    private extractTextFromContentUnion;
+    /**
+     * Convert OpenAI response to Gemini format
+     */
+    convertOpenAIResponseToGemini(openaiResponse: OpenAI.Chat.ChatCompletion): GenerateContentResponse;
+    /**
+     * Convert OpenAI stream chunk to Gemini format
+     */
+    convertOpenAIChunkToGemini(chunk: OpenAI.Chat.ChatCompletionChunk): GenerateContentResponse;
+    private mapOpenAIFinishReasonToGemini;
+    private cleanOrphanedToolCalls;
+    private mergeConsecutiveAssistantMessages;
+}
+
+/**
+ * StreamingToolCallParser - Handles streaming tool call objects with inconsistent chunk formats
+ *
+ * Problems this parser addresses:
+ * - Tool calls arrive with varying chunk shapes (empty strings, partial JSON, complete objects)
+ * - Tool calls may lack IDs, names, or have inconsistent indices
+ * - Multiple tool calls can be processed simultaneously with interleaved chunks
+ * - Index collisions occur when the same index is reused for different tool calls
+ * - JSON arguments are fragmented across multiple chunks and need reconstruction
+ */
+/**
+ * Type definition for the result of parsing a JSON chunk in tool calls
+ */
+interface ToolCallParseResult {
+    /** Whether the JSON parsing is complete */
+    complete: boolean;
+    /** The parsed JSON value (only present when complete is true) */
+    value?: Record<string, unknown>;
+    /** Error information if parsing failed */
+    error?: Error;
+    /** Whether the JSON was repaired (e.g., auto-closed unclosed strings) */
+    repaired?: boolean;
+}
+declare class StreamingToolCallParser {
+    /** Accumulated buffer containing all received chunks for each tool call index */
+    private buffers;
+    /** Current nesting depth in JSON structure for each tool call index */
+    private depths;
+    /** Whether we're currently inside a string literal for each tool call index */
+    private inStrings;
+    /** Whether the next character should be treated as escaped for each tool call index */
+    private escapes;
+    /** Metadata for each tool call index */
+    private toolCallMeta;
+    /** Map from tool call ID to actual index used for storage */
+    private idToIndexMap;
+    /** Counter for generating new indices when collisions occur */
+    private nextAvailableIndex;
+    /**
+     * Processes a new chunk of tool call data and attempts to parse complete JSON objects
+     */
+    addChunk(index: number, chunk: string, id?: string, name?: string): ToolCallParseResult;
+    /**
+     * Gets the current tool call metadata for a specific index
+     */
+    getToolCallMeta(index: number): {
+        id?: string;
+        name?: string;
+    };
+    /**
+     * Gets all completed tool calls that are ready to be emitted
+     */
+    getCompletedToolCalls(): Array<{
+        id?: string;
+        name?: string;
+        args: Record<string, unknown>;
+        index: number;
+    }>;
+    private findNextAvailableIndex;
+    private findMostRecentIncompleteIndex;
+    /**
+     * Resets the parser state for a specific tool call index
+     */
+    resetIndex(index: number): void;
+    /**
+     * Resets the entire parser state for processing a new stream
+     */
+    reset(): void;
+    /**
+     * Gets the current accumulated buffer content for a specific index
+     */
+    getBuffer(index: number): string;
+    /**
+     * Gets the current parsing state information for a specific index
+     */
+    getState(index: number): {
+        depth: number;
+        inString: boolean;
+        escape: boolean;
+    };
+}
+
+/**
+ * Text-based tool call parser for models that don't support native OpenAI tool_calls.
+ * Supports multiple XML and JSON formats used by Qwen and other models.
+ */
+/**
+ * Parsed tool call from text content
+ */
+interface ParsedTextToolCall {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Result of text tool call parsing
+ */
+interface TextToolCallParseResult {
+    toolCalls: ParsedTextToolCall[];
+    remainingText: string;
+    /** Extracted thinking/reasoning content from <think> tags */
+    thinkingContent?: string;
+}
+/**
+ * Parses tool calls from text content for models that don't support native OpenAI tool_calls.
+ *
+ * Supports multiple formats:
+ * 1. XML-style: <tool_call>{"name": "tool_name", "arguments": {...}}</tool_call>
+ * 2. Function notation: tool_name({"arg": "value"})
+ * 3. JSON block: ```json\n{"tool": "name", "args": {...}}\n```
+ * 4. Bracket notation: [tool_call: tool_name(args)]
+ * 5. Llama/Qwen style: <function=name><parameter=key>value</parameter></function>
+ */
+declare class TextToolCallParser {
+    private toolCallCounter;
+    private availableToolNames;
+    constructor(availableToolNames?: string[]);
+    /**
+     * Set the available tool names for validation
+     */
+    setAvailableTools(toolNames: string[]): void;
+    /**
+     * Generate a unique tool call ID
+     */
+    private generateId;
+    /**
+     * Check if a tool name is valid
+     */
+    private isValidTool;
+    /**
+     * Parse tool calls from text content
+     */
+    parse(content: string): TextToolCallParseResult;
+    /**
+     * Parse thinking/reasoning content from <think> tags (Qwen models)
+     * Supports: <think>...</think>, <thinking>...</thinking>, <reasoning>...</reasoning>
+     */
+    private parseThinkTags;
+    /**
+     * Parse XML-style tool calls: <tool_call>{"name": "...", "arguments": {...}}</tool_call>
+     */
+    private parseXmlStyle;
+    /**
+     * Parse function call XML: <function_call>{"name": "...", "parameters": {...}}</function_call>
+     */
+    private parseFunctionCallXml;
+    /**
+     * Parse Llama/Qwen style tool calls: <function=name><parameter=key>value</parameter></function>
+     * Also handles variations like </tool_call> at the end
+     */
+    private parseLlamaStyleXml;
+    /**
+     * Parse JSON code blocks that contain tool call structures
+     */
+    private parseJsonBlocks;
+    /**
+     * Parse bracket notation: [tool_call: name(args)] or [name: args]
+     */
+    private parseBracketNotation;
+    /**
+     * Parse inline function calls: tool_name({...})
+     */
+    private parseInlineFunctionCalls;
+    /**
+     * Parse various JSON formats for tool calls
+     */
+    private parseToolCallJson;
+    /**
+     * Reset the parser state
+     */
+    reset(): void;
+}
+
+/**
+ * OpenAI Content Generator exports
+ */
+
+/**
+ * Create an OpenAI-compatible content generator with the default provider
+ */
+declare function createOpenAIContentGenerator(contentGeneratorConfig: ContentGeneratorConfig): ContentGenerator;
+
+/**
+ * QwenAgentAdapter
+ *
+ * Adapter layer that wraps the Qwen-style content generator and provides
+ * the same interface as AgentLoop. This enables:
+ * - Text-based XML tool call parsing for Qwen models
+ * - Streaming tool call reconstruction
+ * - Same event emission interface for frontend compatibility
+ */
+
+/**
+ * Extended configuration for QwenAgentAdapter
+ */
+interface QwenAgentConfig extends AgentConfig {
+    /** Enable text-based tool call parsing (XML format support) */
+    enableTextToolCallParsing?: boolean;
+    /** Sampling parameters for the model */
+    samplingParams?: ContentGeneratorConfig['samplingParams'];
+}
+/**
+ * QwenAgentAdapter provides an AgentLoop-compatible interface
+ * while using the Qwen content generator with XML tool call parsing
+ */
+declare class QwenAgentAdapter {
+    private config;
+    private state;
+    private tools;
+    private logger;
+    private aborted;
+    private contentGenerator;
+    constructor(config: QwenAgentConfig);
+    /**
+     * Emit an event to the callback if configured
+     */
+    private emit;
+    private createInitialMetrics;
+    private createInitialState;
+    private getSystemMessage;
+    private estimateContextSize;
+    private manageContextWindow;
+    private checkContextLimits;
+    /**
+     * Convert internal messages to Gemini-style Content format
+     */
+    private messagesToContents;
+    /**
+     * Convert tool definitions to Gemini Tool format
+     */
+    private toolsToGeminiFormat;
+    /**
+     * Extract tool calls from Gemini response
+     */
+    private extractToolCalls;
+    /**
+     * Extract text content from Gemini response
+     */
+    private extractTextContent;
+    /**
+     * Main agent loop - runs until task completion or max iterations
+     */
+    run(userPrompt: string): Promise<string>;
+    private callLLM;
+    private handleToolCalls;
+    private trackToolMetrics;
+    private addToolResultMessage;
+    private looksLikeCompletion;
+    private shouldStopLoop;
+    private serializeMetrics;
+    abort(): void;
+    getState(): Readonly<AgentState>;
+    getMetrics(): Readonly<AgentMetrics>;
+    getTokensUsed(): number;
+}
+
+interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    retryableStatuses: number[];
+}
+declare class APIClient {
+    private apiKey;
+    private baseUrl;
+    private model;
+    private retryConfig;
+    constructor(config: {
+        apiKey: string;
+        baseUrl: string;
+        model: string;
+        retryConfig?: Partial<RetryConfig>;
+    });
+    private sleep;
+    private calculateBackoff;
+    private shouldRetry;
+    createCompletion(messages: Message[], tools?: ToolDefinition[], options?: {
+        stream?: boolean;
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<CompletionResponse>;
+    createStreamingCompletion(messages: Message[], tools?: ToolDefinition[], options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }): AsyncGenerator<StreamChunk, void, unknown>;
+    accumulateStream(messages: Message[], tools?: ToolDefinition[], options?: {
+        maxTokens?: number;
+        temperature?: number;
+        onToken?: (token: string) => void;
+    }): Promise<Message>;
+}
+
+interface ToolRegistryConfig {
+    workingDir: string;
+    ignorePatterns?: string[];
+}
+declare function createToolRegistry(config: ToolRegistryConfig | string): ToolRegistry;
+
+/**
+ * TodoWrite Tool
+ *
+ * Creates and manages a structured task list for coding sessions.
+ * This helps track progress, organize complex tasks, and demonstrates
+ * thoroughness to the user.
+ */
+
+/**
+ * Todo item structure
+ */
+interface TodoItem {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    /** Active form description for UI display during execution */
+    activeForm?: string;
+}
+/**
+ * Read todos from file
+ */
+declare function readTodos(sessionId?: string): Promise<TodoItem[]>;
+/**
+ * Write todos to file
+ */
+declare function writeTodos(todos: TodoItem[], sessionId?: string): Promise<void>;
+/**
+ * Create the todo_write tool handler
+ */
+declare function createTodoWriteHandler(sessionId?: string): ToolHandler;
+/**
+ * Todo write tool definition
+ */
+declare const todoWriteDefinition: ToolDefinition;
+/**
+ * List all todo sessions
+ */
+declare function listTodoSessions(): Promise<string[]>;
+
+/**
+ * Plan Mode Tools
+ *
+ * Tools for entering/exiting plan mode where the agent plans before executing.
+ * Plan mode ensures user approval before the agent starts writing code.
+ */
+
+/**
+ * Plan mode state interface
+ */
+interface PlanModeState {
+    enabled: boolean;
+    plan?: string;
+    awaitingApproval: boolean;
+    approved: boolean;
+}
+/**
+ * Get or create plan mode state for a session
+ */
+declare function getPlanModeState(sessionId?: string): PlanModeState;
+/**
+ * Set plan mode approval status (called by frontend)
+ */
+declare function setPlanApproval(sessionId: string, approved: boolean): void;
+/**
+ * Enter plan mode for a session
+ */
+declare function enterPlanMode(sessionId?: string): void;
+/**
+ * Check if plan mode is enabled
+ */
+declare function isPlanModeEnabled(sessionId?: string): boolean;
+/**
+ * Create exit_plan_mode tool handler
+ */
+declare function createExitPlanModeHandler(sessionId?: string, onEvent?: AgentEventCallback): ToolHandler;
+/**
+ * exit_plan_mode tool definition
+ */
+declare const exitPlanModeDefinition: ToolDefinition;
+/**
+ * Create enter_plan_mode tool handler (for explicit plan mode entry)
+ */
+declare function createEnterPlanModeHandler(sessionId?: string, onEvent?: AgentEventCallback): ToolHandler;
+/**
+ * enter_plan_mode tool definition
+ */
+declare const enterPlanModeDefinition: ToolDefinition;
+
+/**
+ * Background Process Tools
+ *
+ * Tools for running processes in the background and managing them.
+ * Enables long-running tasks like dev servers without blocking the agent.
+ */
+
+/**
+ * Background process info
+ */
+interface BackgroundProcess {
+    id: string;
+    pid: number;
+    command: string;
+    startTime: number;
+    output: string[];
+    isComplete: boolean;
+    exitCode: number | null;
+    process: ChildProcess;
+}
+/**
+ * Background process manager
+ */
+declare class BackgroundProcessManager {
+    private processes;
+    private counter;
+    /**
+     * Start a background process
+     */
+    start(command: string, workingDir: string, onEvent?: AgentEventCallback): BackgroundProcess;
+    /**
+     * Get a background process by ID
+     */
+    get(id: string): BackgroundProcess | undefined;
+    /**
+     * Get all background processes
+     */
+    getAll(): BackgroundProcess[];
+    /**
+     * Kill a background process
+     */
+    kill(id: string): boolean;
+    /**
+     * Get output from a background process
+     */
+    getOutput(id: string, tail?: number): string;
+    /**
+     * Clean up completed processes
+     */
+    cleanup(): void;
+}
+declare const manager: BackgroundProcessManager;
+/**
+ * Create run_background handler
+ */
+declare function createRunBackgroundHandler(workingDir: string, onEvent?: AgentEventCallback): ToolHandler;
+/**
+ * Create get_process_output handler
+ */
+declare function createGetProcessOutputHandler(): ToolHandler;
+/**
+ * Create kill_process handler
+ */
+declare function createKillProcessHandler(): ToolHandler;
+/**
+ * Create list_processes handler
+ */
+declare function createListProcessesHandler(): ToolHandler;
+declare const runBackgroundDefinition: ToolDefinition;
+declare const getProcessOutputDefinition: ToolDefinition;
+declare const killProcessDefinition: ToolDefinition;
+declare const listProcessesDefinition: ToolDefinition;
+
+type LogEventType = 'tool_call' | 'tool_result' | 'context_truncated' | 'assistant_message' | 'user_message' | 'info' | 'warn' | 'error' | 'success' | 'metrics_update' | 'iteration_start' | 'task_complete';
+interface LogEvent {
+    type: LogEventType;
+    timestamp: number;
+    data: {
+        message?: string;
+        toolName?: string;
+        toolArgs?: string;
+        success?: boolean;
+        output?: string;
+        error?: string;
+        iteration?: number;
+        maxIterations?: number;
+        metrics?: AgentMetrics;
+        removedCount?: number;
+        tokenLimit?: number;
+    };
+}
+type LogEventCallback = (event: LogEvent) => void;
+declare class Logger {
+    private verbose;
+    private currentMetricsLine;
+    private onLogEvent?;
+    constructor(verbose?: boolean, onLogEvent?: LogEventCallback);
+    setLogEventCallback(callback: LogEventCallback | undefined): void;
+    private emit;
+    private timestamp;
+    private num;
+    private truncate;
+    private colorize;
+    private statusIcon;
+    private line;
+    private label;
+    private section;
+    private clearStatusLine;
+    private restoreStatusLine;
+    private print;
+    info(message: string): void;
+    debug(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    success(message: string): void;
+    tool(name: string, args: string): void;
+    toolResult(name: string, result: ToolResult): void;
+    assistant(message: string): void;
+    user(message: string): void;
+    separator(): void;
+    banner(): void;
+    config(config: Record<string, unknown>): void;
+    metricsUpdate(metrics: AgentMetrics, iteration: number): void;
+    clearMetricsLine(): void;
+    metricsSummary(metrics: AgentMetrics, iteration: number): void;
+    iterationHeader(iteration: number, maxIterations: number): void;
+}
+
+interface GeoffConfig {
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    maxIterations?: number;
+    maxTokens?: number;
+    temperature?: number;
+    verbose?: boolean;
+    ignorePatterns?: string[];
+    blockedCommands?: string[];
+    retry?: {
+        maxRetries?: number;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+    };
+}
+/**
+ * Load configuration from .geoff.json files only.
+ * Priority (highest to lowest):
+ * 1. Project config (.geoff.json in working directory)
+ * 2. User config (~/.geoff.json)
+ * 3. Default config
+ *
+ * Model configuration (model, baseUrl, apiKey) comes exclusively from .geoff.json
+ */
+declare function loadConfig(workingDirectory: string): GeoffConfig;
+/**
+ * Validate configuration values
+ */
+declare function validateConfig(config: GeoffConfig): {
+    valid: boolean;
+    errors: string[];
+};
+
+export { APIClient, type AgentConfig, type AgentEvent, type AgentEventCallback, type AgentEventType, AgentLoop, type AgentMetrics, type AgentState, type BackgroundProcess, type CompletionRequest, type CompletionResponse, ContentGenerationPipeline, type ContentGenerator, type ContentGeneratorConfig, DEFAULT_QWEN_MODEL, type GenerateContentParameters, GenerateContentResponse, type GeoffConfig, Logger, type Message, OpenAIContentConverter, OpenAIContentGenerator, type PlanModeState, QwenAgentAdapter, type QwenAgentConfig, StreamingToolCallParser, TextToolCallParser, type TodoItem, type ToolCall, type ToolDefinition, type ToolHandler, type ToolRegistry, type ToolResult, manager as backgroundProcessManager, createEnterPlanModeHandler, createExitPlanModeHandler, createGetProcessOutputHandler, createKillProcessHandler, createListProcessesHandler, createOpenAIContentGenerator, createRunBackgroundHandler, createTodoWriteHandler, createToolRegistry, enterPlanMode, enterPlanModeDefinition, exitPlanModeDefinition, getPlanModeState, getProcessOutputDefinition, isPlanModeEnabled, killProcessDefinition, listProcessesDefinition, listTodoSessions, loadConfig, readTodos, runBackgroundDefinition, setPlanApproval, todoWriteDefinition, validateConfig, writeTodos };