chainlesschain 0.166.98 → 0.166.100

package/src/lib/llm-pricing.js

@@ -216,13 +216,18 @@ export function normalizePricingTerms(value) {
   const allowed = new Set([
     "cacheReadMultiplier",
     "cacheWriteMultiplier",
+    "cacheWrite1hMultiplier",
     "longContext",
     "serviceMultipliers",
   ]);
   if (!object(value) || Reflect.ownKeys(value).some((key) => !allowed.has(key)))
     fail();
   const result = {};
-  for (const key of ["cacheReadMultiplier", "cacheWriteMultiplier"]) {
+  for (const key of [
+    "cacheReadMultiplier",
+    "cacheWriteMultiplier",
+    "cacheWrite1hMultiplier",
+  ]) {
     if (!Object.hasOwn(value, key)) continue;
     if (!finite(value[key])) fail();
     result[key] = value[key];
@@ -289,8 +294,15 @@ export function lookupRate(provider, model, table = PRICE_TABLE) {
       // An unrecognized new generation must not inherit an older family price.
       // Explicit operator overrides remain authoritative.
       if (
-        ["opus", "sonnet"].includes(e.match) &&
-        Number(/^claude-(?:opus|sonnet)-(\d+)(?:[.-]|$)/u.exec(m)?.[1]) >= 5 &&
+        e.match === "haiku" &&
+        /(?:^|[.:/])(?:claude-)?haiku-(?:[5-9]|\d{2,})(?:[.-]|$)/u.test(m) &&
+        !e.explicitOverride
+      )
+        continue;
+      if (
+        ["opus", "sonnet", "haiku"].includes(e.match) &&
+        Number(/^claude-(?:opus|sonnet|haiku)-(\d+)(?:[.-]|$)/u.exec(m)?.[1]) >=
+          5 &&
         !e.explicitOverride
       )
         continue;
@@ -337,18 +349,42 @@ export function estimateCost({
   outputTokens = 0,
   cacheReadTokens = 0,
   cacheCreationTokens = 0,
+  cacheCreation5mTokens,
+  cacheCreation1hTokens,
+  cacheCreationInvalid = false,
+  pricingContextInvalid = false,
   requestInputTokens,
   serviceTier = "standard",
   regionalProcessing = false,
   table,
 } = {}) {
   const rate = lookupRate(provider, model, table);
+  const splitPresent =
+    cacheCreation5mTokens != null || cacheCreation1hTokens != null;
+  const splitValid =
+    splitPresent &&
+    Number.isSafeInteger(cacheCreation5mTokens) &&
+    cacheCreation5mTokens >= 0 &&
+    Number.isSafeInteger(cacheCreation1hTokens) &&
+    cacheCreation1hTokens >= 0 &&
+    cacheCreation5mTokens + cacheCreation1hTokens === cacheCreationTokens;
+  const missingCacheEvidence =
+    cacheCreationInvalid ||
+    (splitPresent && !splitValid) ||
+    (rate?.terms?.cacheWrite1hMultiplier != null &&
+      cacheCreationTokens > 0 &&
+      !splitValid);
   const tierMultiplier = rate?.terms?.serviceMultipliers
     ? Object.hasOwn(rate.terms.serviceMultipliers, serviceTier)
       ? rate.terms.serviceMultipliers[serviceTier]
       : null
     : 1;
-  if (!rate || tierMultiplier == null) {
+  if (
+    !rate ||
+    tierMultiplier == null ||
+    missingCacheEvidence ||
+    pricingContextInvalid
+  ) {
     return {
       inputCost: 0,
       outputCost: 0,
@@ -384,9 +420,14 @@ export function estimateCost({
     inputMultiplier *
     multiplier;
   const cacheCreationCost =
-    (Number(cacheCreationTokens) / 1e6) *
+    ((splitValid
+      ? cacheCreation5mTokens *
+          (rate.terms?.cacheWriteMultiplier ?? CACHE_WRITE_MULTIPLIER) +
+        cacheCreation1hTokens * (rate.terms?.cacheWrite1hMultiplier ?? 2)
+      : Number(cacheCreationTokens) *
+        (rate.terms?.cacheWriteMultiplier ?? CACHE_WRITE_MULTIPLIER)) /
+      1e6) *
     rate.in *
-    (rate.terms?.cacheWriteMultiplier ?? CACHE_WRITE_MULTIPLIER) *
     inputMultiplier *
     multiplier;
   return {
@@ -419,6 +460,15 @@ export function priceRollup(aggregate, { table } = {}) {
       outputTokens: row.outputTokens,
       cacheReadTokens: row.cacheReadTokens,
       cacheCreationTokens: row.cacheCreationTokens,
+      cacheCreation5mTokens: row.cacheCreation5mTokens,
+      cacheCreation1hTokens: row.cacheCreation1hTokens,
+      cacheCreationInvalid: row.cacheCreationInvalid,
+      pricingContextInvalid:
+        row.pricingContextInvalid === true ||
+        (String(row.provider).toLowerCase() === "anthropic" &&
+          String(row.model).toLowerCase() === "claude-haiku-5-5" &&
+          row.regionalProcessing == null &&
+          row.regional_processing == null),
       serviceTier: row.serviceTier ?? row.service_tier ?? "standard",
       regionalProcessing:
         row.regionalProcessing ?? row.regional_processing ?? false,
@@ -479,7 +529,11 @@ export function priceRollup(aggregate, { table } = {}) {
   for (const row of byModel) {
     if (row.matched) {
       totalCost += row.cost;
-    } else if (row.totalTokens > 0) {
+    } else if (
+      row.totalTokens > 0 ||
+      row.cacheReadTokens > 0 ||
+      row.cacheCreationTokens > 0
+    ) {
       unpriced.push({
         provider: row.provider,
         model: row.model,

package/src/lib/model-capabilities.js

@@ -98,15 +98,17 @@ export function resolveAgentOutputBudget({
     const effectiveModel = model || "claude-sonnet-4-6";
     const { maxTokens } = mergeProviderOptions("anthropic", effectiveModel);
     const defaultCap = maxTokens || 8192;
+    const explicitCap =
+      effectiveModel === "claude-haiku-5-5" ? 128000 : defaultCap;
     const requestMaxOutputTokens =
-      requested === null ? defaultCap : Math.min(defaultCap, requested);
+      requested === null ? defaultCap : Math.min(explicitCap, requested);
     return Object.freeze({
       requestMaxOutputTokens,
       plannedOutputReserveTokens: requestMaxOutputTokens,
       outputReserveSource:
         requested === null
           ? "anthropic-request-default"
-          : requested > defaultCap
+          : requested > explicitCap
             ? "anthropic-request-clamp"
             : "explicit-request-cap",
     });
@@ -271,6 +273,12 @@ export function resolveModelCapabilityProfile({
     runtimeVerified: false,
     ...output,
     advertisedMaxOutputTokens: documented?.advertisedMaxOutputTokens ?? null,
+    ...(documented?.adaptiveThinkingDefault
+      ? {
+          adaptiveThinkingDefault: true,
+          defaultReasoningEffort: documented.defaultReasoningEffort,
+        }
+      : {}),
     ...(documented?.reasoningEfforts
       ? { reasoningEfforts: [...documented.reasoningEfforts] }
       : {}),

package/src/lib/model-catalog-review.js

@@ -92,6 +92,7 @@ export function reviewModelCatalog(review, snapshots = {}) {
     for (const field of [
       "cacheReadMultiplier",
       "cacheWriteMultiplier",
+      "cacheWrite1hMultiplier",
       "longContext",
       "serviceMultipliers",
     ]) {

package/src/lib/model-context-catalog.js

@@ -144,13 +144,38 @@ export const DOCUMENTED_OPENAI_MODELS = Object.freeze({
 });
 
 export const DOCUMENTED_ANTHROPIC_MODELS = Object.freeze({
+  "claude-haiku-5-5": Object.freeze({
+    contextWindowTokens: 1000000,
+    advertisedMaxOutputTokens: 128000,
+    reasoningEfforts: Object.freeze(["low", "medium", "high", "xhigh", "max"]),
+    defaultReasoningEffort: "medium",
+    adaptiveThinkingDefault: true,
+    pricing: Object.freeze({ in: 0.1, out: 0.5 }),
+    pricingTerms: Object.freeze({
+      cacheReadMultiplier: 0.1,
+      cacheWriteMultiplier: 1.25,
+      cacheWrite1hMultiplier: 2,
+      longContext: Object.freeze({
+        threshold: 100000,
+        inputMultiplier: 5,
+        outputMultiplier: 5,
+      }),
+      serviceMultipliers: Object.freeze({ standard: 1, default: 1 }),
+    }),
+    sources: Object.freeze([
+      "https://platform.claude.com/docs/en/models/haiku-5-5/overview",
+      "https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide",
+      "https://platform.claude.com/docs/en/about-claude/pricing",
+    ]),
+  }),
   "claude-sonnet-5-5": Object.freeze({
     contextWindowTokens: 1000000,
     advertisedMaxOutputTokens: null,
     pricing: Object.freeze({ in: 2, out: 10 }),
-    pricingTerms: Object.freeze({ cacheReadMultiplier: 0.1 }),
+    pricingTerms: Object.freeze({ cacheReadMultiplier: 0.05 }),
     sources: Object.freeze([
       "https://code.claude.com/docs/en/changelog#2-1-284",
+      "https://platform.claude.com/docs/en/about-claude/pricing",
     ]),
   }),
   "claude-opus-5-5": Object.freeze({

package/src/lib/provider-http-error.js

@@ -3,6 +3,11 @@
  * Keep structured provider diagnostics while redacting credential-shaped text.
  */
 
+import {
+  attachStreamRetryMetadata,
+  captureStreamRetryMetadata,
+} from "./stream-retry.js";
+
 function safePart(value, secrets = []) {
   if (value == null) return "";
   let text = String(value);
@@ -111,3 +116,14 @@ export async function formatProviderResponseError(
     secrets,
   });
 }
+
+/** Keep response status authoritative even if reading its error body fails. */
+export async function createProviderResponseError(provider, response, options) {
+  const metadata = captureStreamRetryMetadata(response);
+  let message = await formatProviderResponseError(provider, response, options);
+  const remaining = metadata.retryAfterAt - Date.now();
+  if (Number.isFinite(remaining) && remaining > 0) {
+    message += ` Retry-After: wait at least ${Math.ceil(remaining / 1000)}s before an explicit retry.`;
+  }
+  return attachStreamRetryMetadata(new Error(message), metadata);
+}

package/src/lib/provider-options.js

@@ -78,7 +78,11 @@ export function inferModelOverrides(modelId) {
     return { maxTokens: 16384 };
   }
 
-  // Claude Haiku — cheaper, smaller output by default.
+  if (modelId === "claude-haiku-5-5") {
+    return { maxTokens: 4096, temperature: undefined };
+  }
+
+  // Older Claude Haiku — smaller output by default.
   if (id.includes("haiku")) {
     return { maxTokens: 4096 };
   }
@@ -136,6 +140,39 @@ export function mergeProviderOptions(provider, modelId, callOverrides = {}) {
   return deepMerge(defaults, modelLayer, callOverrides || {});
 }
 
+/** Exact Haiku 5.5 request contract; null leaves older model behavior intact. */
+export function haiku55ThinkingParams(model, options = {}) {
+  if (model !== "claude-haiku-5-5") return null;
+  if (options.thinkingBudget != null) {
+    throw new TypeError(
+      "Haiku 5.5 supports adaptive thinking, not thinkingBudget",
+    );
+  }
+  const intensity = {
+    think: "medium",
+    hard: "high",
+    "think-hard": "high",
+    harder: "high",
+    ultra: "xhigh",
+    ultrathink: "xhigh",
+    true: "high",
+  };
+  const effort =
+    options.thinkingEffort ?? intensity[options.thinking] ?? "medium";
+  if (!["low", "medium", "high", "xhigh", "max"].includes(effort)) {
+    throw new TypeError(`Unsupported Haiku 5.5 reasoning effort: ${effort}`);
+  }
+  if (options.thinking === false && ["xhigh", "max"].includes(effort)) {
+    throw new TypeError(
+      "Haiku 5.5 cannot disable thinking at xhigh or max effort",
+    );
+  }
+  return {
+    thinking: { type: options.thinking === false ? "disabled" : "adaptive" },
+    output_config: { effort },
+  };
+}
+
 // =====================================================================
 // provider-options V2 governance overlay (iter27)
 // =====================================================================

package/src/lib/search-command.js

@@ -37,7 +37,10 @@ export function buildSearchCommand({
   isContent,
   platform = process.platform,
 }) {
-  const pat = String(pattern ?? "");
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return { error: "search_files requires a non-empty string pattern" };
+  }
+  const pat = pattern;
 
   if (platform === "win32") {
     // cmd.exe has no reliable way to escape an embedded double-quote, and the

package/src/lib/stream-retry.js

@@ -12,11 +12,196 @@
  * agent runtime.
  */
 
-import { isAbortError } from "./abort-utils.js";
+import {
+  createAbortError,
+  isAbortError,
+  raceWithAbort,
+  throwIfAborted,
+} from "./abort-utils.js";
 
 /** Bounded auto-retry budget for streaming connection drops (Claude-Code 2.1.181). */
 export const STREAM_RETRY_MAX = 2;
 export const STREAM_RETRY_BASE_MS = 400;
+export const STREAM_RETRY_MAX_DELAY_MS = 60_000;
+
+function isFailureStatus(status) {
+  return Number.isInteger(status) && status >= 400 && status <= 599;
+}
+
+function retryAfterHeader(headers) {
+  if (!headers) return undefined;
+  if (typeof headers.get === "function") return headers.get("retry-after");
+  const entries = Object.entries(headers).filter(
+    ([name]) => name.toLowerCase() === "retry-after",
+  );
+  // Multiple spellings or a list of values are ambiguous, not a delay.
+  return entries.length === 1 ? entries[0][1] : undefined;
+}
+
+function httpDate(value, now) {
+  // Accept the three HTTP-date wire formats, not Date.parse's permissive
+  // numeric/local-date syntax (e.g. "-1", "1.5", or "2026-10-12").
+  const weekday = "(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)";
+  const month = "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)";
+  let match = new RegExp(
+    `^(${weekday}), (\\d{2}) ${month} (\\d{4}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$`,
+  ).exec(value);
+  let day, monthName, year, hour, minute, second, dayName;
+  if (match) {
+    [, dayName, day, monthName, year, hour, minute, second] = match;
+  } else {
+    match = new RegExp(
+      `^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\\d{2})-${month}-(\\d{2}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$`,
+    ).exec(value);
+    if (match) {
+      [, dayName, day, monthName, year, hour, minute, second] = match;
+      const currentYear = new Date(now).getUTCFullYear();
+      year = Math.floor(currentYear / 100) * 100 + Number(year);
+      if (year > currentYear + 50) year -= 100;
+    } else {
+      match = new RegExp(
+        `^(${weekday}) ${month} ( [1-9]|[12]\\d|3[01]) (\\d{2}):(\\d{2}):(\\d{2}) (\\d{4})$`,
+      ).exec(value);
+      if (!match) return undefined;
+      [, dayName, monthName, day, hour, minute, second, year] = match;
+    }
+  }
+  const months = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split(" ");
+  const monthIndex = months.indexOf(monthName);
+  const date = new Date(0);
+  date.setUTCFullYear(Number(year), monthIndex, Number(day));
+  date.setUTCHours(Number(hour), Number(minute), Number(second), 0);
+  // Reject normalized invalid calendar dates/times and mismatched weekdays.
+  if (
+    date.getUTCFullYear() !== Number(year) ||
+    date.getUTCMonth() !== monthIndex ||
+    date.getUTCDate() !== Number(day) ||
+    date.getUTCHours() !== Number(hour) ||
+    date.getUTCMinutes() !== Number(minute) ||
+    date.getUTCSeconds() !== Number(second) ||
+    date.toUTCString().slice(0, 3) !== dayName.slice(0, 3)
+  ) {
+    return undefined;
+  }
+  return date.getTime();
+}
+
+/** Capture a deadline when headers arrive, before reading a slow response body.
+ * No metadata here grants permission to retry an HTTP/provider verdict.
+ */
+export function captureStreamRetryMetadata(response, now = Date.now()) {
+  const metadata = {};
+  if (Number.isInteger(response?.status)) metadata.status = response.status;
+  const raw = retryAfterHeader(response?.headers);
+  if (typeof raw !== "string" || !Number.isFinite(now)) return metadata;
+  const value = raw.trim();
+  if (/^\d+$/.test(value)) {
+    const seconds = Number(value);
+    const deadline = now + seconds * 1000;
+    // A valid but unrepresentably large delay is a refusal to retry within our
+    // budget, NOT a missing header. Infinity is an internal fail-closed sentinel.
+    metadata.retryAfterAt = Number.isSafeInteger(deadline)
+      ? deadline
+      : Infinity;
+  } else {
+    const deadline = httpDate(value, now);
+    if (deadline !== undefined) metadata.retryAfterAt = deadline;
+  }
+  return metadata;
+}
+
+/** Preserve the original Error identity/code and the strongest known verdict. */
+export function attachStreamRetryMetadata(error, metadata = {}) {
+  if (!error || (typeof error !== "object" && typeof error !== "function"))
+    return error;
+  const hasFailureStatus = [
+    error.status,
+    error.statusCode,
+    error.cause?.status,
+    error.cause?.statusCode,
+  ].some(isFailureStatus);
+  if (!hasFailureStatus && Number.isInteger(metadata.status)) {
+    error.status = metadata.status;
+  }
+  if (
+    typeof metadata.retryAfterAt === "number" &&
+    !Number.isNaN(metadata.retryAfterAt) &&
+    metadata.retryAfterAt !== -Infinity
+  ) {
+    const previous = [error.retryAfterAt, error.cause?.retryAfterAt].filter(
+      (value) => typeof value === "number" && !Number.isNaN(value),
+    );
+    error.retryAfterAt = Math.max(metadata.retryAfterAt, ...previous);
+  }
+  return error;
+}
+
+/** Resolve the wait AFTER retry eligibility is checked; null means give up.
+ * Never clamp a server deadline to a shorter wait or authorize an HTTP replay.
+ * Attempt 1 is the first retry, matching the existing retry observer contract.
+ */
+export function resolveStreamRetryDelay(error, attempt, options = {}) {
+  const base = options.baseDelayMs ?? STREAM_RETRY_BASE_MS;
+  const now = options.now ?? Date.now();
+  const max = options.maxDelayMs ?? STREAM_RETRY_MAX_DELAY_MS;
+  if (
+    !Number.isInteger(attempt) ||
+    attempt < 1 ||
+    !Number.isFinite(base) ||
+    base < 0 ||
+    !Number.isFinite(now) ||
+    !Number.isFinite(max) ||
+    max < 0
+  )
+    return null;
+  const deadlines = [error?.retryAfterAt, error?.cause?.retryAfterAt].filter(
+    (value) => typeof value === "number" && !Number.isNaN(value),
+  );
+  const delay = Math.ceil(
+    Math.max(base * 2 ** (attempt - 1), 0, ...deadlines.map((at) => at - now)),
+  );
+  // Node clamps overflowing setTimeout delays to 1ms. Reject rather than
+  // accidentally turning a requested long delay into an immediate replay.
+  return Number.isFinite(delay) && delay <= max && delay <= 2_147_483_647
+    ? delay
+    : null;
+}
+
+/** Wait without keeping an obsolete backoff alive after user cancellation. */
+export async function waitForStreamRetry(ms, signal, { sleep } = {}) {
+  throwIfAborted(signal);
+  if (!Number.isFinite(ms) || ms < 0 || ms > 2_147_483_647)
+    throw new RangeError("Invalid streaming retry delay");
+  if (sleep) {
+    await raceWithAbort(
+      Promise.resolve().then(() => {
+        throwIfAborted(signal);
+        return sleep(ms);
+      }),
+      signal,
+    );
+    throwIfAborted(signal);
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    let timer;
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason || createAbortError());
+    };
+    timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+  });
+  throwIfAborted(signal);
+}
 
 /**
  * Hard ceiling on the *configurable* retry budget (Claude-Code 2.1.186:
@@ -61,6 +246,29 @@ export function isRetryableStreamError(err, signal) {
   if (isAbortError(err)) return false;
   if (signal && signal.aborted) return false;
   if (!err) return false;
+  if (
+    [err, err.cause].some(
+      (error) =>
+        error?.noReplay === true ||
+        error?.streamOutputVisible === true ||
+        error?.isOutputBackpressureFailure === true,
+    )
+  )
+    return false;
+  const msg = String(err.message || err).toLowerCase();
+  // A provider verdict stays terminal even when its detail mentions a timeout,
+  // reset or network failure. Inspect it before transport codes and wording so
+  // formatted HTTP diagnostics and failed Responses cannot trigger a replay.
+  if (
+    err.code === "CC_OPENAI_RESPONSES_FAILED" ||
+    err.cause?.code === "CC_OPENAI_RESPONSES_FAILED" ||
+    [err.status, err.statusCode, err.cause?.status, err.cause?.statusCode].some(
+      (status) => Number.isInteger(status) && status >= 400 && status <= 599,
+    ) ||
+    /\bhttp\s+[45]\d{2}\b/.test(msg)
+  ) {
+    return false;
+  }
   const code = String(err.code || err.cause?.code || "").toUpperCase();
   if (
     [
@@ -76,7 +284,6 @@ export function isRetryableStreamError(err, signal) {
   ) {
     return true;
   }
-  const msg = String(err.message || err).toLowerCase();
   return /econnreset|etimedout|econnrefused|eai_again|socket hang ?up|terminated|fetch failed|network error|timed?\s*out|premature close/.test(
     msg,
   );