coder-agent 2.6.0 → 2.6.2

package/dist/agent.js

@@ -276,6 +276,104 @@ async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initial
                 err.status = res.status;
                 throw err;
             }
+            if (params.stream) {
+                const decoder = new TextDecoder();
+                let buffer = "";
+                let accumulatedContent = "";
+                let accumulatedToolCalls = [];
+                if (!silent) {
+                    stopSpinner();
+                }
+                const processChunk = (chunk) => {
+                    buffer += decoder.decode(chunk, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        if (trimmed === "data: [DONE]")
+                            break;
+                        if (trimmed.startsWith("data: ")) {
+                            try {
+                                const parsed = JSON.parse(trimmed.slice(6));
+                                const choice = parsed.choices?.[0];
+                                if (!choice)
+                                    continue;
+                                const content = choice.delta?.content;
+                                if (content) {
+                                    accumulatedContent += content;
+                                    if (!silent) {
+                                        process.stdout.write(content);
+                                    }
+                                }
+                                const toolCalls = choice.delta?.tool_calls;
+                                if (toolCalls) {
+                                    for (const tc of toolCalls) {
+                                        const idx = tc.index ?? 0;
+                                        if (!accumulatedToolCalls[idx]) {
+                                            accumulatedToolCalls[idx] = {
+                                                id: tc.id || "",
+                                                type: "function",
+                                                function: { name: "", arguments: "" }
+                                            };
+                                        }
+                                        if (tc.id)
+                                            accumulatedToolCalls[idx].id = tc.id;
+                                        if (tc.function?.name) {
+                                            accumulatedToolCalls[idx].function.name += tc.function.name;
+                                        }
+                                        if (tc.function?.arguments) {
+                                            accumulatedToolCalls[idx].function.arguments += tc.function.arguments;
+                                        }
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                // Ignore partial JSON parse errors
+                            }
+                        }
+                    }
+                };
+                const bodyStream = res.body;
+                if (bodyStream && typeof bodyStream[Symbol.asyncIterator] === "function") {
+                    for await (const chunk of bodyStream) {
+                        if (signal?.aborted) {
+                            const abortErr = new Error("The user aborted a request.");
+                            abortErr.name = "AbortError";
+                            throw abortErr;
+                        }
+                        processChunk(chunk);
+                    }
+                }
+                else if (bodyStream && typeof bodyStream.getReader === "function") {
+                    const reader = bodyStream.getReader();
+                    while (true) {
+                        if (signal?.aborted) {
+                            const abortErr = new Error("The user aborted a request.");
+                            abortErr.name = "AbortError";
+                            throw abortErr;
+                        }
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (value)
+                            processChunk(value);
+                    }
+                }
+                const finalResponse = {
+                    choices: [
+                        {
+                            message: {
+                                role: "assistant",
+                                content: accumulatedContent,
+                                tool_calls: accumulatedToolCalls.length > 0 ? accumulatedToolCalls.filter(Boolean) : undefined
+                            }
+                        }
+                    ]
+                };
+                return { data: finalResponse, modelUsed: currentModel };
+            }
             const data = await res.json();
             return { data, modelUsed: currentModel };
         }
@@ -331,11 +429,13 @@ export class Agent {
     memory;
     model;
     memoryScope;
-    constructor(apiKey, model = "gemini-2.5-flash", memoryScope = "project") {
+    confirmHandler;
+    constructor(apiKey, model = "gemini-2.5-flash", memoryScope = "project", confirmHandler) {
         this.apiKey = apiKey;
         this.memory = new Memory();
         this.model = model;
         this.memoryScope = memoryScope;
+        this.confirmHandler = confirmHandler;
     }
     clearMemory() {
         this.memory.clear();
@@ -449,6 +549,7 @@ export class Agent {
                     tools: TOOL_DEFINITIONS,
                     tool_choice: "auto",
                     temperature: 0.2,
+                    stream: true,
                 }, 3, 1500, signal);
                 stopSpinner();
                 if (signal?.aborted) {
@@ -516,7 +617,7 @@ export class Agent {
                             modifiedFiles.add(path.normalize(args.file_path));
                         }
                     }
-                    const result = await dispatchTool(name, args, signal);
+                    const result = await dispatchTool(name, args, this.confirmHandler, signal);
                     if (signal?.aborted) {
                         const abortErr = new Error("The user aborted a request.");
                         abortErr.name = "AbortError";
@@ -558,11 +659,7 @@ export class Agent {
                 console.log(chalk.dim('─') + ' ' + chalk.dim(`${modifiedFiles.size} file(s) modified`));
             }
             // ── Phase 3: Final Agent Response ───────────────────────────────────────
-            console.log(chalk.dim('\n' + '─'.repeat(48) + '\n'));
-            if (cleanContent) {
-                console.log(formatResponseText(cleanContent));
-                console.log(""); // one trailing blank line
-            }
+            // Content has already been streamed in real-time.
             if (iterations >= MAX_ITERATIONS) {
                 console.log(chalk.hex('#ff453a')('✕ error'));
                 console.log(chalk.dim('  Max tool iterations reached.'));

package/dist/index.js

@@ -114,6 +114,7 @@ async function promptApiKey() {
 }
 // ─── Main Execution ───────────────────────────────────────────────────────────
 async function main() {
+    let rl;
     const args = process.argv.slice(2);
     let tempModel;
     let tempMemoryScope;
@@ -182,7 +183,28 @@ async function main() {
     if (!apiKey) {
         apiKey = await promptApiKey();
     }
-    const agent = new Agent(apiKey, modelToUse, tempMemoryScope);
+    const confirmHandler = async (question) => {
+        if (rl) {
+            return new Promise((resolve) => {
+                rl.question(question, (answer) => {
+                    resolve(answer.trim().toLowerCase().startsWith("y"));
+                });
+            });
+        }
+        else {
+            const rlConfirm = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            return new Promise((resolve) => {
+                rlConfirm.question(question, (answer) => {
+                    rlConfirm.close();
+                    resolve(answer.trim().toLowerCase().startsWith("y"));
+                });
+            });
+        }
+    };
+    const agent = new Agent(apiKey, modelToUse, tempMemoryScope, confirmHandler);
     // Single-Shot Mode
     if (queryArgs.length > 0) {
         const singleShotPrompt = queryArgs.join(" ").trim();
@@ -206,7 +228,7 @@ async function main() {
     }
     // Interactive REPL Mode
     printBanner(modelToUse);
-    const rl = readline.createInterface({
+    rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
         terminal: true,

package/dist/tools.js

@@ -212,7 +212,7 @@ export async function list_directory({ dir_path = "." }) {
         return `ERROR: ${e.message}`;
     }
 }
-export async function run_shell({ command, cwd }, signal) {
+export async function run_shell({ command, cwd }, confirmHandler, signal) {
     try {
         let targetCwd = process.cwd();
         if (cwd) {
@@ -234,7 +234,22 @@ export async function run_shell({ command, cwd }, signal) {
         if (cwd) {
             console.log(`  in directory: ${chalk.gray(cwd)}`);
         }
-        const allowed = await askConfirmation(`  Allow execution? (y/N): `);
+        let allowed = false;
+        if (confirmHandler) {
+            allowed = await confirmHandler(`  Allow execution? (y/N): `);
+        }
+        else {
+            const rlConfirm = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            allowed = await new Promise((resolve) => {
+                rlConfirm.question(`  Allow execution? (y/N): `, (answer) => {
+                    rlConfirm.close();
+                    resolve(answer.trim().toLowerCase().startsWith("y"));
+                });
+            });
+        }
         if (!allowed) {
             return "ERROR: Command execution denied by user.";
         }
@@ -392,12 +407,12 @@ export async function patch_file({ file_path, target_code, replacement_code }) {
     }
 }
 // ─── Dispatcher ──────────────────────────────────────────────────────────────
-export async function dispatchTool(name, args, signal) {
+export async function dispatchTool(name, args, confirmHandler, signal) {
     switch (name) {
         case "read_file": return read_file(args);
         case "write_file": return write_file(args);
         case "list_directory": return list_directory(args);
-        case "run_shell": return run_shell(args, signal);
+        case "run_shell": return run_shell(args, confirmHandler, signal);
         case "web_search": return web_search(args, signal);
         case "find_files": return find_files(args);
         case "read_file_lines": return read_file_lines(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-agent",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "CLI coding agent powered by Google Gemini",
   "type": "module",
   "main": "dist/index.js",