@axlsdk/axl 0.24.0 → 0.24.2

package/dist/index.cjs

@@ -1,3 +1,4 @@
+const __AXL_BUILD_PATH__ = __filename;
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -351,12 +352,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,
@@ -366,6 +369,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;
@@ -509,8 +519,62 @@ var ValidationError = class extends AxlError {
   }
 };
 
-// src/accounting.ts
+// src/shared-context.ts
 var import_node_async_hooks = require("async_hooks");
+var import_node_url = require("url");
+var PROTOCOL = 1;
+var CONTEXT_KEY = /* @__PURE__ */ Symbol.for(`axl.accounting.context.v${PROTOCOL}`);
+var GUARD_KEY = /* @__PURE__ */ Symbol.for("axl.accounting.scopeGuard");
+function createContext() {
+  let operationCounter = 0;
+  return {
+    protocol: PROTOCOL,
+    id: /* @__PURE__ */ Symbol("axl.accounting.context.instance"),
+    accounting: new import_node_async_hooks.AsyncLocalStorage(),
+    dispatch: new import_node_async_hooks.AsyncLocalStorage(),
+    capture: new import_node_async_hooks.AsyncLocalStorage(),
+    correlation: new import_node_async_hooks.AsyncLocalStorage(),
+    turn: new import_node_async_hooks.AsyncLocalStorage(),
+    nextOperationId: () => `op_${++operationCounter}`
+  };
+}
+function isStorage(value) {
+  return typeof value === "object" && value !== null && typeof value.getStore === "function" && typeof value.run === "function";
+}
+function isCompatible(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.protocol === PROTOCOL && typeof candidate.id === "symbol" && isStorage(candidate.accounting) && isStorage(candidate.dispatch) && isStorage(candidate.capture) && isStorage(candidate.correlation) && isStorage(candidate.turn) && typeof candidate.nextOperationId === "function";
+}
+var registry = globalThis;
+var installed = registry[CONTEXT_KEY];
+var sharedContext = installed === void 0 ? registry[CONTEXT_KEY] = createContext() : isCompatible(installed) ? installed : createContext();
+var installedGuard = registry[GUARD_KEY];
+var sharedGuard = typeof installedGuard === "object" && installedGuard !== null && isStorage(installedGuard.storage) && installedGuard.warned instanceof WeakMap ? installedGuard : registry[GUARD_KEY] = {
+  storage: new import_node_async_hooks.AsyncLocalStorage(),
+  warned: /* @__PURE__ */ new WeakMap()
+};
+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.2" : "unknown"
+};
+function warnCrossCopy(other, joined) {
+  if (other === thisCopy) return;
+  if (sharedGuard.warned.get(other)?.has(thisCopy)) return;
+  const fromThis = sharedGuard.warned.get(thisCopy) ?? /* @__PURE__ */ new WeakSet();
+  if (fromThis.has(other)) return;
+  fromThis.add(other);
+  sharedGuard.warned.set(thisCopy, fromThis);
+  try {
+    console.warn(
+      `[axl] Cross-copy accounting: ${other.path} (v${other.version}) and ${thisCopy.path} (v${thisCopy.version}). ` + (joined ? "Shared accounting, admission, and request capture context joined." : "Accounting protocols could not join; paid work is refused and the active scope is incomplete.")
+    );
+  } catch {
+  }
+}
+
+// src/accounting.ts
 var RECORD_SPEND = /* @__PURE__ */ Symbol.for("axl.accounting.recordSpend");
 var AdmissionController = class {
   /** The configured USD threshold. Admission closes at `knownSpend >= limit`. */
@@ -572,10 +636,8 @@ function emptyUsage() {
 function isUsableCost(cost) {
   return typeof cost === "number" && Number.isFinite(cost) && cost >= 0;
 }
-var operationCounter = 0;
 function nextOperationId() {
-  operationCounter += 1;
-  return `op_${operationCounter}`;
+  return sharedContext.nextOperationId();
 }
 var AccountingScope = class {
   parent;
@@ -596,10 +658,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;
@@ -613,6 +681,11 @@ var AccountingScope = class {
   recordDenied() {
     this.denied += 1;
   }
+  /** A foreign protocol attempted work we cannot measure. Mark every live ancestor. */
+  markUninstrumented() {
+    if (this.finalized || this.reasons.has("uninstrumented")) return;
+    this.reasons.set("uninstrumented", 1);
+  }
   /** An already-open operation refused at the dispatch check: retract it. */
   recordRetracted(op) {
     this.seen.add(op.id);
@@ -623,7 +696,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;
@@ -632,13 +705,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);
@@ -665,7 +782,7 @@ var AccountingScope = class {
       version: 1,
       currency: "USD",
       knownCost: this.knownCost,
-      completeness: this.unknown > 0 ? "incomplete" : "complete",
+      completeness: this.reasons.size > 0 ? "incomplete" : "complete",
       reasons: Object.fromEntries(this.reasons),
       usage: { ...this.usage },
       operations: {
@@ -680,8 +797,8 @@ var AccountingScope = class {
     };
   }
 };
-var accountingStorage = new import_node_async_hooks.AsyncLocalStorage();
-var dispatchAdmissionStorage = new import_node_async_hooks.AsyncLocalStorage();
+var accountingStorage = sharedContext.accounting;
+var dispatchAdmissionStorage = sharedContext.dispatch;
 function currentDispatchAdmission() {
   return dispatchAdmissionStorage.getStore();
 }
@@ -710,14 +827,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);
@@ -742,6 +859,17 @@ function admissionDenied(controller, descriptor) {
   });
 }
 function openOperation(descriptor) {
+  const inheritedGuard = sharedGuard.storage.getStore();
+  const guard = inheritedGuard && (inheritedGuard.isActive?.() ?? true) ? inheritedGuard : void 0;
+  if (guard && guard.contextId !== sharedContext.id) {
+    guard.markUninstrumented();
+    warnCrossCopy(guard.owner, false);
+    throw new AxlError(
+      "INCOMPATIBLE_ACCOUNTING_SCOPE",
+      "The active @axlsdk/axl accounting scope uses an incompatible loaded copy; paid work was refused before dispatch."
+    );
+  }
+  if (guard) warnCrossCopy(guard.owner, true);
   const scope = accountingStorage.getStore();
   if (!scope || scope.isFinalized) return void 0;
   const denier = denyingController(scope);
@@ -758,6 +886,8 @@ function openOperation(descriptor) {
     kind: descriptor.kind,
     purpose: scope.purpose,
     model: descriptor.model,
+    diagnosticModelUri: descriptor.diagnosticModelUri,
+    agentCall: descriptor.agentCall === true,
     dispatched: false,
     dispatchObservable: false
   };
@@ -798,25 +928,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);
@@ -829,15 +965,62 @@ 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;
+  if (enclosingGuard)
+    warnCrossCopy(enclosingGuard.owner, enclosingGuard.contextId === sharedContext.id);
+  if (enclosingGuard && enclosingGuard.contextId !== sharedContext.id) {
+    enclosingGuard.markUninstrumented();
+    scope.markUninstrumented();
+    scope.finalize();
+    return {
+      outcome: {
+        status: "rejected",
+        error: new AxlError(
+          "INCOMPATIBLE_ACCOUNTING_SCOPE",
+          "The active @axlsdk/axl accounting scope uses an incompatible loaded copy; paid work was refused before dispatch."
+        )
+      },
+      accounting: scope.toAccounting(),
+      diagnostics: scope.toDiagnostics()
+    };
+  }
+  const markUninstrumented = () => {
+    let current = scope;
+    while (current) {
+      if (!current.isFinalized) current.markUninstrumented();
+      current = current.parent;
+    }
+  };
+  const isActive = () => {
+    let current = scope;
+    while (current) {
+      if (!current.isFinalized) return true;
+      current = current.parent;
+    }
+    return false;
+  };
   try {
-    const value = await accountingStorage.run(scope, fn);
+    const value = await sharedGuard.storage.run(
+      { contextId: sharedContext.id, owner: thisCopy, markUninstrumented, isActive },
+      () => 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) {
@@ -1216,10 +1399,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) {
@@ -1266,7 +1451,7 @@ function tool(config) {
       } catch (err) {
         if (options?.signal?.aborted) options.signal.throwIfAborted();
         if (isAbortError(err)) throw err;
-        if (err instanceof AdmissionDeniedError) throw err;
+        if (isAdmissionDeniedError(err)) throw err;
         rethrowEventStreamOverflow(err);
         lastError = err instanceof Error ? err : new Error(String(err));
         if (attempt === maxAttempts) break;
@@ -1320,9 +1505,11 @@ function tool(config) {
     },
     _execute: execute
   };
-  TOOL_INTERNALS.set(instance, {
-    prepareInput,
-    executePrepared
+  Object.defineProperty(instance, TOOL_INTERNALS, {
+    value: {
+      prepareInput,
+      executePrepared
+    }
   });
   return instance;
 }
@@ -1353,6 +1540,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) {
@@ -1750,12 +1938,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);
@@ -5946,7 +6158,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;
 }
@@ -6303,10 +6515,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",
@@ -9020,7 +9229,7 @@ var TranscriptionProviderRegistry = class {
 };
 
 // src/context.ts
-var import_node_async_hooks3 = require("async_hooks");
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_crypto = require("crypto");
 var import_zod2 = require("zod");
 
@@ -11205,7 +11414,6 @@ function warnDiagnosticOnce(key, message, silent, docs = DOCS_URL) {
 var warnSchemaDiagnosticOnce = warnDiagnosticOnce;
 
 // src/diagnostics/capture.ts
-var import_node_async_hooks2 = require("async_hooks");
 var DEFAULT_MAX_RECORD_BYTES = 256 * 1024;
 var DEFAULT_MAX_RUN_BYTES = 16 * 1024 * 1024;
 var DEFAULT_MAX_QUEUE_BYTES = 1024 * 1024;
@@ -11466,8 +11674,8 @@ function positive(value, fallback) {
 function describe(error) {
   return error instanceof Error ? error.message : String(error);
 }
-var channelStorage = new import_node_async_hooks2.AsyncLocalStorage();
-var correlationStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var channelStorage = sharedContext.capture;
+var correlationStorage = sharedContext.correlation;
 function currentCaptureChannel() {
   return channelStorage.getStore();
 }
@@ -11483,7 +11691,7 @@ function runWithCaptureCorrelation(correlation, fn) {
   const merged = { ...correlationStorage.getStore(), ...correlation };
   return correlationStorage.run(merged, fn);
 }
-var turnStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var turnStorage = sharedContext.turn;
 function currentCaptureTurn() {
   return turnStorage.getStore()?.current;
 }
@@ -11506,6 +11714,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() {
@@ -11699,7 +11935,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;
 }
@@ -11716,7 +11958,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;
@@ -11771,7 +12014,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({
@@ -12204,13 +12448,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 {
@@ -12226,7 +12463,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 {
@@ -12352,7 +12589,7 @@ async function executeAcceptedTool(options) {
     }
   } catch (error) {
     rethrowEventStreamOverflow(error);
-    if (error instanceof AdmissionDeniedError) throw error;
+    if (isAdmissionDeniedError(error)) throw error;
     const abort = cancellationError(signal, error);
     if (abort !== void 0) return cancellation("handler", abort);
     return failed("handler", error, { attempts });
@@ -12525,9 +12762,9 @@ function recordToolSpanOutcome(span, outcome) {
 }
 
 // src/context.ts
-var signalStorage = new import_node_async_hooks3.AsyncLocalStorage();
-var hardSignalStorage = new import_node_async_hooks3.AsyncLocalStorage();
-var timeoutTrackerStorage = new import_node_async_hooks3.AsyncLocalStorage();
+var signalStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var hardSignalStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var timeoutTrackerStorage = new import_node_async_hooks2.AsyncLocalStorage();
 var MAX_TIMER_DELAY_MS = 2147483647;
 function composeAbortSignals(...signals) {
   const active = signals.filter((signal) => signal !== void 0);
@@ -12632,7 +12869,7 @@ function parseHumanDecision(value) {
   }
   return invalid3();
 }
-var askStorage = new import_node_async_hooks3.AsyncLocalStorage();
+var askStorage = new import_node_async_hooks2.AsyncLocalStorage();
 var inlineSchemaCache = /* @__PURE__ */ new WeakMap();
 function zodToJsonSchema(schema) {
   const cached = inlineSchemaCache.get(schema);
@@ -13914,6 +14151,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,
@@ -16467,7 +16705,7 @@ ${summaryResponse.content}`
       try {
         result = await (transcriptionOperation ? transcriptionOperation.run(() => resolved.provider.transcribe(providerRequest)) : resolved.provider.transcribe(providerRequest));
       } catch (error) {
-        if (error instanceof AdmissionDeniedError) {
+        if (isAdmissionDeniedError(error)) {
           transcriptionOperation?.settleFailure();
           throw error;
         }
@@ -16731,13 +16969,13 @@ function agent(config) {
     _config: config,
     _name: defaultName,
     async ask(prompt, options) {
-      const registry = new ProviderRegistry();
+      const registry2 = new ProviderRegistry();
       const transcriptionRegistry = new TranscriptionProviderRegistry();
       const ctx = new WorkflowContext({
         input: prompt,
         executionId: (0, import_node_crypto2.randomUUID)(),
         config: {},
-        providerRegistry: registry,
+        providerRegistry: registry2,
         transcriptionProviderRegistry: transcriptionRegistry
       });
       return ctx.ask(agentInstance, prompt, options);
@@ -16761,7 +16999,7 @@ function workflow(config) {
 // src/runtime.ts
 var import_node_events2 = require("events");
 var import_node_crypto4 = require("crypto");
-var import_node_async_hooks4 = require("async_hooks");
+var import_node_async_hooks3 = require("async_hooks");
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
 
@@ -18941,7 +19179,7 @@ function assertNoRemovedObservationCallbacks(options) {
     `runtime.createContext() no longer accepts ${removed.join(", ")}. Observe ctx.events or use runtime.stream() instead. See docs/migration/stream-first-observation.md.`
   );
 }
-var costScopeStorage = new import_node_async_hooks4.AsyncLocalStorage();
+var costScopeStorage = new import_node_async_hooks3.AsyncLocalStorage();
 function forwardAbortSignal(external, internal) {
   if (!external) return () => {
   };
@@ -20659,8 +20897,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();
@@ -20669,49 +20908,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);
       }
@@ -20737,9 +20938,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
@@ -20763,13 +20969,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
       }
@@ -20979,7 +21185,7 @@ function pickExport(mod, key) {
 // src/cli-internals.ts
 var import_node_path4 = require("path");
 var import_node_fs4 = require("fs");
-var import_node_url = require("url");
+var import_node_url2 = require("url");
 var CONFIG_CANDIDATES = [
   "axl.config.mts",
   "axl.config.ts",
@@ -21021,7 +21227,7 @@ async function ensureTsxRegistered() {
   return tsxRegistered;
 }
 async function importModule(filePath, _parentURL) {
-  const url = (0, import_node_url.pathToFileURL)(filePath).href;
+  const url = (0, import_node_url2.pathToFileURL)(filePath).href;
   if (!needsTsxLoader(filePath)) {
     return await import(url);
   }