chainlesschain 0.162.197 → 0.162.200

package/src/lib/abort-utils.js

@@ -18,3 +18,71 @@ export function throwIfAborted(signal, message = "Agent loop interrupted") {
     throw signal.reason || createAbortError(message);
   }
 }
+
+/**
+ * Await a value while making a host AbortSignal authoritative over settlement.
+ * The source promise is always observed after cancellation, so a late rejection
+ * cannot become unhandled and a late success cannot revive the cancelled path.
+ */
+export function raceWithAbort(
+  value,
+  signal,
+  message = "Agent loop interrupted",
+) {
+  if (!signal) return Promise.resolve(value);
+  try {
+    throwIfAborted(signal, message);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (typeof signal.addEventListener !== "function") {
+    return Promise.resolve(value);
+  }
+
+  const source = Promise.resolve(value);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      try {
+        signal.removeEventListener?.("abort", onAbort);
+      } catch {
+        // Listener cleanup cannot change the already-authoritative settlement.
+      }
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(signal.reason || createAbortError(message));
+    };
+    try {
+      signal.addEventListener("abort", onAbort, { once: true });
+    } catch (error) {
+      settled = true;
+      // Observe a later source rejection even though the signal contract was
+      // malformed and this wrapper must fail immediately.
+      source.catch(() => {});
+      reject(error);
+      return;
+    }
+    source.then(
+      (result) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(result);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      },
+    );
+    // AbortSignal does not replay an event that fired immediately before the
+    // listener was attached. Re-check after both observers are installed so
+    // that narrow registration race still settles as cancellation, while the
+    // source remains observed if it finishes later.
+    if (signal.aborted) onAbort();
+  });
+}

package/src/lib/agent-core.js

@@ -1,60 +1,2 @@
 /** @deprecated Thin re-export shim; canonical impl is `../runtime/agent-core.js` (CLI Runtime Convergence, Phase 6b) — import from there in new code. */
-export {
-  AGENT_TOOLS,
-  AGENT_TOOL_REGISTRY,
-  MAX_SUB_AGENT_DEPTH,
-  MAX_SUB_AGENTS_PER_RUN,
-  MAX_TOOL_RESULT_CHARS,
-  capToolResultString,
-  safeStringifyToolResult,
-  tokenizeShellWords,
-  reloadSkills,
-  getAgentToolDefinitions,
-  getAgentToolDescriptors,
-  getCachedPython,
-  _resetCachedPythonForTests,
-  getEnvironmentInfo,
-  _environmentProcessDeps,
-  _agentToolProcessDeps,
-  getBaseSystemPrompt,
-  buildSystemPrompt,
-  executeTool,
-  computeProposedEdit,
-  editNotebookCell,
-  renderNotebook,
-  classifyError,
-  isValidPackageName,
-  chatWithTools,
-  agentLoop,
-  formatToolArgs,
-  getActiveMcpServers,
-  listBackgroundShellTasks,
-  killBackgroundShellTask,
-  killAllBackgroundShellTasks,
-  killAllBackgroundShellTasksSync,
-  _backgroundProcessDeps,
-  _runBackgroundTaskkill,
-  _gitProcessDeps,
-  reapIdleBackgroundShellTasks,
-  _ingestSearchOutput,
-  writeFileVerified,
-  formatProviderHttpError,
-  _accumulateOllamaStream,
-  _accumulateOpenAIStream,
-  _accumulateAnthropicStream,
-  _streamErrorDisposition,
-  _isRetryableStreamError,
-  _retryStreamingChat,
-  _iterateStreamWithStall,
-  _toAnthropicMessages,
-  _anthropicThinkingParams,
-  _normalizeAnthropicResponse,
-  _resetFileFreshness,
-  _withPostEditDiagnostics,
-  _getSharedCodeIntel,
-  disposeSharedCodeIntel,
-  emitToolHookLifecycle,
-  emitToolBatchHookLifecycle,
-  buildSubAgentHandoffContext,
-  _resetSubtreeInstructionLoaders,
-} from "../runtime/agent-core.js";
+export * from "../runtime/agent-core.js";

package/src/lib/background-interaction-journal.js

@@ -9,7 +9,7 @@
 
 import { createHash } from "node:crypto";
 import {
-  appendEvent as storeAppendEvent,
+  appendAuthorityEvent as storeAppendAuthorityEvent,
   readEvents as storeReadEvents,
   findLatestEvent as storeFindLatestEvent,
 } from "../harness/jsonl-session-store.js";
@@ -26,7 +26,7 @@ export const MAX_BACKGROUND_INTERACTION_RECORDS = 256;
 const TERMINAL_STATUSES = new Set(["resolved", "rejected", "cancelled"]);
 
 export const _deps = {
-  appendEvent: storeAppendEvent,
+  appendEvent: storeAppendAuthorityEvent,
   readEvents: storeReadEvents,
   findLatestEvent: storeFindLatestEvent,
 };

package/src/lib/chat-core.js

@@ -90,6 +90,21 @@ function _cachedPromptTokens(usage) {
   return 0;
 }
 
+async function _deliverToken(onToken, token, guard) {
+  if (typeof onToken !== "function") return;
+  // Terminal backpressure is not provider silence. Suspend the network stall
+  // timer while the UI sink drains, then re-arm it before reading more bytes.
+  guard.stop();
+  try {
+    await onToken(token);
+  } catch (error) {
+    if (error?.isOutputBackpressureFailure === true) throw error;
+    // Generic UI callbacks retain their historical best-effort semantics.
+  } finally {
+    guard.bump();
+  }
+}
+
 /**
  * Stream a response from Ollama.
  * If `onUsage` is provided, it's called with `{inputTokens, outputTokens}`
@@ -156,7 +171,7 @@ export async function streamOllama(
           const json = JSON.parse(line);
           if (json.message?.content) {
             fullResponse += json.message.content;
-            onToken(json.message.content);
+            await _deliverToken(onToken, json.message.content, guard);
           }
           if (json.done && onUsage) {
             const inputTokens = Number(json.prompt_eval_count) || 0;
@@ -165,7 +180,8 @@ export async function streamOllama(
               onUsage({ inputTokens, outputTokens });
             }
           }
-        } catch {
+        } catch (error) {
+          if (error?.isOutputBackpressureFailure === true) throw error;
           // Partial JSON, skip
         }
       }
@@ -257,7 +273,7 @@ export async function streamOpenAI(
             const content = json.choices?.[0]?.delta?.content;
             if (content) {
               fullResponse += content;
-              onToken(content);
+              await _deliverToken(onToken, content, guard);
             }
             if (json.usage && onUsage) {
               // Split cached prompt tokens out of prompt_tokens so cc cost
@@ -270,7 +286,8 @@ export async function streamOpenAI(
                 onUsage({ inputTokens, outputTokens, cacheReadTokens });
               }
             }
-          } catch {
+          } catch (error) {
+            if (error?.isOutputBackpressureFailure === true) throw error;
             // Partial data
           }
         }
@@ -377,7 +394,7 @@ export async function streamAnthropic(
             const delta = obj.delta?.text;
             if (delta) {
               fullResponse += delta;
-              onToken(delta);
+              await _deliverToken(onToken, delta, guard);
             }
           } else if (obj.type === "message_start") {
             const u = obj.message?.usage || {};
@@ -390,7 +407,8 @@ export async function streamAnthropic(
           } else if (obj.type === "message_delta") {
             outputTokens = Number(obj.usage?.output_tokens) || outputTokens;
           }
-        } catch {
+        } catch (error) {
+          if (error?.isOutputBackpressureFailure === true) throw error;
           /* skip malformed */
         }
       }