@pensar/apex 2.5.0 → 2.6.1-canary.025b1ecf

package/build/cli-se8ae8z3.js

@@ -0,0 +1,2250 @@
+import {
+  APICallError,
+  init_dist3
+} from "./cli-gsaf4jk3.js";
+import {
+  init_zod
+} from "./cli-3qznjsnr.js";
+import {
+  NEVER,
+  string,
+  number,
+  unknown,
+  array,
+  strictObject,
+  discriminatedUnion,
+  _enum,
+  literal
+} from "./cli-mz5pk30x.js";
+import {
+  __esm
+} from "./cli-h6y3bt60.js";
+
+// src/core/id/id.ts
+import { randomBytes } from "node:crypto";
+function schema(prefix) {
+  return string().startsWith(prefixes[prefix]);
+}
+function descending(prefix, given) {
+  return generateID(prefix, true, given);
+}
+function generateID(prefix, descending, given) {
+  if (!given) {
+    return create(prefix, descending);
+  }
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
+  }
+  return given;
+}
+function randomBase62(length) {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  let result = "";
+  const bytes = randomBytes(length);
+  for (let i = 0;i < length; i++) {
+    result += chars[bytes[i] % 62];
+  }
+  return result;
+}
+function create(prefix, descending, timestamp) {
+  const currentTimestamp = timestamp ?? Date.now();
+  if (currentTimestamp !== lastTimestamp) {
+    lastTimestamp = currentTimestamp;
+    counter = 0;
+  }
+  counter++;
+  let now = BigInt(currentTimestamp) * BigInt(4096) + BigInt(counter);
+  now = descending ? ~now : now;
+  const timeBytes = Buffer.alloc(6);
+  for (let i = 0;i < 6; i++) {
+    timeBytes[i] = Number(now >> BigInt(40 - 8 * i) & BigInt(255));
+  }
+  return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12);
+}
+var prefixes, LENGTH = 26, lastTimestamp = 0, counter = 0, newSessionId = () => descending("session"), newMessageId = () => descending("message"), newPartId = () => descending("part"), newAttemptId = () => descending("attempt"), newIdempotencyKey = () => descending("idempotency"), isSessionId = (s) => s.startsWith(`${prefixes.session}_`), isAttemptId = (s) => s.startsWith(`${prefixes.attempt}_`), isIdempotencyKey = (s) => s.startsWith(`${prefixes.idempotency}_`);
+var init_id = __esm(() => {
+  init_zod();
+  prefixes = {
+    session: "ses",
+    message: "msg",
+    permission: "per",
+    user: "usr",
+    part: "prt",
+    attempt: "atm",
+    idempotency: "idem"
+  };
+});
+
+// src/core/ai/inference-attempt/errors.ts
+var InferenceAttemptValidationError;
+var init_errors = __esm(() => {
+  InferenceAttemptValidationError = class InferenceAttemptValidationError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "InferenceAttemptValidationError";
+      this.code = code;
+    }
+  };
+});
+
+// src/core/ai/inference-attempt/envelope.ts
+function assertLineage(lineage) {
+  if (lineage.sequence === 1 && lineage.previousAttemptId !== undefined) {
+    throw new InferenceAttemptValidationError("invalid-envelope", "first attempt cannot name a previousAttemptId");
+  }
+  if (lineage.sequence > 1 && lineage.previousAttemptId === undefined) {
+    throw new InferenceAttemptValidationError("invalid-envelope", "retry lineage requires previousAttemptId");
+  }
+}
+var INFERENCE_ATTEMPT_SCHEMA = "pensar.inference_attempt", INFERENCE_ATTEMPT_VERSION = 1, ATTEMPT_LIFECYCLES, ATTEMPT_OPERATION_KINDS, ATTEMPT_TRANSPORTS, CACHE_BREAKPOINTS, attemptIdSchema, idempotencyKeySchema, maybeTokenCountSchema, attemptTokensSchema, modelRefSchema, attributionSchema, lineageSchema, evidenceSchema, InferenceAttemptSchema;
+var init_envelope = __esm(() => {
+  init_zod();
+  init_id();
+  init_errors();
+  ATTEMPT_LIFECYCLES = [
+    "started",
+    "completed",
+    "failed",
+    "partial",
+    "aborted",
+    "retried"
+  ];
+  ATTEMPT_OPERATION_KINDS = [
+    "agent.stream",
+    "structured.generate",
+    "context.summarize",
+    "tool.repair"
+  ];
+  ATTEMPT_TRANSPORTS = [
+    "anthropic-messages",
+    "bedrock-converse",
+    "pensar-anthropic-stream",
+    "pensar-anthropic-rest",
+    "openai-responses",
+    "sdk-normalized"
+  ];
+  CACHE_BREAKPOINTS = [
+    "anthropic.cacheControl",
+    "bedrock.cachePoint"
+  ];
+  attemptIdSchema = string().refine(isAttemptId, {
+    message: "attemptId must start with atm_"
+  });
+  idempotencyKeySchema = string().refine(isIdempotencyKey, {
+    message: "idempotencyKey must start with idem_"
+  });
+  maybeTokenCountSchema = number().int().nonnegative().nullable();
+  attemptTokensSchema = strictObject({
+    inclusiveInput: maybeTokenCountSchema,
+    uncachedInput: maybeTokenCountSchema,
+    cacheRead: maybeTokenCountSchema,
+    cacheWrite: maybeTokenCountSchema,
+    output: maybeTokenCountSchema
+  });
+  modelRefSchema = strictObject({
+    provider: string().min(1),
+    modelId: string().min(1),
+    transport: _enum(ATTEMPT_TRANSPORTS).optional()
+  });
+  attributionSchema = strictObject({
+    sessionId: string().min(1).optional(),
+    runId: string().min(1).optional(),
+    agentId: string().min(1).optional(),
+    parentAttemptId: attemptIdSchema.optional(),
+    rootAttemptId: attemptIdSchema
+  });
+  lineageSchema = strictObject({
+    sequence: number().int().positive(),
+    previousAttemptId: attemptIdSchema.optional()
+  });
+  evidenceSchema = strictObject({
+    providerRequestId: string().min(1).optional(),
+    cacheTtlSeconds: number().int().nonnegative().optional(),
+    cacheBreakpoint: _enum(CACHE_BREAKPOINTS).optional()
+  });
+  InferenceAttemptSchema = strictObject({
+    schema: literal(INFERENCE_ATTEMPT_SCHEMA),
+    version: literal(INFERENCE_ATTEMPT_VERSION),
+    attemptId: attemptIdSchema,
+    idempotencyKey: idempotencyKeySchema,
+    lifecycle: _enum(ATTEMPT_LIFECYCLES),
+    operationKind: _enum(ATTEMPT_OPERATION_KINDS),
+    lineage: lineageSchema,
+    attribution: attributionSchema,
+    requested: modelRefSchema,
+    effective: modelRefSchema,
+    tokens: attemptTokensSchema,
+    evidence: evidenceSchema
+  });
+});
+
+// src/core/ai/inference-attempt/tokens.ts
+function parseTokenCount(value, label) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || !Number.isFinite(value)) {
+    throw new InferenceAttemptValidationError("invalid-token", `${label} must be a finite non-negative integer or null`);
+  }
+  return value;
+}
+function deriveInputTokens(tokens) {
+  const { inclusiveInput, uncachedInput, cacheRead, cacheWrite, output } = tokens;
+  const unknownCount = [
+    inclusiveInput,
+    uncachedInput,
+    cacheRead,
+    cacheWrite
+  ].filter((value) => value === null).length;
+  if (unknownCount !== 1) {
+    return tokens;
+  }
+  const derived = {
+    inclusiveInput,
+    uncachedInput,
+    cacheRead,
+    cacheWrite,
+    output
+  };
+  if (inclusiveInput === null && uncachedInput !== null && cacheRead !== null && cacheWrite !== null) {
+    derived.inclusiveInput = uncachedInput + cacheRead + cacheWrite;
+  } else if (uncachedInput === null && inclusiveInput !== null && cacheRead !== null && cacheWrite !== null) {
+    derived.uncachedInput = inclusiveInput - cacheRead - cacheWrite;
+  } else if (cacheRead === null && inclusiveInput !== null && uncachedInput !== null && cacheWrite !== null) {
+    derived.cacheRead = inclusiveInput - uncachedInput - cacheWrite;
+  } else if (cacheWrite === null && inclusiveInput !== null && uncachedInput !== null && cacheRead !== null) {
+    derived.cacheWrite = inclusiveInput - uncachedInput - cacheRead;
+  }
+  for (const [label, value] of [
+    ["inclusiveInput", derived.inclusiveInput],
+    ["uncachedInput", derived.uncachedInput],
+    ["cacheRead", derived.cacheRead],
+    ["cacheWrite", derived.cacheWrite]
+  ]) {
+    if (value !== null && value < 0) {
+      throw new InferenceAttemptValidationError("inclusive-identity", `derived ${label} is negative (${value})`);
+    }
+  }
+  return derived;
+}
+function assertTokenIdentity(tokens) {
+  const { inclusiveInput, uncachedInput, cacheRead, cacheWrite } = tokens;
+  if (inclusiveInput !== null && uncachedInput !== null && cacheRead !== null && cacheWrite !== null) {
+    if (inclusiveInput !== uncachedInput + cacheRead + cacheWrite) {
+      throw new InferenceAttemptValidationError("inclusive-identity", `inclusive input ${inclusiveInput} !== uncached ${uncachedInput} + cacheRead ${cacheRead} + cacheWrite ${cacheWrite}`);
+    }
+    return;
+  }
+  if (inclusiveInput === null) {
+    return;
+  }
+  for (const [label, value] of [
+    ["uncachedInput", uncachedInput],
+    ["cacheRead", cacheRead],
+    ["cacheWrite", cacheWrite]
+  ]) {
+    if (value !== null && value > inclusiveInput) {
+      throw new InferenceAttemptValidationError("inclusive-identity", `${label} ${value} exceeds inclusive input ${inclusiveInput}`);
+    }
+  }
+  const knownSum = (uncachedInput ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+  if (knownSum > inclusiveInput) {
+    throw new InferenceAttemptValidationError("inclusive-identity", `known input components ${knownSum} exceed inclusive input ${inclusiveInput}`);
+  }
+}
+function finalizeTokens(tokens) {
+  const derived = deriveInputTokens(tokens);
+  assertTokenIdentity(derived);
+  return derived;
+}
+var UNKNOWN_TOKENS;
+var init_tokens = __esm(() => {
+  init_errors();
+  UNKNOWN_TOKENS = {
+    inclusiveInput: null,
+    uncachedInput: null,
+    cacheRead: null,
+    cacheWrite: null,
+    output: null
+  };
+});
+
+// src/core/ai/inference-attempt/adapters.ts
+function adaptTransportUsage(input) {
+  if (!ATTEMPT_TRANSPORTS.includes(input.transport)) {
+    throw new InferenceAttemptValidationError("invalid-envelope", `unknown transport ${String(input.transport)}`);
+  }
+  const usage = asRecord(input.usage, "usage");
+  const meta = asRecord(input.providerMetadata, "providerMetadata");
+  const tokens = finalizeTokens(adaptTokens(input.transport, usage, meta));
+  return {
+    tokens,
+    evidence: extractEvidence(input, meta)
+  };
+}
+function adaptTokens(transport, usage, meta) {
+  switch (transport) {
+    case "anthropic-messages":
+      return adaptAnthropicMessages(usage, meta);
+    case "bedrock-converse":
+      return adaptBedrockConverse(usage, meta);
+    case "pensar-anthropic-stream":
+      return adaptPensarAnthropicStream(usage);
+    case "pensar-anthropic-rest":
+      return adaptPensarAnthropicRest(usage);
+    case "openai-responses":
+      return adaptOpenAIResponses(usage);
+    case "sdk-normalized":
+      return adaptSdkNormalized(usage, meta);
+  }
+}
+function adaptAnthropicMessages(usage, meta) {
+  const anthropicMeta = asRecord(meta?.anthropic, "providerMetadata.anthropic");
+  const uncachedInput = firstToken(usage, ["input_tokens", "inputTokens"]);
+  const cacheRead = firstToken(usage, [
+    "cache_read_input_tokens",
+    "cacheReadInputTokens"
+  ]);
+  const cacheWrite = firstToken(usage, [
+    "cache_creation_input_tokens",
+    "cacheCreationInputTokens"
+  ]);
+  const output = firstToken(usage, ["output_tokens", "outputTokens"]);
+  return {
+    inclusiveInput: null,
+    uncachedInput: uncachedInput ?? firstToken(anthropicMeta, ["inputTokens"]),
+    cacheRead: cacheRead ?? firstToken(anthropicMeta, ["cacheReadInputTokens"]),
+    cacheWrite: cacheWrite ?? firstToken(anthropicMeta, ["cacheCreationInputTokens"]),
+    output: output ?? firstToken(anthropicMeta, ["outputTokens"])
+  };
+}
+function adaptBedrockConverse(usage, meta) {
+  const bedrockMeta = asRecord(meta?.bedrock, "providerMetadata.bedrock");
+  const bedrockUsage = asRecord(bedrockMeta?.usage, "providerMetadata.bedrock.usage");
+  const anthropicMeta = asRecord(meta?.anthropic, "providerMetadata.anthropic");
+  if (usage && (hasOwn(usage, "cacheReadInputTokens") || hasOwn(usage, "cacheWriteInputTokens"))) {
+    return {
+      inclusiveInput: null,
+      uncachedInput: readToken(usage, "inputTokens"),
+      cacheRead: firstToken({ ...bedrockUsage, ...usage }, [
+        "cacheReadInputTokens"
+      ]),
+      cacheWrite: firstToken({ ...bedrockUsage, ...usage }, [
+        "cacheWriteInputTokens"
+      ]),
+      output: readToken(usage, "outputTokens")
+    };
+  }
+  const sdk = readSdkOrV3Usage(usage);
+  const cacheRead = firstPresent(firstToken(bedrockUsage, ["cacheReadInputTokens"]), firstToken(bedrockMeta, ["cacheReadInputTokens"]), firstToken(anthropicMeta, ["cacheReadInputTokens"]), sdk.cacheRead);
+  const cacheWrite = firstPresent(firstToken(bedrockUsage, ["cacheWriteInputTokens"]), firstToken(bedrockMeta, ["cacheWriteInputTokens"]), firstToken(anthropicMeta, [
+    "cacheWriteInputTokens",
+    "cacheCreationInputTokens"
+  ]), sdk.cacheWrite);
+  return {
+    inclusiveInput: sdk.inclusive,
+    uncachedInput: sdk.uncached,
+    cacheRead,
+    cacheWrite,
+    output: sdk.output
+  };
+}
+function adaptPensarAnthropicStream(usage) {
+  const sdk = readSdkOrV3Usage(usage);
+  return {
+    inclusiveInput: sdk.inclusive,
+    uncachedInput: sdk.uncached,
+    cacheRead: sdk.cacheRead,
+    cacheWrite: sdk.cacheWrite,
+    output: sdk.output
+  };
+}
+function adaptPensarAnthropicRest(usage) {
+  const nativeUncached = firstToken(usage, ["input_tokens"]);
+  if (nativeUncached !== null) {
+    return {
+      inclusiveInput: null,
+      uncachedInput: nativeUncached,
+      cacheRead: firstToken(usage, ["cache_read_input_tokens"]),
+      cacheWrite: firstToken(usage, ["cache_creation_input_tokens"]),
+      output: firstToken(usage, ["output_tokens"])
+    };
+  }
+  const sdk = readSdkOrV3Usage(usage);
+  return {
+    inclusiveInput: null,
+    uncachedInput: sdk.inclusive,
+    cacheRead: null,
+    cacheWrite: null,
+    output: sdk.output
+  };
+}
+function adaptOpenAIResponses(usage) {
+  const details = asRecord(usage?.input_tokens_details, "input_tokens_details");
+  const nativeInclusive = firstToken(usage, ["input_tokens"]);
+  if (nativeInclusive !== null || details) {
+    return {
+      inclusiveInput: nativeInclusive,
+      uncachedInput: null,
+      cacheRead: firstToken(details, ["cached_tokens"]),
+      cacheWrite: 0,
+      output: firstToken(usage, ["output_tokens"])
+    };
+  }
+  const sdk = readSdkOrV3Usage(usage);
+  return {
+    inclusiveInput: sdk.inclusive,
+    uncachedInput: sdk.uncached,
+    cacheRead: sdk.cacheRead,
+    cacheWrite: 0,
+    output: sdk.output
+  };
+}
+function adaptSdkNormalized(usage, meta) {
+  const sdk = readSdkOrV3Usage(usage);
+  const anthropicMeta = asRecord(meta?.anthropic, "providerMetadata.anthropic");
+  return {
+    inclusiveInput: sdk.inclusive,
+    uncachedInput: sdk.uncached,
+    cacheRead: firstToken(anthropicMeta, ["cacheReadInputTokens"]) ?? sdk.cacheRead,
+    cacheWrite: firstToken(anthropicMeta, ["cacheCreationInputTokens"]) ?? sdk.cacheWrite,
+    output: sdk.output
+  };
+}
+function readSdkOrV3Usage(usage) {
+  if (!usage) {
+    return {
+      inclusive: null,
+      uncached: null,
+      cacheRead: null,
+      cacheWrite: null,
+      output: null
+    };
+  }
+  if (isRecord(usage.inputTokens)) {
+    const nested = usage.inputTokens;
+    const outputNested = isRecord(usage.outputTokens) ? usage.outputTokens : undefined;
+    return {
+      inclusive: readToken(nested, "total"),
+      uncached: readToken(nested, "noCache"),
+      cacheRead: readToken(nested, "cacheRead"),
+      cacheWrite: readToken(nested, "cacheWrite"),
+      output: outputNested ? readToken(outputNested, "total") : readToken(usage, "outputTokens")
+    };
+  }
+  const details = asRecord(usage.inputTokenDetails, "inputTokenDetails");
+  return {
+    inclusive: readToken(usage, "inputTokens"),
+    uncached: firstToken(details, ["noCacheTokens", "noCache"]),
+    cacheRead: firstToken(details, ["cacheReadTokens", "cacheRead"]),
+    cacheWrite: firstToken(details, ["cacheWriteTokens", "cacheWrite"]),
+    output: readToken(usage, "outputTokens")
+  };
+}
+function extractEvidence(input, meta) {
+  const evidence = {};
+  const anthropicMeta = asRecord(meta?.anthropic, "providerMetadata.anthropic");
+  const bedrockMeta = asRecord(meta?.bedrock, "providerMetadata.bedrock");
+  const bedrockMetadata = asRecord(bedrockMeta?.$metadata, "providerMetadata.bedrock.$metadata");
+  const openaiMeta = asRecord(meta?.openai, "providerMetadata.openai");
+  const providerRequestId = readNonEmptyString(input.providerRequestId, "providerRequestId") ?? firstString(anthropicMeta, ["id", "messageId", "requestId"]) ?? firstString(bedrockMeta, ["requestId"]) ?? firstString(bedrockMetadata, ["requestId"]) ?? firstString(openaiMeta, ["id", "responseId", "requestId"]);
+  if (providerRequestId) {
+    evidence.providerRequestId = providerRequestId;
+  }
+  if (input.cacheTtlSeconds !== undefined) {
+    const ttl = parseTokenCount(input.cacheTtlSeconds, "cacheTtlSeconds");
+    if (ttl !== null) {
+      evidence.cacheTtlSeconds = ttl;
+    }
+  }
+  if (input.cacheBreakpoint) {
+    if (!CACHE_BREAKPOINTS.includes(input.cacheBreakpoint)) {
+      throw new InferenceAttemptValidationError("invalid-envelope", `unknown cacheBreakpoint ${String(input.cacheBreakpoint)}`);
+    }
+    evidence.cacheBreakpoint = input.cacheBreakpoint;
+  }
+  return evidence;
+}
+function asRecord(value, label) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new InferenceAttemptValidationError("invalid-token", `${label} must be an object`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(obj, key) {
+  return Object.hasOwn(obj, key);
+}
+function readToken(obj, key) {
+  if (!obj || !hasOwn(obj, key)) {
+    return null;
+  }
+  return parseTokenCount(obj[key], key);
+}
+function firstToken(obj, keys) {
+  if (!obj) {
+    return null;
+  }
+  for (const key of keys) {
+    if (hasOwn(obj, key)) {
+      return parseTokenCount(obj[key], key);
+    }
+  }
+  return null;
+}
+function firstPresent(...values) {
+  for (const value of values) {
+    if (value !== null) {
+      return value;
+    }
+  }
+  return null;
+}
+function firstString(obj, keys) {
+  if (!obj) {
+    return;
+  }
+  for (const key of keys) {
+    if (hasOwn(obj, key)) {
+      return readNonEmptyString(obj[key], key);
+    }
+  }
+  return;
+}
+function readNonEmptyString(value, label) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw new InferenceAttemptValidationError("invalid-envelope", `${label} must be a non-empty string`);
+  }
+  return value;
+}
+var init_adapters = __esm(() => {
+  init_envelope();
+  init_errors();
+  init_tokens();
+});
+
+// src/core/ai/inference-attempt/identity.ts
+function allocateAttemptIdentity(opts) {
+  return {
+    attemptId: newAttemptId(),
+    idempotencyKey: opts?.idempotencyKey ?? newIdempotencyKey()
+  };
+}
+var init_identity = __esm(() => {
+  init_id();
+});
+
+// src/core/ai/inference-attempt/validate.ts
+function parseInferenceAttempt(value) {
+  const parsed = InferenceAttemptSchema.safeParse(value);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const path = issue?.path.length ? issue.path.join(".") : "envelope";
+    throw new InferenceAttemptValidationError("invalid-envelope", `${path}: ${issue?.message ?? "invalid envelope"}`);
+  }
+  assertLineage(parsed.data.lineage);
+  const tokens = finalizeTokens(parsed.data.tokens);
+  return { ...parsed.data, tokens };
+}
+var init_validate = __esm(() => {
+  init_envelope();
+  init_errors();
+  init_tokens();
+});
+
+// src/core/ai/inference-attempt/builder.ts
+function startInferenceAttempt(input) {
+  const identity = allocateAttemptIdentity({
+    idempotencyKey: input.idempotencyKey
+  });
+  const lineage = input.lineage ?? { sequence: 1 };
+  const attribution = {
+    ...input.attribution,
+    rootAttemptId: input.attribution?.rootAttemptId ?? identity.attemptId
+  };
+  const requested = input.requested;
+  const effective = input.effective ?? requested;
+  const started = parseInferenceAttempt({
+    schema: INFERENCE_ATTEMPT_SCHEMA,
+    version: INFERENCE_ATTEMPT_VERSION,
+    attemptId: identity.attemptId,
+    idempotencyKey: identity.idempotencyKey,
+    lifecycle: "started",
+    operationKind: input.operationKind,
+    lineage,
+    attribution,
+    requested,
+    effective,
+    tokens: UNKNOWN_TOKENS,
+    evidence: {}
+  });
+  const settle = (lifecycle, usage) => {
+    const { tokens, evidence } = resolveUsage(usage);
+    return parseInferenceAttempt({
+      schema: INFERENCE_ATTEMPT_SCHEMA,
+      version: INFERENCE_ATTEMPT_VERSION,
+      attemptId: identity.attemptId,
+      idempotencyKey: identity.idempotencyKey,
+      lifecycle,
+      operationKind: input.operationKind,
+      lineage,
+      attribution,
+      requested,
+      effective: usage?.effective ?? effective,
+      tokens,
+      evidence
+    });
+  };
+  return {
+    attemptId: identity.attemptId,
+    idempotencyKey: identity.idempotencyKey,
+    started,
+    complete: (usage) => settle("completed", usage),
+    fail: (usage) => settle("failed", usage),
+    abort: (usage) => settle("aborted", usage),
+    partial: (usage) => settle("partial", usage),
+    retried: (usage) => settle("retried", usage),
+    retry: (() => {
+      let used = false;
+      return () => {
+        if (used) {
+          throw new InferenceAttemptValidationError("invalid-envelope", "retry() is single-use; chain from the returned handle");
+        }
+        used = true;
+        return startInferenceAttempt({
+          operationKind: input.operationKind,
+          requested,
+          effective,
+          attribution,
+          idempotencyKey: identity.idempotencyKey,
+          lineage: {
+            sequence: lineage.sequence + 1,
+            previousAttemptId: identity.attemptId
+          }
+        });
+      };
+    })()
+  };
+}
+function resolveUsage(input) {
+  if (!input) {
+    return { tokens: UNKNOWN_TOKENS, evidence: {} };
+  }
+  if (input.tokens) {
+    return {
+      tokens: finalizeTokens(input.tokens),
+      evidence: input.evidence ?? {}
+    };
+  }
+  if (input.transport) {
+    const adapted = adaptTransportUsage({
+      transport: input.transport,
+      usage: input.usage,
+      providerMetadata: input.providerMetadata,
+      providerRequestId: input.providerRequestId,
+      cacheTtlSeconds: input.cacheTtlSeconds,
+      cacheBreakpoint: input.cacheBreakpoint
+    });
+    return {
+      tokens: adapted.tokens,
+      evidence: { ...adapted.evidence, ...input.evidence }
+    };
+  }
+  return {
+    tokens: UNKNOWN_TOKENS,
+    evidence: input.evidence ?? {}
+  };
+}
+var init_builder = __esm(() => {
+  init_adapters();
+  init_envelope();
+  init_errors();
+  init_identity();
+  init_tokens();
+  init_validate();
+});
+
+// src/core/ai/inference-attempt/project.ts
+var init_project = () => {};
+
+// src/core/ai/inference-attempt/recording.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function runWithInferenceRecorder(recorder, operation) {
+  return recorderContext.run(recorder, operation);
+}
+function getInferenceRecorder(binding) {
+  return binding && "inferenceRecorder" in binding ? binding.inferenceRecorder : recorderContext.getStore();
+}
+var recorderContext;
+var init_recording = __esm(() => {
+  recorderContext = new AsyncLocalStorage;
+});
+
+// src/core/ai/inference-attempt/index.ts
+var init_inference_attempt = __esm(() => {
+  init_adapters();
+  init_builder();
+  init_envelope();
+  init_errors();
+  init_identity();
+  init_project();
+  init_recording();
+  init_tokens();
+  init_validate();
+});
+
+// src/core/ai/native-rollout-evidence/content.ts
+import { createHash } from "node:crypto";
+function toJsonValue(value) {
+  return normalizeJsonValue(value, new WeakSet, 0);
+}
+function normalizeJsonValue(value, ancestors, depth) {
+  if (depth > 64) {
+    throw new NativeRolloutContentError("content nesting exceeds 64 levels");
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new NativeRolloutContentError("content contains a non-finite number");
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return { $type: "bigint", value: value.toString() };
+  }
+  if (value instanceof Date) {
+    return { $type: "date", value: value.toISOString() };
+  }
+  if (value instanceof URL) {
+    return { $type: "url", value: value.toString() };
+  }
+  if (value instanceof Uint8Array) {
+    return {
+      $type: "bytes",
+      encoding: "base64",
+      value: Buffer.from(value).toString("base64")
+    };
+  }
+  if (typeof value !== "object") {
+    throw new NativeRolloutContentError(`content contains unsupported ${typeof value}`);
+  }
+  if (ancestors.has(value)) {
+    throw new NativeRolloutContentError("content contains a cycle");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((entry) => entry === undefined ? null : normalizeJsonValue(entry, ancestors, depth + 1));
+    }
+    const normalized = Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+      if (entry === undefined)
+        continue;
+      normalized[key] = normalizeJsonValue(entry, ancestors, depth + 1);
+    }
+    return normalized;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function stringifyCanonicalJson(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stringifyCanonicalJson).join(",")}]`;
+  }
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stringifyCanonicalJson(value[key])}`).join(",")}}`;
+}
+function hashCanonicalJson(value) {
+  const encoded = Buffer.from(stringifyCanonicalJson(value));
+  return {
+    sha256: createHash("sha256").update(encoded).digest("hex"),
+    byteLength: encoded.byteLength
+  };
+}
+function createContentAddressedAsset(content, representation, mediaType = "application/json") {
+  const { sha256, byteLength } = hashCanonicalJson(content);
+  const ref = `sha256:${sha256}`;
+  return {
+    asset: { ref, sha256, mediaType, byteLength, content },
+    reference: { ref, mediaType, byteLength, representation }
+  };
+}
+var NativeRolloutContentError;
+var init_content = __esm(() => {
+  NativeRolloutContentError = class NativeRolloutContentError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "NativeRolloutContentError";
+    }
+  };
+});
+
+// src/core/ai/native-rollout-evidence/provider-metadata.ts
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function collectOpenAiLogprobs(value, probabilities, entries) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectOpenAiLogprobs(entry, probabilities, entries);
+    }
+    return;
+  }
+  const record = asRecord2(value);
+  if (!record)
+    return;
+  if (typeof record.logprob === "number") {
+    if (!Number.isFinite(record.logprob))
+      return;
+    probabilities.push(record.logprob);
+    entries.push(toJsonValue(record));
+    return;
+  }
+  if (Array.isArray(record.content)) {
+    collectOpenAiLogprobs(record.content, probabilities, entries);
+  }
+}
+function openAiExtra(provider, openai, logprobEntries) {
+  const value = {};
+  for (const key of [
+    "responseId",
+    "serviceTier",
+    "acceptedPredictionTokens",
+    "rejectedPredictionTokens"
+  ]) {
+    if (openai[key] !== undefined)
+      value[key] = toJsonValue(openai[key]);
+  }
+  if (logprobEntries.length > 0)
+    value.logprobEntries = logprobEntries;
+  if (Object.keys(value).length === 0) {
+    return {
+      state: "omitted",
+      reason: "the OpenAI adapter supplied no allowlisted native metadata"
+    };
+  }
+  return {
+    state: "available",
+    value: {
+      schema: "pensar.native_rollout_provider_extra.openai",
+      version: 1,
+      provider,
+      value
+    }
+  };
+}
+function extractNativeSamplingEvidence(input) {
+  const metadata = asRecord2(input.providerMetadata);
+  const openai = asRecord2(metadata?.openai);
+  const probabilities = [];
+  const logprobEntries = [];
+  const logprobsValue = openai?.logprobs;
+  if (logprobsValue !== undefined) {
+    collectOpenAiLogprobs(logprobsValue, probabilities, logprobEntries);
+  }
+  const explicitEmptyLogprobs = Array.isArray(logprobsValue) && logprobsValue.length === 0 || Array.isArray(asRecord2(logprobsValue)?.content) && (asRecord2(logprobsValue)?.content).length === 0;
+  const openAiRoute = input.provider.toLowerCase().includes("openai");
+  const logprobs = probabilities.length > 0 || explicitEmptyLogprobs ? { state: "available", value: probabilities } : openAiRoute || openai !== undefined ? {
+    state: "omitted",
+    reason: "the OpenAI adapter did not return completion logprobs"
+  } : {
+    state: "unsupported",
+    reason: "this provider route exposes no supported logprob field"
+  };
+  return {
+    promptTokenIds: { state: "unsupported", reason: NO_TOKEN_IDS },
+    completionTokenIds: { state: "unsupported", reason: NO_TOKEN_IDS },
+    logprobs,
+    tokenizer: {
+      state: "unsupported",
+      reason: "the provider boundary exposes no tokenizer identity"
+    },
+    extra: openai !== undefined ? openAiExtra(input.provider, openai, logprobEntries) : {
+      state: "unsupported",
+      reason: "this provider route has no documented native extra adapter"
+    }
+  };
+}
+var NO_TOKEN_IDS = "the provider boundary does not expose numeric native token ids";
+var init_provider_metadata = __esm(() => {
+  init_content();
+});
+
+// src/core/ai/native-rollout-evidence/schema.ts
+function cloneJsonValue(value, ancestors, depth) {
+  if (depth > 64) {
+    throw new JsonValueValidationError("JSON nesting exceeds 64 levels");
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new JsonValueValidationError("JSON contains a non-finite number");
+    }
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new JsonValueValidationError(`JSON contains unsupported ${typeof value}`);
+  }
+  if (ancestors.has(value)) {
+    throw new JsonValueValidationError("JSON contains a cycle");
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    throw new JsonValueValidationError("JSON contains a non-record object");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const cloned = [];
+      for (let index = 0;index < value.length; index++) {
+        if (!Object.hasOwn(value, index)) {
+          throw new JsonValueValidationError("JSON arrays cannot contain holes");
+        }
+        cloned.push(cloneJsonValue(value[index], ancestors, depth + 1));
+      }
+      return cloned;
+    }
+    const cloned = Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+      cloned[key] = cloneJsonValue(entry, ancestors, depth + 1);
+    }
+    return cloned;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function evidenceAvailabilitySchema(value) {
+  return discriminatedUnion("state", [
+    strictObject({ state: literal("available"), value }),
+    strictObject({
+      state: _enum(NATIVE_EVIDENCE_UNAVAILABLE_STATES),
+      reason: string().min(1)
+    }),
+    strictObject({
+      state: _enum(NATIVE_EVIDENCE_PARTIAL_STATES),
+      reason: string().min(1),
+      partial: value.optional(),
+      observed: strictObject({
+        sha256: string().regex(SHA256_PATTERN),
+        byteLength: number().int().nonnegative()
+      }).optional()
+    })
+  ]);
+}
+var NATIVE_ROLLOUT_EVIDENCE_SCHEMA = "pensar.native_rollout_evidence", NATIVE_ROLLOUT_EVIDENCE_VERSION = 1, NATIVE_ROLLOUT_CAPTURE_REPORT_SCHEMA = "pensar.native_rollout_capture_report", JsonValueValidationError, JsonValueSchema, SHA256_PATTERN, CONTENT_REF_PATTERN, ContentReferenceSchema, ContentAddressedAssetSchema, NATIVE_EVIDENCE_UNAVAILABLE_STATES, NATIVE_EVIDENCE_PARTIAL_STATES, NATIVE_EVIDENCE_AVAILABILITY_STATES, contentAvailabilitySchema, tokenIdsAvailabilitySchema, logprobsAvailabilitySchema, tokenizerAvailabilitySchema, ProviderExtraSchema, providerExtraAvailabilitySchema, attemptIdSchema2, idempotencyKeySchema2, NATIVE_ROLLOUT_ATTEMPT_LIFECYCLES, NativeRolloutAttemptSchema, modelRefSchema2, NativeRolloutBoundarySchema, CaptureDiagnosticSchema, NativeRolloutEvidenceEnvelopeSchema, NATIVE_ROLLOUT_CAPTURE_STATES, NativeRolloutCaptureReportSchema;
+var init_schema = __esm(() => {
+  init_zod();
+  init_id();
+  init_inference_attempt();
+  JsonValueValidationError = class JsonValueValidationError extends Error {
+  };
+  JsonValueSchema = unknown().transform((value, context) => {
+    try {
+      return cloneJsonValue(value, new WeakSet, 0);
+    } catch (error) {
+      context.addIssue({
+        code: "custom",
+        message: error instanceof JsonValueValidationError ? error.message : "invalid JSON value"
+      });
+      return NEVER;
+    }
+  });
+  SHA256_PATTERN = /^[a-f0-9]{64}$/;
+  CONTENT_REF_PATTERN = /^sha256:[a-f0-9]{64}$/;
+  ContentReferenceSchema = strictObject({
+    ref: string().regex(CONTENT_REF_PATTERN),
+    mediaType: string().min(1),
+    byteLength: number().int().nonnegative(),
+    representation: string().min(1)
+  });
+  ContentAddressedAssetSchema = strictObject({
+    ref: string().regex(CONTENT_REF_PATTERN),
+    sha256: string().regex(SHA256_PATTERN),
+    mediaType: string().min(1),
+    byteLength: number().int().nonnegative(),
+    content: JsonValueSchema
+  });
+  NATIVE_EVIDENCE_UNAVAILABLE_STATES = [
+    "unsupported",
+    "omitted"
+  ];
+  NATIVE_EVIDENCE_PARTIAL_STATES = [
+    "truncated",
+    "interrupted"
+  ];
+  NATIVE_EVIDENCE_AVAILABILITY_STATES = [
+    "available",
+    ...NATIVE_EVIDENCE_UNAVAILABLE_STATES,
+    ...NATIVE_EVIDENCE_PARTIAL_STATES
+  ];
+  contentAvailabilitySchema = evidenceAvailabilitySchema(ContentReferenceSchema);
+  tokenIdsAvailabilitySchema = evidenceAvailabilitySchema(array(number().int().nonnegative()));
+  logprobsAvailabilitySchema = evidenceAvailabilitySchema(array(number().finite()));
+  tokenizerAvailabilitySchema = evidenceAvailabilitySchema(strictObject({
+    name: string().min(1),
+    version: string().min(1).optional()
+  }));
+  ProviderExtraSchema = strictObject({
+    schema: string().min(1),
+    version: number().int().positive(),
+    provider: string().min(1),
+    value: JsonValueSchema
+  });
+  providerExtraAvailabilitySchema = evidenceAvailabilitySchema(ProviderExtraSchema);
+  attemptIdSchema2 = string().refine(isAttemptId, {
+    message: "attemptId must start with atm_"
+  });
+  idempotencyKeySchema2 = string().refine(isIdempotencyKey, {
+    message: "idempotencyKey must start with idem_"
+  });
+  NATIVE_ROLLOUT_ATTEMPT_LIFECYCLES = [
+    "completed",
+    "failed",
+    "partial",
+    "aborted",
+    "retried"
+  ];
+  NativeRolloutAttemptSchema = strictObject({
+    attemptId: attemptIdSchema2,
+    idempotencyKey: idempotencyKeySchema2,
+    sequence: number().int().positive(),
+    rootAttemptId: attemptIdSchema2,
+    previousAttemptId: attemptIdSchema2.optional(),
+    lifecycle: _enum(NATIVE_ROLLOUT_ATTEMPT_LIFECYCLES)
+  });
+  modelRefSchema2 = strictObject({
+    provider: string().min(1),
+    modelId: string().min(1),
+    transport: _enum(ATTEMPT_TRANSPORTS).optional()
+  });
+  NativeRolloutBoundarySchema = strictObject({
+    input: strictObject({
+      normalizedRef: ContentReferenceSchema,
+      native: contentAvailabilitySchema
+    }),
+    output: strictObject({
+      normalized: contentAvailabilitySchema,
+      native: contentAvailabilitySchema
+    })
+  });
+  CaptureDiagnosticSchema = strictObject({
+    code: string().min(1),
+    message: string().min(1),
+    field: string().min(1).optional()
+  });
+  NativeRolloutEvidenceEnvelopeSchema = strictObject({
+    schema: literal(NATIVE_ROLLOUT_EVIDENCE_SCHEMA),
+    version: literal(NATIVE_ROLLOUT_EVIDENCE_VERSION),
+    runId: string().min(1),
+    sessionId: string().min(1).optional(),
+    parent: strictObject({
+      sessionId: string().min(1),
+      toolCallId: string().min(1)
+    }).optional(),
+    segmentId: string().min(1),
+    turnId: string().min(1),
+    turnIndex: number().int().positive(),
+    operationKind: _enum(ATTEMPT_OPERATION_KINDS),
+    attempt: NativeRolloutAttemptSchema,
+    requested: modelRefSchema2,
+    effective: modelRefSchema2,
+    boundary: NativeRolloutBoundarySchema,
+    native: strictObject({
+      promptTokenIds: tokenIdsAvailabilitySchema,
+      completionTokenIds: tokenIdsAvailabilitySchema,
+      logprobs: logprobsAvailabilitySchema,
+      tokenizer: tokenizerAvailabilitySchema,
+      extra: providerExtraAvailabilitySchema
+    }),
+    assets: array(ContentAddressedAssetSchema),
+    limitations: array(CaptureDiagnosticSchema)
+  });
+  NATIVE_ROLLOUT_CAPTURE_STATES = [
+    "disabled",
+    "complete",
+    "limited",
+    "interrupted"
+  ];
+  NativeRolloutCaptureReportSchema = strictObject({
+    schema: literal(NATIVE_ROLLOUT_CAPTURE_REPORT_SCHEMA),
+    version: literal(NATIVE_ROLLOUT_EVIDENCE_VERSION),
+    runId: string().min(1),
+    state: _enum(NATIVE_ROLLOUT_CAPTURE_STATES),
+    attemptedRecords: number().int().nonnegative(),
+    writtenRecords: number().int().nonnegative(),
+    droppedRecords: number().int().nonnegative(),
+    deliveryUnknownRecords: number().int().nonnegative(),
+    diagnostics: array(CaptureDiagnosticSchema)
+  });
+});
+
+// src/core/ai/native-rollout-evidence/validate.ts
+function contentReferences(value) {
+  if (value.state === "available")
+    return [value.value];
+  if ((value.state === "truncated" || value.state === "interrupted") && value.partial) {
+    return [value.partial];
+  }
+  return [];
+}
+function parseNativeRolloutEvidence(value) {
+  const parsed = NativeRolloutEvidenceEnvelopeSchema.safeParse(value);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const path = issue?.path.length ? issue.path.join(".") : "envelope";
+    throw new NativeRolloutEvidenceValidationError("invalid-envelope", `${path}: ${issue?.message ?? "invalid envelope"}`);
+  }
+  const envelope = parsed.data;
+  const { attempt } = envelope;
+  if (attempt.sequence === 1 && attempt.previousAttemptId !== undefined || attempt.sequence > 1 && attempt.previousAttemptId === undefined || attempt.sequence === 1 && attempt.rootAttemptId !== attempt.attemptId) {
+    throw new NativeRolloutEvidenceValidationError("invalid-lineage", "attempt sequence, rootAttemptId, and previousAttemptId disagree");
+  }
+  const assetsByRef = new Map;
+  for (const asset of envelope.assets) {
+    if (assetsByRef.has(asset.ref)) {
+      throw new NativeRolloutEvidenceValidationError("duplicate-content-reference", `asset ${asset.ref} is listed more than once`);
+    }
+    const measured = hashCanonicalJson(asset.content);
+    if (`sha256:${measured.sha256}` !== asset.ref || measured.sha256 !== asset.sha256) {
+      throw new NativeRolloutEvidenceValidationError("content-hash-mismatch", `asset ${asset.ref} does not match its canonical content hash`);
+    }
+    if (measured.byteLength !== asset.byteLength) {
+      throw new NativeRolloutEvidenceValidationError("content-length-mismatch", `asset ${asset.ref} byteLength does not match canonical content`);
+    }
+    assetsByRef.set(asset.ref, asset);
+  }
+  const references = [
+    envelope.boundary.input.normalizedRef,
+    ...contentReferences(envelope.boundary.input.native),
+    ...contentReferences(envelope.boundary.output.normalized),
+    ...contentReferences(envelope.boundary.output.native)
+  ];
+  for (const reference of references) {
+    const asset = assetsByRef.get(reference.ref);
+    if (!asset) {
+      throw new NativeRolloutEvidenceValidationError("unresolved-content-reference", `content reference ${reference.ref} has no asset`);
+    }
+    if (asset.mediaType !== reference.mediaType || asset.byteLength !== reference.byteLength) {
+      throw new NativeRolloutEvidenceValidationError("content-length-mismatch", `content reference ${reference.ref} metadata disagrees with its asset`);
+    }
+  }
+  if (envelope.native.completionTokenIds.state === "available" && envelope.native.logprobs.state === "available" && envelope.native.completionTokenIds.value.length !== envelope.native.logprobs.value.length) {
+    throw new NativeRolloutEvidenceValidationError("misaligned-logprobs", "completionTokenIds and logprobs must have identical lengths");
+  }
+  return envelope;
+}
+function serializeNativeRolloutEvidence(envelope) {
+  return stringifyCanonicalJson(parseNativeRolloutEvidence(envelope));
+}
+var NativeRolloutEvidenceValidationError;
+var init_validate2 = __esm(() => {
+  init_content();
+  init_schema();
+  NativeRolloutEvidenceValidationError = class NativeRolloutEvidenceValidationError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "NativeRolloutEvidenceValidationError";
+      this.code = code;
+    }
+  };
+});
+
+// src/core/ai/native-rollout-evidence/capture.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+function positiveInteger(name, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return value;
+}
+function integerAtLeast(name, value, minimum) {
+  positiveInteger(name, value);
+  if (value < minimum) {
+    throw new Error(`${name} must be at least ${minimum}`);
+  }
+  return value;
+}
+function resolveLimits(input) {
+  const merged = { ...DEFAULT_NATIVE_ROLLOUT_CAPTURE_LIMITS, ...input };
+  return {
+    maxAssetBytes: integerAtLeast("maxAssetBytes", merged.maxAssetBytes, 256),
+    maxEnvelopeBytes: positiveInteger("maxEnvelopeBytes", merged.maxEnvelopeBytes),
+    maxPendingRecords: positiveInteger("maxPendingRecords", merged.maxPendingRecords),
+    maxDiagnostics: positiveInteger("maxDiagnostics", merged.maxDiagnostics),
+    sinkTimeoutMs: positiveInteger("sinkTimeoutMs", merged.sinkTimeoutMs)
+  };
+}
+function addDiagnostic(store, diagnostic) {
+  if (store.diagnostics.length < store.limits.maxDiagnostics) {
+    store.diagnostics.push(diagnostic);
+  }
+}
+function markInterrupted(store, value) {
+  if (value && (typeof value === "object" || typeof value === "function") && "then" in value) {
+    return Promise.resolve(value).catch((error) => {
+      store.interrupted = true;
+      throw error;
+    });
+  }
+  return value;
+}
+function recorderOnlyStore(runId) {
+  return {
+    enabled: false,
+    runId,
+    sink: undefined,
+    attemptSink: undefined,
+    limits: { ...DEFAULT_NATIVE_ROLLOUT_CAPTURE_LIMITS },
+    diagnostics: [],
+    attemptedRecords: 0,
+    writtenRecords: 0,
+    droppedRecords: 0,
+    deliveryUnknownRecords: 0,
+    pendingWrites: new Set,
+    activeSinkWrites: new Set,
+    activeAttemptWrites: new Set,
+    retainedFailures: new Set,
+    openFinalizers: new Set,
+    flushers: new Set,
+    nextSegment: 1,
+    nextTurnBySession: new Map,
+    interrupted: false
+  };
+}
+function createNativeRolloutEvidenceCapture(input) {
+  if (!input.runId)
+    throw new Error("runId is required");
+  const enabled = input.enabled ?? false;
+  if (enabled && !input.sink) {
+    throw new Error("an evidence sink is required when capture is enabled");
+  }
+  const store = {
+    enabled,
+    runId: input.runId,
+    sink: input.sink,
+    attemptSink: input.attemptSink,
+    limits: resolveLimits(input.limits),
+    diagnostics: [],
+    attemptedRecords: 0,
+    writtenRecords: 0,
+    droppedRecords: 0,
+    deliveryUnknownRecords: 0,
+    pendingWrites: new Set,
+    activeSinkWrites: new Set,
+    activeAttemptWrites: new Set,
+    retainedFailures: new Set,
+    openFinalizers: new Set,
+    flushers: new Set,
+    nextSegment: 1,
+    nextTurnBySession: new Map,
+    interrupted: false
+  };
+  return {
+    run(fn) {
+      if (!store.enabled)
+        return fn();
+      try {
+        return markInterrupted(store, captureStore.run(store, fn));
+      } catch (error) {
+        store.interrupted = true;
+        throw error;
+      }
+    },
+    async flush() {
+      for (const flush of [...store.flushers])
+        await flush();
+      while (store.pendingWrites.size > 0) {
+        await Promise.all([...store.pendingWrites]);
+      }
+      for (const finalize of [...store.openFinalizers])
+        finalize();
+      while (store.pendingWrites.size > 0) {
+        await Promise.all([...store.pendingWrites]);
+      }
+      const state = !store.enabled ? "disabled" : store.interrupted ? "interrupted" : store.droppedRecords > 0 || store.deliveryUnknownRecords > 0 || store.diagnostics.length > 0 ? "limited" : "complete";
+      return {
+        schema: NATIVE_ROLLOUT_CAPTURE_REPORT_SCHEMA,
+        version: NATIVE_ROLLOUT_EVIDENCE_VERSION,
+        runId: store.runId,
+        state,
+        attemptedRecords: store.attemptedRecords,
+        writtenRecords: store.writtenRecords,
+        droppedRecords: store.droppedRecords,
+        deliveryUnknownRecords: store.deliveryUnknownRecords,
+        diagnostics: [...store.diagnostics]
+      };
+    }
+  };
+}
+function runWithNativeRolloutOperation(context, fn) {
+  const operation = {
+    ...context,
+    invocation: Symbol("model-call"),
+    finalizers: new Set,
+    closed: false
+  };
+  const close = () => {
+    if (operation.closed)
+      return;
+    operation.closed = true;
+    for (const finalize of [...operation.finalizers])
+      finalize();
+    operation.finalizers.clear();
+  };
+  let result;
+  try {
+    result = operationStore.run(operation, fn);
+  } catch (error) {
+    close();
+    throw error;
+  }
+  if (result && (typeof result === "object" || typeof result === "function") && "then" in result) {
+    return Promise.resolve(result).finally(close);
+  }
+  return result;
+}
+function runWithNativeRolloutSession(context, fn) {
+  if (context.parentSessionId === undefined !== (context.parentToolCallId === undefined)) {
+    throw new Error("parentSessionId and parentToolCallId must be supplied together");
+  }
+  return sessionStore.run(context, fn);
+}
+function boundedSinkWrite(operation, controller, timeoutMs) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort(new Error("native evidence sink timed out"));
+      resolve("unknown");
+    }, timeoutMs);
+  });
+  return Promise.race([
+    operation.then(() => "written"),
+    timeout
+  ]).finally(() => {
+    if (timer)
+      clearTimeout(timer);
+  });
+}
+function queueEnvelope(store, envelope) {
+  store.attemptedRecords += 1;
+  let parsed;
+  let byteLength;
+  try {
+    parsed = parseNativeRolloutEvidence(envelope);
+    byteLength = Buffer.byteLength(serializeNativeRolloutEvidence(parsed));
+  } catch {
+    store.droppedRecords += 1;
+    addDiagnostic(store, {
+      code: "invalid_record",
+      message: "a captured attempt failed evidence validation"
+    });
+    return;
+  }
+  if (byteLength > store.limits.maxEnvelopeBytes) {
+    store.droppedRecords += 1;
+    addDiagnostic(store, {
+      code: "envelope_limit",
+      message: "a captured attempt exceeded the envelope byte limit"
+    });
+    return;
+  }
+  if (store.activeSinkWrites.size >= store.limits.maxPendingRecords) {
+    store.droppedRecords += 1;
+    addDiagnostic(store, {
+      code: "queue_limit",
+      message: "the evidence sink queue reached its record limit"
+    });
+    return;
+  }
+  const controller = new AbortController;
+  const write = Promise.resolve().then(() => store.sink?.write(parsed, { signal: controller.signal })).finally(() => {
+    store.activeSinkWrites.delete(write);
+  });
+  store.activeSinkWrites.add(write);
+  const pending = boundedSinkWrite(write, controller, store.limits.sinkTimeoutMs).then((outcome) => {
+    if (outcome === "written") {
+      store.writtenRecords += 1;
+    } else {
+      store.deliveryUnknownRecords += 1;
+      addDiagnostic(store, {
+        code: "sink_delivery_unknown",
+        message: "the evidence sink did not confirm persistence before its deadline"
+      });
+    }
+  }).catch(() => {
+    store.droppedRecords += 1;
+    addDiagnostic(store, {
+      code: "sink_failure",
+      message: "the evidence sink did not persist a captured attempt"
+    });
+  }).finally(() => {
+    store.pendingWrites.delete(pending);
+  });
+  store.pendingWrites.add(pending);
+}
+function queueAttempt(store, attempt) {
+  if (!store.attemptSink)
+    return;
+  if (Buffer.byteLength(JSON.stringify(attempt)) > store.limits.maxEnvelopeBytes) {
+    addDiagnostic(store, {
+      code: "attempt_envelope_limit",
+      message: "an inference-attempt event exceeded the envelope byte limit"
+    });
+    return;
+  }
+  if (store.activeAttemptWrites.size >= store.limits.maxPendingRecords) {
+    addDiagnostic(store, {
+      code: "attempt_queue_limit",
+      message: "the inference-attempt sink queue reached its record limit"
+    });
+    return;
+  }
+  const controller = new AbortController;
+  const write = Promise.resolve().then(() => store.attemptSink?.write(attempt, { signal: controller.signal })).finally(() => {
+    store.activeAttemptWrites.delete(write);
+  });
+  store.activeAttemptWrites.add(write);
+  const pending = boundedSinkWrite(write, controller, store.limits.sinkTimeoutMs).then((outcome) => {
+    if (outcome === "unknown") {
+      addDiagnostic(store, {
+        code: "attempt_sink_delivery_unknown",
+        message: "the inference-attempt sink did not confirm persistence before its deadline"
+      });
+    }
+  }).catch(() => {
+    addDiagnostic(store, {
+      code: "attempt_sink_failure",
+      message: "the inference-attempt sink rejected an event"
+    });
+  }).finally(() => {
+    store.pendingWrites.delete(pending);
+  });
+  store.pendingWrites.add(pending);
+}
+function addAsset(assets, asset) {
+  assets.set(asset.ref, asset);
+}
+function requiredContent(store, value, representation) {
+  const limitations = [];
+  let normalized;
+  try {
+    normalized = toJsonValue(value);
+  } catch (error) {
+    normalized = {
+      capture: "unavailable",
+      reason: error instanceof NativeRolloutContentError ? error.message : "content normalization failed"
+    };
+    limitations.push({
+      code: "content_unavailable",
+      message: "normalized boundary input could not be represented as JSON",
+      field: "boundary.input.normalizedRef"
+    });
+  }
+  const measured = hashCanonicalJson(normalized);
+  if (measured.byteLength > store.limits.maxAssetBytes) {
+    normalized = {
+      capture: "truncated",
+      original: measured
+    };
+    representation = `${representation};truncated`;
+    limitations.push({
+      code: "asset_limit",
+      message: "normalized boundary input exceeded the asset byte limit",
+      field: "boundary.input.normalizedRef"
+    });
+  }
+  const { asset, reference } = createContentAddressedAsset(normalized, representation);
+  return { normalizedRef: reference, assets: [asset], limitations };
+}
+function optionalContent(store, value, representation, absent, absentReason) {
+  if (value === undefined) {
+    return {
+      availability: { state: absent, reason: absentReason },
+      assets: [],
+      limitations: []
+    };
+  }
+  let normalized;
+  try {
+    normalized = toJsonValue(value);
+  } catch {
+    return {
+      availability: {
+        state: "omitted",
+        reason: "the exposed content could not be represented as JSON"
+      },
+      assets: [],
+      limitations: [
+        {
+          code: "content_unavailable",
+          message: "exposed boundary content could not be represented as JSON"
+        }
+      ]
+    };
+  }
+  const measured = hashCanonicalJson(normalized);
+  if (measured.byteLength > store.limits.maxAssetBytes) {
+    return {
+      availability: {
+        state: "truncated",
+        reason: "the exposed content exceeded the asset byte limit",
+        observed: measured
+      },
+      assets: [],
+      limitations: [
+        {
+          code: "asset_limit",
+          message: "exposed boundary content exceeded the asset byte limit"
+        }
+      ]
+    };
+  }
+  const { asset, reference } = createContentAddressedAsset(normalized, representation);
+  return {
+    availability: { state: "available", value: reference },
+    assets: [asset],
+    limitations: []
+  };
+}
+function normalizedCallOptions(options) {
+  return {
+    prompt: options.prompt,
+    maxOutputTokens: options.maxOutputTokens,
+    temperature: options.temperature,
+    stopSequences: options.stopSequences,
+    topP: options.topP,
+    topK: options.topK,
+    presencePenalty: options.presencePenalty,
+    frequencyPenalty: options.frequencyPenalty,
+    responseFormat: options.responseFormat,
+    seed: options.seed,
+    tools: options.tools,
+    toolChoice: options.toolChoice,
+    includeRawChunks: options.includeRawChunks,
+    providerOptions: options.providerOptions
+  };
+}
+function allocateTurn(store, context) {
+  const sessionKey = context.sessionId ?? "";
+  const turnIndex = (store.nextTurnBySession.get(sessionKey) ?? 0) + 1;
+  store.nextTurnBySession.set(sessionKey, turnIndex);
+  const segment = store.nextSegment++;
+  return {
+    segmentId: `segment_${segment.toString().padStart(6, "0")}`,
+    turnId: `turn_${turnIndex.toString().padStart(6, "0")}`,
+    turnIndex
+  };
+}
+function beginAttempt(store, context, provider, modelId, options, retry) {
+  const input = store.enabled ? requiredContent(store, normalizedCallOptions(options), "ai-sdk-v3-call-options") : RECORDER_ONLY_INPUT;
+  if (!retry) {
+    const turn = allocateTurn(store, context);
+    const capture = {
+      turn,
+      attempt: startInferenceAttempt({
+        operationKind: context.operationKind,
+        requested: {
+          provider,
+          modelId: context.requestedModelId,
+          ...context.transport ? { transport: context.transport } : {}
+        },
+        effective: {
+          provider,
+          modelId,
+          ...context.transport ? { transport: context.transport } : {}
+        },
+        attribution: {
+          runId: store.runId,
+          ...context.sessionId ? { sessionId: context.sessionId } : {}
+        }
+      }),
+      modelContext: context,
+      provider,
+      modelId,
+      input
+    };
+    queueAttempt(store, capture.attempt.started);
+    return capture;
+  }
+  const capture = {
+    turn: {
+      ...retry.capture.turn
+    },
+    attempt: retry.capture.attempt.retry(),
+    modelContext: context,
+    provider,
+    modelId,
+    input
+  };
+  queueAttempt(store, capture.attempt.started);
+  return capture;
+}
+function isAborted(options, error) {
+  return options.abortSignal?.aborted === true || error instanceof Error && error.name === "AbortError";
+}
+function errorRequestBody(error) {
+  return APICallError.isInstance(error) ? error.requestBodyValues : undefined;
+}
+function emitAttempt(store, recorder, capture, input) {
+  const usage = {
+    transport: "sdk-normalized",
+    usage: input.usage,
+    providerMetadata: input.providerMetadata,
+    providerRequestId: input.providerRequestId,
+    effective: {
+      provider: capture.provider,
+      modelId: input.effectiveModelId ?? capture.modelId,
+      ...capture.modelContext.transport ? { transport: capture.modelContext.transport } : {}
+    }
+  };
+  const settle = (attemptUsage) => {
+    switch (input.lifecycle) {
+      case "completed":
+        return capture.attempt.complete(attemptUsage);
+      case "failed":
+        return capture.attempt.fail(attemptUsage);
+      case "partial":
+        return capture.attempt.partial(attemptUsage);
+      case "aborted":
+        return capture.attempt.abort(attemptUsage);
+      case "retried":
+        return capture.attempt.retried(attemptUsage);
+    }
+  };
+  let attempt;
+  try {
+    attempt = settle(usage);
+  } catch {
+    addDiagnostic(store, {
+      code: "attempt_usage_unavailable",
+      message: "the inference-attempt observer could not normalize usage"
+    });
+    attempt = settle();
+  }
+  recorder?.settle(attempt);
+  queueAttempt(store, attempt);
+  if (!store.enabled)
+    return;
+  const assets = new Map;
+  for (const asset of capture.input.assets)
+    addAsset(assets, asset);
+  const limitations = [
+    ...capture.input.limitations,
+    ...input.limitations ?? []
+  ];
+  const nativeInput = optionalContent(store, input.nativeInput, "provider-request-body", "omitted", "the provider did not expose its serialized request body");
+  for (const asset of nativeInput.assets)
+    addAsset(assets, asset);
+  limitations.push(...nativeInput.limitations);
+  const normalizedOutput = optionalContent(store, input.normalizedOutput, "ai-sdk-v3-output", "omitted", "the provider call returned no normalized output");
+  for (const asset of normalizedOutput.assets)
+    addAsset(assets, asset);
+  limitations.push(...normalizedOutput.limitations);
+  let normalizedOutputAvailability = normalizedOutput.availability;
+  if (normalizedOutputAvailability.state === "available" && input.normalizedOutputState && input.normalizedOutputState !== "available") {
+    normalizedOutputAvailability = {
+      state: input.normalizedOutputState,
+      reason: input.normalizedOutputState === "truncated" ? "the bounded collector omitted later output parts" : "the provider output ended before a complete terminal result",
+      partial: normalizedOutputAvailability.value
+    };
+  }
+  if (input.lifecycle === "aborted" && normalizedOutputAvailability.state === "omitted") {
+    normalizedOutputAvailability = {
+      state: "interrupted",
+      reason: "the provider call was cancelled before returning output"
+    };
+  }
+  const nativeOutput = optionalContent(store, input.nativeOutput, "provider-response-body", input.nativeOutputAbsent ?? "omitted", input.nativeOutputReason ?? "the provider did not expose its native response body");
+  for (const asset of nativeOutput.assets)
+    addAsset(assets, asset);
+  limitations.push(...nativeOutput.limitations);
+  let nativeOutputAvailability = nativeOutput.availability;
+  if (nativeOutputAvailability.state === "available" && input.nativeOutputState && input.nativeOutputState !== "available") {
+    nativeOutputAvailability = {
+      state: input.nativeOutputState,
+      reason: input.nativeOutputState === "truncated" ? "the bounded collector omitted later raw response chunks" : "the provider raw response ended before a complete terminal result",
+      partial: nativeOutputAvailability.value
+    };
+  }
+  const sampling = extractNativeSamplingEvidence({
+    provider: capture.provider,
+    providerMetadata: input.providerMetadata
+  });
+  if ((input.lifecycle === "aborted" || input.lifecycle === "partial") && sampling.logprobs.state === "omitted") {
+    sampling.logprobs = {
+      state: "interrupted",
+      reason: "the stream ended before completion logprobs were observed"
+    };
+  }
+  queueEnvelope(store, {
+    schema: NATIVE_ROLLOUT_EVIDENCE_SCHEMA,
+    version: NATIVE_ROLLOUT_EVIDENCE_VERSION,
+    runId: store.runId,
+    ...capture.modelContext.sessionId ? { sessionId: capture.modelContext.sessionId } : {},
+    ...capture.modelContext.parentSessionId && capture.modelContext.parentToolCallId ? {
+      parent: {
+        sessionId: capture.modelContext.parentSessionId,
+        toolCallId: capture.modelContext.parentToolCallId
+      }
+    } : {},
+    segmentId: capture.turn.segmentId,
+    turnId: capture.turn.turnId,
+    turnIndex: capture.turn.turnIndex,
+    operationKind: capture.modelContext.operationKind,
+    attempt: {
+      attemptId: attempt.attemptId,
+      idempotencyKey: attempt.idempotencyKey,
+      sequence: attempt.lineage.sequence,
+      rootAttemptId: attempt.attribution.rootAttemptId,
+      ...attempt.lineage.previousAttemptId ? { previousAttemptId: attempt.lineage.previousAttemptId } : {},
+      lifecycle: input.lifecycle
+    },
+    requested: {
+      provider: capture.provider,
+      modelId: capture.modelContext.requestedModelId,
+      ...capture.modelContext.transport ? { transport: capture.modelContext.transport } : {}
+    },
+    effective: {
+      provider: capture.provider,
+      modelId: input.effectiveModelId ?? capture.modelId,
+      ...capture.modelContext.transport ? { transport: capture.modelContext.transport } : {}
+    },
+    boundary: {
+      input: {
+        normalizedRef: capture.input.normalizedRef,
+        native: nativeInput.availability
+      },
+      output: {
+        normalized: normalizedOutputAvailability,
+        native: nativeOutputAvailability
+      }
+    },
+    native: sampling,
+    assets: [...assets.values()],
+    limitations
+  });
+}
+function safeEmitAttempt(store, recorder, capture, input) {
+  try {
+    emitAttempt(store, recorder, capture, input);
+  } catch {
+    store.attemptedRecords += 1;
+    store.droppedRecords += 1;
+    addDiagnostic(store, {
+      code: "capture_failure",
+      message: "the passive collector could not assemble an attempt record"
+    });
+  }
+}
+function collectStreamPart(store, collector, part) {
+  if (part.type === "finish") {
+    collector.sawFinish = true;
+    collector.finishReason = part.finishReason.unified;
+    collector.providerMetadata = part.providerMetadata;
+    collector.usage = part.usage;
+  } else if (part.type === "response-metadata") {
+    collector.responseId = part.id;
+    collector.responseModelId = part.modelId;
+  } else if (part.type === "error") {
+    collector.sawError = true;
+  } else if (part.type !== "stream-start") {
+    collector.sawOutput = true;
+  }
+  if (!store.enabled)
+    return;
+  try {
+    const normalized = toJsonValue(part);
+    const size = Buffer.byteLength(stringifyCanonicalJson(normalized)) + (collector.parts.length > 0 ? 1 : 0);
+    if (!collector.truncated && collector.byteLength + size <= store.limits.maxAssetBytes) {
+      collector.parts.push(normalized);
+      collector.byteLength += size;
+    } else {
+      collector.truncated = true;
+    }
+    if (part.type === "raw") {
+      const raw = toJsonValue(part.rawValue);
+      const rawSize = Buffer.byteLength(stringifyCanonicalJson(raw)) + (collector.rawParts.length > 0 ? 1 : 0);
+      if (!collector.rawTruncated && collector.rawByteLength + rawSize <= store.limits.maxAssetBytes) {
+        collector.rawParts.push(raw);
+        collector.rawByteLength += rawSize;
+      } else {
+        collector.rawTruncated = true;
+      }
+    }
+  } catch {
+    collector.truncated = true;
+    if (part.type === "raw")
+      collector.rawTruncated = true;
+  }
+}
+function wrapCapturedStream(store, recorder, capture, result, options, retainFailure) {
+  const collector = {
+    parts: [],
+    rawParts: [],
+    byteLength: Buffer.byteLength('{"parts":[]}'),
+    rawByteLength: Buffer.byteLength('{"chunks":[]}'),
+    sawOutput: false,
+    truncated: false,
+    rawTruncated: false,
+    sawError: false,
+    sawFinish: false
+  };
+  const reader = result.stream.getReader();
+  let finalized = false;
+  const terminalLifecycle = () => {
+    if (!collector.sawFinish || collector.sawError) {
+      return { lifecycle: "partial", outputState: "interrupted" };
+    }
+    return {
+      lifecycle: collector.finishReason === "length" ? "partial" : "completed",
+      outputState: "available"
+    };
+  };
+  const finalize = (lifecycle, outputState, retryable = false) => {
+    if (finalized)
+      return;
+    finalized = true;
+    store.openFinalizers.delete(interrupt);
+    const limitations = [];
+    if (collector.truncated) {
+      limitations.push({
+        code: "stream_limit",
+        message: "the bounded collector omitted later stream parts",
+        field: "boundary.output.normalized"
+      });
+    }
+    if (collector.rawTruncated) {
+      limitations.push({
+        code: "stream_limit",
+        message: "the bounded collector omitted later raw response chunks",
+        field: "boundary.output.native"
+      });
+    }
+    if (collector.finishReason === "length") {
+      limitations.push({
+        code: "provider_length_limit",
+        message: "the provider stopped generation at its output length limit",
+        field: "boundary.output.normalized"
+      });
+    }
+    const emit = (retryLifecycle) => {
+      safeEmitAttempt(store, recorder, capture, {
+        lifecycle: retryLifecycle ?? lifecycle,
+        nativeInput: result.request?.body,
+        normalizedOutput: { parts: collector.parts },
+        normalizedOutputState: collector.truncated ? "truncated" : outputState,
+        nativeOutput: collector.rawParts.length > 0 ? { chunks: collector.rawParts } : undefined,
+        nativeOutputState: outputState === "interrupted" ? "interrupted" : collector.rawTruncated ? "truncated" : "available",
+        nativeOutputAbsent: options.includeRawChunks ? "omitted" : "unsupported",
+        nativeOutputReason: options.includeRawChunks ? "the provider emitted no raw response chunks" : "raw provider chunks were not enabled for this existing call",
+        providerMetadata: collector.providerMetadata,
+        usage: collector.usage,
+        providerRequestId: collector.responseId,
+        effectiveModelId: collector.responseModelId,
+        limitations
+      });
+      collector.parts.length = 0;
+      collector.rawParts.length = 0;
+      collector.byteLength = 0;
+      collector.rawByteLength = 0;
+    };
+    if (retryable)
+      retainFailure(emit);
+    else
+      emit();
+  };
+  const interrupt = () => {
+    const terminal = terminalLifecycle();
+    finalize(terminal.lifecycle, terminal.outputState);
+  };
+  if (store.openFinalizers.size >= store.limits.maxPendingRecords) {
+    store.openFinalizers.values().next().value?.();
+  }
+  store.openFinalizers.add(interrupt);
+  let stream;
+  try {
+    stream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const next = await reader.read();
+          if (next.done) {
+            const terminal = terminalLifecycle();
+            controller.close();
+            finalize(terminal.lifecycle, terminal.outputState, collector.sawError);
+            return;
+          }
+          if (!finalized) {
+            try {
+              collectStreamPart(store, collector, next.value);
+            } catch {
+              collector.truncated = true;
+            }
+          }
+          if (next.value.type === "error") {
+            const aborted = isAborted(options, next.value.error);
+            finalize(aborted ? "aborted" : "partial", "interrupted", !aborted);
+          }
+          if (recorder && next.value.type === "tool-call") {
+            await recorder.beforeToolCall(capture.attempt.attemptId, {
+              toolCallId: next.value.toolCallId,
+              toolName: next.value.toolName
+            });
+            options.abortSignal?.throwIfAborted();
+          }
+          controller.enqueue(next.value);
+        } catch (error) {
+          controller.error(error);
+          const aborted = isAborted(options, error);
+          finalize(aborted ? "aborted" : collector.sawOutput ? "partial" : "failed", "interrupted", !aborted);
+        }
+      },
+      async cancel(reason) {
+        if (collector.sawFinish) {
+          const terminal = terminalLifecycle();
+          finalize(terminal.lifecycle, terminal.outputState);
+        } else {
+          finalize("aborted", "interrupted");
+        }
+        await reader.cancel(reason);
+      }
+    });
+  } catch (error) {
+    store.openFinalizers.delete(interrupt);
+    reader.releaseLock();
+    throw error;
+  }
+  return { ...result, stream };
+}
+function withNativeRolloutEvidenceModel(model, defaultContext) {
+  const recorder = getInferenceRecorder();
+  const store = captureStore.getStore() ?? (recorder ? recorderOnlyStore(recorder.runId) : undefined);
+  if (!store || !store.enabled && !recorder)
+    return model;
+  const activeStore = store;
+  const pendingFailures = new Map;
+  const scopeFinalizers = new Map;
+  let pendingFailureCount = 0;
+  let flusherRegistered = false;
+  const releaseFlusherIfIdle = () => {
+    if (pendingFailureCount > 0)
+      return;
+    activeStore.flushers.delete(flush);
+    flusherRegistered = false;
+  };
+  const ensureFlusher = () => {
+    if (pendingFailureCount === 0)
+      return;
+    if (flusherRegistered)
+      return;
+    activeStore.flushers.add(flush);
+    flusherRegistered = true;
+  };
+  const waitForPendingWrites = async () => {
+    if (activeStore.pendingWrites.size > 0) {
+      await Promise.all([...activeStore.pendingWrites]);
+    }
+  };
+  const removeScopeFinalizerIfIdle = (invocation) => {
+    if (pendingFailures.has(invocation))
+      return;
+    const registered = scopeFinalizers.get(invocation);
+    if (!registered)
+      return;
+    registered.operation.finalizers.delete(registered.finalize);
+    scopeFinalizers.delete(invocation);
+  };
+  const settlePendingFailure = (invocation, pending, emit) => {
+    const failures = pendingFailures.get(invocation);
+    const index = failures?.indexOf(pending) ?? -1;
+    if (!failures || index < 0)
+      return;
+    failures.splice(index, 1);
+    if (failures.length === 0)
+      pendingFailures.delete(invocation);
+    activeStore.retainedFailures.delete(pending.settle);
+    pendingFailureCount -= 1;
+    removeScopeFinalizerIfIdle(invocation);
+    if (emit)
+      pending.emit();
+    releaseFlusherIfIdle();
+  };
+  const ensureScopeFinalizer = (operation) => {
+    if (scopeFinalizers.has(operation.invocation))
+      return;
+    const finalize = () => {
+      for (const pending of [
+        ...pendingFailures.get(operation.invocation) ?? []
+      ]) {
+        settlePendingFailure(operation.invocation, pending, true);
+      }
+    };
+    scopeFinalizers.set(operation.invocation, { operation, finalize });
+    if (operation.closed)
+      finalize();
+    else
+      operation.finalizers.add(finalize);
+  };
+  async function flush() {
+    for (const [invocation, failures] of [...pendingFailures]) {
+      for (const pending of [...failures]) {
+        if (activeStore.activeSinkWrites.size >= activeStore.limits.maxPendingRecords) {
+          await waitForPendingWrites();
+        }
+        settlePendingFailure(invocation, pending, true);
+      }
+    }
+    releaseFlusherIfIdle();
+  }
+  const context = () => {
+    const override = operationStore.getStore();
+    const session = sessionStore.getStore();
+    return {
+      model: {
+        ...defaultContext,
+        ...override?.operationKind ? { operationKind: override.operationKind } : {},
+        ...override?.sessionId ? { sessionId: override.sessionId } : {},
+        ...session?.sessionId ? { sessionId: session.sessionId } : {},
+        ...session?.parentSessionId && session.parentToolCallId ? {
+          parentSessionId: session.parentSessionId,
+          parentToolCallId: session.parentToolCallId
+        } : {}
+      },
+      invocation: override?.invocation ?? Symbol("unscoped-model-call"),
+      ...override ? { operation: override } : {}
+    };
+  };
+  const takePendingFailure = (invocation) => {
+    const failures = pendingFailures.get(invocation);
+    const pending = failures?.shift();
+    if (pending) {
+      activeStore.retainedFailures.delete(pending.settle);
+      pendingFailureCount -= 1;
+    }
+    if (failures?.length === 0)
+      pendingFailures.delete(invocation);
+    removeScopeFinalizerIfIdle(invocation);
+    releaseFlusherIfIdle();
+    return pending;
+  };
+  const addPendingFailure = (invocation, failure, operation) => {
+    if (!operation) {
+      failure.emit();
+      return;
+    }
+    if (activeStore.retainedFailures.size >= activeStore.limits.maxPendingRecords) {
+      const settleOldest = activeStore.retainedFailures.values().next().value;
+      if (settleOldest) {
+        addDiagnostic(activeStore, {
+          code: "retry_lineage_limit",
+          message: "a retained failed attempt was finalized before a later retry could be attributed"
+        });
+        settleOldest();
+      }
+    }
+    const pending = {
+      ...failure,
+      settle: () => settlePendingFailure(invocation, pending, true)
+    };
+    const failures = pendingFailures.get(invocation) ?? [];
+    failures.push(pending);
+    pendingFailures.set(invocation, failures);
+    activeStore.retainedFailures.add(pending.settle);
+    pendingFailureCount += 1;
+    ensureScopeFinalizer(operation);
+    ensureFlusher();
+  };
+  async function doGenerate(options) {
+    const current = context();
+    const retry = takePendingFailure(current.invocation);
+    if (retry) {
+      retry.emit("retried");
+    }
+    let capture;
+    try {
+      capture = beginAttempt(activeStore, current.model, model.provider, model.modelId, options, retry);
+    } catch (error) {
+      if (recorder)
+        throw error;
+      addDiagnostic(activeStore, {
+        code: "capture_failure",
+        message: "the passive collector could not start an attempt record"
+      });
+      return await model.doGenerate(options);
+    }
+    if (recorder) {
+      await recorder.beforeDispatch(capture.attempt.started);
+      options.abortSignal?.throwIfAborted();
+    }
+    let result;
+    try {
+      result = await model.doGenerate(options);
+    } catch (error) {
+      const aborted = isAborted(options, error);
+      const emit = (lifecycle) => safeEmitAttempt(activeStore, recorder, capture, {
+        lifecycle: lifecycle ?? (aborted ? "aborted" : "failed"),
+        nativeInput: errorRequestBody(error),
+        normalizedOutputState: "interrupted",
+        nativeOutputAbsent: "omitted",
+        nativeOutputReason: "the provider call ended before returning output"
+      });
+      if (aborted)
+        emit();
+      else
+        addPendingFailure(current.invocation, { capture, emit }, current.operation);
+      throw error;
+    }
+    if (recorder) {
+      for (const item of result.content) {
+        if (item.type === "tool-call") {
+          await recorder.beforeToolCall(capture.attempt.attemptId, {
+            toolCallId: item.toolCallId,
+            toolName: item.toolName
+          });
+          options.abortSignal?.throwIfAborted();
+        }
+      }
+    }
+    const lifecycle = result.finishReason.unified === "length" ? "partial" : "completed";
+    safeEmitAttempt(activeStore, recorder, capture, {
+      lifecycle,
+      nativeInput: result.request?.body,
+      normalizedOutput: {
+        content: result.content,
+        finishReason: result.finishReason,
+        usage: result.usage,
+        providerMetadata: result.providerMetadata,
+        response: result.response ? {
+          id: result.response.id,
+          timestamp: result.response.timestamp,
+          modelId: result.response.modelId
+        } : undefined
+      },
+      nativeOutput: result.response?.body,
+      providerMetadata: result.providerMetadata,
+      usage: result.usage,
+      providerRequestId: result.response?.id,
+      effectiveModelId: result.response?.modelId,
+      limitations: lifecycle === "partial" ? [
+        {
+          code: "provider_length_limit",
+          message: "the provider stopped generation at its output length limit",
+          field: "boundary.output.normalized"
+        }
+      ] : []
+    });
+    return result;
+  }
+  async function doStream(options) {
+    const current = context();
+    const retry = takePendingFailure(current.invocation);
+    if (retry) {
+      retry.emit("retried");
+    }
+    let capture;
+    try {
+      capture = beginAttempt(activeStore, current.model, model.provider, model.modelId, options, retry);
+    } catch (error) {
+      if (recorder)
+        throw error;
+      addDiagnostic(activeStore, {
+        code: "capture_failure",
+        message: "the passive collector could not start an attempt record"
+      });
+      return await model.doStream(options);
+    }
+    if (recorder) {
+      await recorder.beforeDispatch(capture.attempt.started);
+      options.abortSignal?.throwIfAborted();
+    }
+    let result;
+    try {
+      result = await model.doStream(options);
+    } catch (error) {
+      const aborted = isAborted(options, error);
+      const emit = (lifecycle) => safeEmitAttempt(activeStore, recorder, capture, {
+        lifecycle: lifecycle ?? (aborted ? "aborted" : "failed"),
+        nativeInput: errorRequestBody(error),
+        normalizedOutputState: "interrupted",
+        nativeOutputAbsent: "omitted",
+        nativeOutputReason: "the provider call ended before returning output"
+      });
+      if (aborted)
+        emit();
+      else
+        addPendingFailure(current.invocation, { capture, emit }, current.operation);
+      throw error;
+    }
+    try {
+      return wrapCapturedStream(activeStore, recorder, capture, result, options, (emit) => {
+        addPendingFailure(current.invocation, { capture, emit }, current.operation);
+      });
+    } catch (error) {
+      if (recorder)
+        throw error;
+      addDiagnostic(activeStore, {
+        code: "capture_failure",
+        message: "the passive collector could not wrap the provider stream"
+      });
+      return result;
+    }
+  }
+  return {
+    specificationVersion: model.specificationVersion,
+    provider: model.provider,
+    modelId: model.modelId,
+    supportedUrls: model.supportedUrls,
+    doGenerate,
+    doStream
+  };
+}
+var DEFAULT_NATIVE_ROLLOUT_CAPTURE_LIMITS, captureStore, operationStore, sessionStore, RECORDER_ONLY_INPUT;
+var init_capture = __esm(() => {
+  init_dist3();
+  init_inference_attempt();
+  init_content();
+  init_provider_metadata();
+  init_schema();
+  init_validate2();
+  DEFAULT_NATIVE_ROLLOUT_CAPTURE_LIMITS = {
+    maxAssetBytes: 1048576,
+    maxEnvelopeBytes: 2097152,
+    maxPendingRecords: 32,
+    maxDiagnostics: 32,
+    sinkTimeoutMs: 2000
+  };
+  captureStore = new AsyncLocalStorage2;
+  operationStore = new AsyncLocalStorage2;
+  sessionStore = new AsyncLocalStorage2;
+  RECORDER_ONLY_INPUT = {
+    normalizedRef: createContentAddressedAsset({ capture: "recorder-only" }, "recorder-only").reference,
+    assets: [],
+    limitations: []
+  };
+});
+
+// src/core/ai/native-rollout-evidence/index.ts
+var init_native_rollout_evidence = __esm(() => {
+  init_capture();
+  init_content();
+  init_provider_metadata();
+  init_schema();
+  init_validate2();
+});
+
+export { schema, descending, newSessionId, newMessageId, newPartId, isSessionId, init_id, InferenceAttemptSchema, parseInferenceAttempt, runWithInferenceRecorder, getInferenceRecorder, init_inference_attempt, toJsonValue, stringifyCanonicalJson, JsonValueSchema, NATIVE_EVIDENCE_AVAILABILITY_STATES, parseNativeRolloutEvidence, serializeNativeRolloutEvidence, createNativeRolloutEvidenceCapture, runWithNativeRolloutOperation, runWithNativeRolloutSession, withNativeRolloutEvidenceModel, init_native_rollout_evidence };