codeep 1.2.17 → 1.2.18

package/dist/utils/agent.js

@@ -1,24 +1,17 @@
 /**
- * Agent loop - autonomous task execution
+ * Agent loop - autonomous task execution.
+ *
+ * Private chat/stream logic lives in agentChat.ts and agentStream.ts.
  */
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
 // Debug logging helper - only logs when CODEEP_DEBUG=1
 const debug = (...args) => {
     if (process.env.CODEEP_DEBUG === '1') {
         console.error('[DEBUG]', ...args);
     }
 };
-/**
- * Custom error class for timeout - allows distinguishing from user abort
- */
-class TimeoutError extends Error {
-    constructor(message = 'Request timed out') {
-        super(message);
-        this.name = 'TimeoutError';
-    }
-}
+// Import chat layer (prompt building + API calls)
+import { agentChat, getAgentSystemPrompt, getFallbackSystemPrompt, loadProjectRules, formatChatHistoryForAgent, } from './agentChat.js';
+export { loadProjectRules, formatChatHistoryForAgent };
 /**
  * Calculate dynamic timeout based on task complexity
  * Complex tasks (creating pages, multiple files) need more time
@@ -38,9 +31,9 @@ function calculateDynamicTimeout(prompt, iteration, baseTimeout) {
     const calculatedTimeout = baseTimeout * multiplier;
     return Math.min(Math.max(calculatedTimeout, 120000), 300000);
 }
-import { parseToolCalls, executeTool, createActionLog, formatToolDefinitions, getOpenAITools, getAnthropicTools, parseOpenAIToolCalls, parseAnthropicToolCalls } from './tools.js';
-import { config, getApiKey } from '../config/index.js';
-import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools } from '../config/providers.js';
+import { parseToolCalls, executeTool, createActionLog } from './tools.js';
+import { config } from '../config/index.js';
+import { supportsNativeTools } from '../config/providers.js';
 import { startSession, endSession, undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession } from './history.js';
 import { runAllVerifications, formatErrorsForAgent, hasVerificationErrors, getVerificationSummary } from './verify.js';
 import { gatherSmartContext, formatSmartContext, extractTargetFile } from './smartContext.js';
@@ -50,683 +43,6 @@ const DEFAULT_OPTIONS = {
     maxDuration: 20 * 60 * 1000, // 20 minutes
     usePlanning: false, // Disable task planning - causes more problems than it solves
 };
-/**
- * Load project rules from .codeep/rules.md or CODEEP.md
- * Returns the rules content formatted for system prompt, or empty string if no rules found
- */
-export function loadProjectRules(projectRoot) {
-    const candidates = [
-        join(projectRoot, '.codeep', 'rules.md'),
-        join(projectRoot, 'CODEEP.md'),
-    ];
-    for (const filePath of candidates) {
-        if (existsSync(filePath)) {
-            try {
-                const content = readFileSync(filePath, 'utf-8').trim();
-                if (content) {
-                    debug('Loaded project rules from', filePath);
-                    return `\n\n## Project Rules\nThe following rules are defined by the project owner. You MUST follow these rules:\n\n${content}`;
-                }
-            }
-            catch (err) {
-                debug('Failed to read project rules from', filePath, err);
-            }
-        }
-    }
-    return '';
-}
-/**
- * Format chat session history for inclusion in agent system prompt.
- * Keeps the most recent messages within a character budget so the agent
- * has conversational context without overwhelming the context window.
- */
-export function formatChatHistoryForAgent(history, maxChars = 16000) {
-    if (!history || history.length === 0)
-        return '';
-    // Filter out agent execution messages
-    const filtered = history.filter(m => {
-        const content = m.content.trimStart();
-        if (content.startsWith('[AGENT]') || content.startsWith('[DRY RUN]'))
-            return false;
-        if (content.startsWith('Agent completed') || content.startsWith('Agent failed') || content.startsWith('Agent stopped'))
-            return false;
-        return true;
-    });
-    if (filtered.length === 0)
-        return '';
-    // Walk backward (newest first) and accumulate within budget
-    const selected = [];
-    let totalChars = 0;
-    for (let i = filtered.length - 1; i >= 0; i--) {
-        const msg = filtered[i];
-        const entry = `${msg.role === 'user' ? 'User' : 'Assistant'}: ${msg.content}`;
-        if (totalChars + entry.length > maxChars && selected.length > 0)
-            break;
-        // If single message exceeds budget, truncate it
-        if (entry.length > maxChars) {
-            selected.unshift({ role: msg.role, content: msg.content.slice(0, maxChars - 100) + '\n[truncated]' });
-            break;
-        }
-        selected.unshift(msg);
-        totalChars += entry.length;
-    }
-    if (selected.length === 0)
-        return '';
-    const lines = selected.map(m => `**${m.role === 'user' ? 'User' : 'Assistant'}:** ${m.content}`).join('\n\n');
-    return `\n\n## Prior Conversation Context\nThe following is the recent chat history from this session. Use it as background context to understand the user's intent, but focus on completing the current task.\n\n${lines}`;
-}
-/**
- * Generate system prompt for agent mode (used with native tool calling)
- */
-function getAgentSystemPrompt(projectContext) {
-    return `You are an AI coding agent with FULL autonomous access to this project.
-
-## Your Capabilities
-- Read, write, edit, and delete files and directories
-- Create directories with create_directory tool
-- Execute shell commands (npm, git, build tools, etc.)
-- Search code in the project
-- List directory contents
-
-## IMPORTANT: Follow User Instructions Exactly
-- Do EXACTLY what the user asks
-- If user says "create a website" -> create ALL necessary files (HTML, CSS, JS, images, etc.)
-- If user says "create folder X" -> use create_directory tool to create folder X
-- If user says "delete file X" -> use delete_file tool to delete file X
-- The user may write in any language - understand their request and execute it
-- Tool names and parameters must ALWAYS be in English (e.g., "create_directory", not "kreiraj_direktorij")
-- KEEP WORKING until the ENTIRE task is finished - do NOT stop after creating just directories or partial files
-- Only stop when you have created ALL files needed for a complete, working solution
-
-## Rules
-1. Always read files before editing them to understand the current content
-2. Use edit_file for modifications to existing files (preserves other content)
-3. Use write_file only for creating new files or complete overwrites
-4. Use create_directory to create new folders/directories
-5. Use list_files to see directory contents
-6. Use search_code to find files or search patterns
-7. NEVER use execute_command for: ls, find, cat, grep, mkdir, rm, cp, mv, touch
-8. Use execute_command ONLY for: npm, git, composer, pip, cargo (build/package managers)
-9. When the task is complete, respond with a summary WITHOUT any tool calls
-10. IMPORTANT: After finishing, your response must NOT include any tool calls - just provide a summary
-11. IGNORE the .codeep folder - it contains internal configuration, do NOT read or modify it
-
-## Self-Verification
-After you make changes, the system will automatically run build and tests.
-If there are errors, you will receive them and must fix them.
-- Read error messages carefully
-- Fix the specific files and lines mentioned
-- Keep trying until verification passes
-
-## Project Context
-**Name:** ${projectContext.name}
-**Type:** ${projectContext.type}
-
-**Structure:**
-\`\`\`
-${projectContext.structure}
-\`\`\`
-
-**Key Files:** ${projectContext.keyFiles.join(', ')}
-
-You have FULL READ AND WRITE access. Use the tools to complete tasks autonomously.`;
-}
-/**
- * Generate fallback system prompt (text-based tool calling)
- */
-function getFallbackSystemPrompt(projectContext) {
-    return `You are an AI coding agent with FULL autonomous access to this project.
-
-## IMPORTANT: Follow User Instructions Exactly
-- Do EXACTLY what the user asks
-- If user says "create a website" -> create ALL necessary files (HTML, CSS, JS, images, etc.)
-- If user says "create folder X" -> use create_directory tool
-- If user says "delete file X" -> use delete_file tool
-- The user may write in any language - understand and execute
-- Tool names and parameters must ALWAYS be in English
-- KEEP WORKING until the ENTIRE task is finished - do NOT stop after creating just directories or partial files
-- Only stop when you have created ALL files needed for a complete, working solution
-
-## Available Tools
-${formatToolDefinitions()}
-
-## Tool Call Format
-When you need to use a tool, respond with:
-<tool_call>
-{"tool": "tool_name", "parameters": {"param1": "value1"}}
-</tool_call>
-
-## Examples
-<tool_call>
-{"tool": "create_directory", "parameters": {"path": "my-folder"}}
-</tool_call>
-
-<tool_call>
-{"tool": "list_files", "parameters": {"path": "."}}
-</tool_call>
-
-<tool_call>
-{"tool": "write_file", "parameters": {"path": "test/index.html", "content": "<!DOCTYPE html>..."}}
-</tool_call>
-
-## Rules
-1. Use the exact format shown above
-2. Use list_files to see directory contents
-3. Use search_code to find files or search patterns
-4. NEVER use execute_command for: ls, find, cat, grep, mkdir, rm, cp, mv, touch
-5. Use execute_command ONLY for: npm, git, composer, pip, cargo (build/package managers)
-6. Always read files before editing
-7. When done, respond WITHOUT tool calls
-8. IGNORE the .codeep folder - it contains internal configuration, do NOT read or modify it
-
-## Project: ${projectContext.name} (${projectContext.type})
-${projectContext.structure}
-
-You have FULL access. Execute tasks autonomously.`;
-}
-/**
- * Make a chat API call for agent mode with native tool support
- */
-async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTimeout) {
-    const protocol = config.get('protocol');
-    const model = config.get('model');
-    const apiKey = getApiKey();
-    const providerId = config.get('provider');
-    const baseUrl = getProviderBaseUrl(providerId, protocol);
-    const authHeader = getProviderAuthHeader(providerId, protocol);
-    if (!baseUrl) {
-        throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
-    }
-    // Check if provider supports native tools - if not, use text-based fallback directly
-    if (!supportsNativeTools(providerId, protocol)) {
-        // Provider doesn't support native tools, use text-based fallback
-        return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
-    }
-    const controller = new AbortController();
-    const timeoutMs = dynamicTimeout || config.get('apiTimeout');
-    let isTimeout = false;
-    const timeout = setTimeout(() => {
-        isTimeout = true;
-        controller.abort();
-    }, timeoutMs);
-    if (abortSignal) {
-        abortSignal.addEventListener('abort', () => {
-            isTimeout = false; // User abort, not timeout
-            controller.abort();
-        });
-    }
-    const headers = {
-        'Content-Type': 'application/json',
-    };
-    if (authHeader === 'Bearer') {
-        headers['Authorization'] = `Bearer ${apiKey}`;
-    }
-    else {
-        headers['x-api-key'] = apiKey;
-    }
-    if (protocol === 'anthropic') {
-        headers['anthropic-version'] = '2023-06-01';
-    }
-    try {
-        let endpoint;
-        let body;
-        const useStreaming = Boolean(onChunk);
-        if (protocol === 'openai') {
-            endpoint = `${baseUrl}/chat/completions`;
-            body = {
-                model,
-                messages: [
-                    { role: 'system', content: systemPrompt },
-                    ...messages,
-                ],
-                tools: getOpenAITools(),
-                tool_choice: 'auto',
-                stream: useStreaming,
-                temperature: config.get('temperature'),
-                max_tokens: Math.max(config.get('maxTokens'), 16384),
-            };
-        }
-        else {
-            endpoint = `${baseUrl}/v1/messages`;
-            body = {
-                model,
-                system: systemPrompt,
-                messages: messages,
-                tools: getAnthropicTools(),
-                stream: useStreaming,
-                temperature: config.get('temperature'),
-                max_tokens: Math.max(config.get('maxTokens'), 16384),
-            };
-        }
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            // Check if error is due to tools not being supported - fallback to text mode
-            if (errorText.includes('tools') || errorText.includes('function') || response.status === 400) {
-                return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
-            }
-            throw new Error(`API error: ${response.status} - ${errorText}`);
-        }
-        // Streaming path — parse tool calls from SSE deltas
-        if (useStreaming && response.body) {
-            if (protocol === 'openai') {
-                return await handleOpenAIAgentStream(response.body, onChunk, model, providerId);
-            }
-            else {
-                return await handleAnthropicAgentStream(response.body, onChunk, model, providerId);
-            }
-        }
-        // Non-streaming path (fallback if no body)
-        const data = await response.json();
-        // Track token usage
-        const usageExtractor = protocol === 'openai' ? extractOpenAIUsage : extractAnthropicUsage;
-        const usage = usageExtractor(data);
-        if (usage)
-            recordTokenUsage(usage, model, providerId);
-        debug('Raw API response:', JSON.stringify(data, null, 2).substring(0, 1500));
-        if (protocol === 'openai') {
-            const message = data.choices?.[0]?.message;
-            const content = message?.content || '';
-            const rawToolCalls = message?.tool_calls || [];
-            debug('Raw tool_calls:', JSON.stringify(rawToolCalls, null, 2));
-            const toolCalls = parseOpenAIToolCalls(rawToolCalls);
-            debug('Parsed tool calls:', toolCalls.length, toolCalls.map(t => t.tool));
-            // If no native tool calls, try parsing from content (some models return text-based)
-            if (toolCalls.length === 0 && content) {
-                debug('No native tool calls, checking content for text-based calls...');
-                debug('Content preview:', content.substring(0, 300));
-                const textToolCalls = parseToolCalls(content);
-                if (textToolCalls.length > 0) {
-                    debug('Found text-based tool calls:', textToolCalls.length);
-                    return { content, toolCalls: textToolCalls, usedNativeTools: false };
-                }
-            }
-            if (onChunk && content) {
-                onChunk(content);
-            }
-            return { content, toolCalls, usedNativeTools: true };
-        }
-        else {
-            // Anthropic format
-            const contentBlocks = data.content || [];
-            let textContent = '';
-            for (const block of contentBlocks) {
-                if (block.type === 'text') {
-                    textContent += block.text;
-                    if (onChunk)
-                        onChunk(block.text);
-                }
-            }
-            const toolCalls = parseAnthropicToolCalls(contentBlocks);
-            return { content: textContent, toolCalls, usedNativeTools: true };
-        }
-    }
-    catch (error) {
-        const err = error;
-        // Check if this was a timeout vs user abort
-        if (err.name === 'AbortError') {
-            if (isTimeout) {
-                throw new TimeoutError(`API request timed out after ${timeoutMs}ms`);
-            }
-            // User abort - rethrow as-is
-            throw error;
-        }
-        // If native tools failed, try fallback
-        if (err.message.includes('tools') || err.message.includes('function')) {
-            return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-/**
- * Fallback chat without native tools (text-based parsing)
- */
-async function agentChatFallback(messages, systemPrompt, onChunk, abortSignal, dynamicTimeout) {
-    const protocol = config.get('protocol');
-    const model = config.get('model');
-    const apiKey = getApiKey();
-    const providerId = config.get('provider');
-    const baseUrl = getProviderBaseUrl(providerId, protocol);
-    const authHeader = getProviderAuthHeader(providerId, protocol);
-    if (!baseUrl) {
-        throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
-    }
-    const controller = new AbortController();
-    const timeoutMs = dynamicTimeout || config.get('apiTimeout');
-    let isTimeout = false;
-    const timeout = setTimeout(() => {
-        isTimeout = true;
-        controller.abort();
-    }, timeoutMs);
-    if (abortSignal) {
-        abortSignal.addEventListener('abort', () => {
-            isTimeout = false; // User abort, not timeout
-            controller.abort();
-        });
-    }
-    const headers = {
-        'Content-Type': 'application/json',
-    };
-    if (authHeader === 'Bearer') {
-        headers['Authorization'] = `Bearer ${apiKey}`;
-    }
-    else {
-        headers['x-api-key'] = apiKey;
-    }
-    if (protocol === 'anthropic') {
-        headers['anthropic-version'] = '2023-06-01';
-    }
-    // Use fallback system prompt with text-based tool format
-    const fallbackPrompt = systemPrompt.includes('## Available Tools')
-        ? systemPrompt
-        : systemPrompt + '\n\n' + formatToolDefinitions();
-    try {
-        let endpoint;
-        let body;
-        if (protocol === 'openai') {
-            endpoint = `${baseUrl}/chat/completions`;
-            body = {
-                model,
-                messages: [
-                    { role: 'system', content: fallbackPrompt },
-                    ...messages,
-                ],
-                stream: Boolean(onChunk),
-                temperature: config.get('temperature'),
-                max_tokens: Math.max(config.get('maxTokens'), 16384), // Ensure enough tokens for large file generation
-            };
-        }
-        else {
-            endpoint = `${baseUrl}/v1/messages`;
-            body = {
-                model,
-                messages: [
-                    { role: 'user', content: fallbackPrompt },
-                    { role: 'assistant', content: 'Understood. I will use the tools as specified.' },
-                    ...messages,
-                ],
-                stream: Boolean(onChunk),
-                temperature: config.get('temperature'),
-                max_tokens: Math.max(config.get('maxTokens'), 16384), // Ensure enough tokens for large file generation
-            };
-        }
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`API error: ${response.status} - ${error}`);
-        }
-        let content;
-        if (onChunk && response.body) {
-            content = await handleStream(response.body, protocol, onChunk);
-        }
-        else {
-            const data = await response.json();
-            // Track token usage
-            const fallbackUsageExtractor = protocol === 'openai' ? extractOpenAIUsage : extractAnthropicUsage;
-            const fallbackUsage = fallbackUsageExtractor(data);
-            if (fallbackUsage)
-                recordTokenUsage(fallbackUsage, model, providerId);
-            if (protocol === 'openai') {
-                content = data.choices?.[0]?.message?.content || '';
-            }
-            else {
-                content = data.content?.[0]?.text || '';
-            }
-        }
-        // Parse tool calls from text response
-        const toolCalls = parseToolCalls(content);
-        return { content, toolCalls, usedNativeTools: false };
-    }
-    catch (error) {
-        const err = error;
-        // Check if this was a timeout vs user abort
-        if (err.name === 'AbortError') {
-            if (isTimeout) {
-                throw new TimeoutError(`API request timed out after ${timeoutMs}ms`);
-            }
-            // User abort - rethrow as-is
-            throw error;
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-/**
- * Handle OpenAI streaming response with tool call accumulation
- */
-async function handleOpenAIAgentStream(body, onChunk, model, providerId) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    let content = '';
-    // Accumulate tool calls from deltas
-    const toolCallMap = new Map();
-    let usageData = null;
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-            if (!line.startsWith('data: '))
-                continue;
-            const data = line.slice(6);
-            if (data === '[DONE]')
-                continue;
-            try {
-                const parsed = JSON.parse(data);
-                // Track usage from final chunk
-                if (parsed.usage) {
-                    usageData = parsed;
-                }
-                const delta = parsed.choices?.[0]?.delta;
-                if (!delta)
-                    continue;
-                // Accumulate text content
-                if (delta.content) {
-                    content += delta.content;
-                    onChunk(delta.content);
-                }
-                // Accumulate tool calls
-                if (delta.tool_calls) {
-                    for (const tc of delta.tool_calls) {
-                        const idx = tc.index ?? 0;
-                        if (!toolCallMap.has(idx)) {
-                            toolCallMap.set(idx, {
-                                id: tc.id || '',
-                                name: tc.function?.name || '',
-                                arguments: '',
-                            });
-                        }
-                        const entry = toolCallMap.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;
-                    }
-                }
-            }
-            catch {
-                // Ignore parse errors
-            }
-        }
-    }
-    // Track token usage if available
-    if (usageData) {
-        const usage = extractOpenAIUsage(usageData);
-        if (usage)
-            recordTokenUsage(usage, model, providerId);
-    }
-    // Convert accumulated tool calls
-    const rawToolCalls = Array.from(toolCallMap.values()).map(tc => ({
-        id: tc.id,
-        type: 'function',
-        function: { name: tc.name, arguments: tc.arguments },
-    }));
-    const toolCalls = parseOpenAIToolCalls(rawToolCalls);
-    debug('Stream parsed tool calls:', toolCalls.length, toolCalls.map(t => t.tool));
-    // If no native tool calls, try text-based parsing
-    if (toolCalls.length === 0 && content) {
-        const textToolCalls = parseToolCalls(content);
-        if (textToolCalls.length > 0) {
-            return { content, toolCalls: textToolCalls, usedNativeTools: false };
-        }
-    }
-    return { content, toolCalls, usedNativeTools: true };
-}
-/**
- * Handle Anthropic streaming response with tool call accumulation
- */
-async function handleAnthropicAgentStream(body, onChunk, model, providerId) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    let content = '';
-    // Accumulate content blocks for tool use
-    const contentBlocks = [];
-    let currentBlockIndex = -1;
-    let currentBlockType = '';
-    let currentToolName = '';
-    let currentToolId = '';
-    let currentToolInput = '';
-    let usageData = null;
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-            if (!line.startsWith('data: '))
-                continue;
-            const data = line.slice(6);
-            try {
-                const parsed = JSON.parse(data);
-                // Track usage
-                if (parsed.usage) {
-                    usageData = parsed;
-                }
-                if (parsed.type === 'message_delta' && parsed.usage) {
-                    usageData = parsed;
-                }
-                if (parsed.type === 'content_block_start') {
-                    currentBlockIndex = parsed.index;
-                    const block = parsed.content_block;
-                    if (block.type === 'text') {
-                        currentBlockType = 'text';
-                    }
-                    else if (block.type === 'tool_use') {
-                        currentBlockType = 'tool_use';
-                        currentToolName = block.name || '';
-                        currentToolId = block.id || '';
-                        currentToolInput = '';
-                    }
-                }
-                else if (parsed.type === 'content_block_delta') {
-                    if (currentBlockType === 'text' && parsed.delta?.text) {
-                        content += parsed.delta.text;
-                        onChunk(parsed.delta.text);
-                    }
-                    else if (currentBlockType === 'tool_use' && parsed.delta?.partial_json) {
-                        currentToolInput += parsed.delta.partial_json;
-                    }
-                }
-                else if (parsed.type === 'content_block_stop') {
-                    if (currentBlockType === 'tool_use') {
-                        contentBlocks.push({
-                            type: 'tool_use',
-                            id: currentToolId,
-                            name: currentToolName,
-                            input: tryParseJSON(currentToolInput),
-                        });
-                    }
-                    currentBlockType = '';
-                }
-            }
-            catch {
-                // Ignore parse errors
-            }
-        }
-    }
-    // Track token usage
-    if (usageData) {
-        const usage = extractAnthropicUsage(usageData);
-        if (usage)
-            recordTokenUsage(usage, model, providerId);
-    }
-    const toolCalls = parseAnthropicToolCalls(contentBlocks);
-    return { content, toolCalls, usedNativeTools: true };
-}
-function tryParseJSON(str) {
-    try {
-        return JSON.parse(str);
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Handle streaming response (text-based fallback)
- */
-async function handleStream(body, protocol, onChunk) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    const chunks = [];
-    let buffer = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-            if (line.startsWith('data: ')) {
-                const data = line.slice(6);
-                if (data === '[DONE]')
-                    continue;
-                try {
-                    const parsed = JSON.parse(data);
-                    let content;
-                    if (protocol === 'openai') {
-                        content = parsed.choices?.[0]?.delta?.content;
-                    }
-                    else if (parsed.type === 'content_block_delta') {
-                        content = parsed.delta?.text;
-                    }
-                    if (content) {
-                        chunks.push(content);
-                        onChunk(content);
-                    }
-                }
-                catch {
-                    // Skip parse errors
-                }
-            }
-        }
-    }
-    return chunks.join('');
-}
 /**
  * Run the agent loop
  */