codeep 1.2.35 → 1.2.37

package/dist/acp/commands.d.ts

@@ -31,6 +31,15 @@ export declare function initWorkspace(workspaceRoot: string): {
     history: Message[];
     welcomeText: string;
 };
+/**
+ * Restore a previously saved ACP session by its Zed sessionId.
+ * Falls back to initWorkspace if the session cannot be found on disk.
+ */
+export declare function loadWorkspace(workspaceRoot: string, acpSessionId: string): {
+    codeepSessionId: string;
+    history: Message[];
+    welcomeText: string;
+};
 /**
  * Try to handle a slash command. Async because skills and diff/review
  * need to call the AI API or run shell commands.

package/dist/acp/commands.js

@@ -74,6 +74,40 @@ export function initWorkspace(workspaceRoot) {
     }
     return { codeepSessionId, history, welcomeText: lines.join('\n') };
 }
+/**
+ * Restore a previously saved ACP session by its Zed sessionId.
+ * Falls back to initWorkspace if the session cannot be found on disk.
+ */
+export function loadWorkspace(workspaceRoot, acpSessionId) {
+    // Ensure workspace is set up
+    const codeepDir = join(workspaceRoot, '.codeep');
+    if (!existsSync(codeepDir)) {
+        mkdirSync(codeepDir, { recursive: true });
+    }
+    if (!isManuallyInitializedProject(workspaceRoot)) {
+        initializeAsProject(workspaceRoot);
+    }
+    if (!hasReadPermission(workspaceRoot)) {
+        setProjectPermission(workspaceRoot, true, true);
+    }
+    // Try to load the session that was saved under this ACP session ID
+    const loaded = loadSession(acpSessionId, workspaceRoot);
+    if (loaded) {
+        const history = loaded;
+        const provider = getCurrentProvider();
+        const model = config.get('model');
+        const lines = [
+            `**Codeep** • ${provider.name} • \`${model}\``,
+            '',
+            `**Session restored:** ${acpSessionId} (${history.length} messages)`,
+            '',
+            ...formatSessionPreviewLines(history),
+        ];
+        return { codeepSessionId: acpSessionId, history, welcomeText: lines.join('\n') };
+    }
+    // Session not found — fall back to initWorkspace behaviour
+    return initWorkspace(workspaceRoot);
+}
 // ─── Command dispatch ─────────────────────────────────────────────────────────
 /**
  * Try to handle a slash command. Async because skills and diff/review

package/dist/acp/protocol.d.ts

@@ -19,15 +19,23 @@ export interface JsonRpcNotification {
     params?: unknown;
 }
 export interface InitializeParams {
-    capabilities?: Record<string, unknown>;
-    workspaceFolders?: {
-        uri: string;
+    protocolVersion?: number;
+    clientCapabilities?: {
+        fs?: {
+            readTextFile?: boolean;
+            writeTextFile?: boolean;
+        };
+        terminal?: boolean;
+    };
+    clientInfo?: {
         name: string;
-    }[];
+        version: string;
+    };
 }
 export interface InitializeResult {
     protocolVersion: number;
     agentCapabilities: {
+        loadSession?: boolean;
         streaming?: boolean;
         fileEditing?: boolean;
     };
@@ -37,21 +45,155 @@ export interface InitializeResult {
     };
     authMethods: unknown[];
 }
-export interface SessionNewParams {
-    cwd: string;
-    mcpServers?: {
+export interface McpServer {
+    name: string;
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface SessionMode {
+    id: string;
+    name: string;
+    description?: string | null;
+}
+export interface SessionModeState {
+    availableModes: SessionMode[];
+    currentModeId: string;
+}
+export interface SessionConfigOption {
+    id: string;
+    name: string;
+    description?: string | null;
+    category?: 'mode' | 'model' | 'thought_level' | null;
+    type: 'select';
+    options?: {
+        id: string;
         name: string;
-        command: string;
-        args: string[];
-        env?: Record<string, string>;
     }[];
+    currentValue?: string;
+}
+export interface SessionNewParams {
+    cwd: string;
+    mcpServers?: McpServer[];
+}
+export interface SessionNewResult {
+    sessionId: string;
+    modes?: SessionModeState | null;
+    configOptions?: SessionConfigOption[] | null;
+}
+export interface SessionLoadParams {
+    sessionId: string;
+    cwd: string;
+    mcpServers?: McpServer[];
+}
+export interface SessionLoadResult {
+    modes?: SessionModeState | null;
+    configOptions?: SessionConfigOption[] | null;
 }
 export interface ContentBlock {
-    type: 'text';
-    text: string;
+    type: 'text' | 'image' | 'audio' | 'resource_link' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    uri?: string;
+    name?: string;
 }
 export interface SessionPromptParams {
     sessionId: string;
     prompt: ContentBlock[];
 }
+export interface SessionPromptResult {
+    stopReason: 'end_turn' | 'cancelled';
+}
+export interface SessionCancelParams {
+    sessionId: string;
+}
+export interface SetSessionModeParams {
+    sessionId: string;
+    modeId: string;
+}
+export interface SetSessionConfigOptionParams {
+    sessionId: string;
+    configId: string;
+    value: unknown;
+}
+export type ToolCallState = 'running' | 'finished' | 'error';
+export interface SessionUpdateContentChunk {
+    type: 'content_chunk';
+    sessionId: string;
+    content: ContentBlock;
+}
+export interface SessionUpdateToolCall {
+    type: 'tool_call';
+    sessionId: string;
+    toolCallId: string;
+    toolName: string;
+    toolInput: unknown;
+    state: ToolCallState;
+    content?: {
+        type: 'text';
+        text: string;
+    }[];
+}
+export interface SessionUpdateThoughtChunk {
+    type: 'agent_thought_chunk';
+    sessionId: string;
+    content: ContentBlock;
+}
+export interface SessionUpdateAvailableCommands {
+    type: 'available_commands_update';
+    sessionId: string;
+    availableCommands: {
+        name: string;
+        description: string;
+        input?: {
+            hint: string;
+        };
+    }[];
+}
+export interface SessionUpdateCurrentMode {
+    type: 'current_mode_update';
+    sessionId: string;
+    currentModeId: string;
+}
+export type SessionUpdateParams = SessionUpdateContentChunk | SessionUpdateToolCall | SessionUpdateThoughtChunk | SessionUpdateAvailableCommands | SessionUpdateCurrentMode;
+export type PermissionOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+export interface PermissionOption {
+    optionId: string;
+    name: string;
+    kind: PermissionOptionKind;
+}
+export interface RequestPermissionParams {
+    sessionId: string;
+    toolCall: {
+        toolCallId: string;
+        toolName: string;
+        toolInput: unknown;
+        state: ToolCallState;
+        content: unknown[];
+    };
+    options: PermissionOption[];
+}
+export interface RequestPermissionResult {
+    outcome: {
+        type: 'cancelled';
+    } | {
+        type: 'selected';
+        optionId: string;
+    };
+}
+export interface FsReadTextFileParams {
+    sessionId: string;
+    path: string;
+    line?: number;
+    limit?: number;
+}
+export interface FsReadTextFileResult {
+    content: string;
+}
+export interface FsWriteTextFileParams {
+    sessionId: string;
+    path: string;
+    content: string;
+}
 export type AcpMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;

package/dist/acp/protocol.js

@@ -1,3 +1,3 @@
 // acp/protocol.ts
-// ACP JSON-RPC message types for Zed Agent Client Protocol
+// ACP JSON-RPC message types — Agent Client Protocol spec
 export {};

package/dist/acp/server.js

@@ -3,9 +3,10 @@
 import { randomUUID } from 'crypto';
 import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
-import { initWorkspace, handleCommand } from './commands.js';
-import { autoSaveSession } from '../config/index.js';
-// All advertised slash commands (shown in Zed autocomplete)
+import { initWorkspace, loadWorkspace, handleCommand } from './commands.js';
+import { autoSaveSession, config } from '../config/index.js';
+import { getCurrentVersion } from '../utils/update.js';
+// ─── Slash commands advertised to Zed ────────────────────────────────────────
 const AVAILABLE_COMMANDS = [
     // Configuration
     { name: 'help', description: 'Show available commands' },
@@ -48,51 +49,92 @@ const AVAILABLE_COMMANDS = [
     { name: 'build', description: 'Build the project' },
     { name: 'deploy', description: 'Deploy the project' },
 ];
+// ─── Mode definitions ─────────────────────────────────────────────────────────
+const AGENT_MODES = {
+    currentModeId: 'auto',
+    availableModes: [
+        { id: 'auto', name: 'Auto', description: 'Agent runs automatically without confirmation' },
+        { id: 'manual', name: 'Manual', description: 'Confirm dangerous operations before running' },
+    ],
+};
+// ─── Config options ───────────────────────────────────────────────────────────
+function buildConfigOptions() {
+    return [
+        {
+            id: 'model',
+            name: 'Model',
+            description: 'AI model to use',
+            category: 'model',
+            type: 'select',
+            currentValue: config.get('model'),
+        },
+    ];
+}
+// ─── Server ───────────────────────────────────────────────────────────────────
 export function startAcpServer() {
     const transport = new StdioTransport();
     // ACP sessionId → full AcpSession (includes history + codeep session tracking)
     const sessions = new Map();
     transport.start((msg) => {
-        switch (msg.method) {
+        // Notifications have no id — handle separately
+        if (!('id' in msg)) {
+            handleNotification(msg);
+            return;
+        }
+        const req = msg;
+        switch (req.method) {
             case 'initialize':
-                handleInitialize(msg);
-                break;
-            case 'initialized':
-                // no-op acknowledgment
+                handleInitialize(req);
                 break;
+            case 'initialized': /* no-op acknowledgment */ break;
             case 'session/new':
