chainlesschain 0.166.98 → 0.166.100

package/src/lib/usage-pricing-context.js

@@ -1,11 +1,52 @@
 import {
   DOCUMENTED_OPENAI_MODELS,
+  DOCUMENTED_ANTHROPIC_MODELS,
   GPT6_PRICING_TERMS,
 } from "./model-context-catalog.js";
 
+/** Keep TTL evidence distinct from the aggregate cache-write count. */
+export function projectCacheCreationUsage(usage = {}) {
+  if (usage.cacheCreationInvalid === true)
+    return { cacheCreationInvalid: true };
+  if (
+    Object.hasOwn(usage, "cache_creation_input_tokens") &&
+    Object.hasOwn(usage, "cacheCreationTokens") &&
+    usage.cache_creation_input_tokens !== usage.cacheCreationTokens
+  )
+    return { cacheCreationInvalid: true };
+  const nested = usage.cache_creation;
+  const hasFlat =
+    Object.hasOwn(usage, "cacheCreation5mTokens") ||
+    Object.hasOwn(usage, "cacheCreation1hTokens");
+  if (!Object.hasOwn(usage, "cache_creation") && !hasFlat) return {};
+  if (
+    Object.hasOwn(usage, "cache_creation") &&
+    (nested === null || typeof nested !== "object" || Array.isArray(nested))
+  )
+    return { cacheCreationInvalid: true };
+  const five = nested?.ephemeral_5m_input_tokens ?? usage.cacheCreation5mTokens;
+  const hour = nested?.ephemeral_1h_input_tokens ?? usage.cacheCreation1hTokens;
+  const total = usage.cache_creation_input_tokens ?? usage.cacheCreationTokens;
+  if (
+    ![five, hour, total].every(
+      (value) => Number.isSafeInteger(value) && value >= 0,
+    ) ||
+    five + hour !== total ||
+    (hasFlat &&
+      nested != null &&
+      (five !== usage.cacheCreation5mTokens ||
+        hour !== usage.cacheCreation1hTokens))
+  ) {
+    return { cacheCreationInvalid: true };
+  }
+  return { cacheCreation5mTokens: five, cacheCreation1hTokens: hour };
+}
+
 /** Only bounded, non-secret pricing labels may enter the durable usage ledger. */
 export function projectUsagePricingContext(usage = {}) {
-  const projected = {};
+  const projected = projectCacheCreationUsage(usage);
+  if (usage.pricingContextInvalid === true)
+    projected.pricingContextInvalid = true;
   for (const [key, alias] of [
     ["service_tier", "serviceTier"],
     ["regional_processing", "regionalProcessing"],
@@ -31,23 +72,56 @@ export function projectUsagePricingContext(usage = {}) {
       projected[key] = value;
     }
   }
+  if (Object.hasOwn(usage, "inference_geo")) {
+    const geo = usage.inference_geo;
+    if (geo !== "us" && geo !== "global") {
+      projected.inference_geo = "unknown";
+      projected.pricingContextInvalid = true;
+    } else {
+      if (
+        Object.hasOwn(projected, "regional_processing") &&
+        projected.regional_processing !== (geo === "us")
+      ) {
+        throw new TypeError(
+          "usage inference_geo conflicts with regional processing",
+        );
+      }
+      projected.inference_geo = geo;
+      projected.regional_processing = geo === "us";
+    }
+  }
   return projected;
 }
 
 /** Preserve per-request thresholds in a bounded set of aggregate price buckets. */
 export function mergeUsagePricingBucket(entry, usage) {
-  if (
-    String(entry.provider).toLowerCase() !== "openai" ||
-    !DOCUMENTED_OPENAI_MODELS[String(entry.model).toLowerCase()]?.pricing
-  )
-    return;
+  const provider = String(entry.provider).toLowerCase();
+  const model = String(entry.model).toLowerCase();
+  const terms =
+    provider === "openai" && DOCUMENTED_OPENAI_MODELS[model]?.pricing
+      ? GPT6_PRICING_TERMS
+      : provider === "anthropic"
+        ? DOCUMENTED_ANTHROPIC_MODELS[model]?.pricingTerms
+        : null;
+  if (!terms?.longContext) return;
   const metadata = projectUsagePricingContext(usage);
+  const pricingContextInvalid =
+    metadata.pricingContextInvalid === true ||
+    (provider === "anthropic" &&
+      model === "claude-haiku-5-5" &&
+      metadata.regional_processing == null);
   const promptTokens =
     usage.requestInputTokens ??
     usage.inputTokens +
       (usage.cacheReadTokens || 0) +
       (usage.cacheCreationTokens || 0);
-  const long = promptTokens > GPT6_PRICING_TERMS.longContext.threshold;
+  const long = promptTokens > terms.longContext.threshold;
+  const cache = projectCacheCreationUsage(usage);
+  const cacheEvidence = cache.cacheCreationInvalid
+    ? "invalid"
+    : cache.cacheCreation5mTokens != null
+      ? "split"
+      : "missing";
   const serviceTier = metadata.service_tier || "standard";
   const regionalProcessing = metadata.regional_processing === true;
   entry.pricingBuckets ||= [];
@@ -55,8 +129,9 @@ export function mergeUsagePricingBucket(entry, usage) {
     (item) =>
       item.serviceTier === serviceTier &&
       item.regionalProcessing === regionalProcessing &&
-      item.requestInputTokens > GPT6_PRICING_TERMS.longContext.threshold ===
-        long,
+      (item.pricingContextInvalid === true) === pricingContextInvalid &&
+      (item.cacheEvidence || "missing") === cacheEvidence &&
+      item.requestInputTokens > terms.longContext.threshold === long,
   );
   if (!bucket) {
     bucket = {
@@ -69,6 +144,18 @@ export function mergeUsagePricingBucket(entry, usage) {
       serviceTier,
       regionalProcessing,
       requestInputTokens: promptTokens,
+      ...(pricingContextInvalid ? { pricingContextInvalid: true } : {}),
+      ...(provider === "anthropic"
+        ? {
+            cacheEvidence,
+            ...(cacheEvidence === "split"
+              ? { cacheCreation5mTokens: 0, cacheCreation1hTokens: 0 }
+              : {}),
+            ...(cacheEvidence === "invalid"
+              ? { cacheCreationInvalid: true }
+              : {}),
+          }
+        : {}),
     };
     entry.pricingBuckets.push(bucket);
   }
@@ -79,8 +166,11 @@ export function mergeUsagePricingBucket(entry, usage) {
     "cacheCreationTokens",
     "totalTokens",
     "calls",
+    ...(cacheEvidence === "split"
+      ? ["cacheCreation5mTokens", "cacheCreation1hTokens"]
+      : []),
   ]) {
-    const value = usage[key] ?? (key === "calls" ? 1 : 0);
+    const value = cache[key] ?? usage[key] ?? (key === "calls" ? 1 : 0);
     if (
       !Number.isSafeInteger(value) ||
       value < 0 ||

package/src/runtime/agent-core.js

@@ -15,6 +15,7 @@
  */
 
 import fs from "fs";
+import { isUtf8 } from "node:buffer";
 import {
   _isNonNegativeSafeInteger,
   _providerUsageCount,
@@ -59,6 +60,8 @@ import {
   TASK_RECOVERY_TOOLS,
 } from "../lib/task-progress-tracker.js";
 import { TOOL_RECOVERY_PAUSED_CODE } from "../lib/tool-recovery-result.js";
+import { haiku55ThinkingParams } from "../lib/provider-options.js";
+import { projectUsagePricingContext } from "../lib/usage-pricing-context.js";
 import broker from "../lib/process-execution-broker/index.js";
 import os from "os";
 import { createHash, randomUUID } from "node:crypto";
@@ -153,6 +156,10 @@ import {
   isRetryableStreamError,
   STREAM_RETRY_BASE_MS,
   resolveStreamRetryMax,
+  captureStreamRetryMetadata,
+  attachStreamRetryMetadata,
+  resolveStreamRetryDelay,
+  waitForStreamRetry,
 } from "../lib/stream-retry.js";
 import {
   annotateLines,
@@ -181,7 +188,7 @@ import {
 } from "../lib/unattended-action-policy.js";
 import {
   formatProviderHttpError,
-  formatProviderResponseError,
+  createProviderResponseError,
 } from "../lib/provider-http-error.js";
 import { buildPermissionDecision } from "../lib/permission-decision.js";
 import { resolveSandboxPolicyPath } from "../lib/agent-sandbox.js";
@@ -2024,6 +2031,20 @@ function applyLiteralEdit(content, oldStr, newStr, replaceAll) {
   return { count, newContent };
 }
 
+// Edits derive their output from the entire existing file. A replacement
+// decoder would silently rewrite unrelated legacy or malformed bytes.
+function readUtf8ForEdit(filePath) {
+  const bytes = fs.readFileSync(filePath);
+  if (!isUtf8(bytes)) {
+    return {
+      error: "File is not valid UTF-8; text edits require valid UTF-8 bytes.",
+      code: "CC_EDIT_INVALID_UTF8",
+    };
+  }
+  // Buffer decoding preserves a valid UTF-8 BOM and literal U+FFFD characters.
+  return { content: bytes.toString("utf8") };
+}
+
 /**
  * Compute the content an edit tool WOULD write, without writing it — the
  * left/right sides for an IDE diff review. Mirrors the corresponding
@@ -2085,7 +2106,9 @@ export function computeProposedEdit(name, args = {}, cwd = process.cwd()) {
     }
     if (name === "edit_file") {
       if (!fs.existsSync(filePath)) return null;
-      const content = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return null;
+      const content = decoded.content;
       if (
         typeof args.old_string !== "string" ||
         args.old_string === "" ||
@@ -2113,7 +2136,9 @@ export function computeProposedEdit(name, args = {}, cwd = process.cwd()) {
     if (name === "edit_file_hashed") {
       if (!fs.existsSync(filePath)) return null;
       if (!args.anchor_hash || typeof args.new_line !== "string") return null;
-      const original = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return null;
+      const original = decoded.content;
       const result = replaceByHash(original, {
         anchorHash: args.anchor_hash,
         expectedLine: args.expected_line,
@@ -5835,7 +5860,9 @@ async function executeToolInner(
       if (!fs.existsSync(filePath)) {
         return attachDescriptor({ error: `Notebook not found: ${filePath}` });
       }
-      const original = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return attachDescriptor(decoded);
+      const original = decoded.content;
       const res = editNotebookCell(original, args);
       if (res.error) return attachDescriptor({ error: res.error });
       const wrote = writeFileVerified(filePath, res.text);
@@ -5871,7 +5898,9 @@ async function executeToolInner(
       }
       const staleEdit = _checkFileFreshness(filePath);
       if (staleEdit) return attachDescriptor({ error: staleEdit });
-      const content = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return attachDescriptor(decoded);
+      const content = decoded.content;
       const replaceAll = args.replace_all === true;
       const { count, newContent } = applyLiteralEdit(
         content,
@@ -5971,7 +6000,9 @@ async function executeToolInner(
       }
       const staleHashed = _checkFileFreshness(filePath);
       if (staleHashed) return attachDescriptor({ error: staleHashed });
-      const original = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return attachDescriptor(decoded);
+      const original = decoded.content;
       const result = replaceByHash(original, {
         anchorHash: args.anchor_hash,
         expectedLine: args.expected_line,
@@ -11893,7 +11924,7 @@ export async function chatWithTools(rawMessages, options) {
       }),
     });
     if (!response.ok) {
-      throw new Error(await formatProviderResponseError("ollama", response));
+      throw await createProviderResponseError("ollama", response);
     }
     const data = await response.json();
     if (
@@ -11962,10 +11993,16 @@ export async function chatWithTools(rawMessages, options) {
       messages: _toAnthropicMessages(otherMsgs),
       tools: anthropicTools,
     };
-    // Extended thinking — OPT-IN via options.thinking; off by default so the
-    // request is byte-identical to before. Model-aware (adaptive+effort on Opus
-    // 4.6+/Sonnet 4.6, legacy enabled+budget else; nothing on Haiku). temperature
-    // is never sent. RUNTIME-UNVERIFIED: no Anthropic key here to E2E the
+    if (
+      effModel.toLowerCase() === "claude-haiku-5-5" &&
+      body.messages.at(-1)?.role === "assistant"
+    ) {
+      throw new TypeError("Haiku 5.5 does not support assistant prefill.");
+    }
+    // Legacy models retain opt-in thinking. Exact Haiku 5.5 uses its documented
+    // adaptive/medium default and accepts an explicit disabled setting.
+    // Sampling parameters are never sent. RUNTIME-UNVERIFIED: no Anthropic key
+    // here to E2E the
     // thinking-block signature replay (see cli_claude_code_parity_landed memory).
     const thinkingParams = _anthropicThinkingParams(
       effModel,
@@ -12040,12 +12077,17 @@ export async function chatWithTools(rawMessages, options) {
     });
 
     if (!response.ok) {
-      throw new Error(await formatProviderResponseError("anthropic", response));
+      throw await createProviderResponseError("anthropic", response);
     }
 
     const data = await response.json();
     const normalized = _normalizeAnthropicResponse(data);
     if (_hasCompleteProviderUsage(data.usage)) {
+      const cacheCreationTokens = _optionalProviderUsageCount(
+        data.usage,
+        "cache_creation_input_tokens",
+        "cache_creation_tokens",
+      );
       normalized.usage = {
         // With prompt caching, Anthropic splits input into uncached
         // `input_tokens` + cache read/write — capture all three so cost
@@ -12066,11 +12108,11 @@ export async function chatWithTools(rawMessages, options) {
           "cache_read_input_tokens",
           "cache_read_tokens",
         ),
-        cache_creation_input_tokens: _optionalProviderUsageCount(
-          data.usage,
-          "cache_creation_input_tokens",
-          "cache_creation_tokens",
-        ),
+        cache_creation_input_tokens: cacheCreationTokens,
+        ...projectUsagePricingContext({
+          ...data.usage,
+          cache_creation_input_tokens: cacheCreationTokens,
+        }),
       };
     }
     return normalized;
@@ -12191,7 +12233,7 @@ export async function chatWithTools(rawMessages, options) {
       body: JSON.stringify(responseBody),
     });
     if (!response.ok) {
-      throw new Error(await formatProviderResponseError(provider, response));
+      throw await createProviderResponseError(provider, response);
     }
     const data = await response.json();
     const out = normalizeOpenAIResponsesResponse(data);
@@ -12272,7 +12314,7 @@ export async function chatWithTools(rawMessages, options) {
   });
 
   if (!response.ok) {
-    throw new Error(await formatProviderResponseError(provider, response));
+    throw await createProviderResponseError(provider, response);
   }
 
   const data = await response.json();
@@ -12359,9 +12401,11 @@ function _ollamaInitState() {
 
 function _streamUiCallbacks(onToken, onThinking) {
   let pending = [];
+  let visible = false;
   const capture = (callback) =>
     typeof callback === "function"
       ? (value) => {
+          if (typeof value === "string" && value.length > 0) visible = true;
           try {
             const result = callback(value);
             if (result && typeof result.then === "function") {
@@ -12375,6 +12419,7 @@ function _streamUiCallbacks(onToken, onThinking) {
   return {
     onToken: capture(onToken),
     onThinking: capture(onThinking),
+    hasVisibleOutput: () => visible,
     async settle() {
       if (pending.length === 0) return;
       const current = pending;
@@ -12478,11 +12523,17 @@ export function _accumulateOllamaStream(lines, onToken) {
  * Parity with Claude-Code 2.1.179 ("preserving partial responses instead of
  * showing raw errors"). Pure + exported for unit tests.
  */
-export function _streamErrorDisposition(err, signal, partialText) {
+export function _streamErrorDisposition(
+  err,
+  signal,
+  partialText,
+  visible = false,
+) {
   if (err?.isOutputBackpressureFailure === true) return "rethrow";
   if (isAbortError(err)) return "rethrow";
   if (signal && signal.aborted) return "rethrow";
-  if (typeof partialText === "string" && partialText.trim()) return "preserve";
+  if (visible || (typeof partialText === "string" && partialText.length > 0))
+    return "preserve";
   return "rethrow";
 }
 
@@ -12547,16 +12598,22 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
   const retries = opts.retries ?? resolveStreamRetryMax();
   const base = opts.baseDelayMs ?? STREAM_RETRY_BASE_MS;
   const signal = opts.signal;
-  const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = typeof opts.now === "function" ? opts.now : Date.now;
   let attempt = 0;
   for (;;) {
+    throwIfAborted(signal);
     const attemptStartedAt = now();
     try {
       return await streamFn(attempt);
     } catch (err) {
       if (attempt >= retries || !_isRetryableStreamError(err, signal))
         throw err;
+      const attemptEndedAt = now();
+      const delayMs = resolveStreamRetryDelay(err, attempt + 1, {
+        baseDelayMs: base,
+        now: attemptEndedAt,
+      });
+      if (delayMs === null) throw err;
       attempt++;
       if (
         opts.strictRetryObserver === true &&
@@ -12571,7 +12628,7 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
       if (typeof opts.onRetry === "function") {
         try {
           const observation = opts.onRetry(attempt, err, {
-            durationMs: Math.max(0, now() - attemptStartedAt),
+            durationMs: Math.max(0, attemptEndedAt - attemptStartedAt),
           });
           if (observation && typeof observation.then === "function") {
             void Promise.resolve(observation).catch(() => {});
@@ -12600,8 +12657,7 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
           }
         }
       }
-      await sleep(base * Math.pow(2, attempt - 1));
-      if (signal && signal.aborted) throw err; // user bailed during backoff
+      await waitForStreamRetry(delayMs, signal, { sleep: opts.sleep });
     }
   }
 }
@@ -12724,8 +12780,9 @@ async function _chatOllamaStreaming(
     body: JSON.stringify({ ...body, stream: true }),
   });
   if (!response.ok) {
-    throw new Error(await formatProviderResponseError("ollama", response));
+    throw await createProviderResponseError("ollama", response);
   }
+  const retryMetadata = captureStreamRetryMetadata(response);
   const state = _ollamaInitState();
   const ui = _streamUiCallbacks(onToken);
   const reader = response.body.getReader();
@@ -12750,7 +12807,17 @@ async function _chatOllamaStreaming(
       await ui.settle();
     }
   } catch (err) {
-    if (_streamErrorDisposition(err, signal, state.content) === "rethrow")
+    attachStreamRetryMetadata(err, retryMetadata);
+    if (!ui.hasVisibleOutput() && !state.content && state.toolCalls?.length)
+      err.noReplay = true;
+    if (
+      _streamErrorDisposition(
+        err,
+        signal,
+        state.content,
+        ui.hasVisibleOutput(),
+      ) === "rethrow"
+    )
       throw err;
     return _finalizeTruncatedStream(_ollamaFinalize, state);
   }
@@ -12775,8 +12842,9 @@ async function _chatAnthropicStreaming(
     body: JSON.stringify(body),
   });
   if (!response.ok) {
-    throw new Error(await formatProviderResponseError("anthropic", response));
+    throw await createProviderResponseError("anthropic", response);
   }
+  const retryMetadata = captureStreamRetryMetadata(response);
   const state = _anthropicInitState();
   const ui = _streamUiCallbacks(onToken, onThinking);
   const reader = response.body.getReader();
@@ -12801,7 +12869,21 @@ async function _chatAnthropicStreaming(
       await ui.settle();
     }
   } catch (err) {
-    if (_streamErrorDisposition(err, signal, state.text) === "rethrow")
+    attachStreamRetryMetadata(err, retryMetadata);
+    if (
+      !ui.hasVisibleOutput() &&
+      !state.text &&
+      Object.values(state.blocks).some((block) => block.type === "tool_use")
+    )
+      err.noReplay = true;
+    if (
+      _streamErrorDisposition(
+        err,
+        signal,
+        state.text,
+        ui.hasVisibleOutput(),
+      ) === "rethrow"
+    )
       throw err;
     return _finalizeTruncatedStream(_anthropicFinalize, state);
   }
@@ -12833,8 +12915,9 @@ async function _chatOpenAIStreaming(
     body: JSON.stringify(body),
   });
   if (!response.ok) {
-    throw new Error(await formatProviderResponseError(provider, response));
+    throw await createProviderResponseError(provider, response);
   }
+  const retryMetadata = captureStreamRetryMetadata(response);
   const state = _openaiInitState();
   const ui = _streamUiCallbacks(onToken);
   const reader = response.body.getReader();
@@ -12859,7 +12942,17 @@ async function _chatOpenAIStreaming(
       await ui.settle();
     }
   } catch (err) {
-    if (_streamErrorDisposition(err, signal, state.text) === "rethrow")
+    attachStreamRetryMetadata(err, retryMetadata);
+    if (!ui.hasVisibleOutput() && !state.text && state.tools.length)
+      err.noReplay = true;
+    if (
+      _streamErrorDisposition(
+        err,
+        signal,
+        state.text,
+        ui.hasVisibleOutput(),
+      ) === "rethrow"
+    )
       throw err;
     const out = _finalizeTruncatedStream(_openaiFinalize, state);
     const providerReceipt = _openAIProviderRequestReceipt(
@@ -12905,8 +12998,9 @@ async function _chatOpenAIResponsesStreaming(
     body: JSON.stringify(body),
   });
   if (!response.ok) {
-    throw new Error(await formatProviderResponseError("openai", response));
+    throw await createProviderResponseError("openai", response);
   }
+  const retryMetadata = captureStreamRetryMetadata(response);
   const state = createOpenAIResponsesStreamState();
   const ui = _streamUiCallbacks(onToken, onThinking);
   const reader = response.body.getReader();
@@ -12931,10 +13025,31 @@ async function _chatOpenAIResponsesStreaming(
       await ui.settle();
     }
   } catch (error) {
-    if (_streamErrorDisposition(error, signal, state.text) === "rethrow") {
+    if (state.terminalError) throw state.terminalError;
+    attachStreamRetryMetadata(error, retryMetadata);
+    if (
+      !ui.hasVisibleOutput() &&
+      !state.text &&
+      state.outputItems.some((item) => item?.type === "function_call")
+    )
+      error.noReplay = true;
+    if (
+      !state.normalized &&
+      _streamErrorDisposition(
+        error,
+        signal,
+        state.text,
+        ui.hasVisibleOutput(),
+      ) === "rethrow"
+    ) {
       throw error;
     }
-    const out = _finalizeTruncatedStream(finalizeOpenAIResponsesStream, state);
+    throwIfAborted(signal);
+    if (isAbortError(error) || error?.isOutputBackpressureFailure === true)
+      throw error;
+    const out = state.normalized
+      ? finalizeOpenAIResponsesStream(state)
+      : _finalizeTruncatedStream(finalizeOpenAIResponsesStream, state);
     const responseId = out.responseId || state.responseId;
     delete out.responseId;
     const providerReceipt = _openAIProviderRequestReceipt(
@@ -13067,11 +13182,12 @@ export function _openAIResponsesReasoningParams(
 
 /**
  * Decide the Anthropic `thinking` request params for a model. Returns null
- * (off) unless the caller opts in via options.thinking (true | "think" |
- * "hard" | "ultra"). Model-aware per the Claude API:
+ * (off) on legacy models unless the caller opts in via options.thinking
+ * (true | "think" | "hard" | "ultra"). Model-aware per the Claude API:
+ *   - exact Haiku 5.5 → adaptive/medium by default, explicitly disableable
  *   - Opus 4.6/4.7/4.8, Sonnet 4.6 → adaptive thinking + output_config.effort
  *   - Sonnet 4.5 / Opus 4.0-4.5 / older → legacy enabled+budget (< max_tokens)
- *   - anything else (e.g. Haiku) → null (no thinking)
+ *   - other models, including older Haiku → null (no explicit thinking)
  * temperature is never added (it 400s on Opus 4.7/4.8). Note: `xhigh`/`max`
  * effort are Opus-tier — on Sonnet they may error; left to the caller's intent.
  * RUNTIME-UNVERIFIED — no Anthropic key to validate the wire shape live.
@@ -13082,9 +13198,10 @@ export function _anthropicThinkingParams(
   options = {},
   maxTokens = 8192,
 ) {
+  const m = String(model || "").toLowerCase();
+  if (m === "claude-haiku-5-5") return haiku55ThinkingParams(m, options);
   const want = options?.thinking;
   if (!want) return null; // off by default → request unchanged
-  const m = String(model || "").toLowerCase();
   const adaptive = /opus-4-(6|7|8)/.test(m) || /sonnet-4-6/.test(m);
   const legacy =
     /sonnet-4-5/.test(m) ||
@@ -16320,12 +16437,27 @@ export async function* agentLoop(messages, options) {
           toolName,
           earlyAuthorityDenial,
         );
+        const preExecutionDenied =
+          earlyAuthorityDenial.code === TOOL_RECOVERY_PAUSED_CODE;
+        if (preExecutionDenied) {
+          // Declare the rejected request without an execution/ledger boundary
+          // or its arguments. Consumers can pair the refusal by provider ID.
+          yield {
+            type: "tool-pre-execution-denied",
+            tool: toolName,
+            tool_use_id: call.id,
+            turn_id: `${runId}:t${budget.consumed}`,
+            preExecutionDenied: true,
+            execution_started: false,
+          };
+        }
         yield {
           type: "tool-result",
           tool: toolName,
           result: earlyAuthorityDenial,
           error: earlyAuthorityDenial.error,
           execution_started: false,
+          ...(preExecutionDenied ? { preExecutionDenied: true } : {}),
           tool_use_id: call.id,
           turn_id: `${runId}:t${budget.consumed}`,
           permission_decision_id: decision?.id || null,

package/src/runtime/headless-runner.js

@@ -3231,6 +3231,19 @@ async function runAgentHeadlessInWorkspace(
             });
             break;
           }
+          case "tool-pre-execution-denied": {
+            // A request declaration is not an invocation: do not start a
+            // side effect, telemetry call, or persisted compact tool record.
+            emitStream({
+              type: "tool_use",
+              id: event.tool_use_id,
+              tool: event.tool,
+              args: {},
+              preExecutionDenied: true,
+              execution_started: false,
+            });
+            break;
+          }
           case "tool-executing": {
             const telemetryToolId = runtimeToolCallId(event.tool_use_id);
             const line = `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}`;
@@ -3352,6 +3365,10 @@ async function runAgentHeadlessInWorkspace(
               ...(event.execution_started === false
                 ? { execution_started: false }
                 : {}),
+              ...(event.preExecutionDenied === true &&
+              event.execution_started === false
+                ? { preExecutionDenied: true }
+                : {}),
               error: err,
               result: event.result,
               ...(event.permission_decision_id

package/src/runtime/headless-stream.js

@@ -990,6 +990,19 @@ async function runTurn(
     }
     turnBindingFeed?.handleEvent(event);
     switch (event.type) {
+      case "tool-pre-execution-denied": {
+        // Keep the request/result pair visible without plan/ledger execution
+        // bookkeeping and without exposing rejected request arguments.
+        emit({
+          type: "tool_use",
+          id: event.tool_use_id,
+          tool: event.tool,
+          args: {},
+          preExecutionDenied: true,
+          execution_started: false,
+        });
+        break;
+      }
       case "tool-executing": {
         // Additive protocol-v1 correlation id ("tu-<n>", session-scoped —
         // agent-sdk docs/PROTOCOL.md §1.2.1): the matching tool_result below
@@ -1129,6 +1142,10 @@ async function runTurn(
           ...(event.execution_started === false
             ? { execution_started: false }
             : {}),
+          ...(event.preExecutionDenied === true &&
+          event.execution_started === false
+            ? { preExecutionDenied: true }
+            : {}),
           error: err,
           result: event.result,
           ...(event.permission_decision_id