chainlesschain 0.166.100 → 0.166.101

package/src/lib/formal-budget-transport.js

@@ -0,0 +1,345 @@
+import {
+  budgetError,
+  canonical,
+  requireBudget,
+} from "./formal-budget-contract.js";
+
+export const FORMAL_BUDGET_RUNTIME_READINESS = Object.freeze({
+  paidReady: false,
+  reason:
+    "Agent, Chat, compaction, advisor, probes, retries and child-process egress are not yet all routed through this authority",
+});
+export function requireFormalBudgetRuntime() {
+  throw budgetError(
+    "CC_BUDGET_RUNTIME_NOT_COVERED",
+    FORMAL_BUDGET_RUNTIME_READINESS.reason,
+  );
+}
+
+// JSON.parse alone accepts duplicate keys (including escaped aliases) and
+// overflows numeric literals to Infinity. Neither is safe accounting evidence.
+export function parseBudgetJson(text) {
+  requireBudget(typeof text === "string", "JSON text required");
+  let at = 0;
+  const whitespace = () => {
+    while (at < text.length && /[\x20\t\r\n]/u.test(text[at])) at++;
+  };
+  function string() {
+    requireBudget(text[at] === '"', "JSON string expected");
+    const start = at++;
+    while (at < text.length) {
+      const char = text[at++];
+      if (char === '"') return JSON.parse(text.slice(start, at));
+      if (char === "\\") at++;
+    }
+    requireBudget(false, "Unterminated JSON string");
+  }
+  function value(depth) {
+    requireBudget(depth <= 64, "JSON nesting exceeds accounting parser bound");
+    whitespace();
+    if (text[at] === '"') {
+      string();
+      return;
+    }
+    if (text[at] === "{") {
+      at++;
+      whitespace();
+      const keys = new Set();
+      if (text[at] === "}") {
+        at++;
+        return;
+      }
+      for (;;) {
+        whitespace();
+        const key = string();
+        requireBudget(
+          !keys.has(key),
+          "Duplicate JSON member in provider evidence",
+        );
+        keys.add(key);
+        whitespace();
+        requireBudget(text[at++] === ":", "JSON member separator expected");
+        value(depth + 1);
+        whitespace();
+        const separator = text[at++];
+        if (separator === "}") return;
+        requireBudget(separator === ",", "JSON object separator expected");
+      }
+    }
+    if (text[at] === "[") {
+      at++;
+      whitespace();
+      if (text[at] === "]") {
+        at++;
+        return;
+      }
+      for (;;) {
+        value(depth + 1);
+        whitespace();
+        const separator = text[at++];
+        if (separator === "]") return;
+        requireBudget(separator === ",", "JSON array separator expected");
+      }
+    }
+    for (const literal of ["true", "false", "null"])
+      if (text.startsWith(literal, at)) {
+        at += literal.length;
+        return;
+      }
+    const number = text
+      .slice(at)
+      .match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u)?.[0];
+    requireBudget(
+      number && Number.isFinite(Number(number)),
+      "Invalid or non-finite JSON number",
+    );
+    at += number.length;
+  }
+  value(0);
+  whitespace();
+  requireBudget(at === text.length, "Trailing JSON input");
+  return JSON.parse(text);
+}
+
+/** Allowlist only; the caller must still supply the existing OS sandbox. */
+export function formalBudgetTaskEnvironment(environment = process.env) {
+  return Object.fromEntries(
+    [
+      "PATH",
+      "Path",
+      "SystemRoot",
+      "SYSTEMROOT",
+      "WINDIR",
+      "ComSpec",
+      "PATHEXT",
+      "TEMP",
+      "TMP",
+      "TMPDIR",
+      "LANG",
+      "LC_ALL",
+      "LC_CTYPE",
+    ]
+      .filter((key) => typeof environment[key] === "string")
+      .map((key) => [key, environment[key]]),
+  );
+}
+
+async function boundedText(response, maximumBytes) {
+  requireBudget(response.body?.getReader, "Response body unavailable");
+  const reader = response.body.getReader(),
+    chunks = [];
+  let size = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      requireBudget(
+        size <= maximumBytes,
+        "Provider response exceeded bounded parser",
+      );
+      chunks.push(Buffer.from(value));
+    }
+  } catch (error) {
+    try {
+      await reader.cancel();
+    } catch {
+      /* keep original unknown outcome */
+    }
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder("utf-8", { fatal: true }).decode(
+    Buffer.concat(chunks),
+  );
+}
+function streamReceipt(text) {
+  let terminal = false,
+    receipt = null,
+    usage = null,
+    finishReason = null;
+  for (const frame of text.replaceAll("\r\n", "\n").split("\n\n")) {
+    if (!frame.trim()) continue;
+    const data = frame
+      .split("\n")
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trimStart())
+      .join("\n");
+    if (!data) continue;
+    requireBudget(!terminal, "Unexpected stream data after terminal marker");
+    if (data === "[DONE]") {
+      requireBudget(
+        finishReason !== null,
+        "Stream ended without a completed choice",
+      );
+      terminal = true;
+      continue;
+    }
+    const row = parseBudgetJson(data);
+    requireBudget(row && !Object.hasOwn(row, "error"), "Provider stream error");
+    const identity = {
+      id: row.id,
+      model: row.model,
+      service_tier: row.service_tier,
+    };
+    if (!receipt) receipt = identity;
+    else {
+      // Some providers only send service_tier on the final usage frame.
+      requireBudget(
+        row.id === receipt.id && row.model === receipt.model,
+        "Stream identity changed",
+      );
+      if (row.service_tier !== undefined) {
+        requireBudget(
+          receipt.service_tier === undefined ||
+            row.service_tier === receipt.service_tier,
+          "Stream tier changed",
+        );
+        receipt.service_tier = row.service_tier;
+      }
+    }
+    requireBudget(
+      Array.isArray(row.choices) &&
+        row.choices.length <= 1 &&
+        row.choices.every((choice) => choice.index === 0),
+      "Multiple/unknown streamed completions",
+    );
+    for (const choice of row.choices) {
+      requireBudget(
+        finishReason === null,
+        "Choice data received after completed stream choice",
+      );
+      if (choice.finish_reason != null) {
+        requireBudget(
+          ["stop", "length", "tool_calls"].includes(choice.finish_reason),
+          "Unsupported stream finish reason",
+        );
+        finishReason = choice.finish_reason;
+      }
+    }
+    if (row.usage != null) {
+      requireBudget(
+        finishReason !== null,
+        "Usage received before complete stream choice",
+      );
+      requireBudget(
+        usage === null || canonical(usage) === canonical(row.usage),
+        "Conflicting streamed usage",
+      );
+      usage = row.usage;
+    }
+  }
+  requireBudget(
+    terminal && finishReason !== null && receipt && usage,
+    "Incomplete stream or missing usage",
+  );
+  return { ...receipt, usage };
+}
+
+/**
+ * Trusted-host JSON/SSE transport: credential stays in this closure, and every
+ * physical request consumes a durable dispatch exactly once. No auto retries.
+ * This is not the unrestricted Agent/Chat transport and is not auto-enabled.
+ */
+export function createFormalBudgetTransport({
+  authority,
+  credentialProvider,
+  fetchImpl = globalThis.fetch,
+  maximumResponseBytes = 16 * 1024 * 1024,
+  timeoutMs = 60_000,
+}) {
+  requireBudget(
+    authority &&
+      typeof credentialProvider === "function" &&
+      typeof fetchImpl === "function",
+    "Authority and trusted credential provider required",
+  );
+  requireBudget(
+    Number.isSafeInteger(maximumResponseBytes) &&
+      maximumResponseBytes > 0 &&
+      maximumResponseBytes <= 16 * 1024 * 1024,
+    "Invalid response byte bound",
+  );
+  requireBudget(
+    Number.isSafeInteger(timeoutMs) && timeoutMs > 0 && timeoutMs <= 300_000,
+    "Invalid timeout",
+  );
+  return Object.freeze({
+    async dispatch({ runId, callId, body, signal }) {
+      // Snapshot before await so caller mutation cannot alter the reserved body.
+      const request = JSON.parse(canonical(body));
+      authority.reserve({ runId, callId, body: request });
+      let settled = false;
+      try {
+        const reserved = authority.reservedContract(callId);
+        const credential = await credentialProvider({
+          contractId: reserved.id,
+          provider: reserved.provider,
+          endpoint: reserved.endpoint,
+        });
+        requireBudget(
+          typeof credential === "string" &&
+            credential.length > 0 &&
+            !/[\r\n]/u.test(credential),
+          "Credential unavailable",
+        );
+        const deadline = AbortSignal.timeout(timeoutMs);
+        const options = {
+          method: "POST",
+          redirect: "error",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${credential}`,
+          },
+          body: JSON.stringify(request),
+          signal: signal ? AbortSignal.any([signal, deadline]) : deadline,
+        };
+        // Final expiry/request check is AFTER every awaited preparation. There
+        // must be no await between this durable admission and physical fetch.
+        const contract = authority.markDispatched(callId, request);
+        const response = await fetchImpl(contract.endpoint, options);
+        requireBudget(response.ok, "Provider HTTP response not successful");
+        const text = await boundedText(response, maximumResponseBytes);
+        let receipt;
+        if (request.stream === true) {
+          requireBudget(
+            response.headers.get("content-type")?.includes("text/event-stream"),
+            "Unexpected stream content type",
+          );
+          receipt = streamReceipt(text);
+        } else {
+          receipt = parseBudgetJson(text);
+          requireBudget(
+            receipt && !Object.hasOwn(receipt, "error"),
+            "Provider error envelope cannot settle",
+          );
+          requireBudget(
+            Array.isArray(receipt.choices) &&
+              receipt.choices.length === 1 &&
+              receipt.choices[0].index === 0 &&
+              ["stop", "length", "tool_calls"].includes(
+                receipt.choices[0].finish_reason,
+              ),
+            "Incomplete or multiple completion response",
+          );
+        }
+        const cost = authority.settle(callId, receipt);
+        settled = true;
+        return { body: text, streaming: request.stream === true, cost };
+      } catch {
+        if (!settled) {
+          // Do not persist provider errors which may contain credentials/content.
+          authority.markUnknown(
+            callId,
+            "transport or settlement outcome unknown",
+          );
+        }
+        throw budgetError(
+          "CC_BUDGET_TRANSPORT_UNKNOWN",
+          "Provider outcome unknown; reservation retained and further dispatch blocked",
+        );
+      }
+    },
+  });
+}

package/src/runtime/agent-core.js

@@ -198,6 +198,7 @@ import {
   settleManagedToolCheckpoint,
 } from "../lib/managed-tool-checkpoint.js";
 import { sessionBudgetAdmissionError } from "../lib/session-budget-production-root.js";
+import { projectRuntimeTokenUsage } from "../lib/runtime-usage-ledger.js";
 import {
   createMcpCallLedger,
   McpEffect,
@@ -11860,6 +11861,11 @@ export async function chatWithTools(rawMessages, options) {
 
   throwIfAborted(signal);
 
+  // Host accounting starts only after request admission. A rejected model
+  // projection never reaches the provider; failures after this boundary must
+  // still retain conservative usage accounting regardless of error metadata.
+  await options.onProviderCallStart?.();
+
   if (provider === "ollama") {
     const apiUrl = `${baseUrl}/api/chat`;
     // Multimodal (`cc agent --image`): ollama wants `{content, images:[base64]}`
@@ -13471,6 +13477,19 @@ function _workflowNestedToolOutcomeUnknown(binding, toolName, result) {
   return error;
 }
 
+function _takeCompactionProviderReceipt(call, workflowEffectId) {
+  if (!call?.providerReceipt || call.providerReceiptEmitted) return null;
+  call.providerReceiptEmitted = true;
+  return {
+    type: "provider-request-receipt",
+    callId: call.callId,
+    workflowEffectId,
+    callSequence: call.callSequence,
+    source: "semantic-compaction",
+    ...call.providerReceipt,
+  };
+}
+
 function _workflowCompactionOutcomeUnknown(
   cause,
   code = "CC_WORKFLOW_COMPACTION_PROVIDER_OUTCOME_UNKNOWN",
@@ -13870,6 +13889,21 @@ function _instrumentAutoCompactorUsage(compactor, options) {
         this,
         requestBinding ? [...args, requestBinding] : args,
       );
+      // Keep validated provider-returned usage private to this actual call.
+      // It is not settled yet: the host consumes token-usage exactly once.
+      try {
+        call.returnedUsage = projectRuntimeTokenUsage({
+          callId: call.callId,
+          provider: result?.provider || call.provider,
+          model: result?.model || call.model,
+          source: call.source,
+          usage: result?.usage,
+        });
+        if (result?.callId && result.callId !== call.callId)
+          call.returnedUsage = null;
+      } catch {
+        call.returnedUsage = null;
+      }
       call.providerReceipt = providerRequestId
         ? _snapshotProviderRequestReceipt(
             result?.providerReceipt,
@@ -13879,6 +13913,7 @@ function _instrumentAutoCompactorUsage(compactor, options) {
         : null;
       return result;
     } catch (error) {
+      call.returnedUsage = null;
       if (workflowEffectId) {
         throw _workflowCompactionOutcomeUnknown(error);
       }
@@ -14026,8 +14061,8 @@ async function _getAutoCompactor(options) {
               compressOptions,
               sessionId: options.sessionId,
               operationId: `auto-${randomUUID()}`,
-              provider: options.provider,
-              model: options.model,
+              provider: options.provider || "ollama",
+              model: options.model || "unknown",
               env: options.contextMemoryEnv || process.env,
               persist: options.persistCompaction !== false,
               trigger: "auto",
@@ -15062,6 +15097,37 @@ export async function* agentLoop(messages, options) {
             !["committed", "degraded"].includes(stats.canonicalReceipt.status)
           ) {
             automaticCompactionSettlementBlocked = true;
+            const unsettledCall = compactionUsageState.calls.at(-1);
+            if (unsettledCall) {
+              const providerReceipt = _takeCompactionProviderReceipt(
+                unsettledCall,
+                workflowEffectId,
+              );
+              if (providerReceipt) yield providerReceipt;
+              if (
+                unsettledCall.returnedUsage &&
+                stats.summaryUsageUnknown !== true
+              ) {
+                yield {
+                  type: "token-usage",
+                  ...unsettledCall.returnedUsage,
+                  runId,
+                };
+              } else {
+                yield {
+                  type: "compaction-usage-unknown",
+                  callId: unsettledCall.callId,
+                  runId,
+                  provider: unsettledCall.provider,
+                  model: unsettledCall.model,
+                  source: "semantic-compaction",
+                  code: "provider_usage_unsettled",
+                  reason:
+                    stats.summaryUsageUnknownReason ||
+                    "provider_transport_outcome_unknown",
+                };
+              }
+            }
             yield {
               type: "compaction-degraded",
               runId,
@@ -15080,6 +15146,20 @@ export async function* agentLoop(messages, options) {
               backgroundSubAgents,
               backgroundUsageFailureState,
             );
+            if (workflowEffectId) {
+              throw _markWorkflowCompactionFailureReported(
+                _workflowCompactionOutcomeUnknown(
+                  null,
+                  "CC_WORKFLOW_COMPACTION_SETTLEMENT_UNKNOWN",
+                  "Workflow-bound semantic compaction requires reconciliation",
+                ),
+              );
+            }
+            yield {
+              type: "run-ended",
+              runId,
+              reason: "compaction-settlement-failed",
+            };
             return;
           }
           const observerFailure = compactionUsageState.calls.find(
@@ -15092,16 +15172,11 @@ export async function* agentLoop(messages, options) {
           }
           compactionUsageCall = compactionUsageState.calls.at(-1) || null;
           const compactionUsage = _compactionTokenUsage(stats);
-          if (compactionUsageCall?.providerReceipt) {
-            yield {
-              type: "provider-request-receipt",
-              callId: compactionUsageCall.callId,
-              workflowEffectId,
-              callSequence: compactionUsageCall.callSequence,
-              source: "semantic-compaction",
-              ...compactionUsageCall.providerReceipt,
-            };
-          }
+          const providerReceipt = _takeCompactionProviderReceipt(
+            compactionUsageCall,
+            workflowEffectId,
+          );
+          if (providerReceipt) yield providerReceipt;
           if (stats.degraded === true) {
             const usageOutcomeUnknown = stats.summaryUsageUnknown === true;
             const projectedStats = usageOutcomeUnknown
@@ -15177,6 +15252,11 @@ export async function* agentLoop(messages, options) {
                 ),
               );
             }
+            yield {
+              type: "run-ended",
+              runId,
+              reason: "compaction-usage-unknown",
+            };
             return;
           }
           if (
@@ -15239,6 +15319,11 @@ export async function* agentLoop(messages, options) {
                   ),
                 );
               }
+              yield {
+                type: "run-ended",
+                runId,
+                reason: "compaction-settlement-failed",
+              };
               return;
             }
             if (!hermeticExecution) {
@@ -15303,6 +15388,79 @@ export async function* agentLoop(messages, options) {
         }
         compactionUsageCall =
           compactionUsageCall || compactionUsageState?.calls?.at(-1) || null;
+        const { getRejectedCompactionUsage } =
+          await import("../lib/context-memory-kernel/live-compaction.js");
+        const rejectedUsage = getRejectedCompactionUsage(_e);
+        const returnedUsage = compactionUsageCall?.returnedUsage;
+        const providerReceipt = _takeCompactionProviderReceipt(
+          compactionUsageCall,
+          workflowEffectId,
+        );
+        if (providerReceipt) yield providerReceipt;
+        const knownPlanRejection =
+          rejectedUsage &&
+          returnedUsage &&
+          (!rejectedUsage.callId ||
+            rejectedUsage.callId === returnedUsage.callId) &&
+          (!rejectedUsage.receipt.callId ||
+            rejectedUsage.receipt.callId === returnedUsage.callId) &&
+          rejectedUsage.provider === returnedUsage.provider &&
+          rejectedUsage.model === returnedUsage.model &&
+          [
+            "input_tokens",
+            "output_tokens",
+            "cache_read_input_tokens",
+            "cache_creation_input_tokens",
+          ].every(
+            (field) =>
+              rejectedUsage.usage[field] === returnedUsage.usage[field],
+          );
+        if (knownPlanRejection || (!rejectedUsage && returnedUsage)) {
+          automaticCompactionSettlementBlocked = true;
+          // Yield through the existing host ledger/budget settlement path;
+          // never claim a callback or an error flag already paid this debt.
+          yield { type: "token-usage", ...returnedUsage, runId };
+          yield {
+            type: "compaction-degraded",
+            runId,
+            code: _e.code,
+            reason: knownPlanRejection
+              ? "canonical_compaction_plan_rejected"
+              : "canonical_compaction_settlement_failed",
+            summaryMode: "none",
+          };
+          await _awaitBackgroundUsageSettlement(
+            backgroundSubAgents,
+            backgroundUsageFailureState,
+          );
+          if (workflowEffectId) {
+            if (knownPlanRejection) {
+              const error = new Error(
+                "Workflow-bound compaction plan was rejected; the task is incomplete",
+                { cause: _e },
+              );
+              error.code = "CC_WORKFLOW_COMPACTION_PLAN_REJECTED";
+              error.contextOutcome = "aborted";
+              error.usageOutcome = "known";
+              throw error;
+            }
+            const error = _workflowCompactionOutcomeUnknown(
+              _e,
+              "CC_WORKFLOW_COMPACTION_SETTLEMENT_UNKNOWN",
+              "Workflow-bound semantic compaction settlement is unknown",
+            );
+            error.usageOutcome = "known";
+            throw _markWorkflowCompactionFailureReported(error);
+          }
+          yield {
+            type: "run-ended",
+            runId,
+            reason: knownPlanRejection
+              ? "compaction-plan-rejected"
+              : "compaction-settlement-failed",
+          };
+          return;
+        }
         if (compactionUsageCall) {
           automaticCompactionSettlementBlocked = true;
           yield {
@@ -15326,6 +15484,11 @@ export async function* agentLoop(messages, options) {
                 : _workflowCompactionOutcomeUnknown(_e),
             );
           }
+          yield {
+            type: "run-ended",
+            runId,
+            reason: "compaction-usage-unknown",
+          };
           return;
         }
         yield {