codeep 1.2.74 → 1.2.76

package/README.md

@@ -25,7 +25,8 @@
 - **Z.AI (ZhipuAI)** — GLM-5, GLM-4.7, GLM-4.7 Flash (international & China endpoints)
 - **MiniMax** — MiniMax M2.5 (international & China endpoints)
 - **DeepSeek** — DeepSeek V3, DeepSeek R1 (reasoning)
-- **Anthropic** — Claude Sonnet 4.6, Claude Opus 4.6, Claude Haiku 4.5
+- **Anthropic** — Claude Sonnet 4.6, Claude Opus 4.6, Claude Sonnet 4.5, Claude Haiku 4.5
+- **Google AI** — Gemini 3.1 Pro Preview, Gemini 3 Pro Preview, Gemini 3 Flash Preview, Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.5 Flash Lite
 - Switch between providers with `/provider`
 - Configure different API keys per provider
 - Both OpenAI-compatible and Anthropic API protocols supported
@@ -668,6 +669,7 @@ With write access enabled:
 | `MINIMAX_CN_API_KEY` | MiniMax China API key |
 | `DEEPSEEK_API_KEY` | DeepSeek API key |
 | `ANTHROPIC_API_KEY` | Anthropic Claude API key |
+| `GOOGLE_API_KEY` | Google AI (Gemini) API key |
 
 ### Settings (`/settings`)
 
@@ -681,7 +683,7 @@ With write access enabled:
 | Agent Mode | ON | `ON` = agent runs automatically (requires write permission via `/grant`), `Manual` = use /agent |
 | Agent API Timeout | 180000ms | Timeout per agent API call (auto-adjusted for complexity) |
 | Agent Max Duration | 20 min | Maximum time for agent to run (5-60 min) |
-| Agent Max Iterations | 100 | Maximum agent iterations (10-200) |
+| Agent Max Iterations | 200 | Maximum agent iterations (10-500) |
 | Agent Confirmation | Dangerous | `Never`, `Dangerous` (default), or `Always` |
 | Agent Auto-Commit | Off | Automatically commit after agent completes |
 | Agent Branch | Off | Create new branch for agent commits |

package/dist/acp/protocol.d.ts

