chainlesschain 0.166.132 → 0.166.135

package/src/runtime/agent-core.js

@@ -10,7 +10,10 @@ import {
   normalizeProviderBaseUrl,
   openAICompatibleBaseUrl,
 } from "../lib/provider-protocol.js";
-import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import {
+  BUILT_IN_PROVIDERS,
+  resolveProviderDefinition,
+} from "../lib/llm-providers.js";
 import { resolveLlmConnection } from "../lib/llm-connection-resolution.js";
 /**
  * Agent Core — transport-independent agentic logic
@@ -12122,11 +12125,65 @@ function getEffectiveToolDefinitions(options = {}) {
   });
 }
 
+function projectExactFileMutationToolSchemas(
+  definitions,
+  scope,
+  externalToolExecutors,
+) {
+  if (scope == null) return definitions;
+  return definitions.map((tool) => {
+    const name = tool?.function?.name;
+    if (
+      !["write_file", "edit_file", "edit_file_hashed"].includes(name) ||
+      !AGENT_TOOLS.includes(tool) ||
+      externalToolExecutors?.[name]
+    ) {
+      return tool;
+    }
+    const parameters = tool.function.parameters;
+    return {
+      ...tool,
+      function: {
+        ...tool.function,
+        parameters: {
+          ...parameters,
+          properties: {
+            ...parameters.properties,
+            path: {
+              ...parameters.properties.path,
+              // Complete host-authorized set: never truncate this enum or
+              // derive it from a read result. Normal tool context budgeting
+              // sees the same schema that is sent to the provider.
+              enum: [...scope.allowedPaths],
+              description:
+                "Use exactly one listed canonical repo-relative path. Read tools may return absolute paths; those are not valid mutation arguments in this run. Do not use an absolute path, ./ prefix, .. segment or backslash. This schema is guidance; all execution-time permission and file-identity checks still apply.",
+            },
+          },
+        },
+      },
+    };
+  });
+}
+
 function getProviderToolDefinitions(options = {}) {
-  return projectMcpToolDefinitions(
+  const definitions = projectMcpToolDefinitions(
     getEffectiveToolDefinitions(options),
     options.externalToolExecutors,
   );
+  if (options.fileMutationScope == null) return definitions;
+  if (options.exactToolNames !== true || options.hermeticExecution !== true) {
+    throw new Error(
+      "exact file mutation scope requires exactToolNames=true and hermeticExecution=true",
+    );
+  }
+  const scope = normalizeExactFileMutationScope(options.fileMutationScope, {
+    cwd: options.cwd || process.cwd(),
+  });
+  return projectExactFileMutationToolSchemas(
+    definitions,
+    scope,
+    options.externalToolExecutors,
+  );
 }
 
 const PROVIDER_REQUEST_ID_RE = /^[\x21-\x7e]{1,512}$/;
@@ -12540,7 +12597,7 @@ export async function chatWithTools(rawMessages, options) {
   }
 
   // OpenAI-compatible providers
-  const providerDefinition = BUILT_IN_PROVIDERS[provider];
+  const providerDefinition = resolveProviderDefinition(provider);
   const url = openAICompatibleBaseUrl(provider, baseUrl);
 
   if (!providerDefinition || !url) {
@@ -12555,7 +12612,8 @@ export async function chatWithTools(rawMessages, options) {
 
   const envKey = providerDefinition.apiKeyEnv;
   const key = apiKey;
-  if (!key) throw new Error(`${envKey} required for provider ${provider}`);
+  if (!key && provider !== "custom")
+    throw new Error(`${envKey} required for provider ${provider}`);
   const effectiveModel = model || providerDefinition.models?.[0];
   const modelProfile = resolveModelCapabilityProfile({
     provider,
@@ -12613,34 +12671,69 @@ export async function chatWithTools(rawMessages, options) {
       );
     }
 
-    const response = await providerFetch(`${url}/responses`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${key}`,
-        ...(supportsOpenAIRequestIdentity && providerRequestId
-          ? { "X-Client-Request-Id": providerRequestId }
+    // A JSON-body disconnect has produced no accepted output or executable
+    // tools. Apply the same bounded transport retry and usage settlement used
+    // by streaming; HTTP/provider verdicts and governed workflow calls retain
+    // their existing no-replay rules.
+    return await _retryStreamingChat(
+      (attempt = 0) =>
+        _withResponsesRequestDeadline(
+          async (requestSignal) => {
+            const requestId = supportsOpenAIRequestIdentity
+              ? _physicalProviderRequestId(providerRequestId, attempt)
+              : null;
+            const response = await providerFetch(`${url}/responses`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${key}`,
+                ...(requestId ? { "X-Client-Request-Id": requestId } : {}),
+              },
+              signal: requestSignal,
+              body: JSON.stringify(responseBody),
+            });
+            if (!response.ok) {
+              throw await createProviderResponseError(provider, response);
+            }
+            const retryMetadata = captureStreamRetryMetadata(response);
+            try {
+              const data = await response.json();
+              const out = normalizeOpenAIResponsesResponse(data);
+              if (out.usage)
+                out.usage = preserveRequestedServiceTierEvidence(
+                  out.usage,
+                  options.serviceTier,
+                );
+              delete out.responseId;
+              const providerReceipt = supportsOpenAIRequestIdentity
+                ? _openAIProviderRequestReceipt(response, data, requestId)
+                : null;
+              if (providerReceipt) out.providerReceipt = providerReceipt;
+              return out;
+            } catch (error) {
+              attachStreamRetryMetadata(error, retryMetadata);
+              throw error;
+            }
+          },
+          signal,
+          options.streamStallTimeoutMs,
+        ),
+      {
+        signal,
+        retries: options.workflowEffectId ? 0 : undefined,
+        strictRetryObserver: options.strictUsageTelemetry === true,
+        ...(typeof options.onStreamRetry === "function"
+          ? {
+              onRetry: (attempt, error, telemetry) =>
+                options.onStreamRetry(attempt, error, {
+                  ...telemetry,
+                  provider,
+                  model: effectiveModel,
+                }),
+            }
           : {}),
       },
-      signal,
-      body: JSON.stringify(responseBody),
-    });
-    if (!response.ok) {
-      throw await createProviderResponseError(provider, response);
-    }
-    const data = await response.json();
-    const out = normalizeOpenAIResponsesResponse(data);
-    if (out.usage)
-      out.usage = preserveRequestedServiceTierEvidence(
-        out.usage,
-        options.serviceTier,
-      );
-    delete out.responseId;
-    const providerReceipt = supportsOpenAIRequestIdentity
-      ? _openAIProviderRequestReceipt(response, data, providerRequestId)
-      : null;
-    if (providerReceipt) out.providerReceipt = providerReceipt;
-    return out;
+    );
   }
 
   // Real token streaming (--include-partial-messages) for every OpenAI-compatible
@@ -12695,7 +12788,7 @@ export async function chatWithTools(rawMessages, options) {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${key}`,
+      ...(key ? { Authorization: `Bearer ${key}` } : {}),
       ...(supportsOpenAIRequestIdentity && providerRequestId
         ? { "X-Client-Request-Id": providerRequestId }
         : {}),
@@ -12989,6 +13082,36 @@ const STREAM_STALL_MS = 20000;
 const STREAM_STALL_TIMEOUT_MS = 180000;
 const _STREAM_STALL = Symbol("stream-stall");
 
+/** Bound the whole JSON attempt, including headers and a stalled body read. */
+async function _withResponsesRequestDeadline(
+  operation,
+  signal,
+  configuredTimeout,
+) {
+  const timeoutMs = configuredTimeout ?? STREAM_STALL_TIMEOUT_MS;
+  if (timeoutMs === 0) return operation(signal);
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2_147_483_647)
+    throw new RangeError("Invalid Responses request timeout");
+  const controller = new AbortController();
+  const requestSignal = signal
+    ? AbortSignal.any([signal, controller.signal])
+    : controller.signal;
+  const timer = setTimeout(() => {
+    const error = new Error(
+      "OpenAI Responses request timed out before its complete response was received",
+    );
+    error.code = "ETIMEDOUT";
+    controller.abort(error);
+  }, timeoutMs);
+  timer.unref?.();
+  try {
+    throwIfAborted(requestSignal);
+    return await raceWithAbort(operation(requestSignal), requestSignal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 /**
  * Run a streaming chat attempt with bounded auto-retry on transient API
  * connection drops (Claude-Code 2.1.181: "auto-retry for API connection drops
@@ -13118,7 +13241,9 @@ export async function* _iterateStreamWithStall(reader, opts = {}) {
       // socket) and throw a retryable error the dispatch seam re-issues.
       if (timeoutMs && elapsed >= timeoutMs) {
         try {
-          await reader.cancel();
+          // Cancellation itself can hang on a broken transport. Observe its
+          // rejection, but never let it postpone the authoritative timeout.
+          void Promise.resolve(reader.cancel()).catch(() => {});
         } catch {
           /* best-effort release — the throw below is what matters */
         }
@@ -13315,7 +13440,7 @@ async function _chatOpenAIStreaming(
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
       ...(providerRequestId
         ? { "X-Client-Request-Id": providerRequestId }
         : {}),
@@ -13416,7 +13541,7 @@ async function _chatOpenAIResponsesStreaming(
   const decoder = new TextDecoder();
   let buf = "";
   try {
-    for await (const value of _iterateStreamWithStall(reader, {
+    responses: for await (const value of _iterateStreamWithStall(reader, {
       onStall,
       stallMs,
       stallTimeoutMs,
@@ -13427,6 +13552,22 @@ async function _chatOpenAIResponsesStreaming(
       for (const line of lines) {
         reduceOpenAIResponsesStreamLine(state, line, ui.onToken, ui.onThinking);
         await ui.settle();
+        if (state.terminalError) throw state.terminalError;
+        if (state.normalized) {
+          // response.completed/incomplete is authoritative. Some gateways
+          // leave the HTTP stream alive after it; socket EOF is not required.
+          // Observe an already-queued transport error (especially cancellation)
+          // without waiting for a pending trailing read to finish.
+          await Promise.race([reader.read(), Promise.resolve()]);
+          throwIfAborted(signal);
+          try {
+            void Promise.resolve(reader.cancel()).catch(() => {});
+          } catch {
+            // The terminal response is already complete; cleanup is best effort.
+          }
+          buf = "";
+          break responses;
+        }
       }
     }
     if (buf.trim()) {
@@ -13468,6 +13609,12 @@ async function _chatOpenAIResponsesStreaming(
     );
     if (providerReceipt) out.providerReceipt = providerReceipt;
     return out;
+  } finally {
+    try {
+      reader.releaseLock?.();
+    } catch {
+      // A cancelled or still-settling reader can reject lock release.
+    }
   }
   const out = finalizeOpenAIResponsesStream(state);
   if (out.usage)
@@ -15018,6 +15165,7 @@ export async function* agentLoop(messages, options) {
   let effectiveToolOptions = hermeticExecution
     ? {
         ...options,
+        fileMutationScope,
         hostManagedToolPolicy: null,
         hostManagedToolPolicyAuthority: null,
         extraToolDefinitions: [],

package/src/runtime/headless-runner.js

@@ -467,15 +467,15 @@ export function resolveEnabledTools({ allowedTools, readOnly } = {}) {
   return names;
 }
 
-/** Normalize a comma/space separated CLI list into a string[] (or null). */
+/** An absent CLI list is unrestricted; an explicit empty list permits none. */
 export function parseToolList(value) {
-  if (!value) return null;
+  if (value === null || value === undefined) return null;
   if (Array.isArray(value)) return value.flatMap((v) => parseToolList(v) || []);
   const out = String(value)
     .split(/[,\s]+/)
     .map((s) => s.trim())
     .filter(Boolean);
-  return out.length > 0 ? out : null;
+  return out;
 }
 
 /**