-                handleSessionNew(msg);
+                handleSessionNew(req);
+                break;
+            case 'session/load':
+                handleSessionLoad(req);
                 break;
             case 'session/prompt':
-                handleSessionPrompt(msg);
+                handleSessionPrompt(req);
+                break;
+            case 'session/set_mode':
+                handleSetMode(req);
                 break;
-            case 'session/cancel':
-                handleSessionCancel(msg);
+            case 'session/set_config_option':
+                handleSetConfigOption(req);
                 break;
             default:
-                transport.error(msg.id, -32601, `Method not found: ${msg.method}`);
+                transport.error(req.id, -32601, `Method not found: ${req.method}`);
         }
     });
+    // ── Notification handler (no id, no response) ──────────────────────────────
+    function handleNotification(msg) {
+        if (msg.method === 'session/cancel') {
+            const { sessionId } = (msg.params ?? {});
+            sessions.get(sessionId)?.abortController?.abort();
+        }
+    }
+    // ── initialize ──────────────────────────────────────────────────────────────
     function handleInitialize(msg) {
         const _params = msg.params;
         const result = {
             protocolVersion: 1,
             agentCapabilities: {
+                loadSession: true,
                 streaming: true,
                 fileEditing: true,
             },
             agentInfo: {
                 name: 'codeep',
-                version: '1.0.0',
+                version: getCurrentVersion(),
             },
             authMethods: [],
         };
         transport.respond(msg.id, result);
     }