@@ -34,6 +34,7 @@ export interface InitializeParams {
 }
 export interface AgentCapabilities {
     loadSession?: boolean;
+    terminal?: boolean;
     promptCapabilities?: {
         image?: boolean;
         audio?: boolean;
@@ -174,7 +175,17 @@ export interface SessionUpdateSessionInfo {
     title: string;
     updatedAt?: string;
 }
-export type SessionUpdateInner = SessionUpdateAgentMessageChunk | SessionUpdateAgentThoughtChunk | SessionUpdateToolCall | SessionUpdateToolCallUpdate | SessionUpdateAvailableCommands | SessionUpdateCurrentMode | SessionUpdateConfigOption | SessionUpdateSessionInfo;
+export interface PlanEntry {
+    id: string;
+    content: string;
+    priority: 'high' | 'medium' | 'low';
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface SessionUpdatePlan {
+    sessionUpdate: 'plan';
+    entries: PlanEntry[];
+}
+export type SessionUpdateInner = SessionUpdateAgentMessageChunk | SessionUpdateAgentThoughtChunk | SessionUpdateToolCall | SessionUpdateToolCallUpdate | SessionUpdatePlan | SessionUpdateAvailableCommands | SessionUpdateCurrentMode | SessionUpdateConfigOption | SessionUpdateSessionInfo;
 export interface SessionUpdateParams {
     sessionId: string;
     update: SessionUpdateInner;
@@ -237,4 +248,46 @@ export interface FsWriteTextFileParams {
     path: string;
     content: string;
 }
+export interface TerminalCreateParams {
+    sessionId: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+    outputByteLimit?: number;
+}
+export interface TerminalCreateResult {
+    terminalId: string;
+}
+export interface TerminalWaitForExitParams {
+    sessionId: string;
+    terminalId: string;
+    timeoutMs?: number;
+}
+export type TerminalExitStatus = {
+    type: 'exited';
+    code: number;
+} | {
+    type: 'killed';
+    signal?: string;
+};
+export interface TerminalWaitForExitResult {
+    exitStatus: TerminalExitStatus;
+}
+export interface TerminalOutputParams {
+    sessionId: string;
+    terminalId: string;
+    offset?: number;
+}
+export interface TerminalOutputResult {
+    output: string;
+    /** Absent while the process is still running; present once the process has exited. */
+    exitStatus?: TerminalExitStatus;
+}
+export interface TerminalReleaseParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalReleaseResult {
+}
 export type AcpMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;

package/dist/acp/server.js

@@ -4,8 +4,10 @@ import { randomUUID } from 'crypto';
 import { basename as pathBasename } from 'path';
 import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
+import { executeCommandAsync } from '../utils/shell.js';
 import { initWorkspace, loadWorkspace, handleCommand } from './commands.js';
 import { autoSaveSession, config, setProvider, listSessionsWithInfo, deleteSession as deleteSessionFile } from '../config/index.js';
+import { ApiError } from '../api/index.js';
 import { PROVIDERS } from '../config/providers.js';
 import { getCurrentVersion } from '../utils/update.js';
 // ─── Slash commands advertised to Zed ────────────────────────────────────────
@@ -148,6 +150,7 @@ export function startAcpServer() {
                 handleSessionDelete(req);
                 break;
             default:
+                process.stderr.write(`[codeep-acp] Unknown method: ${req.method}\n`);
                 transport.error(req.id, -32601, `Method not found: ${req.method}`);
         }
     });
@@ -165,6 +168,7 @@ export function startAcpServer() {
             protocolVersion: 1,
             agentCapabilities: {
                 loadSession: true,
+                terminal: true,
                 sessionCapabilities: { list: {} },
             },
             agentInfo: {
@@ -381,6 +385,18 @@ export function startAcpServer() {
             .join('\n');
         const abortController = new AbortController();
         session.abortController = abortController;
+        // Plan tracking: build a live plan from tool calls as the agent works
+        // ACP spec: send complete list on every update, client replaces current plan
+        const planEntries = new Map();
+        const sendPlan = () => {
+            transport.notify('session/update', {
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: 'plan',
+                    entries: [...planEntries.values()],
+                },
+            });
+        };
         const agentResponseChunks = [];
         const sendChunk = (text) => {
             agentResponseChunks.push(text);
@@ -456,6 +472,16 @@ export function startAcpServer() {
                                     : {}),
                             },
                         });
+                        // Add to plan as in_progress — only meaningful actions (not reads)
+                        if (kind === 'edit' || kind === 'execute' || kind === 'delete') {
+                            planEntries.set(toolCallId, {
+                                id: toolCallId,
+                                content: title || toolName,
+                                priority: kind === 'execute' ? 'high' : 'medium',
+                                status: 'in_progress',
+                            });
+                            sendPlan();
+                        }
                     }
                     else {
                         // tool_call_update: update status to completed/failed, with optional content
@@ -468,6 +494,70 @@ export function startAcpServer() {
                                 ...(rawOutput !== undefined ? { rawOutput } : {}),
                             },
                         });
