chainlesschain 0.166.74 → 0.166.77

package/src/lib/decision-layer/runtime.js

@@ -38,12 +38,28 @@ function timeoutSignal(signal, timeoutMs) {
 
 function projectUnavailable(error) {
   if (error?.name === "TimeoutError") return "provider-timeout";
+  if (error?.code === "CC_DECISION_USAGE_UNKNOWN_BLOCKED") {
+    return "provider-usage-unknown-blocked";
+  }
   if (error?.code === "CC_DECISION_PROVIDER_HTTP_ERROR") {
     return "provider-http-error";
   }
   return "provider-unavailable";
 }
 
+function unavailableOutcome(reasonCode) {
+  return {
+    status: "unavailable",
+    reasonCode,
+    selectedCandidateId: null,
+    selectedDigest: null,
+    selectedSkillId: null,
+    needsSkillProbability: null,
+    choiceConfidence: null,
+    resultDigest: null,
+  };
+}
+
 function asPersistenceError(error) {
   if (error?.runtimeLedgerPersistence === true) return error;
   try {
@@ -63,6 +79,7 @@ export function createSkillDecisionRuntime({
   persist = null,
   observe = null,
   sessionBudget = null,
+  initialUsageUnknown = false,
   thresholds = {},
   timeoutMs = DEFAULT_TIMEOUT_MS,
   idGenerator = () => randomUUID(),
@@ -84,6 +101,7 @@ export function createSkillDecisionRuntime({
   let providerAuthority = null;
   let boundTenantId = null;
   let boundSessionId = null;
+  let unknownUsageSeen = initialUsageUnknown === true;
   if (normalizedMode !== "off") {
     providerAuthority = captureDecisionProviderAuthority(provider);
     boundTenantId = requiredText(tenantId, "tenantId");
@@ -104,6 +122,11 @@ export function createSkillDecisionRuntime({
     }
   };
 
+  const persistDecisionUsage = async (type, event) => {
+    await persist(type, event);
+    if (type === "model_usage_unknown") unknownUsageSeen = true;
+  };
+
   const runtime = Object.freeze({
     schema: SKILL_DECISION_RUNTIME_SCHEMA,
     mode: normalizedMode,
@@ -144,56 +167,70 @@ export function createSkillDecisionRuntime({
       }
       let outcome;
       let requestSignal = null;
-      try {
-        const raw = await runMeteredDirectModelCall({
-          sessionId: boundSessionId,
-          persist,
-          provider: providerAuthority.provider,
-          model: providerAuthority.model,
-          source: "model",
-          operationId: `decision:${decisionId}`,
-          sessionBudget,
-          call: () => {
-            requestSignal = timeoutSignal(signal, timeoutMs);
-            return providerAuthority.decide(request, {
-              signal: requestSignal,
-            });
-          },
-        });
-        const normalized = normalizeSkillDecisionProviderResult(request, raw);
-        const resolved = resolveSkillDecision(request, normalized, thresholds);
-        outcome = {
-          status: resolved.status,
-          reasonCode: resolved.reasonCode,
-          selectedCandidateId: resolved.selectedCandidateId,
-          selectedDigest: resolved.selectedDigest,
-          selectedSkillId: resolved.selectedSkillId,
-          needsSkillProbability: resolved.needsSkillProbability,
-          choiceConfidence: resolved.choiceConfidence,
-          resultDigest: resolved.resultDigest,
-        };
-      } catch (error) {
-        const localTimeout =
-          !signal?.aborted &&
-          requestSignal?.aborted &&
-          requestSignal.reason === error &&
-          error?.name === "TimeoutError";
-        if (
-          signal?.aborted ||
-          (isTerminalModelFailure(error) && !localTimeout)
-        ) {
-          throw error;
+      if (unknownUsageSeen) {
+        outcome = unavailableOutcome("provider-usage-unknown-blocked");
+      } else {
+        try {
+          const { result: raw, settlement } = await runMeteredDirectModelCall({
+            sessionId: boundSessionId,
+            persist: persistDecisionUsage,
+            provider: providerAuthority.provider,
+            model: providerAuthority.model,
+            source: "model",
+            operationId: `decision:${decisionId}`,
+            sessionBudget,
+            includeSettlement: true,
+            call: () => {
+              if (unknownUsageSeen) {
+                const error = new Error("decision usage recovery is required");
+                error.code = "CC_DECISION_USAGE_UNKNOWN_BLOCKED";
+                throw error;
+              }
+              requestSignal = timeoutSignal(signal, timeoutMs);
+              return providerAuthority.decide(request, {
+                signal: requestSignal,
+              });
+            },
+          });
+          if (settlement !== "known") {
+            // The metered call already persisted model_usage_unknown. Without a
+            // budget root it may return the answer; never expose that answer.
+            outcome = unavailableOutcome("provider-usage-unknown");
+          } else {
+            const normalized = normalizeSkillDecisionProviderResult(
+              request,
+              raw,
+            );
+            const resolved = resolveSkillDecision(
+              request,
+              normalized,
+              thresholds,
+            );
+            outcome = {
+              status: resolved.status,
+              reasonCode: resolved.reasonCode,
+              selectedCandidateId: resolved.selectedCandidateId,
+              selectedDigest: resolved.selectedDigest,
+              selectedSkillId: resolved.selectedSkillId,
+              needsSkillProbability: resolved.needsSkillProbability,
+              choiceConfidence: resolved.choiceConfidence,
+              resultDigest: resolved.resultDigest,
+            };
+          }
+        } catch (error) {
+          const localTimeout =
+            !signal?.aborted &&
+            requestSignal?.aborted &&
+            requestSignal.reason === error &&
+            error?.name === "TimeoutError";
+          if (
+            signal?.aborted ||
+            (isTerminalModelFailure(error) && !localTimeout)
+          ) {
+            throw error;
+          }
+          outcome = unavailableOutcome(projectUnavailable(error));
         }
-        outcome = {
-          status: "unavailable",
-          reasonCode: projectUnavailable(error),
-          selectedCandidateId: null,
-          selectedDigest: null,
-          selectedSkillId: null,
-          needsSkillProbability: null,
-          choiceConfidence: null,
-          resultDigest: null,
-        };
       }
       const finishedAt = now();
       if (

package/src/lib/direct-model-usage.js

@@ -54,6 +54,7 @@ function unknownUsageEvent({
  * Meter one direct provider call that runs outside agentLoop. The started row is
  * durable before the callback resumes into provider work; every outcome then
  * settles known or unknown without persisting prompts, responses, or errors.
+ * Opt-in includeSettlement returns that persisted status with the raw result.
  */
 export async function runMeteredDirectModelCall({
   sessionId,
@@ -63,6 +64,7 @@ export async function runMeteredDirectModelCall({
   source = "model",
   operationId = undefined,
   sessionBudget = null,
+  includeSettlement = false,
   call,
 }) {
   if (typeof call !== "function") {
@@ -78,7 +80,12 @@ export async function runMeteredDirectModelCall({
       );
     }
   }
-  if (!sessionId) return call();
+  if (!sessionId) {
+    if (includeSettlement) {
+      throw new TypeError("direct model settlement requires a session");
+    }
+    return call();
+  }
   if (typeof persist !== "function") {
     throw new TypeError("metered direct model call requires persistence");
   }
@@ -96,6 +103,9 @@ export async function runMeteredDirectModelCall({
     `direct model call ${source}`,
   );
   let result;
+  let settlement = "unknown";
+  const returnSettled = (status) =>
+    includeSettlement ? Object.freeze({ result, settlement: status }) : result;
   try {
     result = await call();
   } catch (error) {
@@ -139,7 +149,7 @@ export async function runMeteredDirectModelCall({
       if (markSessionBudgetUsageUnknown(sessionBudget, unknown)) {
         rejectSessionBudgetUsageUnknown(unknown, `direct model call ${source}`);
       }
-      return result;
+      return returnSettled("unknown");
     }
     await persistUsageEvent(persist, "token_usage", event);
     recordSessionBudgetUsage(
@@ -147,6 +157,7 @@ export async function runMeteredDirectModelCall({
       event,
       `direct model call ${source} usage settlement`,
     );
+    settlement = "known";
   } else {
     const unknown = unknownUsageEvent({
       callId,
@@ -161,5 +172,5 @@ export async function runMeteredDirectModelCall({
       rejectSessionBudgetUsageUnknown(unknown, `direct model call ${source}`);
     }
   }
-  return result;
+  return returnSettled(settlement);
 }

package/src/lib/evolution/evolution-eval-child-evidence-ledger-adapter.js

@@ -8,6 +8,8 @@ import {
   EVOLUTION_EVAL_SUPERVISION_SCHEMA,
   EVOLUTION_EVAL_TARGET_INVOCATION_SCHEMA,
   EVOLUTION_EVAL_TARGET_REVOCATION_SCHEMA,
+} from "./evolution-eval-contracts.js";
+import {
   computeEvolutionEvalReceiptDigest,
   computeEvolutionEvalSignedEvidenceDigest,
 } from "./evolution-eval-gate.js";