chainlesschain 0.163.6 → 0.163.7

package/src/harness/prompt-compressor.js

@@ -32,6 +32,7 @@ export * from "./structured-handoff.js";
 // a long, tool-heavy history stays sub-second instead of O(n²·content).
 const DEDUP_JACCARD_MAX_CHARS = 4000;
 const DEDUP_FUZZY_WINDOW = 100;
+const SUMMARY_CALL_ID_MAX_CHARS = 128;
 export const SUMMARY_INPUT_DEFAULT_MAX_CHARS = 24000;
 export const SUMMARY_INPUT_HARD_MAX_CHARS = 32000;
 const SUMMARY_INPUT_MIN_CHARS = 1024;
@@ -123,6 +124,31 @@ function boundedFailureMessage(error) {
     .slice(0, 240);
 }
 
+function safeSummaryCallId(value) {
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value.length > SUMMARY_CALL_ID_MAX_CHARS ||
+    /\p{Cc}/u.test(value)
+  ) {
+    return null;
+  }
+  return value.trim();
+}
+
+function summaryUsageCount(usage, canonical, alias, { required = false } = {}) {
+  const hasCanonical = Object.hasOwn(usage, canonical);
+  const hasAlias = Object.hasOwn(usage, alias);
+  if (!hasCanonical && !hasAlias) return required ? null : 0;
+  if (hasCanonical && hasAlias && usage[canonical] !== usage[alias]) {
+    return null;
+  }
+  const value = hasCanonical ? usage[canonical] : usage[alias];
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+    ? value
+    : null;
+}
+
 export function estimateTokens(text) {
   if (!text) return 0;
   const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
@@ -571,8 +597,18 @@ export class PromptCompressor {
     let summaryUsageUnknownReason = null;
     let summaryProvider = null;
     let summaryModel = null;
+    let summaryCallId = null;
+    let summaryUsageLedgerSettled = false;
     try {
       const queryResult = await this.llmQuery(prompt);
+      if (
+        queryResult &&
+        typeof queryResult === "object" &&
+        !Array.isArray(queryResult)
+      ) {
+        summaryCallId = safeSummaryCallId(queryResult.callId);
+        summaryUsageLedgerSettled = queryResult.usageLedgerSettled === true;
+      }
       if (
         queryResult &&
         typeof queryResult === "object" &&
@@ -580,20 +616,46 @@ export class PromptCompressor {
       ) {
         rawSummary = queryResult.summary;
         const usage = queryResult.usage;
-        if (usage && typeof usage === "object") {
+        const inputTokens = usage
+          ? summaryUsageCount(usage, "input_tokens", "prompt_tokens", {
+              required: true,
+            })
+          : null;
+        const outputTokens = usage
+          ? summaryUsageCount(usage, "output_tokens", "completion_tokens", {
+              required: true,
+            })
+          : null;
+        const cacheReadTokens = usage
+          ? summaryUsageCount(
+              usage,
+              "cache_read_input_tokens",
+              "cache_read_tokens",
+            )
+          : null;
+        const cacheCreationTokens = usage
+          ? summaryUsageCount(
+              usage,
+              "cache_creation_input_tokens",
+              "cache_creation_tokens",
+            )
+          : null;
+        if (
+          usage &&
+          typeof usage === "object" &&
+          !Array.isArray(usage) &&
+          Number.isSafeInteger(inputTokens) &&
+          inputTokens >= 0 &&
+          Number.isSafeInteger(outputTokens) &&
+          outputTokens >= 0 &&
+          cacheReadTokens != null &&
+          cacheCreationTokens != null
+        ) {
           summaryUsage = {
-            inputTokens: Number(usage.input_tokens ?? usage.prompt_tokens) || 0,
-            outputTokens:
-              Number(usage.output_tokens ?? usage.completion_tokens) || 0,
-            cacheReadTokens:
-              Number(
-                usage.cache_read_input_tokens ?? usage.cache_read_tokens,
-              ) || 0,
-            cacheCreationTokens:
-              Number(
-                usage.cache_creation_input_tokens ??
-                  usage.cache_creation_tokens,
-              ) || 0,
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            cacheCreationTokens,
           };
         } else if (queryResult.usageOutcome !== "not-billable") {
           // Standard provider adapters return an explicit `usage` field. A
@@ -612,6 +674,13 @@ export class PromptCompressor {
       // provider failure would manufacture an extractive summary after Stop and
       // let callers apply/persist it even though the operation was cancelled.
       if (isAbortError(error)) throw error;
+      // A durable-ledger write failure is authoritative too. Falling back here
+      // would let the host continue after losing the model-call boundary.
+      if (error?.runtimeLedgerPersistence === true) throw error;
+      summaryCallId = safeSummaryCallId(
+        error?.compactionCallId ?? error?.callId,
+      );
+      summaryUsageLedgerSettled = error?.usageLedgerSettled === true;
       degraded = true;
       summaryMode = "extractive-fallback";
       degradedReason = `llm_query_failed:${boundedFailureMessage(error)}`;
@@ -670,6 +739,10 @@ export class PromptCompressor {
           : {}),
         ...(summaryProvider ? { summaryProvider } : {}),
         ...(summaryModel ? { summaryModel } : {}),
+        ...(summaryCallId ? { summaryCallId } : {}),
+        ...(summaryUsageLedgerSettled
+          ? { summaryUsageLedgerSettled: true }
+          : {}),
       },
     };
   }

package/src/harness/provider-backed-compaction.js

@@ -8,6 +8,49 @@ const DEFAULT_MAX_OUTPUT_TOKENS = 2048;
 const MIN_MAX_OUTPUT_TOKENS = 256;
 const MAX_MAX_OUTPUT_TOKENS = 4096;
 const MANUAL_MAX_MESSAGES = 4;
+const MAX_USAGE_CALL_ID_CHARS = 128;
+
+function safeUsageCallId(value) {
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value.length > MAX_USAGE_CALL_ID_CHARS ||
+    /\p{Cc}/u.test(value)
+  ) {
+    return null;
+  }
+  return value.trim();
+}
+
+function attachProviderCallId(result, startedCallId) {
+  const callId =
+    safeUsageCallId(startedCallId) || safeUsageCallId(result?.callId);
+  if (!callId) return result;
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    return { ...result, callId };
+  }
+  return { summary: result, callId };
+}
+
+function attachProviderCallIdToError(error, callId) {
+  const safeCallId = safeUsageCallId(callId);
+  if (
+    !safeCallId ||
+    !error ||
+    (typeof error !== "object" && typeof error !== "function")
+  ) {
+    return;
+  }
+  try {
+    Object.defineProperty(error, "compactionCallId", {
+      configurable: true,
+      value: safeCallId,
+    });
+  } catch {
+    // Frozen provider errors still propagate; their call remains conservative
+    // because no unsafe metadata is manufactured here.
+  }
+}
 
 function boundedMaxOutputTokens(value) {
   const parsed = Math.trunc(Number(value));
@@ -20,9 +63,11 @@ function boundedMaxOutputTokens(value) {
   );
 }
 
-function tokenCount(value) {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : 0;
+function tokenCount(value, { required = false } = {}) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return value;
+  }
+  return required ? null : 0;
 }
 
 function responseSummary(response) {
@@ -56,9 +101,12 @@ function preserveCompletedExchange(originalMessages, compactedMessages) {
 export function compactionTokenUsage(stats) {
   const usage = stats?.summaryUsage;
   if (!usage || typeof usage !== "object") return null;
+  const inputTokens = tokenCount(usage.inputTokens, { required: true });
+  const outputTokens = tokenCount(usage.outputTokens, { required: true });
+  if (inputTokens == null || outputTokens == null) return null;
   return {
-    input_tokens: tokenCount(usage.inputTokens),
-    output_tokens: tokenCount(usage.outputTokens),
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
     cache_read_input_tokens: tokenCount(usage.cacheReadTokens),
     cache_creation_input_tokens: tokenCount(usage.cacheCreationTokens),
   };
@@ -78,35 +126,52 @@ export async function compactConversationWithProvider(messages, options = {}) {
   const model = options.model || null;
   const maxOutputTokens = boundedMaxOutputTokens(options.maxOutputTokens);
   const chatFn = options.chatFn;
+  const invokeProviderCall = async (call) => {
+    const callId = safeUsageCallId(await options.onProviderCallStart?.());
+    try {
+      return attachProviderCallId(await call(), callId);
+    } catch (error) {
+      attachProviderCallIdToError(error, callId);
+      throw error;
+    }
+  };
   const llmQuery =
     typeof options.llmQuery === "function"
-      ? options.llmQuery
+      ? async (prompt) => invokeProviderCall(() => options.llmQuery(prompt))
       : async (prompt) => {
           if (typeof chatFn !== "function") {
             throw new Error("provider adapter unavailable");
           }
-          const response = await chatFn([{ role: "user", content: prompt }], {
-            ...(options.chatOptions || {}),
-            provider,
-            model,
-            baseUrl: options.baseUrl,
-            apiKey: options.apiKey,
-            signal: options.signal,
-            contextEngine: null,
-            enabledToolNames: [],
-            extraToolDefinitions: [],
-            hostManagedToolPolicy: null,
-            onToken: undefined,
-            onStall: undefined,
-            onStreamRetry: undefined,
-            maxOutputTokens,
+          return invokeProviderCall(async () => {
+            const response = await chatFn([{ role: "user", content: prompt }], {
+              ...(options.chatOptions || {}),
+              provider,
+              model,
+              baseUrl: options.baseUrl,
+              apiKey: options.apiKey,
+              signal: options.signal,
+              contextEngine: null,
+              enabledToolNames: [],
+              extraToolDefinitions: [],
+              hostManagedToolPolicy: null,
+              onToken: undefined,
+              onStall: undefined,
+              onStreamRetry: undefined,
+              maxOutputTokens,
+            });
+            return {
+              summary: responseSummary(response),
+              usage: response?.usage || null,
+              provider,
+              model,
+              ...(safeUsageCallId(response?.callId)
+                ? { callId: safeUsageCallId(response.callId) }
+                : {}),
+              ...(response?.usageLedgerSettled === true
+                ? { usageLedgerSettled: true }
+                : {}),
+            };
           });
-          return {
-            summary: responseSummary(response),
-            usage: response?.usage || null,
-            provider,
-            model,
-          };
         };
 
   const compressor =
@@ -178,6 +243,10 @@ export async function compactConversationWithProvider(messages, options = {}) {
             stats.summaryUsageUnknownReason ||
             "provider_transport_outcome_unknown",
           usageOutcome: "unknown",
+          ...(stats.summaryCallId ? { callId: stats.summaryCallId } : {}),
+          ...(stats.summaryUsageLedgerSettled === true
+            ? { usageLedgerSettled: true }
+            : {}),
         }
       : null;
 
@@ -198,6 +267,10 @@ export async function compactConversationWithProvider(messages, options = {}) {
           model: stats.summaryModel || model,
           usage,
           source: "semantic-compaction",
+          ...(stats.summaryCallId ? { callId: stats.summaryCallId } : {}),
+          ...(stats.summaryUsageLedgerSettled === true
+            ? { usageLedgerSettled: true }
+            : {}),
         }
       : null,
     usageUnknownEvent,

package/src/lib/advisor-runtime.js

@@ -888,6 +888,7 @@ export class AdvisorRuntime {
         guidance: buildAdvisorGuidance({ ok: true, advice }),
       };
     } catch (error) {
+      if (error?.runtimeLedgerPersistence === true) throw error;
       const failure = {
         callId,
         trigger,
@@ -994,7 +995,8 @@ export class AdvisorRuntime {
       });
       try {
         await onAdvice?.(result, selected);
-      } catch {
+      } catch (error) {
+        if (error?.runtimeLedgerPersistence === true) throw error;
         // Rendering/telemetry callbacks are advisory only.
       }
       if (!result.ok || !result.guidance) {