+                        // Mark plan entry as completed
+                        const entry = planEntries.get(toolCallId);
+                        if (entry) {
+                            entry.status = 'completed';
+                            sendPlan();
+                        }
+                    }
+                },
+                // Only request permission in Manual mode
+                onRequestPermission: session.currentModeId === 'manual'
+                    ? async (toolCall) => {
+                        const permToolCallId = `perm_${randomUUID()}`;
+                        const result = await transport.request('session/request_permission', {
+                            sessionId: params.sessionId,
+                            toolCall: {
+                                toolCallId: permToolCallId,
+                                toolName: toolCall.tool,
+                                toolInput: toolCall.parameters,
+                                status: 'pending',
+                                content: [],
+                            },
+                            options: [
+                                { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
+                                { optionId: 'allow_always', name: 'Allow always', kind: 'allow_always' },
+                                { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' },
+                                { optionId: 'reject_always', name: 'Reject always', kind: 'reject_always' },
+                            ],
+                        });
+                        // Map ACP outcome back to PermissionOutcome
+                        if (!result || result.outcome.type === 'cancelled')
+                            return 'reject_once';
+                        return result.outcome.optionId;
+                    }
+                    : undefined,
+                onExecuteCommand: async (command, args, cwd) => {
+                    try {
+                        const createResult = await transport.request('terminal/create', {
+                            sessionId: params.sessionId,
+                            command,
+                            args,
+                            cwd,
+                            outputByteLimit: 1_000_000,
+                        });
+                        const { terminalId } = createResult;
+                        const waitResult = await transport.request('terminal/waitForExit', {
+                            sessionId: params.sessionId,
+                            terminalId,
+                            timeoutMs: 120_000,
+                        });
+                        const outputResult = await transport.request('terminal/output', {
+                            sessionId: params.sessionId,
+                            terminalId,
+                        });
+                        await transport.request('terminal/release', {
+                            sessionId: params.sessionId,
+                            terminalId,
+                        });
+                        const exitCode = waitResult.exitStatus.type === 'exited' ? waitResult.exitStatus.code : 1;
+                        return { stdout: outputResult.output ?? '', stderr: '', exitCode };
+                    }
+                    catch (err) {
+                        // Zed terminal unavailable — fall back to local execution
+                        const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
+                        return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
                     }
                 },
             }).then(() => {
@@ -487,6 +577,14 @@ export function startAcpServer() {
                 if (err.name === 'AbortError') {
                     transport.respond(msg.id, { stopReason: 'cancelled' });
                 }
+                else if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
+                    sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
+                    transport.respond(msg.id, { stopReason: 'end_turn' });
+                }
+                else if (err instanceof ApiError && err.status >= 500) {
+                    sendChunk(`⚠️ API server error (${err.status}). Please try again.`);
+                    transport.respond(msg.id, { stopReason: 'end_turn' });
+                }
                 else {
                     transport.error(msg.id, -32000, err.message);
                 }
@@ -496,7 +594,17 @@ export function startAcpServer() {
             });
         })
             .catch((err) => {
-            transport.error(msg.id, -32000, err.message);
+            if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
+                sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
+                transport.respond(msg.id, { stopReason: 'end_turn' });
+            }
+            else if (err instanceof ApiError && err.status >= 500) {
+                sendChunk(`⚠️ API server error (${err.status}). Please try again.`);
+                transport.respond(msg.id, { stopReason: 'end_turn' });
+            }
+            else {
+                transport.error(msg.id, -32000, err.message);
+            }
             if (session)
                 session.abortController = null;
         });

package/dist/acp/session.d.ts

@@ -1,4 +1,6 @@
+import { PermissionOutcome } from '../utils/agent.js';
 import { ProjectContext } from '../utils/project.js';
