@axlsdk/axl 0.24.1 → 0.24.3

package/dist/index.cjs

@@ -343,6 +343,12 @@ function isEventStreamOverflowError(error) {
 function rethrowEventStreamOverflow(error) {
   if (isEventStreamOverflowError(error)) throw error;
 }
+function isUnrecoverableError(error) {
+  return isEventStreamOverflowError(error) || isAdmissionDeniedError(error);
+}
+function rethrowUnrecoverable(error) {
+  if (isUnrecoverableError(error)) throw error;
+}
 function preserveErrorCause(error, cause) {
   if (cause === void 0 || cause === error || "cause" in error) return error;
   Object.defineProperty(error, "cause", {
@@ -352,12 +358,14 @@ function preserveErrorCause(error, cause) {
   });
   return error;
 }
+var TOOL_FAILURE_MARKER = /* @__PURE__ */ Symbol.for("axl.toolFailure.v1");
 var ToolFailure = class extends AxlError {
   modelMessage;
   constructor(options) {
     super(options.code ?? "TOOL_FAILURE", options.message);
     this.name = "ToolFailure";
     this.modelMessage = options.modelMessage;
+    Object.defineProperty(this, TOOL_FAILURE_MARKER, { value: true });
     if (options.cause !== void 0) {
       Object.defineProperty(this, "cause", {
         configurable: true,
@@ -367,6 +375,13 @@ var ToolFailure = class extends AxlError {
     }
   }
 };
+function isToolFailureError(error) {
+  try {
+    return error instanceof ToolFailure || typeof error === "object" && error !== null && error[TOOL_FAILURE_MARKER] === true && typeof error.modelMessage === "string";
+  } catch {
+    return false;
+  }
+}
 var ToolModelOutputError = class extends AxlError {
   toolName;
   cause;
@@ -548,7 +563,7 @@ var sharedGuard = typeof installedGuard === "object" && installedGuard !== null
 var buildPath = typeof __AXL_BUILD_PATH__ === "string" ? __AXL_BUILD_PATH__ : "<source>";
 var thisCopy = {
   path: buildPath.startsWith("file:") ? (0, import_node_url.fileURLToPath)(buildPath) : buildPath,
-  version: true ? "0.24.1" : "unknown"
+  version: true ? "0.24.3" : "unknown"
 };
 function warnCrossCopy(other, joined) {
   if (other === thisCopy) return;
@@ -649,10 +664,16 @@ var AccountingScope = class {
   reasons = /* @__PURE__ */ new Map();
   breakdown = { generation: 0, judging: 0, external: 0 };
   provenance = /* @__PURE__ */ new Map();
+  modelCalls = /* @__PURE__ */ new Map();
+  modelTiming = /* @__PURE__ */ new Map();
+  diagnosticTokens = { input: 0, output: 0, reasoning: 0 };
+  agentCalls = 0;
+  captureTimingSamples;
   constructor(options) {
     this.parent = options.parent;
     this.purpose = options.purpose;
     this.admission = options.admission;
+    this.captureTimingSamples = options.captureTimingSamples === true;
   }
   get isFinalized() {
     return this.finalized;
@@ -681,7 +702,7 @@ var AccountingScope = class {
     else this.byKind.delete(op.kind);
     this.denied += 1;
   }
-  recordSettled(op, cost, provenance, usage) {
+  recordSettled(op, cost, provenance, usage, timing) {
     this.seen.add(op.id);
     this.openOps.delete(op.id);
     this.settled += 1;
@@ -690,13 +711,57 @@ var AccountingScope = class {
     else this.breakdown[op.purpose] += cost;
     this.provenance.set(provenance, (this.provenance.get(provenance) ?? 0) + cost);
     if (usage) this.addUsage(usage);
+    this.recordAgentCall(op, usage, timing);
   }
-  recordUnknown(op, reason, usage) {
+  recordUnknown(op, reason, usage, timing) {
     this.seen.add(op.id);
     this.openOps.delete(op.id);
     this.unknown += 1;
     this.reasons.set(reason, (this.reasons.get(reason) ?? 0) + 1);
     if (usage) this.addUsage(usage);
+    this.recordAgentCall(op, usage, timing);
+  }
+  recordAgentCall(op, usage, timing) {
+    if (!op.agentCall) return;
+    this.agentCalls++;
+    const model = op.diagnosticModelUri ?? op.model;
+    if (!model) return;
+    this.modelCalls.set(model, (this.modelCalls.get(model) ?? 0) + 1);
+    if (usage) {
+      const finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+      this.diagnosticTokens.input += finite(usage.inputTokens);
+      this.diagnosticTokens.output += finite(usage.outputTokens);
+      this.diagnosticTokens.reasoning += finite(usage.reasoningTokens);
+    }
+    if (!timing) return;
+    let bucket = this.modelTiming.get(model);
+    if (!bucket) {
+      bucket = {
+        calls: 0,
+        queuedMs: 0,
+        retryMs: 0,
+        wireMs: 0,
+        ...this.captureTimingSamples ? { samples: [] } : {}
+      };
+      this.modelTiming.set(model, bucket);
+    }
+    bucket.calls++;
+    bucket.queuedMs += timing.queuedMs;
+    bucket.retryMs += timing.retryMs;
+    bucket.wireMs += timing.wireMs;
+    bucket.samples?.push(timing);
+    if (timing.firstTokenMs != null) {
+      bucket.firstTokenMs = (bucket.firstTokenMs ?? 0) + timing.firstTokenMs;
+      bucket.firstTokenCalls = (bucket.firstTokenCalls ?? 0) + 1;
+    }
+  }
+  toDiagnostics() {
+    return {
+      modelCallCounts: Object.fromEntries(this.modelCalls),
+      tokens: { ...this.diagnosticTokens },
+      agentCalls: this.agentCalls,
+      modelTiming: Object.fromEntries(this.modelTiming)
+    };
   }
   hasSeen(id) {
     return this.seen.has(id);
@@ -768,14 +833,14 @@ function settleOperationUp(start, op, outcome) {
     if (scope.isFinalized) return;
     switch (outcome.outcome) {
       case "settled":
-        scope.recordSettled(op, outcome.cost, outcome.provenance, outcome.usage);
+        scope.recordSettled(op, outcome.cost, outcome.provenance, outcome.usage, outcome.timing);
         if (scope.admission && !chargedControllers.has(scope.admission)) {
           chargedControllers.add(scope.admission);
           recordSpend(scope.admission, outcome.cost);
         }
         break;
       case "unknown":
-        scope.recordUnknown(op, outcome.reason, outcome.usage);
+        scope.recordUnknown(op, outcome.reason, outcome.usage, outcome.timing);
         break;
       case "retracted":
         scope.recordRetracted(op);
@@ -827,6 +892,8 @@ function openOperation(descriptor) {
     kind: descriptor.kind,
     purpose: scope.purpose,
     model: descriptor.model,
+    diagnosticModelUri: descriptor.diagnosticModelUri,
+    agentCall: descriptor.agentCall === true,
     dispatched: false,
     dispatchObservable: false
   };
@@ -867,25 +934,31 @@ function openOperation(descriptor) {
           outcome: "settled",
           cost: input.cost,
           provenance: input.provenance ?? "adapter_reported",
-          usage: input.usage
+          usage: input.usage,
+          timing: input.timing
         });
         return;
       }
       if (input.cost !== void 0 || input.usage !== void 0) {
-        finish({ outcome: "unknown", reason: "unpriced_model", usage: input.usage });
+        finish({
+          outcome: "unknown",
+          reason: "unpriced_model",
+          usage: input.usage,
+          timing: input.timing
+        });
         return;
       }
-      handle.settleFailure();
+      handle.settleFailure(void 0, input.timing);
     },
     settleUnknown(reason, usage) {
       finish({ outcome: "unknown", reason, usage });
     },
-    settleFailure(usage) {
+    settleFailure(usage, timing) {
       if (op.dispatchObservable && !op.dispatched) {
-        finish({ outcome: "settled", cost: 0, provenance: "adapter_reported", usage });
+        finish({ outcome: "settled", cost: 0, provenance: "adapter_reported", usage, timing });
         return;
       }
-      finish({ outcome: "unknown", reason: "usage_missing", usage });
+      finish({ outcome: "unknown", reason: "usage_missing", usage, timing });
     },
     run(fn) {
       return runWithDispatchAdmission(handle.dispatchAdmission, fn);
@@ -898,7 +971,8 @@ async function runInAccountingScope(options, fn) {
   const scope = new AccountingScope({
     parent,
     purpose: options.purpose ?? parent?.purpose ?? "generation",
-    admission: options.admission
+    admission: options.admission,
+    captureTimingSamples: options.captureTimingSamples
   });
   const inheritedGuard = sharedGuard.storage.getStore();
   const enclosingGuard = inheritedGuard && (inheritedGuard.isActive?.() ?? true) ? inheritedGuard : void 0;
@@ -916,7 +990,8 @@ async function runInAccountingScope(options, fn) {
           "The active @axlsdk/axl accounting scope uses an incompatible loaded copy; paid work was refused before dispatch."
         )
       },
-      accounting: scope.toAccounting()
+      accounting: scope.toAccounting(),
+      diagnostics: scope.toDiagnostics()
     };
   }
   const markUninstrumented = () => {
@@ -940,10 +1015,18 @@ async function runInAccountingScope(options, fn) {
       () => accountingStorage.run(scope, fn)
     );
     scope.finalize();
-    return { outcome: { status: "fulfilled", value }, accounting: scope.toAccounting() };
+    return {
+      outcome: { status: "fulfilled", value },
+      accounting: scope.toAccounting(),
+      diagnostics: scope.toDiagnostics()
+    };
   } catch (error) {
     scope.finalize();
-    return { outcome: { status: "rejected", error }, accounting: scope.toAccounting() };
+    return {
+      outcome: { status: "rejected", error },
+      accounting: scope.toAccounting(),
+      diagnostics: scope.toDiagnostics()
+    };
   }
 }
 function validateReportedCost(amountUsd) {
@@ -1322,10 +1405,12 @@ function toolArgumentIssues(error) {
   }
   return [{ path: [], code: "invalid_arguments", message: "Tool arguments are invalid." }];
 }
-var TOOL_INTERNALS = /* @__PURE__ */ new WeakMap();
+var TOOL_INTERNALS = /* @__PURE__ */ Symbol.for("axl.tool.internals.v1");
 function getToolInternals(tool2) {
-  const internals = TOOL_INTERNALS.get(tool2);
-  if (!internals) throw new Error(`Tool "${tool2.name}" was not created by tool()`);
+  const internals = tool2[TOOL_INTERNALS];
+  if (!internals || typeof internals.prepareInput !== "function" || typeof internals.executePrepared !== "function") {
+    throw new Error(`Tool "${tool2.name}" was not created by a compatible tool()`);
+  }
   return internals;
 }
 function prepareToolInput(tool2, input) {
@@ -1372,8 +1457,7 @@ function tool(config) {
       } catch (err) {
         if (options?.signal?.aborted) options.signal.throwIfAborted();
         if (isAbortError(err)) throw err;
-        if (isAdmissionDeniedError(err)) throw err;
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
         lastError = err instanceof Error ? err : new Error(String(err));
         if (attempt === maxAttempts) break;
         if (retryPolicy.on && !retryPolicy.on(lastError)) {
@@ -1426,9 +1510,11 @@ function tool(config) {
     },
     _execute: execute
   };
-  TOOL_INTERNALS.set(instance, {
-    prepareInput,
-    executePrepared
+  Object.defineProperty(instance, TOOL_INTERNALS, {
+    value: {
+      prepareInput,
+      executePrepared
+    }
   });
   return instance;
 }
@@ -1459,6 +1545,7 @@ async function resolveApiKey(source) {
 // src/providers/default-endpoints.ts
 var OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
 var ANTHROPIC_DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
+var GEMINI_DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 
 // src/providers/rate-limiter.ts
 function sanitizeRateLimitConfig(config) {
@@ -1856,12 +1943,36 @@ var anthropicQuotaDialect = makeDialect(
     return "unknown";
   }
 );
+var geminiQuotaDialect = makeDialect([], (error) => {
+  if (error.code === "quota_exceeded") return "spend_cap";
+  if (Array.isArray(error.details)) {
+    for (const detail of error.details) {
+      if (typeof detail !== "object" || detail === null) continue;
+      const violations = detail.violations;
+      if (!Array.isArray(violations)) continue;
+      if (violations.some((violation) => {
+        if (typeof violation !== "object" || violation === null) return false;
+        const id = violation.quotaId;
+        return typeof id === "string" && /perday|daily|spend|billing/i.test(id);
+      }))
+        return "spend_cap";
+    }
+  }
+  const message = error.message;
+  if (typeof message === "string" && /monthly spending cap|spend(?:-based|ing)? (?:cap|limit)|prepay(?:ment)? credits? (?:are )?depleted/i.test(
+    message
+  )) {
+    return "spend_cap";
+  }
+  return "unknown";
+});
 var DIALECTS = /* @__PURE__ */ new Map([
   ["openai", { origin: new URL(OPENAI_DEFAULT_BASE_URL).origin, dialect: openaiQuotaDialect }],
   [
     "anthropic",
     { origin: new URL(ANTHROPIC_DEFAULT_BASE_URL).origin, dialect: anthropicQuotaDialect }
-  ]
+  ],
+  ["google", { origin: new URL(GEMINI_DEFAULT_BASE_URL).origin, dialect: geminiQuotaDialect }]
 ]);
 function quotaDialectFor(family, origin) {
   const entry = DIALECTS.get(family);
@@ -6052,7 +6163,7 @@ var GEMINI_PRICING = {
   },
   "gemini-3.8-flash": { input: 75e-8, cached: 75e-9, output: 375e-8 }
 };
-var CANONICAL_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+var CANONICAL_GEMINI_BASE_URL = GEMINI_DEFAULT_BASE_URL;
 function isValidTokenCount2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -6409,10 +6520,7 @@ var GeminiProvider = class {
   axlRateGovernors;
   constructor(options = {}) {
     this.apiKeySource = options.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY ?? "";
-    this.baseUrl = (options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta").replace(
-      /\/$/,
-      ""
-    );
+    this.baseUrl = (options.baseUrl ?? GEMINI_DEFAULT_BASE_URL).replace(/\/$/, "");
     assertSafeProviderBaseUrl(
       this.baseUrl,
       "Google provider",
@@ -11611,6 +11719,34 @@ function toAccountingUsage(usage) {
     cacheWriteTokens: usage.cache_write_tokens ?? 0
   };
 }
+function safeTiming(response) {
+  try {
+    const timing = response.timing;
+    if (!timing) return void 0;
+    const queuedMs = timing.queuedMs;
+    const retryMs = timing.retryMs;
+    const wireMs = timing.wireMs;
+    if (![queuedMs, retryMs, wireMs].every((value) => Number.isFinite(value) && value >= 0)) {
+      return void 0;
+    }
+    const attempts = timing.attempts;
+    const ttfbMs = timing.ttfbMs;
+    const rateLimitRetries = timing.rateLimitRetries;
+    const firstTokenMs = timing.firstTokenMs;
+    const valid = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+    return {
+      queuedMs,
+      retryMs,
+      wireMs,
+      ...valid(attempts) ? { attempts } : {},
+      ...valid(ttfbMs) ? { ttfbMs } : {},
+      ...valid(rateLimitRetries) ? { rateLimitRetries } : {},
+      ...valid(firstTokenMs) ? { firstTokenMs } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
 function composeLifecycle(caller, onDispatch) {
   return {
     onDispatch() {
@@ -11804,7 +11940,13 @@ var CaptureRecorder = class {
   }
 };
 function openProviderOperation(raw, kind, options) {
-  const handle = openOperation({ kind, model: options.model, provider: raw.name });
+  const handle = openOperation({
+    kind,
+    model: options.model,
+    diagnosticModelUri: options.accountingModelUri,
+    provider: raw.name,
+    agentCall: options.accountingModelUri !== void 0
+  });
   if (handle && raw.reportsRequestLifecycle === true) handle.markDispatchObservable();
   return handle;
 }
@@ -11821,7 +11963,8 @@ function createScopedProvider(raw) {
       handle.settle({
         cost: response.cost,
         provenance: response.costProvenance,
-        usage: toAccountingUsage(response.usage)
+        usage: toAccountingUsage(response.usage),
+        timing: safeTiming(response)
       });
       recorder?.end({ response });
       return response;
@@ -11876,7 +12019,8 @@ function createScopedProvider(raw) {
             handle?.settle({
               cost: result.value.cost,
               provenance: result.value.costProvenance,
-              usage: toAccountingUsage(result.value.usage)
+              usage: toAccountingUsage(result.value.usage),
+              timing: safeTiming(result.value)
             });
             settled = true;
             recorder?.end({
@@ -12309,13 +12453,6 @@ function eventError(error) {
     return { name: "Error", message: "Unknown thrown value" };
   }
 }
-function isToolFailure(error) {
-  try {
-    return error instanceof ToolFailure;
-  } catch {
-    return false;
-  }
-}
 function cancellation(phase, error, result) {
   let reason;
   try {
@@ -12331,7 +12468,7 @@ function cancellation(phase, error, result) {
 }
 function failed(phase, error, options = {}) {
   let modelMessage;
-  if (isToolFailure(error)) {
+  if (isToolFailureError(error)) {
     try {
       modelMessage = typeof error.modelMessage === "string" ? error.modelMessage : void 0;
     } catch {
@@ -12456,8 +12593,7 @@ async function executeAcceptedTool(options) {
       }
     }
   } catch (error) {
-    rethrowEventStreamOverflow(error);
-    if (isAdmissionDeniedError(error)) throw error;
+    rethrowUnrecoverable(error);
     const abort = cancellationError(signal, error);
     if (abort !== void 0) return cancellation("handler", abort);
     return failed("handler", error, { attempts });
@@ -14019,6 +14155,7 @@ ${appendedSchemaText}`;
       const turnStart = Date.now();
       const chatOptions = {
         model,
+        accountingModelUri: effectiveModelUri,
         temperature: options?.temperature ?? agent2._config.temperature,
         tools: toolDefs.length > 0 ? toolDefs : void 0,
         maxTokens: options?.maxTokens ?? agent2._config.maxTokens ?? 4096,
@@ -14722,7 +14859,8 @@ ${appendedSchemaText}`;
             metadata: this.metadata
           });
         } catch (err) {
-          rethrowEventStreamOverflow(err);
+          rethrowUnrecoverable(err);
+          if (this.currentSignal?.aborted) throw err;
           validateErr = err;
           const reason = err instanceof Error ? err.message : String(err);
           validateResult = { valid: false, reason: `Validator error: ${reason}` };
@@ -15313,15 +15451,13 @@ ${summaryResponse.content}`
               reject(new QuorumNotMet(quorum, successCount, results));
             }
           }).catch((err) => {
-            if (isEventStreamOverflowError(err)) {
-              if (!settled) {
-                settled = true;
-                controller.abort();
-                reject(err);
-              }
+            if (settled) return;
+            if (isUnrecoverableError(err) || parentSignal2?.aborted) {
+              settled = true;
+              controller.abort();
+              reject(err);
               return;
             }
-            if (settled) return;
             const isAbort = err instanceof DOMException && err.name === "AbortError";
             if (isAbort) {
               completedCount++;
@@ -15344,7 +15480,8 @@ ${summaryResponse.content}`
     const parentSignal = this.currentSignal;
     const promises = Array.from({ length: n }, (_, i) => {
       const run = () => fn(i).then((value) => ({ ok: true, value })).catch((err) => {
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
+        if (parentSignal?.aborted) throw err;
         return {
           ok: false,
           error: err instanceof Error ? err.message : String(err)
@@ -15468,6 +15605,7 @@ ${summaryResponse.content}`
   async verify(fn, schema, options) {
     const maxRetries = options?.retries ?? 3;
     let lastRetry = void 0;
+    const scopeSignal = this.currentSignal;
     const emitVerifyOutcome = (passed, attempts, lastError) => {
       this.emitEvent({
         type: "verify",
@@ -15490,25 +15628,24 @@ ${summaryResponse.content}`
           try {
             validateResult = await options.validate(parsed, { metadata: this.metadata });
           } catch (err) {
-            rethrowEventStreamOverflow(err);
+            rethrowUnrecoverable(err);
+            if (scopeSignal?.aborted) throw err;
             const reason = err instanceof Error ? err.message : String(err);
             validateResult = { valid: false, reason: `Validator error: ${reason}` };
           }
           if (!validateResult.valid) {
+            scopeSignal?.throwIfAborted();
             const errorMsg = validateResult.reason ?? "Validation failed";
             lastRetry = { error: errorMsg, output: rawOutput, parsed };
-            if (attempt === maxRetries) {
-              emitVerifyOutcome(false, attempt + 1, errorMsg);
-              if (options?.fallback !== void 0) return options.fallback;
-              throw new ValidationError(parsed, errorMsg, maxRetries);
-            }
+            if (attempt === maxRetries) throw new ValidationError(parsed, errorMsg, maxRetries);
             continue;
           }
         }
         emitVerifyOutcome(true, attempt + 1);
         return parsed;
       } catch (err) {
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
+        if (scopeSignal?.aborted) throw err;
         if (err instanceof ValidationError) {
           lastRetry = {
             error: err.reason,
@@ -15575,7 +15712,8 @@ ${summaryResponse.content}`
         const unpriced = this.budgetContext.unpriced;
         return { value, budgetExceeded: exceeded, totalCost, unpriced };
       } catch (err) {
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
+        if (parentSignal?.aborted) throw err;
         if (this.budgetContext.exceeded) {
           return {
             value: null,
@@ -15584,14 +15722,6 @@ ${summaryResponse.content}`
             unpriced: this.budgetContext.unpriced
           };
         }
-        if (err instanceof DOMException && err.name === "AbortError" && controller) {
-          return {
-            value: null,
-            budgetExceeded: true,
-            totalCost: this.budgetContext.totalCost,
-            unpriced: this.budgetContext.unpriced
-          };
-        }
         throw err;
       } finally {
         if (parentBudget) {
@@ -15707,7 +15837,8 @@ ${summaryResponse.content}`
                   return;
                 }
               } catch (err) {
-                rethrowEventStreamOverflow(err);
+                rethrowUnrecoverable(err);
+                if (parentSignal?.aborted) throw err;
                 remaining--;
                 lastError = err instanceof Error ? err : new Error(`Validator error: ${String(err)}`);
                 if (remaining === 0 && !settled) {
@@ -15727,7 +15858,7 @@ ${summaryResponse.content}`
           controller.abort();
           resolve2(value);
         }).catch((err) => {
-          if (isEventStreamOverflowError(err)) {
+          if (isUnrecoverableError(err)) {
             if (!settled) {
               settled = true;
               controller.abort();
@@ -15736,6 +15867,12 @@ ${summaryResponse.content}`
             throw err;
           }
           if (settled) return;
+          if (parentSignal?.aborted) {
+            settled = true;
+            controller.abort();
+            reject(err);
+            return;
+          }
           if (err instanceof DOMException && err.name === "AbortError") {
             remaining--;
             if (remaining === 0 && !settled) {
@@ -15794,7 +15931,7 @@ ${summaryResponse.content}`
             results[idx] = { ok: true, value };
             successCount++;
           } catch (err) {
-            if (isEventStreamOverflowError(err)) {
+            if (isUnrecoverableError(err)) {
               settled = true;
               controller?.abort();
               reject(err);
@@ -15803,6 +15940,12 @@ ${summaryResponse.content}`
             if (settled) {
               return;
             }
+            if (parentSignal?.aborted) {
+              settled = true;
+              controller?.abort();
+              reject(err);
+              return;
+            }
             if (err instanceof DOMException && err.name === "AbortError" && controller?.signal.aborted) {
               completedCount++;
               return;
@@ -20764,8 +20907,9 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
    * new paid operations once known spend reaches the limit. Already-dispatched
    * work still settles and is still counted.
    *
-   * `metadata`, `modelTiming` and `traces` remain EVENT-derived and therefore
-   * depend on trace configuration; `accounting` never does.
+   * Model metadata and timing share the settlement scope with accounting, so
+   * they cross runtimes and compatible ESM/CJS copies. Workflow names and
+   * captured traces still come from this runtime's events.
    */
   async trackOutcome(fn, options) {
     const parentScope = costScopeStorage.getStore();
@@ -20774,49 +20918,11 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
       trackedIds: /* @__PURE__ */ new Set(),
       parent: parentScope
     };
-    const modelCalls = /* @__PURE__ */ new Map();
-    const modelTiming = /* @__PURE__ */ new Map();
-    const captureTimingSamples = options?.captureTimingSamples === true;
     const workflowCalls = /* @__PURE__ */ new Map();
-    const tokens = { input: 0, output: 0, reasoning: 0 };
-    let agentCalls = 0;
     const capturedTraces = options?.captureTraces ? [] : void 0;
     const listener = (event) => {
       if (!scope.trackedIds.has(event.executionId)) return;
       scope.totalCost += eventCostContribution(event);
-      if (event.type === "agent_call_end") {
-        if (event.model) modelCalls.set(event.model, (modelCalls.get(event.model) ?? 0) + 1);
-        agentCalls++;
-        if (event.tokens) {
-          tokens.input += event.tokens.input ?? 0;
-          tokens.output += event.tokens.output ?? 0;
-          tokens.reasoning += event.tokens.reasoning ?? 0;
-        }
-        const failed2 = event.data?.error != null;
-        if (event.model && event.timing && !failed2) {
-          const t = event.timing;
-          let bucket = modelTiming.get(event.model);
-          if (!bucket) {
-            bucket = {
-              calls: 0,
-              queuedMs: 0,
-              retryMs: 0,
-              wireMs: 0,
-              ...captureTimingSamples ? { samples: [] } : {}
-            };
-            modelTiming.set(event.model, bucket);
-          }
-          bucket.calls++;
-          bucket.samples?.push(t);
-          bucket.queuedMs += t.queuedMs;
-          bucket.retryMs += t.retryMs;
-          bucket.wireMs += t.wireMs;
-          if (t.firstTokenMs != null) {
-            bucket.firstTokenMs = (bucket.firstTokenMs ?? 0) + t.firstTokenMs;
-            bucket.firstTokenCalls = (bucket.firstTokenCalls ?? 0) + 1;
-          }
-        }
-      }
       if (event.type === "workflow_start" && event.workflow) {
         workflowCalls.set(event.workflow, (workflowCalls.get(event.workflow) ?? 0) + 1);
       }
@@ -20842,9 +20948,14 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     this.on("trace", listener);
     let outcome;
     let accounting;
+    let diagnostics;
     try {
-      ({ outcome, accounting } = await runInAccountingScope(
-        { purpose: options?.purpose, admission: options?.admission },
+      ({ outcome, accounting, diagnostics } = await runInAccountingScope(
+        {
+          purpose: options?.purpose,
+          admission: options?.admission,
+          captureTimingSamples: options?.captureTimingSamples
+        },
         () => (
           // Capture wraps the cost scope rather than the other way round so a
           // record can never be written for an operation the accounting scope
@@ -20868,13 +20979,13 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     return {
       ...outcome,
       accounting,
-      ...modelTiming.size > 0 ? { modelTiming: Object.fromEntries(modelTiming) } : {},
+      ...Object.keys(diagnostics.modelTiming).length > 0 ? { modelTiming: diagnostics.modelTiming } : {},
       ...capturedTraces ? { traces: capturedTraces } : {},
       metadata: {
-        models: [...modelCalls.keys()],
-        modelCallCounts: modelCalls.size > 0 ? Object.fromEntries(modelCalls) : void 0,
-        tokens,
-        agentCalls,
+        models: Object.keys(diagnostics.modelCallCounts),
+        modelCallCounts: Object.keys(diagnostics.modelCallCounts).length > 0 ? diagnostics.modelCallCounts : void 0,
+        tokens: diagnostics.tokens,
+        agentCalls: diagnostics.agentCalls,
         workflows: [...workflowCalls.keys()],
         workflowCallCounts: workflowCalls.size > 0 ? Object.fromEntries(workflowCalls) : void 0
       }