coder-agent 2.6.1 → 2.6.3

package/dist/agent.js

@@ -276,6 +276,151 @@ 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();
+                }
+                let typewriterQueue = [];
+                let typewriterActive = false;
+                let resolveTypewriterFinished = null;
+                const pushToTypewriter = (text) => {
+                    typewriterQueue.push(...text.split(""));
+                    if (!typewriterActive) {
+                        typewriterActive = true;
+                        runTypewriterLoop();
+                    }
+                };
+                const runTypewriterLoop = async () => {
+                    while (typewriterQueue.length > 0) {
+                        const len = typewriterQueue.length;
+                        let batchSize = 1;
+                        let delay = 15; // default smooth delay
+                        if (len > 80) {
+                            batchSize = 8;
+                            delay = 1;
+                        }
+                        else if (len > 40) {
+                            batchSize = 4;
+                            delay = 2;
+                        }
+                        else if (len > 20) {
+                            batchSize = 2;
+                            delay = 5;
+                        }
+                        else if (len > 10) {
+                            batchSize = 1;
+                            delay = 8;
+                        }
+                        const chars = typewriterQueue.splice(0, batchSize).join("");
+                        process.stdout.write(chars);
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                    }
+                    typewriterActive = false;
+                    if (resolveTypewriterFinished) {
+                        resolveTypewriterFinished();
+                        resolveTypewriterFinished = null;
+                    }
+                };
+                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) {
+                                        pushToTypewriter(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);
+                    }
+                }
+                // Wait for the typewriter to finish writing before returning
+                if (typewriterActive && !silent) {
+                    await new Promise((resolve) => {
+                        resolveTypewriterFinished = resolve;
+                    });
+                }
+                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 };
         }
@@ -451,6 +596,7 @@ export class Agent {
                     tools: TOOL_DEFINITIONS,
                     tool_choice: "auto",
                     temperature: 0.2,
+                    stream: true,
                 }, 3, 1500, signal);
                 stopSpinner();
                 if (signal?.aborted) {
@@ -560,11 +706,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/package.json

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