+import { ToolCall } from '../utils/tools.js';
 export interface AgentSessionOptions {
     prompt: string;
     workspaceRoot: string;
@@ -7,6 +9,12 @@ export interface AgentSessionOptions {
     onChunk: (text: string) => void;
     onThought?: (text: string) => void;
     onToolCall?: (toolCallId: string, toolName: string, kind: string, title: string, status: 'pending' | 'running' | 'finished' | 'error', locations?: string[], rawOutput?: string) => void;
+    onRequestPermission?: (toolCall: ToolCall) => Promise<PermissionOutcome>;
+    onExecuteCommand?: (command: string, args: string[], cwd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
 /**
  * Build a ProjectContext from a workspace root directory.

package/dist/acp/session.js

@@ -140,6 +140,8 @@ export async function runAgentSession(opts) {
                 toolCallIdMap.delete(mapKey);
             }
         },
+        onRequestPermission: opts.onRequestPermission,
+        onExecuteCommand: opts.onExecuteCommand,
     });
     // result.finalResponse is already emitted via onChunk streaming above;
     // only emit it here if nothing was streamed (e.g. non-streaming fallback path)

package/dist/acp/transport.d.ts

@@ -3,11 +3,18 @@ type MessageHandler = (msg: JsonRpcRequest | JsonRpcNotification) => void;
 export declare class StdioTransport {
     private buffer;
     private handler;
+    private pendingRequests;
+    private requestIdCounter;
     start(handler: MessageHandler): void;
     private onData;
     send(msg: JsonRpcResponse | JsonRpcNotification): void;
     respond(id: number | string, result: unknown): void;
     error(id: number | string, code: number, message: string): void;
     notify(method: string, params: unknown): void;
+    /**
+     * Send a JSON-RPC request to the client and wait for the response.
+     * Used for agent-initiated requests like session/request_permission.
+     */
+    request(method: string, params: unknown): Promise<unknown>;
 }
 export {};

package/dist/acp/transport.js

@@ -3,6 +3,8 @@
 export class StdioTransport {
     buffer = '';
     handler = null;
+    pendingRequests = new Map();
+    requestIdCounter = 1000;
     start(handler) {
         this.handler = handler;
         process.stdin.setEncoding('utf8');
@@ -19,6 +21,16 @@ export class StdioTransport {
                 continue;
             try {
                 const msg = JSON.parse(trimmed);
+                // Check if this is a response to one of our outbound requests
+                if ('result' in msg || 'error' in msg) {
+                    const response = msg;
+                    const resolve = this.pendingRequests.get(response.id);
+                    if (resolve) {
+                        this.pendingRequests.delete(response.id);
+                        resolve(response.result ?? null);
+                        continue;
+                    }
+                }
                 this.handler?.(msg);
             }
             catch {
@@ -38,4 +50,15 @@ export class StdioTransport {
     notify(method, params) {
         this.send({ jsonrpc: '2.0', method, params });
     }
+    /**
+     * Send a JSON-RPC request to the client and wait for the response.
+     * Used for agent-initiated requests like session/request_permission.
+     */
+    request(method, params) {
+        const id = ++this.requestIdCounter;
+        return new Promise((resolve) => {
+            this.pendingRequests.set(id, resolve);
+            process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+        });
+    }
 }

package/dist/config/index.js

@@ -148,7 +148,7 @@ function createConfig() {
         agentAutoCommitBranch: false,
         agentAutoVerify: 'off',
         agentMaxFixAttempts: 3,
-        agentMaxIterations: 100,
+        agentMaxIterations: 200,
         agentMaxDuration: 20,
         agentApiTimeout: 180000,
         protocol: 'openai',

package/dist/renderer/components/Settings.js

@@ -109,7 +109,7 @@ export const SETTINGS = [
         getValue: () => config.get('agentMaxIterations'),
         type: 'number',
         min: 10,
-        max: 200,
+        max: 500,
         step: 10,
     },
     {

package/dist/utils/agent.d.ts

@@ -12,6 +12,7 @@ import { ToolCall, ToolResult, ActionLog } from './tools';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
 import { VerifyResult } from './verify';
 import { TaskPlan, SubTask } from './taskPlanner';
+export type PermissionOutcome = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
 export interface AgentOptions {
     maxIterations: number;
     maxDuration: number;
@@ -23,6 +24,12 @@ export interface AgentOptions {
     onVerification?: (results: VerifyResult[]) => void;
     onTaskPlan?: (plan: TaskPlan) => void;
     onTaskUpdate?: (task: SubTask) => void;
+    onRequestPermission?: (toolCall: ToolCall) => Promise<PermissionOutcome>;
+    onExecuteCommand?: (command: string, args: string[], cwd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
     abortSignal?: AbortSignal;
     dryRun?: boolean;
     autoVerify?: 'off' | 'build' | 'typecheck' | 'test' | 'all' | boolean;

package/dist/utils/agent.js

@@ -11,6 +11,7 @@ const debug = (...args) => {
 };
 // Import chat layer (prompt building + API calls)
 import { agentChat, getAgentSystemPrompt, getFallbackSystemPrompt, loadProjectRules, formatChatHistoryForAgent, } from './agentChat.js';
+import { ApiError } from '../api/index.js';
 export { loadProjectRules, formatChatHistoryForAgent };
 /**
  * Calculate dynamic timeout based on task complexity
@@ -176,6 +177,10 @@ export async function runAgent(prompt, projectContext, options = {}) {
     let consecutiveTimeouts = 0;
     let incompleteWorkRetries = 0;
     const maxIncompleteWorkRetries = 2;
+    // Track tools permanently allowed this session via allow_always
+    const alwaysAllowedTools = new Set();
+    // Tools that require permission when onRequestPermission is set
+    const dangerousTools = new Set(['delete_file', 'execute_command']);
     const maxTimeoutRetries = 3;
     const maxConsecutiveTimeouts = 9; // Allow more consecutive timeouts before giving up
     const baseTimeout = config.get('agentApiTimeout');
@@ -283,6 +288,17 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
                         continue;
                     }
+                    // Don't retry on 4xx client errors except 429 (rate limit)
+                    if (err instanceof ApiError && err.status >= 400 && err.status < 500 && err.status !== 429) {
+                        result = {
+                            success: false,
+                            iterations: iteration,
+                            actions,
+                            finalResponse: '',
+                            error: err.message,
+                        };
+                        return result;
+                    }
                     // All non-abort errors are retryable — retry with backoff
                     retryCount++;
                     const isRateLimit = err.message.includes('429');
@@ -376,9 +392,28 @@ export async function runAgent(prompt, projectContext, options = {}) {
             const toolResults = [];
             for (const toolCall of toolCalls) {
                 opts.onToolCall?.(toolCall);
+                // Permission check for dangerous tools (only when callback is provided, e.g. ACP/Zed)
+                if (opts.onRequestPermission && dangerousTools.has(toolCall.tool) && !alwaysAllowedTools.has(toolCall.tool)) {
+                    const outcome = await opts.onRequestPermission(toolCall);
+                    if (outcome === 'allow_always') {
+                        alwaysAllowedTools.add(toolCall.tool);
+                    }
+                    else if (outcome === 'reject_once' || outcome === 'reject_always') {
+                        const toolResult = {
+                            success: false,
+                            output: '',
+                            error: `User rejected permission for ${toolCall.tool}`,
+                            tool: toolCall.tool,
+                            parameters: toolCall.parameters,
+                        };
+                        opts.onToolResult?.(toolResult, toolCall);
+                        actions.push(createActionLog(toolCall, toolResult));
+                        toolResults.push(`Tool ${toolCall.tool} was rejected by user.`);
+                        continue;
+                    }
+                }
                 let toolResult;
                 if (opts.dryRun) {
-                    // In dry run mode, simulate success
                     toolResult = {
                         success: true,
                         output: `[DRY RUN] Would execute: ${toolCall.tool}`,
@@ -386,8 +421,40 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         parameters: toolCall.parameters,
                     };
                 }
+                else if (opts.onExecuteCommand && toolCall.tool === 'execute_command') {
+                    // Delegate to external terminal (e.g. Zed ACP terminal)
+                    // Note: onExecuteCommand runs after the permission gate above
+                    const command = toolCall.parameters.command;
+                    const args = toolCall.parameters.args || [];
+                    const cwd = projectContext.root || process.cwd();
+                    if (!command) {
+                        toolResult = {
+                            success: false,
+                            output: '',
+                            error: 'execute_command called with missing command field',
+                            tool: toolCall.tool,
+                            parameters: toolCall.parameters,
+                        };
+                    }
+                    else {
+                        try {
+                            const commandResult = await opts.onExecuteCommand(command, args, cwd);
+                            toolResult = {
+                                success: commandResult.exitCode === 0,
+                                output: commandResult.stdout || '(no output)',
+                                error: commandResult.exitCode !== 0 ? (commandResult.stderr || `exited with code ${commandResult.exitCode}`) : undefined,
+                                tool: toolCall.tool,
+                                parameters: toolCall.parameters,
+                            };
+                        }
+                        catch (err) {
+                            debug('onExecuteCommand callback threw, falling back to local execution:', err);
+                            // Fallback to local execution if callback throws
+                            toolResult = await executeTool(toolCall, cwd);
+                        }
+                    }
+                }
                 else {
-                    // Actually execute the tool
                     toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
                 }
                 opts.onToolResult?.(toolResult, toolCall);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.74",
+  "version": "1.2.76",
   "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",