codeep 3.3.3 → 3.4.1

package/dist/acp/serverHandlers.d.ts

@@ -3,7 +3,8 @@ import type { AcpSession } from './commands.js';
 /** Session record held by the running server. Lives in server.ts; re-exposed
  *  here so handler signatures can name it without re-declaring the shape. */
 export interface AcpServerSession extends AcpSession {
-    abortController: AbortController | null;
+    /** Controllers of the prompts still running; session/cancel aborts all. */
+    activePrompts: Set<AbortController>;
     currentModeId: string;
     titleSent: boolean;
     hadHistory: boolean;

package/dist/acp/serverHandlers.js

@@ -18,6 +18,7 @@
 import { AGENT_MODES, buildConfigOptions } from './server.js';
 import { config, setProvider, setApiKey, listSessionsWithInfo, deleteSession as deleteSessionFile, } from '../config/index.js';
 import { disposeSession as disposeMcpSession } from '../utils/mcpRegistry.js';
+import { clearPendingPlan } from '../utils/planMode.js';
 // ─── session/set_mode ─────────────────────────────────────────────────────────
 /**
  * Switch the agent confirmation mode for a session (auto = no prompts,
@@ -192,6 +193,8 @@ export function handleSessionDelete(msg, deps) {
     const { sessionId, cwd } = (msg.params ?? {});
     // Remove from in-memory sessions map if present
     sessions.delete(sessionId);
+    // Its pending /plan goes with it.
+    clearPendingPlan(sessionId);
     // Tear down any MCP server processes attached to this session — leaks
     // children otherwise. Fire-and-forget; client doesn't wait on stop().
     disposeMcpSession(sessionId).catch(() => { });

package/dist/acp/session.d.ts

@@ -1,7 +1,8 @@
 import { PermissionOutcome } from '../utils/agent.js';
 import { ProjectContext } from '../utils/project.js';
 import { ToolCall } from '../utils/tools.js';
-import type { FsCallbacks } from '../utils/toolExecution.js';
+import type { FsCallbacks, TrustBearingWrite } from '../utils/toolExecution.js';
+import type { Message } from '../config/index.js';
 export interface AgentSessionOptions {
     prompt: string;
     workspaceRoot: string;
@@ -10,7 +11,18 @@ 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>;
+    /**
+     * Ask the user about one tool call. Handed straight to runAgent, so the
+     * signature is runAgent's: `trustBearing` is what the agent's own gate
+     * already worked out about the call — the file it would write that decides
+     * what runs later, or null when it writes no such file — and the dialog
+     * words itself from that instead of resolving the path a second time.
+     *
+     * Declared with one parameter, this type said the second argument did not
+     * exist while runAgent passed it on every call, so the one caller that
+     * needs it had to cast its way back to the truth.
+     */
+    onRequestPermission?: (toolCall: ToolCall, trustBearing?: TrustBearingWrite | null) => Promise<PermissionOutcome>;
     /** Tools to force into the per-run dangerous set (ACP manual mode). */
     extraDangerousTools?: string[];
     onExecuteCommand?: (command: string, args: string[], cwd: string) => Promise<{
@@ -20,7 +32,21 @@ export interface AgentSessionOptions {
     }>;
     /** Optional fs delegation when the ACP client advertises `fs` capability. */
     fs?: FsCallbacks;
+    /**
+     * Earlier turns of this conversation. ACP clients send only the new
+     * message, so without this the agent would start every turn blind to a
+     * loaded, rewound or compacted session.
+     */
+    chatHistory?: Message[];
 }
+/**
+ * The part of a session's history the agent sees: user and assistant turns,
+ * as the TUI passes them (`App.getChatHistory`).
+ */
+export declare function toAgentChatHistory(history: Message[]): Array<{
+    role: 'user' | 'assistant';
+    content: string;
+}>;
 /**
  * Build a ProjectContext from a workspace root directory.
  * Falls back to a minimal synthetic context if scanning fails.

package/dist/acp/session.js

@@ -3,6 +3,15 @@
 import { join, isAbsolute } from 'path';
 import { runAgent } from '../utils/agent.js';
 import { getProjectContext } from '../utils/project.js';
+/**
+ * The part of a session's history the agent sees: user and assistant turns,
+ * as the TUI passes them (`App.getChatHistory`).
+ */
+export function toAgentChatHistory(history) {
+    return history
+        .filter((m) => m.role === 'user' || m.role === 'assistant')
+        .map(m => ({ role: m.role, content: m.content }));
+}
 /**
  * Build a ProjectContext from a workspace root directory.
  * Falls back to a minimal synthetic context if scanning fails.
@@ -184,18 +193,28 @@ export async function runAgentSession(opts) {
         // `conversationId` is the ACP session id, which is what
         // registerSessionServers keyed by in server.ts handleSessionNew.
         mcpSessionId: opts.conversationId,
+        chatHistory: opts.chatHistory ? toAgentChatHistory(opts.chatHistory) : undefined,
     });
-    // result.finalResponse is already emitted via onChunk streaming above;
-    // only emit it here if nothing was streamed (e.g. non-streaming fallback path)
-    // — except a paused/interrupted run, whose finalResponse is a fresh "say
+    // result.finalResponse is mostly emitted via onChunk streaming above;
+    // emit all of it here if nothing was streamed (e.g. non-streaming fallback path)
+    // — or a paused/interrupted run, whose finalResponse is a fresh "say
     // continue" notice that was never streamed and must always reach the client.
+    // Otherwise send what the loop wrote itself and never streamed (the
+    // verification result, a reviewer's notes, a notice that replaced the
+    // answer): without it an editor never hears that verification failed.
     if (result.finalResponse && (chunksEmitted === 0 || result.interrupted)) {
         opts.onChunk(result.finalResponse);
     }
+    else if (result.finalResponse && !result.aborted) {
+        const tail = result.unstreamedText ?? '';
+        if (tail)
+            opts.onChunk(`\n\n${tail}`);
+    }
     // Surface errors as thrown exceptions so the ACP server can handle them correctly.
-    // Exception: if finalResponse was already sent as a chunk (e.g. "Agent reached the
-    // iteration limit", "Agent stopped due to repeated API timeouts"), don't also throw —
-    // the user already received the explanation and Zed would show a confusing second error.
+    // Exception: once chunks were streamed, the rest of finalResponse was sent
+    // just above (e.g. "✗ Verification failed", "Agent stopped due to repeated
+    // API timeouts"), so don't also throw — the user already received the
+    // explanation and Zed would show a confusing second error.
     if (!result.success && !result.aborted) {
         const alreadyExplained = result.finalResponse && chunksEmitted > 0;
         if (!alreadyExplained) {

package/dist/acp/transport.d.ts

@@ -1,12 +1,43 @@
 import { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './protocol.js';
-type MessageHandler = (msg: JsonRpcRequest | JsonRpcNotification) => void;
+/**
+ * A frame with its obvious credentials blanked.
+ *
+ * Exported for unit testing (see transport.test.ts).
+ */
+export declare function redactCredentials(frame: string): string;
+type MessageHandler = (msg: JsonRpcRequest | JsonRpcNotification) => void | Promise<unknown>;
+export interface RequestOptions {
+    /**
+     * How long to wait for the client's answer. Defaults to 30s; 0 waits
+     * indefinitely, for calls that wait on a person (permission dialogs) or
+     * on a running process (terminal/wait_for_exit).
+     */
+    timeoutMs?: number;
+    /** Stop waiting when this fires (e.g. the prompt was cancelled). */
+    signal?: AbortSignal;
+}
+/** The client answered one of our requests with a JSON-RPC error. */
+export declare class AcpRequestError extends Error {
+    readonly method: string;
+    readonly code: number;
+    constructor(method: string, code: number, message: string);
+}
+/** The client did not answer one of our requests in time. */
+export declare class AcpRequestTimeoutError extends Error {
+    readonly method: string;
+    readonly timeoutMs: number;
+    constructor(method: string, timeoutMs: number);
+}
 export declare class StdioTransport {
     private buffer;
-    private handler;
+    protected handler: MessageHandler | null;
     private pendingRequests;
     private requestIdCounter;
+    private unanswered;
     start(handler: MessageHandler): void;
-    private onData;
+    protected onData(chunk: string): void;
+    private dispatch;
+    protected write(line: string): void;
     send(msg: JsonRpcResponse | JsonRpcNotification): void;
     respond(id: number | string, result: unknown): void;
     error(id: number | string, code: number, message: string): void;
@@ -14,7 +45,12 @@ export declare class StdioTransport {
     /**
      * Send a JSON-RPC request to the client and wait for the response.
      * Used for agent-initiated requests like session/request_permission.
+     *
+     * Rejects with AcpRequestError when the client answers with an error,
+     * with AcpRequestTimeoutError when it does not answer in time, and with
+     * an AbortError when `signal` fires. A result is never invented: callers
+     * that treat a missing answer as "no" must say so with their own catch.
      */
-    request(method: string, params: unknown): Promise<unknown>;
+    request(method: string, params: unknown, options?: RequestOptions): Promise<unknown>;
 }
 export {};

package/dist/acp/transport.js

@@ -1,36 +1,157 @@
 // acp/transport.ts
 // Newline-delimited JSON-RPC over stdio
-import { appendFileSync, mkdirSync } from 'node:fs';
+import { appendFileSync, chmodSync, mkdirSync, renameSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 // Debug log destination — when CODEEP_ACP_DEBUG is set we mirror every
 // inbound and outbound JSON-RPC frame here. Using a file (not stderr) because
 // most ACP clients (Zed included) do not pipe agent stderr to anywhere the
 // user can easily read; a known on-disk path is reliable everywhere.
+//
+// WHAT IS IN IT, because a user asked for it in a bug report will attach the
+// whole file: every frame of the session. That is the prompts, the model's
+// replies, the contents of every file read or written through fs/*, the
+// commands run in the client's terminal and their output, and the `env` of
+// every terminal/create. redactCredentials() blanks the obvious credential
+// shapes on the way in, but it is a filter over text and not a guarantee — a
+// secret that does not look like one survives it. So: session-private, 0600
+// in a 0700 directory, and not something to paste anywhere unread.
 const ACP_DEBUG_PATH = process.env.CODEEP_ACP_DEBUG_FILE
     || join(homedir(), '.cache', 'codeep', 'acp-debug.log');
 const ACP_DEBUG = !!process.env.CODEEP_ACP_DEBUG;
+/**
+ * Roll the log over at 8MB, keeping one previous file.
+ *
+ * It had no limit at all: every frame was appended and nothing ever truncated
+ * or removed the file, and a frame carries whole file contents and whole
+ * command outputs — so a user who left CODEEP_ACP_DEBUG set grew it until the
+ * disk stopped them. One previous file rather than a truncate because the
+ * frames that explain a broken session are usually the handshake at the top,
+ * which is exactly what a truncate throws away. Bounded at twice this, then.
+ */
+const ACP_DEBUG_MAX_BYTES = 8 * 1024 * 1024;
 if (ACP_DEBUG) {
+    // 0700: the directory holds a file with the whole session in it.
     try {
-        mkdirSync(dirname(ACP_DEBUG_PATH), { recursive: true });
+        mkdirSync(dirname(ACP_DEBUG_PATH), { recursive: true, mode: 0o700 });
     }
     catch { /* ignore */ }
 }
+/** Bytes written so far, so the size check costs no syscall per frame. Null
+ *  until the first write reads what an earlier run left on disk. */
+let acpDebugBytes = null;
 function debugLog(direction, payload) {
     if (!ACP_DEBUG)
         return;
+    const line = `${new Date().toISOString()} [ACP${direction}client] ${redactCredentials(payload)}\n`;
+    const bytes = Buffer.byteLength(line);
     try {
-        appendFileSync(ACP_DEBUG_PATH, `${new Date().toISOString()} [ACP${direction}client] ${payload}\n`);
+        if (acpDebugBytes === null)
+            acpDebugBytes = adoptExistingLog();
+        if (acpDebugBytes > 0 && acpDebugBytes + bytes > ACP_DEBUG_MAX_BYTES) {
+            renameSync(ACP_DEBUG_PATH, `${ACP_DEBUG_PATH}.1`);
+            acpDebugBytes = 0;
+        }
+        // `mode` applies only when the file is created, which after the rename
+        // above is every rollover as well as the first frame of the first run.
+        appendFileSync(ACP_DEBUG_PATH, line, { mode: 0o600 });
+        acpDebugBytes += bytes;
     }
     catch { /* swallow — never break the protocol over a logging failure */ }
 }
+/** The size of the log already on disk, 0 when there is none. */
+function adoptExistingLog() {
+    try {
+        const stat = statSync(ACP_DEBUG_PATH);
+        // A log this build did not create is one an older Codeep created 0644 —
+        // world-readable, with everything listed above in it. Tighten it, but
+        // only at our own path: CODEEP_ACP_DEBUG_FILE may name something whose
+        // mode is not ours to change (a fifo, a tty, a shared file).
+        if (!process.env.CODEEP_ACP_DEBUG_FILE && (stat.mode & 0o077) !== 0) {
+            chmodSync(ACP_DEBUG_PATH, 0o600);
+        }
+        return stat.size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Credential shapes blanked before a frame is mirrored to the debug log.
+ *
+ * The log exists to debug the protocol, so this is deliberately narrow: it
+ * blanks what is unmistakably a secret and leaves everything else readable.
+ * Matched on the frame TEXT rather than on a parsed object because an inbound
+ * frame is logged before it is parsed and may not be JSON at all.
+ *
+ * Nothing here changes the frame on the wire — only the copy on disk.
+ */
+const ACP_DEBUG_REDACTIONS = [
+    // `"apiKey": "…"`, `"authorization": "…"` — the MEMBER NAME says it is a
+    // secret, whatever the value looks like.
+    [/("[A-Za-z0-9_.-]*(?:api[_-]?key|access[_-]?key|secret|token|password|passwd|credential|authorization|cookie|private[_-]?key)[A-Za-z0-9_.-]*"\s*:\s*)"(?:[^"\\]|\\.)*"/gi, '$1"[redacted]"'],
+    // ACP spells an environment as `{"name":…,"value":…}`, so the secret-looking
+    // string is the VALUE of `name` and the rule above cannot see it. This is
+    // the shape terminal/create used to leak the whole of process.env in.
+    [/("name"\s*:\s*"[A-Za-z0-9_.-]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH|COOKIE)[A-Za-z0-9_.-]*"\s*,\s*"value"\s*:\s*)"(?:[^"\\]|\\.)*"/gi, '$1"[redacted]"'],
+    // And the shapes that are a credential wherever they turn up — a command
+    // line the agent ran, a terminal's own output, a file it read.
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, '[redacted]'], // OpenAI / Anthropic
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, '[redacted]'], // GitHub
+    [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, '[redacted]'],
+    [/\bglpat-[A-Za-z0-9_-]{16,}/g, '[redacted]'], // GitLab
+    [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, '[redacted]'], // Slack
+    [/\bAKIA[0-9A-Z]{16}\b/g, '[redacted]'], // AWS access key id
+    [/\bAIza[0-9A-Za-z_-]{20,}/g, '[redacted]'], // Google
+    [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, '[redacted]'], // JWT
+    [/\bBearer\s+[A-Za-z0-9._~+/-]{16,}={0,2}/gi, 'Bearer [redacted]'],
+    // `https://user:password@host` — keep the structure, drop the password.
+    [/((?:https?|ssh|git):\/\/[^\s"'/@]+:)[^\s"'/@]+@/g, '$1[redacted]@'],
+];
+/**
+ * A frame with its obvious credentials blanked.
+ *
+ * Exported for unit testing (see transport.test.ts).
+ */
+export function redactCredentials(frame) {
+    let out = frame;
+    for (const [pattern, replacement] of ACP_DEBUG_REDACTIONS)
+        out = out.replace(pattern, replacement);
+    return out;
+}
 const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
 const REQUEST_TIMEOUT_MS = 30_000; // 30s
+/** The client answered one of our requests with a JSON-RPC error. */
+export class AcpRequestError extends Error {
+    method;
+    code;
+    constructor(method, code, message) {
+        super(`${method} failed: ${message}`);
+        this.method = method;
+        this.code = code;
+        this.name = 'AcpRequestError';
+    }
+}
+/** The client did not answer one of our requests in time. */
+export class AcpRequestTimeoutError extends Error {
+    method;
+    timeoutMs;
+    constructor(method, timeoutMs) {
+        super(`${method} got no response within ${timeoutMs}ms`);
+        this.method = method;
+        this.timeoutMs = timeoutMs;
+        this.name = 'AcpRequestTimeoutError';
+    }
+}
 export class StdioTransport {
     buffer = '';
     handler = null;
     pendingRequests = new Map();
     requestIdCounter = 1000;
+    // Ids of inbound requests we have not answered yet. A handler that fails
+    // before answering gets an error reply; one that fails after answering
+    // must not produce a second response for the same id.
+    unanswered = new Set();
     start(handler) {
         this.handler = handler;
         process.stdin.setEncoding('utf8');
@@ -49,31 +170,67 @@ export class StdioTransport {
             const trimmed = line.trim();
             if (!trimmed)
                 continue;
+            debugLog('←', trimmed);
+            let msg;
             try {
-                debugLog('←', trimmed);
-                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;
+                msg = JSON.parse(trimmed);
+            }
+            catch {
+                continue; // ignore malformed messages
+            }
+            if (!msg || typeof msg !== 'object')
+                continue;
+            // A frame without a method answers one of our outbound requests.
+            if (!('method' in msg) && ('result' in msg || 'error' in msg)) {
+                const response = msg;
+                const pending = this.pendingRequests.get(response.id);
+                if (pending) {
+                    this.pendingRequests.delete(response.id);
+                    if (response.error) {
+                        pending.reject(new AcpRequestError(pending.method, response.error.code, response.error.message));
+                    }
+                    else {
+                        pending.resolve(response.result ?? null);
                     }
                 }
-                this.handler?.(msg);
+                // Nobody is waiting for it any more (timed out or cancelled). It is
+                // a response, so answering it would break JSON-RPC: drop it.
+                continue;
             }
-            catch {
-                // ignore malformed messages
+            this.dispatch(msg);
+        }
+    }
+    dispatch(msg) {
+        const id = 'id' in msg ? msg.id : undefined;
+        if (id !== undefined)
+            this.unanswered.add(id);
+        const fail = (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            // stderr only: stdout carries nothing but JSON-RPC frames.
+            process.stderr.write(`[codeep-acp] ${msg.method} failed: ${message}\n`);
+            if (id !== undefined && this.unanswered.has(id)) {
+                this.error(id, -32603, message);
+            }
+        };
+        try {
+            const out = this.handler?.(msg);
+            if (out && typeof out.then === 'function') {
+                out.then(undefined, fail);
             }
         }
+        catch (err) {
+            fail(err);
+        }
     }
-    send(msg) {
-        const line = JSON.stringify(msg);
+    write(line) {
         debugLog('→', line);
         process.stdout.write(line + '\n');
     }
+    send(msg) {
+        if ('id' in msg)
+            this.unanswered.delete(msg.id);
+        this.write(JSON.stringify(msg));
+    }
     respond(id, result) {
         this.send({ jsonrpc: '2.0', id, result });
     }
@@ -86,17 +243,53 @@ export class StdioTransport {
     /**
      * Send a JSON-RPC request to the client and wait for the response.
      * Used for agent-initiated requests like session/request_permission.
+     *
+     * Rejects with AcpRequestError when the client answers with an error,
+     * with AcpRequestTimeoutError when it does not answer in time, and with
+     * an AbortError when `signal` fires. A result is never invented: callers
+     * that treat a missing answer as "no" must say so with their own catch.
      */
-    request(method, params) {
+    request(method, params, options = {}) {
         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');
-            setTimeout(() => {
+        const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+        const { signal } = options;
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(abortError(method));
+                return;
+            }
+            let timer;
+            const settle = () => {
+                if (timer)
+                    clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const onAbort = () => {
                 if (this.pendingRequests.delete(id)) {
-                    resolve(null);
+                    settle();
+                    reject(abortError(method));
                 }
-            }, REQUEST_TIMEOUT_MS);
+            };
+            this.pendingRequests.set(id, {
+                method,
+                resolve: (result) => { settle(); resolve(result); },
+                reject: (err) => { settle(); reject(err); },
+            });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            if (timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    if (this.pendingRequests.delete(id)) {
+                        settle();
+                        reject(new AcpRequestTimeoutError(method, timeoutMs));
+                    }
+                }, timeoutMs);
+            }
+            this.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }));
         });
     }
 }
+function abortError(method) {
+    const err = new Error(`${method} was cancelled`);
+    err.name = 'AbortError';
+    return err;
+}

package/dist/acp/turns.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Recording a finished turn in an ACP thread's conversation.
+ */
+import { type Message } from '../config/index.js';
+/** The part of a session a turn needs. */
+export interface TurnSession {
+    workspaceRoot: string;
+    history: Message[];
+    codeepSessionId: string;
+    /** Bumped whenever the thread moves to another conversation. */
+    conversation?: number;
+}
+/**
+ * Start a turn: returns the function that records its messages once it ran.
+ * If the thread moved to another conversation meanwhile, the turn belongs to
+ * the one it started in — it is saved there, not appended to the new one —
+ * and after a /rewind of that same conversation it is dropped, since saving
+ * it would undo the rewind.
+ */
+export declare function beginTurn(session: TurnSession): (entries: Message[]) => void;

package/dist/acp/turns.js

@@ -0,0 +1,30 @@
+/**
+ * Recording a finished turn in an ACP thread's conversation.
+ */
+import { config, saveSession } from '../config/index.js';
+/**
+ * Start a turn: returns the function that records its messages once it ran.
+ * If the thread moved to another conversation meanwhile, the turn belongs to
+ * the one it started in — it is saved there, not appended to the new one —
+ * and after a /rewind of that same conversation it is dropped, since saving
+ * it would undo the rewind.
+ */
+export function beginTurn(session) {
+    const conversation = session.conversation ?? 0;
+    const id = session.codeepSessionId;
+    const history = session.history;
+    return (entries) => {
+        const autoSave = config.get('autoSave');
+        if ((session.conversation ?? 0) === conversation) {
+            session.history.push(...entries);
+            if (autoSave && session.history.length > 0)
+                saveSession(session.codeepSessionId, session.history, session.workspaceRoot);
+            return;
+        }
+        if (id === session.codeepSessionId)
+            return;
+        history.push(...entries);
+        if (autoSave)
+            saveSession(id, history, session.workspaceRoot);
+    };
+}

package/dist/api/index.js

@@ -445,6 +445,8 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
                 temperature: omitTemperature ? undefined : temperature,
                 timeoutMs: timeout,
                 onChunk: stream ? onChunk : undefined,
+                // Carries the user's Stop as well as this request's own timeout.
+                signal: controller.signal,
             });
             if (result.promptTokens != null && result.completionTokens != null) {
                 recordTokenUsage({ promptTokens: result.promptTokens, completionTokens: result.completionTokens, totalTokens: result.promptTokens + result.completionTokens }, model, providerId);

package/dist/api/ollamaNative.d.ts

@@ -94,6 +94,9 @@ export interface OllamaChatOptions {
     keepAlive?: string;
     temperature?: number;
     timeoutMs?: number;
+    /** Stops the request when it fires (Stop / cancel). The promise then
+     *  rejects with an error named 'AbortError', as fetch does. */
+    signal?: AbortSignal;
     onChunk?: (text: string) => void;
     /** Tool definitions in OpenAI function format. Ollama's /api/chat accepts the
      *  same `{type:'function',function:{...}}` shape and returns `tool_calls`. */

package/dist/api/ollamaNative.js

@@ -179,10 +179,40 @@ export function streamOllamaNativeChat(opts) {
         ...(Object.keys(options).length ? { options } : {}),
         ...(opts.keepAlive ? { keep_alive: opts.keepAlive } : {}),
     });
-    return new Promise((resolve, reject) => {
+    return new Promise((resolveChat, rejectChat) => {
+        const signal = opts.signal;
+        // Settles once: a request destroyed on abort goes on to emit errors of
+        // its own, which must not replace the abort.
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return false;
+            settled = true;
+            signal?.removeEventListener('abort', onAbort);
+            return true;
+        };
+        const resolve = (result) => { if (settle())
+            resolveChat(result); };
+        const reject = (error) => { if (settle())
+            rejectChat(error); };
+        const abortError = () => {
+            const error = new Error('The operation was aborted');
+            error.name = 'AbortError';
+            return error;
+        };
+        const onAbort = () => {
+            reject(abortError());
+            req?.destroy();
+        };
+        let req;
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
         const u = new URL(url);
         const lib = u.protocol === 'https:' ? https : http;
-        const req = lib.request({
+        req = lib.request({
             hostname: u.hostname,
             port: u.port,
             path: u.pathname + u.search,
@@ -200,6 +230,8 @@ export function streamOllamaNativeChat(opts) {
             let acc = initialOllamaAccumulator();
             const decoder = new TextDecoder();
             res.on('data', (chunk) => {
+                if (settled)
+                    return; // stopped: nothing more reaches the caller
                 buffer += decoder.decode(chunk, { stream: true });
                 const { lines, rest } = splitOllamaLines(buffer);
                 buffer = rest;
@@ -221,7 +253,7 @@ export function streamOllamaNativeChat(opts) {
             res.on('error', reject);
         });
         req.on('error', reject);
-        req.on('timeout', () => { req.destroy(new Error('Ollama request timed out')); });
+        req.on('timeout', () => { req?.destroy(new Error('Ollama request timed out')); });
         req.write(body);
         req.end();
     });