+    // ── session/new ─────────────────────────────────────────────────────────────
     function handleSessionNew(msg) {
         const params = msg.params;
         const acpSessionId = randomUUID();
-        // Initialise workspace: create .codeep folder, load/create codeep session
         const { codeepSessionId, history, welcomeText } = initWorkspace(params.cwd);
         sessions.set(acpSessionId, {
             sessionId: acpSessionId,
@@ -101,25 +143,103 @@ export function startAcpServer() {
             codeepSessionId,
             addedFiles: new Map(),
             abortController: null,
+            currentModeId: 'auto',
         });
-        transport.respond(msg.id, { sessionId: acpSessionId });
-        // Advertise all available slash commands to Zed
+        const result = {
+            sessionId: acpSessionId,
+            modes: AGENT_MODES,
+            configOptions: buildConfigOptions(),
+        };
+        transport.respond(msg.id, result);
+        // Advertise slash commands
         transport.notify('session/update', {
+            type: 'available_commands_update',
             sessionId: acpSessionId,
-            update: {
-                sessionUpdate: 'available_commands_update',
-                availableCommands: AVAILABLE_COMMANDS,
-            },
+            availableCommands: AVAILABLE_COMMANDS,
         });
-        // Stream welcome message
+        // Send welcome message
         transport.notify('session/update', {
+            type: 'content_chunk',
             sessionId: acpSessionId,
-            update: {
-                sessionUpdate: 'agent_message_chunk',
-                content: { type: 'text', text: welcomeText },
-            },
+            content: { type: 'text', text: welcomeText },
+        });
+    }
+    // ── session/load ────────────────────────────────────────────────────────────
+    function handleSessionLoad(msg) {
+        const params = msg.params;
+        // Try to restore existing Codeep session or fall back to fresh workspace
+        const existing = sessions.get(params.sessionId);
+        if (existing) {
+            // Session already in memory — update cwd if changed
+            existing.workspaceRoot = params.cwd;
+            const result = {
+                modes: AGENT_MODES,
+                configOptions: buildConfigOptions(),
+            };
+            transport.respond(msg.id, result);
+            return;
+        }
+        // Session not in memory — try to load from disk
+        const { codeepSessionId, history, welcomeText } = loadWorkspace(params.cwd, params.sessionId);
+        sessions.set(params.sessionId, {
+            sessionId: params.sessionId,
+            workspaceRoot: params.cwd,
+            history,
+            codeepSessionId,
+            addedFiles: new Map(),
+            abortController: null,
+            currentModeId: 'auto',
         });
+        const result = {
+            modes: AGENT_MODES,
+            configOptions: buildConfigOptions(),
+        };
+        transport.respond(msg.id, result);
+        // Send restored session welcome
+        transport.notify('session/update', {
+            type: 'content_chunk',
+            sessionId: params.sessionId,
+            content: { type: 'text', text: welcomeText },
+        });
+    }
+    // ── session/set_mode ────────────────────────────────────────────────────────
+    function handleSetMode(msg) {
+        const { sessionId, modeId } = msg.params;
+        const session = sessions.get(sessionId);
+        if (!session) {
+            transport.error(msg.id, -32602, `Unknown sessionId: ${sessionId}`);
+            return;
+        }
+        const validMode = AGENT_MODES.availableModes.find(m => m.id === modeId);
+        if (!validMode) {
+            transport.error(msg.id, -32602, `Unknown modeId: ${modeId}`);
+            return;
+        }
+        session.currentModeId = modeId;
+        // Map ACP mode to Codeep agentConfirmation setting
+        config.set('agentConfirmation', modeId === 'manual' ? 'dangerous' : 'never');
+        transport.respond(msg.id, {});
+        // Notify Zed of the mode change
+        transport.notify('session/update', {
+            type: 'current_mode_update',
+            sessionId,
+            currentModeId: modeId,
+        });
+    }
+    // ── session/set_config_option ───────────────────────────────────────────────
+    function handleSetConfigOption(msg) {
+        const { sessionId, configId, value } = msg.params;
+        const session = sessions.get(sessionId);
+        if (!session) {
+            transport.error(msg.id, -32602, `Unknown sessionId: ${sessionId}`);
+            return;
+        }
+        if (configId === 'model' && typeof value === 'string') {
+            config.set('model', value);
+        }
+        transport.respond(msg.id, {});
     }
+    // ── session/prompt ──────────────────────────────────────────────────────────
     function handleSessionPrompt(msg) {
         const params = msg.params;
         const session = sessions.get(params.sessionId);
@@ -130,32 +250,29 @@ export function startAcpServer() {
         // Extract text from ContentBlock[]
         const prompt = params.prompt
             .filter((b) => b.type === 'text')
-            .map((b) => b.text)
+            .map((b) => b.text ?? '')
             .join('\n');
         const abortController = new AbortController();
         session.abortController = abortController;
+        const agentResponseChunks = [];
         const sendChunk = (text) => {
+            agentResponseChunks.push(text);
             transport.notify('session/update', {
+                type: 'content_chunk',
                 sessionId: params.sessionId,
-                update: {
-                    sessionUpdate: 'agent_message_chunk',
-                    content: { type: 'text', text },
-                },
+                content: { type: 'text', text },
             });
         };
-        // Try slash commands first (async — skills, diff, scan, etc.)
+        // Try slash commands first
         handleCommand(prompt, session, sendChunk, abortController.signal)
             .then((cmd) => {
             if (cmd.handled) {
-                // For streaming commands (skills, diff), chunks were already sent via onChunk.
-                // For simple commands, send the response now.
                 if (cmd.response)
                     sendChunk(cmd.response);
                 transport.respond(msg.id, { stopReason: 'end_turn' });
                 return;
             }
             // Not a command — run agent loop
-            // Prepend any added-files context to the prompt
             let enrichedPrompt = prompt;
             if (session.addedFiles.size > 0) {
                 const parts = ['[Attached files]'];
@@ -172,28 +289,23 @@ export function startAcpServer() {
                 onChunk: sendChunk,
                 onThought: (text) => {
                     transport.notify('session/update', {
+                        type: 'agent_thought_chunk',
                         sessionId: params.sessionId,
-                        update: {
-                            sessionUpdate: 'agent_thought_chunk',
-                            content: { type: 'text', text },
-                        },
+                        content: { type: 'text', text },
                     });
                 },
-                onToolCall: (toolCallId, _toolName, kind, title, status, locations) => {
+                onToolCall: (toolCallId, toolName, _kind, _title, status, _locations) => {
                     transport.notify('session/update', {
+                        type: 'tool_call',
                         sessionId: params.sessionId,
-                        update: {
-                            sessionUpdate: 'tool_call',
-                            toolCallId,
-                            title,
-                            kind,
-                            status,
-                            ...(locations?.length ? { locations: locations.map(uri => ({ uri })) } : {}),
-                        },
+                        toolCallId,
+                        toolName,
+                        toolInput: {},
+                        state: status === 'running' ? 'running' : status === 'finished' ? 'finished' : 'error',
+                        content: [],
                     });
                 },
                 onFileEdit: (uri, newText) => {
-                    // ACP structured file/edit notification — lets the editor apply changes
                     transport.notify('file/edit', {
                         uri,
                         textChanges: newText
@@ -203,6 +315,10 @@ export function startAcpServer() {
                 },
             }).then(() => {
                 session.history.push({ role: 'user', content: prompt });
+                const agentResponse = agentResponseChunks.join('');
+                if (agentResponse) {
+                    session.history.push({ role: 'assistant', content: agentResponse });
+                }
                 autoSaveSession(session.history, session.workspaceRoot);
                 transport.respond(msg.id, { stopReason: 'end_turn' });
             }).catch((err) => {
@@ -223,11 +339,6 @@ export function startAcpServer() {
                 session.abortController = null;
         });
     }
-    function handleSessionCancel(msg) {
-        const { sessionId } = msg.params;
-        sessions.get(sessionId)?.abortController?.abort();
-        transport.respond(msg.id, {});
-    }
     // Keep process alive until stdin closes (Zed terminates us)
     return new Promise((resolve) => {
         process.stdin.on('end', resolve);

package/dist/acp/session.js

@@ -44,6 +44,8 @@ function toolCallMeta(toolName, params) {
 export async function runAgentSession(opts) {
     const projectContext = buildProjectContext(opts.workspaceRoot);
     let toolCallCounter = 0;
+    // Maps tool call key → ACP toolCallId so onToolResult can emit finished/error status
+    const toolCallIdMap = new Map();
     const result = await runAgent(opts.prompt, projectContext, {
         abortSignal: opts.abortSignal,
         onIteration: (_iteration, _message) => {
@@ -68,6 +70,9 @@ export async function runAgentSession(opts) {
                     : join(opts.workspaceRoot, filePath);
                 locations.push(pathToFileURL(absPath).href);
             }
+            // Track this tool call so onToolResult can emit finished/error
+            const mapKey = toolCall.id ?? `${name}_${toolCallCounter}`;
+            toolCallIdMap.set(mapKey, { toolCallId, kind, locations: locations.length ? locations : undefined });
             // Emit tool_call notification (running state)
             opts.onToolCall?.(toolCallId, name, kind, title, 'running', locations.length ? locations : undefined);
             // For file edits, also send structured file/edit notification
@@ -81,6 +86,30 @@ export async function runAgentSession(opts) {
                 }
             }
         },
+        onToolResult: (toolResult, toolCall) => {
+            // Find the tracked entry: prefer exact id match, then first FIFO entry for same tool name
+            let mapKey;
+            if (toolCall.id && toolCallIdMap.has(toolCall.id)) {
+                mapKey = toolCall.id;
+            }
+            else {
+                // FIFO: find oldest pending entry for this tool name
+                for (const [k, v] of toolCallIdMap) {
+                    if (k.startsWith(`${toolCall.tool}_`) && v.toolCallId) {
+                        mapKey = k;
+                        break;
+                    }
+                }
+            }
+            if (mapKey !== undefined) {
+                const tracked = toolCallIdMap.get(mapKey);
+                if (tracked && opts.onToolCall) {
+                    const status = toolResult.success ? 'finished' : 'error';
+                    opts.onToolCall(tracked.toolCallId, toolCall.tool, tracked.kind, '', status, tracked.locations);
+                }
+                toolCallIdMap.delete(mapKey);
+            }
+        },
     });
     // Emit the final response text if present
     if (result.finalResponse) {

package/dist/acp/transport.d.ts

@@ -1,5 +1,5 @@
 import { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './protocol.js';
-type MessageHandler = (msg: JsonRpcRequest) => void;
+type MessageHandler = (msg: JsonRpcRequest | JsonRpcNotification) => void;
 export declare class StdioTransport {
     private buffer;
     private handler;

package/dist/api/index.js

@@ -579,6 +579,6 @@ export async function validateApiKey(apiKey, providerId) {
         }
     }
     catch (err) {
-        return { valid: false, error: err.message };
+        return { valid: false, error: err instanceof Error ? err.message : String(err) };
     }
 }

package/dist/config/index.js

@@ -1,6 +1,7 @@
 import Conf from 'conf';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs';
 import { join, dirname } from 'path';
+import { randomUUID } from 'crypto';
 import { PROVIDERS, getProvider } from './providers.js';
 import { logSession } from '../utils/logger.js';
 // We'll initialize GLOBAL_SESSIONS_DIR after config is created (to use config.path)
@@ -389,8 +390,17 @@ export function isConfigured(providerId) {
 }
 // Get current provider info
 export function getCurrentProvider() {
-    const providerId = config.get('provider');
-    const provider = getProvider(providerId);
+    let providerId = config.get('provider');
+    let provider = getProvider(providerId);
+    // If stored provider no longer exists in registry, fall back to first available
+    if (!provider) {
+        const fallback = Object.keys(PROVIDERS)[0];
+        if (fallback) {
+            providerId = fallback;
+            provider = getProvider(fallback);
+            config.set('provider', fallback);
+        }
+    }
     return {
         id: providerId,
         name: provider?.name || providerId,
@@ -406,7 +416,7 @@ export function setProvider(providerId) {
     config.set('protocol', provider.defaultProtocol);
     // Load API key for the new provider into cache
     // This is async but we fire-and-forget since the key will be loaded before next API call
-    loadApiKey(providerId);
+    loadApiKey(providerId).catch(() => { });
     return true;
 }
 // Get models for current provider
@@ -425,10 +435,8 @@ export function getModelsForCurrentProvider() {
 export { PROVIDERS } from './providers.js';
 // Generate unique session ID
 function generateSessionId() {
-    const now = new Date();
-    const date = now.toISOString().split('T')[0];
-    const time = now.toTimeString().split(' ')[0].replace(/:/g, '-');
-    return `session-${date}-${time}`;
+    const date = new Date().toISOString().split('T')[0];
+    return `session-${date}-${randomUUID().slice(0, 8)}`;
 }
 // Get or create current session ID
 export function getCurrentSessionId() {
@@ -636,7 +644,7 @@ export function getProjectPermission(projectPath) {
     if (configPath && existsSync(configPath)) {
         try {
             const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-            if (data.permission)
+            if (data.permission && typeof data.permission === 'object')
                 return data.permission;
         }
         catch {

package/dist/config/providers.js

@@ -207,7 +207,7 @@ export function supportsNativeTools(providerId, protocol) {
     const provider = PROVIDERS[providerId];
     if (!provider)
         return false;
-    return provider.protocols[protocol]?.supportsNativeTools ?? true; // Default to true
+    return provider.protocols[protocol]?.supportsNativeTools ?? false; // Default to false (safer)
 }
 /**
  * Returns the effective max output tokens for a provider, capped by the provider's limit.

package/dist/renderer/main.js

@@ -129,17 +129,17 @@ async function handleSubmit(message) {
         executeAgentTask(enhancedTask, dryRun, ctx);
         return;
     }
+    const rateCheck = checkApiRateLimit();
+    if (!rateCheck.allowed) {
+        app.notify(rateCheck.message || 'Rate limit exceeded', 5000);
+        return;
+    }
     // Auto agent mode
     const agentMode = config.get('agentMode') || 'off';
     if (agentMode === 'on' && projectContext && hasWriteAccess && !isAgentRunningFlag) {
         runAgentTask(message, false, ctx, () => pendingInteractiveContext, (v) => { pendingInteractiveContext = v; });
         return;
     }
-    const rateCheck = checkApiRateLimit();
-    if (!rateCheck.allowed) {
-        app.notify(rateCheck.message || 'Rate limit exceeded', 5000);
-        return;
-    }
     try {
         app.startStreaming();
         const history = app.getChatHistory();

package/dist/utils/agent.js

@@ -124,6 +124,8 @@ export async function runAgent(prompt, projectContext, options = {}) {
     let finalResponse = '';
     let result;
     let consecutiveTimeouts = 0;
+    let incompleteWorkRetries = 0;
+    const maxIncompleteWorkRetries = 2;
     const maxTimeoutRetries = 3;
     const maxConsecutiveTimeouts = 9; // Allow more consecutive timeouts before giving up
     const baseTimeout = config.get('agentApiTimeout');
@@ -159,7 +161,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
             const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
             debug(`Using timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms)`);
             // Get AI response with retry logic for timeouts
-            let chatResponse;
+            let chatResponse = null;
             let retryCount = 0;
             while (true) {
                 try {
@@ -248,9 +250,11 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 const wantsToContinue = continueIndicators.some(indicator => lowerResponse.includes(indicator));
                 // Also check if there were tool call parsing failures in this iteration
                 // by looking for incomplete actions (e.g., write_file without content)
-                const hasIncompleteWork = iteration < 10 && wantsToContinue && finalResponse.length < 500;
+                const hasIncompleteWork = wantsToContinue && finalResponse.length < 500
+                    && incompleteWorkRetries < maxIncompleteWorkRetries;
                 if (hasIncompleteWork) {
                     debug('Model wants to continue, prompting for next action');
+                    incompleteWorkRetries++;
                     messages.push({ role: 'assistant', content });
                     messages.push({
                         role: 'user',
@@ -258,6 +262,8 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     });
                     continue;
                 }
+                // Reset counter once model produces real output or we give up
+                incompleteWorkRetries = 0;
                 // Model is done
                 debug(`Agent finished at iteration ${iteration}`);
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.35",
+  "version": "1.2.37",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",