scalix 0.0.1 → 1.0.0

package/dist/agent.js

@@ -0,0 +1,852 @@
+import OpenAI from 'openai';
+import { EventEmitter } from 'eventemitter3';
+import { randomUUID } from 'node:crypto';
+import { getToolPermission } from './sandbox.js';
+import { logger } from './logger.js';
+import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, modelSupportsVision, getModelSpec } from './constants.js';
+import { estimateMessageTokens as estimateTokenCount } from './token-counter.js';
+import { ContextManager } from './context-manager.js';
+import { zodToJsonSchema } from './tool-helper.js';
+import { ToolSelector } from './tool-selector.js';
+import { AgentReplay } from './agent-replay.js';
+import { loadHooks, runHooks } from './hooks.js';
+import { setAgentToolConfig } from './tools-advanced.js';
+import { runVerification, VERIFY_DEFAULTS } from './auto-verify.js';
+import { ChangeTracker } from './change-tracker.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+function transformToolsForApi(tools) {
+    return tools
+        .filter((t) => !('type' in t && t.type === 'mcp'))
+        .map((t) => {
+        const local = t;
+        const fn = local.function ?? local;
+        return {
+            type: 'function',
+            function: {
+                name: fn.name,
+                description: fn.description || '',
+                parameters: fn.inputSchema ? zodToJsonSchema(fn.inputSchema) : (fn.parameters ?? {}),
+            },
+        };
+    });
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function snakeToCamel(s) {
+    return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function normalizeArgs(args) {
+    const out = {};
+    for (const [key, val] of Object.entries(args)) {
+        const camel = snakeToCamel(key);
+        // Prefer the camelCase version if both exist
+        if (!(camel in out))
+            out[camel] = val;
+        // Also keep original key so either convention works
+        if (!(key in out))
+            out[key] = val;
+    }
+    return out;
+}
+function backoffDelay(attempt, base = BACKOFF_DEFAULTS.baseMs, max = BACKOFF_DEFAULTS.maxMs) {
+    const delay = Math.min(base * Math.pow(2, attempt), max);
+    return delay + Math.random() * delay * BACKOFF_DEFAULTS.jitterRatio;
+}
+function withTimeout(promise, ms, label) {
+    if (!isFinite(ms))
+        return promise;
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`Tool "${label}" timed out after ${ms}ms`)), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+export function messageContentToString(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    return content.filter((p) => p.type === 'text').map(p => p.text).join('\n');
+}
+function stripImageParts(content) {
+    const parts = [];
+    for (const part of content) {
+        if (part.type === 'text') {
+            parts.push(part.text);
+        }
+        else if (part.type === 'image_url') {
+            parts.push('[Image attached — model does not support vision, image omitted]');
+        }
+    }
+    return parts.join('\n');
+}
+function messagesToApi(messages, instructions, vision = true) {
+    const out = [
+        { role: 'system', content: instructions },
+    ];
+    for (const m of messages) {
+        if (m.role === 'tool' && m.tool_call_id) {
+            out.push({ role: 'tool', tool_call_id: m.tool_call_id, content: messageContentToString(m.content) });
+        }
+        else if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0) {
+            out.push({
+                role: 'assistant',
+                content: messageContentToString(m.content) || null,
+                tool_calls: m.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.function.name, arguments: tc.function.arguments },
+                })),
+            });
+        }
+        else if (m.role === 'system') {
+            out.push({ role: 'system', content: messageContentToString(m.content) });
+        }
+        else if (m.role === 'user') {
+            if (Array.isArray(m.content)) {
+                out.push({ role: 'user', content: vision ? m.content : stripImageParts(m.content) });
+            }
+            else {
+                out.push({ role: 'user', content: m.content || '' });
+            }
+        }
+        else if (m.role === 'assistant') {
+            out.push({ role: 'assistant', content: messageContentToString(m.content) });
+        }
+    }
+    return out;
+}
+function estimateMessageTokens(messages) {
+    return estimateTokenCount(messages);
+}
+export class Agent extends EventEmitter {
+    client;
+    messages = [];
+    config;
+    modelIndex = 0;
+    log;
+    contextManager;
+    toolSelector = null;
+    _aborted = false;
+    _thinkingActive = false;
+    replay;
+    hooks = [];
+    instructionLoader;
+    _abortController = null;
+    modelFailures = new Map();
+    changeTracker = new ChangeTracker();
+    verifyConfig = null;
+    verifyFailCounts = new Map();
+    compressAttempts = 0;
+    constructor(config) {
+        super();
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+        });
+        this.log = logger.child();
+        const resolvedModels = Array.isArray(config.model)
+            ? (config.model.length > 0 ? config.model : FALLBACK_MODELS)
+            : config.model ? [config.model] : [...FALLBACK_MODELS];
+        if (resolvedModels.length === 0) {
+            throw new Error('No models configured. Run setup or set SCALIX_MODEL environment variable.');
+        }
+        this.config = {
+            apiKey: config.apiKey,
+            models: resolvedModels,
+            instructions: config.instructions ?? DEFAULT_INSTRUCTIONS,
+            tools: config.tools ?? [],
+            maxSteps: config.maxSteps ?? AGENT_DEFAULTS.maxSteps,
+            maxMessages: config.maxMessages ?? AGENT_DEFAULTS.maxMessages,
+            confirmToolCall: config.confirmToolCall,
+            permissionMode: config.permissionMode ?? 'default',
+            maxRetries: config.maxRetries ?? AGENT_DEFAULTS.maxRetries,
+            toolTimeoutMs: config.toolTimeoutMs ?? AGENT_DEFAULTS.toolTimeoutMs,
+            messageKeepRatio: config.messageKeepRatio ?? AGENT_DEFAULTS.messageKeepRatio,
+            circuitBreakerThreshold: config.circuitBreakerThreshold ?? AGENT_DEFAULTS.circuitBreakerThreshold,
+            circuitBreakerResetMs: config.circuitBreakerResetMs ?? AGENT_DEFAULTS.circuitBreakerResetMs,
+            fileRefTruncation: config.fileRefTruncation ?? TOOL_DEFAULTS.fileRefTruncation,
+            thinkingMode: config.thinkingMode ?? 'off',
+        };
+        this.contextManager = new ContextManager(config.contextManager);
+        if (config.dynamicToolSelection) {
+            this.toolSelector = new ToolSelector();
+            this.toolSelector.index(this.config.tools);
+        }
+        this.replay = new AgentReplay(randomUUID().slice(0, 8), this.config.models[0]);
+        this.hooks = loadHooks();
+        this.instructionLoader = config.instructionLoader;
+        if (config.autoVerify === true) {
+            this.verifyConfig = { ...VERIFY_DEFAULTS };
+        }
+        else if (config.autoVerify && typeof config.autoVerify === 'object') {
+            this.verifyConfig = { ...VERIFY_DEFAULTS, ...config.autoVerify };
+        }
+        setAgentToolConfig({
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl,
+            models: this.config.models,
+            permissionMode: this.config.permissionMode,
+            confirmToolCall: this.config.confirmToolCall,
+        });
+    }
+    pickModel() {
+        const startIdx = this.modelIndex;
+        for (let i = 0; i < this.config.models.length; i++) {
+            const idx = (startIdx + i) % this.config.models.length;
+            const model = this.config.models[idx];
+            if (!this.isModelCircuitOpen(model)) {
+                this.modelIndex = idx + 1;
+                return model;
+            }
+        }
+        this.modelFailures.clear();
+        this.modelIndex = (startIdx + 1) % this.config.models.length;
+        return this.config.models[startIdx % this.config.models.length];
+    }
+    shouldFallbackToNext(err) {
+        const e = err;
+        const message = (e?.message || e?.error?.message || '').toLowerCase();
+        const statusCode = e?.status || e?.statusCode || e?.error?.code;
+        if (statusCode === 401 || statusCode === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
+            return false;
+        }
+        return (message.includes('429') ||
+            message.includes('rate limit') ||
+            message.includes('provider returned error') ||
+            message.includes('safety') ||
+            message.includes('streaming failed') ||
+            message.includes('stream error') ||
+            message.includes('try again') ||
+            statusCode === 429 ||
+            statusCode === 500 ||
+            statusCode === 502 ||
+            statusCode === 503 ||
+            statusCode === 404);
+    }
+    isModelCircuitOpen(model) {
+        const state = this.modelFailures.get(model);
+        if (!state)
+            return false;
+        if (Date.now() - state.lastFailure > this.config.circuitBreakerResetMs) {
+            this.modelFailures.delete(model);
+            return false;
+        }
+        return state.count >= this.config.circuitBreakerThreshold;
+    }
+    recordModelFailure(model) {
+        const state = this.modelFailures.get(model) ?? { count: 0, lastFailure: 0 };
+        state.count++;
+        state.lastFailure = Date.now();
+        this.modelFailures.set(model, state);
+    }
+    recordModelSuccess(model) {
+        this.modelFailures.delete(model);
+    }
+    truncateMessages() {
+        if (this.messages.length <= this.config.maxMessages)
+            return;
+        const keepCount = Math.floor(this.config.maxMessages * this.config.messageKeepRatio);
+        const dropped = this.messages.length - keepCount;
+        this.messages = this.messages.slice(dropped);
+        this.log.info(`Truncated ${dropped} oldest messages, keeping ${this.messages.length}`);
+    }
+    emitThinkingEnd() {
+        if (this._thinkingActive) {
+            this._thinkingActive = false;
+            this.emit('thinking:end');
+        }
+    }
+    getMessages() { return [...this.messages]; }
+    clearHistory() {
+        this.messages = [];
+        this.verifyFailCounts.clear();
+        this.modelFailures.clear();
+    }
+    loadMessages(messages) { this.messages = [...messages]; }
+    getInstructions() { return this.config.instructions; }
+    setInstructions(instructions) { this.config.instructions = instructions; }
+    getPermissionMode() { return this.config.permissionMode; }
+    setPermissionMode(mode) { this.config.permissionMode = mode; }
+    getThinking() { return this.config.thinkingMode; }
+    setThinking(mode) { this.config.thinkingMode = mode; }
+    async compact() {
+        const msgCount = this.messages.length;
+        if (msgCount < 4)
+            return 'Not enough messages to compact.';
+        const summaryPrompt = 'Compress this conversation into a detailed summary that preserves ALL technical details: file paths, function names, line numbers, error messages, code changes, commands run, configurations, what worked, what failed, user preferences, and pending work. This summary replaces the original — anything omitted is permanently lost. Be specific and factual, not vague.';
+        try {
+            const model = this.config.models[0];
+            const apiMessages = [
+                { role: 'system', content: 'You are a conversation summarizer. Be concise and factual.' },
+                ...this.messages.map((m) => ({ role: (m.role === 'tool' ? 'user' : m.role), content: messageContentToString(m.content) })),
+                { role: 'user', content: summaryPrompt },
+            ];
+            const result = await this.client.chat.completions.create({
+                model,
+                messages: apiMessages,
+                stream: false,
+            });
+            const summary = result.choices?.[0]?.message?.content?.trim() || '';
+            if (!summary)
+                return 'Compaction failed: no summary generated.';
+            this.messages = [
+                { role: 'system', content: `[Conversation compacted — ${msgCount} messages summarized]\n\n${summary}` },
+            ];
+            if (this.instructionLoader) {
+                try {
+                    const reloaded = await this.instructionLoader();
+                    this.config.instructions = reloaded;
+                }
+                catch (err) {
+                    this.log.warn('Failed to reload instructions after compaction', { error: err?.message });
+                }
+            }
+            return `Compacted ${msgCount} messages into summary.`;
+        }
+        catch (err) {
+            return `Compaction failed: ${err.message}`;
+        }
+    }
+    getContextUsage() {
+        return this.contextManager.getTokenUsage(this.messages);
+    }
+    async autoCompress(reqLog) {
+        if (!this.contextManager.shouldCompress(this.messages)) {
+            this.compressAttempts = 0;
+            return;
+        }
+        if (this.compressAttempts >= 3) {
+            this.messages = this.contextManager.truncateToolResults(this.messages);
+            this.messages = this.contextManager.applySlidingWindow(this.messages);
+            return;
+        }
+        this.compressAttempts++;
+        const beforeTokens = this.contextManager.getTokenUsage(this.messages).tokens;
+        const { toCompress, toKeep } = this.contextManager.splitForCompression(this.messages);
+        if (toCompress.length < 4) {
+            this.messages = this.contextManager.truncateToolResults(this.messages);
+            this.messages = this.contextManager.applySlidingWindow(this.messages);
+            return;
+        }
+        reqLog.info('Auto-compressing context', { messagesToCompress: toCompress.length, keeping: toKeep.length });
+        const backup = [...this.messages];
+        try {
+            const prompt = this.contextManager.buildCompressionPrompt(toCompress);
+            const model = this.config.models[0];
+            const result = await this.client.chat.completions.create({
+                model,
+                messages: [
+                    { role: 'system', content: 'You compress conversation history. Preserve every file path, function name, error message, code change, command, config value, and user instruction verbatim. Omit greetings and filler only. This output replaces the original — anything omitted is permanently lost.' },
+                    { role: 'user', content: prompt },
+                ],
+                stream: false,
+            });
+            const summary = result.choices?.[0]?.message?.content?.trim() || '';
+            if (summary) {
+                this.messages = [
+                    { role: 'system', content: `[Context auto-compressed — ${toCompress.length} messages summarized]\n\n${summary}` },
+                    ...this.contextManager.truncateToolResults(toKeep),
+                ];
+                const afterTokens = this.contextManager.getTokenUsage(this.messages).tokens;
+                const saved = beforeTokens - afterTokens;
+                reqLog.info('Context compressed', { before: beforeTokens, after: afterTokens, saved });
+                this.emit('context:compress', { before: beforeTokens, after: afterTokens, saved });
+            }
+            else {
+                this.messages = backup;
+                reqLog.warn('Auto-compression produced empty summary, keeping original messages');
+            }
+        }
+        catch (err) {
+            this.messages = backup;
+            reqLog.warn('Auto-compression failed, falling back to truncation', { error: err.message });
+            this.messages = this.contextManager.truncateToolResults(this.messages);
+            this.messages = this.contextManager.applySlidingWindow(this.messages);
+        }
+    }
+    addTool(newTool) {
+        this.config.tools.push(newTool);
+        if (this.toolSelector)
+            this.toolSelector.index(this.config.tools);
+    }
+    addModel(model) {
+        if (!this.config.models.includes(model))
+            this.config.models.push(model);
+    }
+    setModel(model) { this.config.models = [model]; }
+    getModels() { return [...this.config.models]; }
+    updateLimit(key, value) {
+        if (key in this.config) {
+            this.config[key] = value;
+        }
+    }
+    getReplay() { return this.replay; }
+    getChangeTracker() { return this.changeTracker; }
+    getHooks() { return this.hooks; }
+    getApiKey() { return this.config.apiKey; }
+    getBaseUrl() { return this.client.baseURL; }
+    abort() {
+        this._aborted = true;
+        if (this._abortController) {
+            this._abortController.abort();
+            this._abortController = null;
+        }
+        this.emitThinkingEnd();
+    }
+    removeModel(model) {
+        const idx = this.config.models.indexOf(model);
+        if (idx !== -1 && this.config.models.length > 1) {
+            this.config.models.splice(idx, 1);
+            return true;
+        }
+        return false;
+    }
+    async expandFileReferences(content) {
+        const pattern = /(?:^|\s)@((?:[\w./-]+\/)?[\w.-]+\.\w+)/g;
+        const matches = [];
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            matches.push(match[1]);
+        }
+        if (matches.length === 0)
+            return content;
+        const { isImageFile, encodeImageToDataUrl } = await import('./tools-vision.js');
+        const contextBlocks = [];
+        const imageParts = [];
+        for (const filePath of matches) {
+            try {
+                const resolved = path.resolve(process.cwd(), filePath);
+                if (isImageFile(filePath)) {
+                    const dataUrl = await encodeImageToDataUrl(resolved);
+                    imageParts.push({ type: 'image_url', image_url: { url: dataUrl, detail: 'auto' } });
+                    contextBlocks.push(`[Image attached: ${filePath}]`);
+                }
+                else {
+                    const fileContent = await fs.readFile(resolved, 'utf-8');
+                    const truncated = fileContent.length > this.config.fileRefTruncation
+                        ? fileContent.slice(0, this.config.fileRefTruncation) + '\n... (truncated)'
+                        : fileContent;
+                    contextBlocks.push(`--- File: ${filePath} ---\n${truncated}\n--- End: ${filePath} ---`);
+                }
+            }
+            catch {
+                contextBlocks.push(`--- File: ${filePath} ---\n[File not found or unreadable]\n--- End: ${filePath} ---`);
+            }
+        }
+        if (imageParts.length > 0) {
+            const textContent = contextBlocks.join('\n\n') + '\n\n' + content;
+            return [
+                { type: 'text', text: textContent },
+                ...imageParts,
+            ];
+        }
+        if (contextBlocks.length === 0)
+            return content;
+        return contextBlocks.join('\n\n') + '\n\n' + content;
+    }
+    async send(content, images) {
+        this._aborted = false;
+        const hasFileRefs = /@(?:[\w./-]+\/)?[\w.-]+\.\w+/.test(content);
+        const expandedContent = hasFileRefs ? await this.expandFileReferences(content) : content;
+        let finalContent = expandedContent;
+        if (images && images.length > 0) {
+            const textPart = {
+                type: 'text',
+                text: typeof expandedContent === 'string' ? expandedContent : expandedContent.filter((p) => p.type === 'text').map(p => p.text).join('\n'),
+            };
+            const existingImages = Array.isArray(expandedContent) ? expandedContent.filter((p) => p.type === 'image_url') : [];
+            const newImages = images.map(dataUrl => ({ type: 'image_url', image_url: { url: dataUrl, detail: 'auto' } }));
+            finalContent = [textPart, ...existingImages, ...newImages];
+        }
+        const userMessage = { role: 'user', content: finalContent };
+        this.messages.push(userMessage);
+        this.emit('message:user', userMessage);
+        this._thinkingActive = true;
+        this.emit('thinking:start');
+        this.truncateMessages();
+        this.replay.record('user_message', { content });
+        const requestId = randomUUID().slice(0, 8);
+        const reqLog = logger.child(requestId);
+        reqLog.info('User message received', { length: content.length });
+        try {
+            const initialModel = this.pickModel();
+            reqLog.info('Starting agent loop', { model: initialModel });
+            return await this.loopStreamingTurns(initialModel, reqLog);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            error.metadata = {
+                model: this.config.models[this.modelIndex % this.config.models.length],
+                status: err.status ?? err.statusCode,
+                error: err.error,
+                requestId,
+            };
+            reqLog.error('Agent send failed', { error: error.message });
+            this.emit('error', error);
+            throw error;
+        }
+        finally {
+            this.emitThinkingEnd();
+        }
+    }
+    async loopStreamingTurns(initialModel, reqLog) {
+        let currentModel = initialModel;
+        let turnCount = 0;
+        let retryAttempt = 0;
+        let emptyTurnCount = 0;
+        while (turnCount < this.config.maxSteps) {
+            if (this._aborted) {
+                reqLog.info('Agent aborted by user');
+                return '[interrupted]';
+            }
+            turnCount++;
+            let fullText = '';
+            const toolCalls = new Map();
+            try {
+                // Sync context limit to the current model's actual context window
+                const modelSpec = getModelSpec(currentModel);
+                const inputBudget = modelSpec.contextWindow - modelSpec.maxOutputTokens;
+                if (inputBudget > 0) {
+                    this.contextManager.setMaxContextTokens(inputBudget);
+                }
+                await this.autoCompress(reqLog);
+                this.emit('context:usage', this.contextManager.getTokenUsage(this.messages));
+                let toolsForRequest = this.config.tools;
+                if (this.toolSelector) {
+                    const lastUserMsg = [...this.messages].reverse().find((m) => m.role === 'user');
+                    const recentTools = this.messages
+                        .filter((m) => m.role === 'assistant' && m.tool_calls)
+                        .flatMap((m) => (m.tool_calls || []).map((tc) => tc.function.name))
+                        .slice(-10);
+                    if (lastUserMsg?.content) {
+                        toolsForRequest = this.toolSelector.select(messageContentToString(lastUserMsg.content), recentTools);
+                    }
+                }
+                const apiTools = toolsForRequest.length > 0 ? transformToolsForApi(toolsForRequest) : undefined;
+                const estimatedTokens = estimateMessageTokens(this.messages);
+                this.emit('cost:estimate', { estimatedTokens, model: currentModel });
+                this._abortController = new AbortController();
+                const vision = modelSupportsVision(currentModel);
+                const apiMessages = messagesToApi(this.messages, this.config.instructions, vision);
+                const thinkingLevel = this.config.thinkingMode !== 'off' ? this.config.thinkingMode : undefined;
+                const stream = await this.client.chat.completions.create({
+                    model: currentModel,
+                    messages: apiMessages,
+                    tools: apiTools && apiTools.length > 0 ? apiTools : undefined,
+                    max_tokens: modelSpec.maxOutputTokens,
+                    temperature: 0.7,
+                    stream: true,
+                    stream_options: { include_usage: true },
+                    ...(thinkingLevel && { thinking_level: thinkingLevel }),
+                }, {
+                    signal: this._abortController.signal,
+                });
+                this.emit('stream:start');
+                retryAttempt = 0;
+                this.recordModelSuccess(currentModel);
+                try {
+                    for await (const chunk of stream) {
+                        if (this._aborted)
+                            break;
+                        const choice = chunk.choices?.[0];
+                        if (choice?.delta) {
+                            const delta = choice.delta;
+                            if (delta.content) {
+                                fullText += delta.content;
+                                this.emit('stream:delta', delta.content, fullText);
+                            }
+                            if (delta.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? toolCalls.size;
+                                    if (!toolCalls.has(idx)) {
+                                        toolCalls.set(idx, { id: tc.id || '', name: tc.function?.name || '', arguments: '' });
+                                    }
+                                    const entry = toolCalls.get(idx);
+                                    if (tc.id)
+                                        entry.id = tc.id;
+                                    if (tc.function?.name)
+                                        entry.name = tc.function.name;
+                                    if (tc.function?.arguments)
+                                        entry.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        if (chunk.usage) {
+                            const inTok = chunk.usage.prompt_tokens ?? 0;
+                            const outTok = chunk.usage.completion_tokens ?? 0;
+                            const totalTok = chunk.usage.total_tokens ?? (inTok + outTok);
+                            const cost = chunk.usage.cost ?? 0;
+                            this.emit('usage', {
+                                prompt_tokens: inTok,
+                                completion_tokens: outTok,
+                                total_tokens: totalTok,
+                                cost,
+                                model: currentModel,
+                            });
+                            this.replay.recordUsage(totalTok, cost);
+                        }
+                    }
+                }
+                finally {
+                    stream.controller?.abort();
+                }
+                for (const [, call] of toolCalls) {
+                    this.emit('tool:call', call.name, call.arguments);
+                    this.replay.record('tool_call', { name: call.name, args: call.arguments });
+                }
+                this.emit('stream:end', fullText);
+                this.replay.record('stream_end', { text: fullText.slice(0, 200) });
+                const resolvedToolCalls = Array.from(toolCalls.values());
+                const hasToolCalls = resolvedToolCalls.length > 0;
+                if (!fullText && !hasToolCalls) {
+                    emptyTurnCount++;
+                    reqLog.warn('Empty assistant turn (no text, no tool calls) — skipping', { emptyTurns: emptyTurnCount });
+                    if (emptyTurnCount >= 3) {
+                        reqLog.error('Too many empty turns, aborting');
+                        return '[no response]';
+                    }
+                    continue;
+                }
+                emptyTurnCount = 0;
+                const assistantMessage = {
+                    role: 'assistant',
+                    content: fullText || null,
+                    tool_calls: hasToolCalls
+                        ? resolvedToolCalls.map(tc => ({
+                            id: tc.id,
+                            type: 'function',
+                            function: { name: tc.name, arguments: tc.arguments },
+                        }))
+                        : undefined,
+                };
+                this.messages.push(assistantMessage);
+                this.emit('message:assistant', assistantMessage);
+                if (resolvedToolCalls.length > 0) {
+                    for (const call of resolvedToolCalls) {
+                        if (this._aborted) {
+                            reqLog.info('Agent aborted, skipping remaining tool calls');
+                            break;
+                        }
+                        const tool = this.config.tools.find((t) => (t.function?.name || t.name) === call.name);
+                        let result;
+                        if (this.hooks.length > 0) {
+                            const hookResults = await runHooks(this.hooks, 'PreToolUse', {
+                                toolName: call.name,
+                                toolArgs: call.arguments,
+                            });
+                            const blocked = hookResults.find((r) => !r.allowed);
+                            if (blocked) {
+                                result = { denied: true, message: blocked.error || `Blocked by PreToolUse hook` };
+                                this.emit('tool:blocked', call.name, 'Blocked by hook');
+                                this.messages.push({ role: 'tool', content: JSON.stringify(result), tool_call_id: call.id, name: call.name });
+                                this.emit('tool:result', call.name, result);
+                                continue;
+                            }
+                        }
+                        const permission = getToolPermission(call.name, this.config.permissionMode);
+                        if (permission === 'block') {
+                            result = { denied: true, message: `Tool ${call.name} is blocked in ${this.config.permissionMode} mode` };
+                            reqLog.info('Tool blocked by permission mode', { tool: call.name, mode: this.config.permissionMode });
+                            this.emit('tool:blocked', call.name, `Blocked in ${this.config.permissionMode} mode`);
+                            this.messages.push({
+                                role: 'tool',
+                                content: JSON.stringify(result),
+                                tool_call_id: call.id,
+                                name: call.name,
+                            });
+                            this.emit('tool:result', call.name, result);
+                            continue;
+                        }
+                        if (permission === 'ask') {
+                            if (!this.config.confirmToolCall) {
+                                result = { denied: true, message: `Tool ${call.name} requires confirmation but no confirmation handler is available` };
+                                reqLog.warn('Tool requires confirmation but no confirmToolCall provided', { tool: call.name });
+                                this.emit('tool:blocked', call.name, 'No confirmation handler');
+                                this.messages.push({
+                                    role: 'tool',
+                                    content: JSON.stringify(result),
+                                    tool_call_id: call.id,
+                                    name: call.name,
+                                });
+                                this.emit('tool:result', call.name, result);
+                                continue;
+                            }
+                            let args;
+                            try {
+                                args = JSON.parse(call.arguments);
+                            }
+                            catch {
+                                args = call.arguments;
+                            }
+                            const CONFIRM_TIMEOUT_MS = 300_000;
+                            const confirmed = await new Promise((resolve) => {
+                                const timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
+                                this.config.confirmToolCall(call.name, args).then((v) => {
+                                    clearTimeout(timer);
+                                    resolve(v);
+                                }).catch(() => {
+                                    clearTimeout(timer);
+                                    resolve(false);
+                                });
+                            });
+                            if (this._aborted)
+                                break;
+                            if (!confirmed) {
+                                result = { denied: true, message: `User denied execution of ${call.name}` };
+                                reqLog.info('Tool call denied by user', { tool: call.name });
+                                this.emit('tool:blocked', call.name, 'User denied');
+                                this.messages.push({
+                                    role: 'tool',
+                                    content: JSON.stringify(result),
+                                    tool_call_id: call.id,
+                                    name: call.name,
+                                });
+                                this.emit('tool:result', call.name, result);
+                                continue;
+                            }
+                        }
+                        const execFn = tool?.function?.execute ?? tool?.execute;
+                        if (tool && typeof execFn === 'function') {
+                            try {
+                                let args;
+                                try {
+                                    args = normalizeArgs(JSON.parse(call.arguments));
+                                }
+                                catch {
+                                    args = {};
+                                }
+                                reqLog.debug('Executing tool', { tool: call.name });
+                                const toolTimeout = (typeof args?.timeout === 'number' && args.timeout > 0)
+                                    ? Math.min(args.timeout, TOOL_DEFAULTS.maxCommandTimeoutMs)
+                                    : this.config.toolTimeoutMs;
+                                result = await withTimeout(execFn(args, { context: {}, workspaceRoot: process.cwd(), permissionMode: this.config.permissionMode }), toolTimeout, call.name);
+                                if (call.name === 'add_mcp_server' && result?.success) {
+                                    this.addTool({ type: 'mcp', serverLabel: args.label, serverUrl: args.url });
+                                }
+                            }
+                            catch (e) {
+                                result = { error: e.message };
+                                reqLog.error('Tool execution failed', { tool: call.name, error: e.message });
+                            }
+                        }
+                        else {
+                            result = { error: `Tool ${call.name} not found or not locally executable.` };
+                        }
+                        let resultStr;
+                        try {
+                            resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+                        }
+                        catch {
+                            try {
+                                const seen = new WeakSet();
+                                resultStr = JSON.stringify(result, (_k, v) => {
+                                    if (typeof v === 'object' && v !== null) {
+                                        if (seen.has(v))
+                                            return '[Circular]';
+                                        seen.add(v);
+                                    }
+                                    return v;
+                                });
+                            }
+                            catch {
+                                resultStr = String(result);
+                            }
+                        }
+                        const MAX_TOOL_RESULT_CHARS = 500_000;
+                        if (resultStr.length > MAX_TOOL_RESULT_CHARS) {
+                            resultStr = resultStr.slice(0, MAX_TOOL_RESULT_CHARS) + `\n...[truncated — ${(resultStr.length - MAX_TOOL_RESULT_CHARS).toLocaleString()} chars removed]`;
+                        }
+                        this.messages.push({
+                            role: 'tool',
+                            content: resultStr,
+                            tool_call_id: call.id,
+                            name: call.name,
+                        });
+                        this.emit('tool:result', call.name, result);
+                        if (this.hooks.length > 0) {
+                            runHooks(this.hooks, 'PostToolUse', {
+                                toolName: call.name,
+                                toolArgs: typeof result === 'string' ? result : JSON.stringify(result),
+                            }).catch((err) => {
+                                reqLog.warn('PostToolUse hook failed', { tool: call.name, error: err.message });
+                            });
+                        }
+                        // Auto-verification after file modifications
+                        const WRITE_TOOL_NAMES = new Set(['write_file', 'edit_file', 'notebook_edit']);
+                        if (WRITE_TOOL_NAMES.has(call.name) && this.verifyConfig?.enabled) {
+                            let filePath = null;
+                            try {
+                                const parsed = JSON.parse(call.arguments);
+                                filePath = parsed.filePath || parsed.file_path || parsed.notebook_path || null;
+                            }
+                            catch (parseErr) {
+                                reqLog.warn('Failed to parse tool arguments for auto-verify', { tool: call.name, error: parseErr.message });
+                            }
+                            if (filePath) {
+                                this.changeTracker.track(filePath, call.name);
+                                this.emit('file:modified', filePath, call.name);
+                                const verifyResult = await runVerification(filePath, process.cwd(), this.verifyConfig);
+                                if (verifyResult) {
+                                    if (verifyResult.passed) {
+                                        this.changeTracker.markVerified(filePath, true);
+                                        this.verifyFailCounts.delete(filePath);
+                                        this.emit('verify:pass', verifyResult);
+                                    }
+                                    else {
+                                        this.changeTracker.markVerified(filePath, false);
+                                        this.emit('verify:fail', verifyResult);
+                                        const failCount = (this.verifyFailCounts.get(filePath) ?? 0) + 1;
+                                        this.verifyFailCounts.set(filePath, failCount);
+                                        if (this.verifyFailCounts.size > 100) {
+                                            const first = this.verifyFailCounts.keys().next().value;
+                                            if (first !== undefined)
+                                                this.verifyFailCounts.delete(first);
+                                        }
+                                        if (failCount <= VERIFY_DEFAULTS.maxFailRetries) {
+                                            this.messages.push({
+                                                role: 'system',
+                                                content: `[AUTO-VERIFY FAILED] ${verifyResult.checker} found errors in ${filePath}:\n\n${verifyResult.output}\n\nFix the errors above before proceeding.`,
+                                            });
+                                            reqLog.info('Auto-verify failed, injecting fix hint', { file: filePath, checker: verifyResult.checker, attempt: failCount });
+                                        }
+                                        else {
+                                            reqLog.warn('Auto-verify: max retries reached, skipping further injection', { file: filePath });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (this._aborted)
+                        return '[interrupted]';
+                    continue;
+                }
+                return fullText;
+            }
+            catch (err) {
+                this._abortController = null;
+                this.recordModelFailure(currentModel);
+                if (this.shouldFallbackToNext(err) && retryAttempt < this.config.maxRetries && turnCount < this.config.maxSteps) {
+                    retryAttempt++;
+                    const delay = backoffDelay(retryAttempt);
+                    reqLog.warn(`Retrying after ${Math.round(delay)}ms (attempt ${retryAttempt}/${this.config.maxRetries})`, {
+                        model: currentModel,
+                        error: err.message,
+                    });
+                    await sleep(delay);
+                    currentModel = this.pickModel();
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw new Error(`Agent exhausted maximum steps (${this.config.maxSteps}) without producing a final response`);
+    }
+}
+export function createAgent(config) {
+    return new Agent(config);
+}
+export { normalizeArgs, snakeToCamel, transformToolsForApi, withTimeout };