stitchkit 0.99.0 → 0.100.1

package/dist/{index-jhx828hc.js → index-f4fx2tza.js}

@@ -16,7 +16,7 @@ import {
   createToolChronology,
   isAssistantHistoryEvidence,
   isCompleteAgentHistoryTurn
-} from "./index-gxrt5h6v.js";
+} from "./index-cyktc4bp.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,
@@ -27,8 +27,12 @@ import {
   AgentRunOperationSchema,
   AgentRunSchema,
   AgentSnapshotSchema,
+  AgentUsageSchema,
   runStateForTerminalReason
 } from "./index-gtj3zc53.js";
+import {
+  createMutationQueue
+} from "./index-q3pyb9n0.js";
 import {
   createLocalStepDurability,
   createToolDurabilityContext,
@@ -38,6 +42,9 @@ import {
   ToolExecutionControlError,
   isToolExecutionControlError
 } from "./index-8qt2m66q.js";
+import {
+  serializeCanonicalJson
+} from "./index-k5hsfc3j.js";
 import {
   isRecord,
   transportResult
@@ -596,15 +603,891 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
       decisions.push(decide(message, "omitted", "incomplete-tool-turn"));
       continue;
     }
-    const assistant = assistantMessages(message, interrupted ? "interrupted" : message.status === "failed" ? "failed" : undefined);
-    chronology = nextChronology;
-    projected.push(...assistant.messages);
-    decisions.push(assistant.messages.length > 0 ? decide(message, "projected", "projected", assistant.rendered) : decide(message, "omitted", "empty"));
-  }
-  return { messages: projected, decisions, system };
-}
-async function projectAgentHistory(messages, options = {}) {
-  return [...(await projectAgentHistoryDetailed(messages, options)).messages];
+    const assistant = assistantMessages(message, interrupted ? "interrupted" : message.status === "failed" ? "failed" : undefined);
+    chronology = nextChronology;
+    projected.push(...assistant.messages);
+    decisions.push(assistant.messages.length > 0 ? decide(message, "projected", "projected", assistant.rendered) : decide(message, "omitted", "empty"));
+  }
+  return { messages: projected, decisions, system };
+}
+async function projectAgentHistory(messages, options = {}) {
+  return [...(await projectAgentHistoryDetailed(messages, options)).messages];
+}
+
+// src/agent-runtime/invocation-schema.ts
+import { z } from "zod";
+var Id = z.string().min(1).max(512);
+var Hash = z.string().regex(/^[a-f0-9]{64}$/);
+var ModelInvocationTraceSchema = z.object({
+  operationId: Id,
+  purpose: Id,
+  project: Id,
+  parent: z.object({ traceId: Id, invocationId: Id.optional() }).strict().optional(),
+  experiment: Id.optional(),
+  case: Id.optional(),
+  profile: Id.optional()
+}).strict();
+var CompletionInvocationInputSchema = z.object({
+  conversationId: Id,
+  idempotencyKey: Id,
+  trace: ModelInvocationTraceSchema,
+  prompt: z.string().min(1),
+  models: z.array(Id).min(1).max(8),
+  settings: z.object({
+    maxOutputTokens: z.int().positive().optional(),
+    temperature: z.number().finite().optional(),
+    topP: z.number().min(0).max(1).optional(),
+    seed: z.int().optional()
+  }).strict().optional(),
+  timeoutMs: z.int().positive().max(3600000)
+}).strict();
+var Identity = z.object({
+  provider: Id.nullable(),
+  modelId: Id.nullable(),
+  responseId: Id.nullable()
+}).strict();
+var InvocationCallerSchema = z.object({ subject: Id }).strict();
+var InvocationProcessSchema = z.object({
+  instanceId: Id,
+  pid: z.int().positive(),
+  hostname: Id
+}).strict();
+var Base = z.object({
+  conversationId: Id,
+  invocationId: Id,
+  operationId: Id,
+  runId: Id.optional()
+});
+var InvocationStartedSchema = Base.extend({
+  type: z.literal("invocation/started"),
+  mode: z.enum(["completion", "agent"]),
+  trace: ModelInvocationTraceSchema,
+  caller: InvocationCallerSchema,
+  executingProcess: InvocationProcessSchema,
+  fingerprint: Hash,
+  requested: z.object({ models: z.array(Id), payloadSha256: Hash }).strict()
+}).strict();
+var InvocationAttemptContextSchema = Base.extend({
+  attemptId: Id,
+  step: z.int().nonnegative()
+}).strict();
+var Attempt = Base.extend({ attemptId: Id, step: z.int().nonnegative() });
+var InvocationRequestSchema = Attempt.extend({
+  type: z.literal("provider/request"),
+  requested: z.object({ modelId: Id, provider: Id }).strict(),
+  executingProcess: InvocationProcessSchema,
+  sent: z.object({
+    modelId: Id,
+    provider: Id,
+    payloadSha256: Hash,
+    artifactId: Id,
+    tools: z.int().nonnegative()
+  }).strict()
+}).strict();
+var InvocationResponseSchema = Attempt.extend({
+  type: z.literal("provider/response"),
+  status: z.enum(["succeeded", "failed", "cancelled"]),
+  effective: Identity,
+  usage: AgentUsageSchema,
+  artifactId: Id,
+  payloadSha256: Hash
+}).strict();
+var InvocationFinishedSchema = Base.extend({
+  type: z.literal("invocation/finished"),
+  failure: z.object({ artifactId: Id, payloadSha256: Hash }).strict().optional(),
+  status: z.enum(["succeeded", "failed", "cancelled"])
+}).strict();
+var ModelInvocationRecordSchema = z.discriminatedUnion("type", [
+  InvocationStartedSchema,
+  InvocationRequestSchema,
+  InvocationResponseSchema,
+  InvocationFinishedSchema
+]);
+var InvocationPayloadSchema = Base.extend({
+  artifactId: Id,
+  sha256: Hash,
+  bytes: z.int().nonnegative(),
+  iv: z.string(),
+  tag: z.string(),
+  ciphertext: z.string()
+}).strict();
+
+// src/agent-runtime/invocation-attempt.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { wrapLanguageModel } from "ai";
+
+// src/agent-runtime/invocation-failure.ts
+class InvocationReceiptError extends Error {
+  constructor(cause) {
+    super("Model invocation receipt could not be recorded", { cause });
+    this.name = "InvocationReceiptError";
+  }
+}
+async function invocationAudit(work) {
+  try {
+    return await work();
+  } catch (error) {
+    throw error instanceof InvocationReceiptError ? error : new InvocationReceiptError(error);
+  }
+}
+
+// src/agent-runtime/invocation-payload.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes,
+  randomUUID
+} from "node:crypto";
+import { z as z2 } from "zod";
+function invocationJson(value) {
+  const errors = new WeakSet;
+  return z2.json().parse(JSON.parse(JSON.stringify(value, (_key, item) => {
+    if (item instanceof Uint8Array)
+      return { base64: Buffer.from(item).toString("base64") };
+    if (item instanceof ArrayBuffer)
+      return { base64: Buffer.from(item).toString("base64") };
+    if (item instanceof Error) {
+      if (errors.has(item))
+        return { name: item.name, message: item.message };
+      errors.add(item);
+      return { name: item.name, message: item.message, cause: item.cause };
+    }
+    return item;
+  })));
+}
+function invocationHash(value) {
+  return createHash("sha256").update(serializeCanonicalJson(invocationJson(value))).digest("hex");
+}
+function createInvocationPayloads(store, key, maxBytes) {
+  if (key.byteLength !== 32)
+    throw new TypeError("Invocation payload key must contain 32 bytes");
+  const encryptionKey = Uint8Array.from(key);
+  return {
+    maxBytes,
+    async write(identity, value) {
+      const data = Buffer.from(serializeCanonicalJson(invocationJson(value)));
+      if (data.byteLength > maxBytes)
+        throw new RangeError("Invocation payload exceeds maxPayloadBytes");
+      const artifactId = randomUUID();
+      const sha256 = createHash("sha256").update(data).digest("hex");
+      const iv = randomBytes(12);
+      const cipher = createCipheriv("aes-256-gcm", encryptionKey, iv);
+      cipher.setAAD(Buffer.from(JSON.stringify([identity.conversationId, identity.invocationId, artifactId])));
+      const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
+      const { conversationId } = identity;
+      if (!store.appendEventOnce)
+        throw new TypeError("Invocation payloads require atomic store.appendEventOnce");
+      await store.appendEventOnce({
+        conversationId,
+        kind: "provider/payload",
+        payload: {
+          ...identity,
+          artifactId,
+          sha256,
+          bytes: data.byteLength,
+          iv: iv.toString("base64"),
+          tag: cipher.getAuthTag().toString("base64"),
+          ciphertext: ciphertext.toString("base64")
+        }
+      }, artifactId);
+      return { artifactId, sha256 };
+    },
+    decrypt(conversationId, value) {
+      const payload = InvocationPayloadSchema.parse(value);
+      if (payload.bytes > maxBytes || payload.ciphertext.length > Math.ceil(maxBytes / 3) * 4) {
+        throw new RangeError("Invocation payload exceeds maxPayloadBytes");
+      }
+      const decipher = createDecipheriv("aes-256-gcm", encryptionKey, Buffer.from(payload.iv, "base64"));
+      decipher.setAAD(Buffer.from(JSON.stringify([conversationId, payload.invocationId, payload.artifactId])));
+      decipher.setAuthTag(Buffer.from(payload.tag, "base64"));
+      const data = Buffer.concat([
+        decipher.update(Buffer.from(payload.ciphertext, "base64")),
+        decipher.final()
+      ]);
+      if (data.length !== payload.bytes || createHash("sha256").update(data).digest("hex") !== payload.sha256) {
+        throw new Error("Invocation payload integrity mismatch");
+      }
+      return z2.json().parse(JSON.parse(data.toString("utf8")));
+    }
+  };
+}
+
+// src/agent-runtime/provider-origin.ts
+import {
+  InvalidToolApprovalError,
+  InvalidToolApprovalSignatureError,
+  ToolCallNotFoundForApprovalError
+} from "ai";
+var providerOrigin = new WeakSet;
+function isOwnInputRefusal(error) {
+  return InvalidToolApprovalSignatureError.isInstance(error) || InvalidToolApprovalError.isInstance(error) || ToolCallNotFoundForApprovalError.isInstance(error);
+}
+function markProviderOrigin(error) {
+  if (typeof error === "object" && error !== null)
+    providerOrigin.add(error);
+  return error;
+}
+function hasProviderOrigin(error) {
+  return typeof error === "object" && error !== null && providerOrigin.has(error);
+}
+function markProviderStream(stream) {
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      let read;
+      try {
+        read = await reader.read();
+      } catch (error) {
+        controller.error(isOwnInputRefusal(error) ? error : markProviderOrigin(error));
+        return;
+      }
+      if (read.done)
+        controller.close();
+      else
+        controller.enqueue(read.value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+
+// src/agent-runtime/runtime-internals.ts
+import { z as z3 } from "zod";
+function findRun(runs, runId) {
+  const run = runs.find((candidate) => candidate.id === runId);
+  if (!run)
+    throw new AgentRuntimeConflictError("run lookup");
+  return run;
+}
+function jsonValue(value) {
+  const parsed = z3.json().safeParse(value);
+  return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
+}
+function providerEnvelope(value) {
+  const parsed = AgentJsonObjectSchema.safeParse(value);
+  if (!parsed.success)
+    return;
+  return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
+}
+function providerResponseIdentity(id, provider) {
+  return AgentProviderResponseSchema.parse({
+    id,
+    ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
+  });
+}
+function appendText(parts, text) {
+  const previous = parts.at(-1);
+  if (previous?.type === "text") {
+    const next = AgentMessagePartSchema.parse({ ...previous, text: previous.text + text });
+    parts.splice(parts.length - 1, 1, next);
+    return;
+  }
+  parts.push(AgentMessagePartSchema.parse({ type: "text", text }));
+}
+function abortTerminalReason(signal) {
+  if (signal.reason === "shutdown")
+    return "shutdown";
+  if (signal.reason === "timeout")
+    return "timeout";
+  if (signal.reason === "supersede")
+    return "superseded";
+  return "interrupted";
+}
+function addUsage(total, step) {
+  const sum = (left, right) => {
+    if (left?.value === undefined && right?.value === undefined) {
+      return { provenance: "unavailable" };
+    }
+    if (left?.value === undefined)
+      return { ...right, provenance: "computed" };
+    if (right?.value === undefined)
+      return { ...left, provenance: "computed" };
+    return { value: left.value + right.value, provenance: "computed" };
+  };
+  const sumCost = (left, right) => {
+    if (left?.value === undefined || right?.value === undefined) {
+      return { provenance: "unavailable" };
+    }
+    if (left.currency !== right.currency)
+      return { provenance: "unavailable" };
+    return {
+      value: left.value + right.value,
+      ...left.currency && { currency: left.currency },
+      provenance: "computed"
+    };
+  };
+  if (!total)
+    return step;
+  const cost = sumCost(total.cost, step.cost);
+  return {
+    inputTokens: sum(total.inputTokens, step.inputTokens),
+    outputTokens: sum(total.outputTokens, step.outputTokens),
+    reasoningTokens: sum(total.reasoningTokens, step.reasoningTokens),
+    cacheReadTokens: sum(total.cacheReadTokens, step.cacheReadTokens),
+    cacheWriteTokens: sum(total.cacheWriteTokens, step.cacheWriteTokens),
+    ...cost && { cost }
+  };
+}
+function mergeModelTotals(sdkTotal, accumulated) {
+  const pick = (total, ours) => {
+    if (ours?.provenance === "unavailable")
+      return ours;
+    return total?.value !== undefined ? { value: total.value, provenance: "computed" } : ours ?? { provenance: "unavailable" };
+  };
+  return {
+    inputTokens: pick(sdkTotal.inputTokens, accumulated?.inputTokens),
+    outputTokens: pick(sdkTotal.outputTokens, accumulated?.outputTokens),
+    reasoningTokens: pick(sdkTotal.reasoningTokens, accumulated?.reasoningTokens),
+    cacheReadTokens: pick(sdkTotal.cacheReadTokens, accumulated?.cacheReadTokens),
+    cacheWriteTokens: pick(sdkTotal.cacheWriteTokens, accumulated?.cacheWriteTokens),
+    cost: accumulated?.cost ?? { provenance: "unavailable" }
+  };
+}
+function statedUsage(usage) {
+  const stated = (value) => value ?? { provenance: "unavailable" };
+  if (!usage)
+    return unknownUsage();
+  return {
+    inputTokens: stated(usage.inputTokens),
+    outputTokens: stated(usage.outputTokens),
+    reasoningTokens: stated(usage.reasoningTokens),
+    cacheReadTokens: stated(usage.cacheReadTokens),
+    cacheWriteTokens: stated(usage.cacheWriteTokens),
+    cost: stated(usage.cost)
+  };
+}
+function unknownUsage() {
+  const nothing = { provenance: "unavailable" };
+  return {
+    inputTokens: nothing,
+    outputTokens: nothing,
+    reasoningTokens: nothing,
+    cacheReadTokens: nothing,
+    cacheWriteTokens: nothing,
+    cost: nothing
+  };
+}
+function normalizeSdkUsage(value) {
+  const reported = (tokens) => tokens === undefined || !Number.isSafeInteger(tokens) || tokens < 0 ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
+  return {
+    inputTokens: reported(value.inputTokens),
+    outputTokens: reported(value.outputTokens),
+    reasoningTokens: reported(value.outputTokenDetails.reasoningTokens),
+    cacheReadTokens: reported(value.inputTokenDetails.cacheReadTokens),
+    cacheWriteTokens: reported(value.inputTokenDetails.cacheWriteTokens)
+  };
+}
+function createIdleDeadline(parent, timeoutMs) {
+  if (timeoutMs === undefined) {
+    const noop = () => {
+      return;
+    };
+    return {
+      signal: parent,
+      touch: noop,
+      start: noop,
+      stop: noop,
+      suspend: noop,
+      resume: noop,
+      dispose: noop
+    };
+  }
+  const controller = new AbortController;
+  let timer;
+  let active = false;
+  let suspended = 0;
+  const clear = () => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  const touch = () => {
+    clear();
+    if (!active || suspended > 0 || controller.signal.aborted)
+      return;
+    timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  };
+  return {
+    signal: AbortSignal.any([parent, controller.signal]),
+    touch,
+    start() {
+      active = true;
+      touch();
+    },
+    stop() {
+      active = false;
+      clear();
+    },
+    suspend() {
+      suspended += 1;
+      clear();
+    },
+    resume() {
+      suspended = Math.max(0, suspended - 1);
+      touch();
+    },
+    dispose() {
+      active = false;
+      clear();
+    }
+  };
+}
+
+// src/agent-runtime/invocation-attempt.ts
+var currentAttempt = new AsyncLocalStorage;
+function currentModelInvocationAttempt() {
+  const value = currentAttempt.getStore();
+  return value && { ...value };
+}
+function wrapInvocationModel(writer, selected, step, model = selected.model) {
+  if (typeof model === "string")
+    throw new TypeError("Invocation receipts require a resolved model object");
+  const begin = async (params) => invocationAudit(async () => {
+    const context = { ...writer.identity, step, attemptId: randomUUID2() };
+    const { headers: _headers, abortSignal: _signal, ...payload } = params;
+    const artifact = await writer.payloads.write(writer.identity, payload);
+    await writer.append({
+      ...writer.identity,
+      type: "provider/request",
+      attemptId: context.attemptId,
+      step,
+      executingProcess: writer.process,
+      requested: {
+        modelId: selected.descriptor.modelId,
+        provider: selected.descriptor.provider
+      },
+      sent: {
+        modelId: model.modelId,
+        provider: model.provider,
+        payloadSha256: artifact.sha256,
+        artifactId: artifact.artifactId,
+        tools: params.tools?.length ?? 0
+      }
+    });
+    try {
+      await writer.onAttempt?.({ ...context });
+    } catch (error) {
+      await finish(context, "failed", { phase: "transport-audit", error });
+      throw error;
+    }
+    return context;
+  });
+  const finish = (...args) => recordResponse(...args).catch((error) => {
+    writer.receiptErrors.push(error);
+  });
+  const recordResponse = async (context, status, payload, usage, response, providerMetadata) => invocationAudit(async () => {
+    const artifact = await writer.payloads.write(writer.identity, boundedEvidence(payload, Math.floor(writer.payloads.maxBytes / 2)));
+    await writer.append({
+      ...writer.identity,
+      type: "provider/response",
+      attemptId: context.attemptId,
+      step,
+      status,
+      effective: {
+        provider: selected.resolveResponseProvider?.({ providerMetadata }) ?? null,
+        modelId: response?.modelId ?? null,
+        responseId: response?.id ?? null
+      },
+      usage: reportedUsage(selected, usage, providerMetadata),
+      artifactId: artifact.artifactId,
+      payloadSha256: artifact.sha256
+    });
+  });
+  return wrapLanguageModel({
+    model,
+    middleware: {
+      specificationVersion: "v4",
+      async wrapGenerate({ doGenerate, params }) {
+        const context = await begin(params);
+        let result;
+        try {
+          result = await currentAttempt.run(context, doGenerate);
+        } catch (error) {
+          await finish(context, params.abortSignal?.aborted ? "cancelled" : "failed", {
+            error
+          });
+          throw markProviderOrigin(error);
+        }
+        await finish(context, result.finishReason.unified === "error" ? "failed" : "succeeded", {
+          content: result.content,
+          usage: result.usage,
+          response: result.response,
+          providerMetadata: result.providerMetadata
+        }, result.usage, result.response, result.providerMetadata);
+        if (result.finishReason.unified === "error") {
+          throw markProviderOrigin(new Error("Provider returned an error finish reason"));
+        }
+        return result;
+      },
+      async wrapStream({ doStream, params }) {
+        const context = await begin(params);
+        let result;
+        try {
+          result = await currentAttempt.run(context, doStream);
+        } catch (error) {
+          await finish(context, params.abortSignal?.aborted ? "cancelled" : "failed", {
+            error
+          });
+          throw markProviderOrigin(error);
+        }
+        const reader = result.stream.getReader();
+        let ended = false;
+        let failed = false;
+        let response;
+        const evidence = streamEvidence(Math.floor(writer.payloads.maxBytes / 2));
+        const end = async (status, value, usage, metadata) => {
+          if (ended)
+            return;
+          ended = true;
+          await finish(context, status, evidence.payload(value), usage, response, metadata);
+        };
+        return {
+          ...result,
+          stream: new ReadableStream({
+            async pull(controller) {
+              let next;
+              try {
+                next = await currentAttempt.run(context, () => reader.read());
+              } catch (error) {
+                await end(params.abortSignal?.aborted ? "cancelled" : "failed", { error });
+                controller.error(markProviderOrigin(error));
+                return;
+              }
+              if (next.done) {
+                await end("failed", { reason: "stream-ended-without-finish" });
+                controller.close();
+                return;
+              }
+              const part = next.value;
+              if (part.type === "response-metadata")
+                response = part;
+              if (part.type === "finish") {
+                await end(failed || part.finishReason.unified === "error" ? "failed" : "succeeded", part, part.usage, part.providerMetadata);
+              } else {
+                if (part.type === "error")
+                  failed = true;
+                evidence.record(part);
+              }
+              controller.enqueue(part);
+            },
+            async cancel(reason) {
+              try {
+                await currentAttempt.run(context, () => reader.cancel(reason));
+              } finally {
+                await end("cancelled", { reason: "consumer-cancelled" });
+              }
+            }
+          })
+        };
+      }
+    }
+  });
+}
+function boundedEvidence(payload, limit) {
+  const serialized = JSON.stringify(invocationJson(payload));
+  const bytes = Buffer.byteLength(serialized);
+  if (bytes <= limit)
+    return payload;
+  return {
+    truncated: { bytes, sha256: createHash2("sha256").update(serialized).digest("hex") }
+  };
+}
+function streamEvidence(limit) {
+  const output = [];
+  const whole = createHash2("sha256");
+  let bytes = 0;
+  let parts = 0;
+  let truncated = false;
+  return {
+    record(part) {
+      const json = invocationJson(part);
+      const serialized = JSON.stringify(json);
+      whole.update(serialized).update(`
+`);
+      parts += 1;
+      const size = Buffer.byteLength(serialized);
+      if (!truncated && bytes + size > limit)
+        truncated = true;
+      if (truncated)
+        return;
+      bytes += size;
+      output.push(json);
+    },
+    payload(terminal) {
+      return {
+        output,
+        terminal,
+        ...truncated && { truncated: { parts, sha256: whole.digest("hex") } }
+      };
+    }
+  };
+}
+function reportedUsage(selected, value, providerMetadata) {
+  const usage = {
+    inputTokens: value?.inputTokens.total,
+    outputTokens: value?.outputTokens.total,
+    totalTokens: undefined,
+    inputTokenDetails: {
+      noCacheTokens: value?.inputTokens.noCache,
+      cacheReadTokens: value?.inputTokens.cacheRead,
+      cacheWriteTokens: value?.inputTokens.cacheWrite
+    },
+    outputTokenDetails: {
+      textTokens: value?.outputTokens.text,
+      reasoningTokens: value?.outputTokens.reasoning
+    },
+    ...value?.raw && { raw: value.raw }
+  };
+  return selected.normalizeUsage?.({ usage, providerMetadata }) ?? normalizeSdkUsage(usage);
+}
+
+// src/agent-runtime/invocations.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { hostname } from "node:os";
+import { generateText } from "ai";
+import { z as z5 } from "zod";
+
+// src/agent-runtime/invocation-read.ts
+import { z as z4 } from "zod";
+var InvocationReadInputSchema = z4.object({
+  conversationId: z4.string().min(1),
+  fromSeq: z4.int().positive().optional(),
+  limit: z4.int().positive().max(1e4)
+}).strict();
+async function readInvocationRecords(store, input) {
+  const page = await store.readEvents(InvocationReadInputSchema.parse(input));
+  return {
+    items: page.items.flatMap((event) => {
+      if (![
+        "invocation/started",
+        "invocation/finished",
+        "provider/request",
+        "provider/response"
+      ].includes(event.kind))
+        return [];
+      if (!event.payload || typeof event.payload !== "object" || !("invocationId" in event.payload))
+        return [];
+      return [
+        {
+          seq: event.seq,
+          occurredAt: event.occurredAt,
+          record: ModelInvocationRecordSchema.parse(event.payload)
+        }
+      ];
+    }),
+    ...page.nextSeq !== undefined && { nextSeq: page.nextSeq }
+  };
+}
+async function readInvocationPayload(store, payloads, input) {
+  const keyed = await store.findEventOnce?.({
+    conversationId: input.conversationId,
+    kind: "provider/payload",
+    key: input.artifactId
+  });
+  if (keyed)
+    return payloads.decrypt(input.conversationId, keyed.payload);
+  let fromSeq;
+  do {
+    const page = await store.readEvents({
+      conversationId: input.conversationId,
+      fromSeq,
+      limit: 1000
+    });
+    for (const event of page.items) {
+      if (event.kind !== "provider/payload")
+        continue;
+      const payload = InvocationPayloadSchema.parse(event.payload);
+      if (payload.artifactId === input.artifactId)
+        return payloads.decrypt(input.conversationId, payload);
+    }
+    fromSeq = page.nextSeq;
+  } while (fromSeq !== undefined);
+  throw new Error("Invocation artifact not found");
+}
+
+// src/agent-runtime/invocations.ts
+var executingProcess = { instanceId: randomUUID3(), pid: process.pid, hostname: hostname() };
+var agentBindings = new WeakMap;
+function beginAgentInvocation(ledger, store, input, context) {
+  const binding = agentBindings.get(ledger);
+  if (!binding || binding.store !== store)
+    throw new TypeError("Agent and invocations must share the same store");
+  return binding.start(input, context);
+}
+function withReceipt(result, writer) {
+  const [receiptError] = writer.receiptErrors;
+  return receiptError === undefined ? result : { ...result, receiptError };
+}
+async function generateWithFallback(models, writer, input, abortSignal) {
+  for (const [step, key] of input.models.entries()) {
+    abortSignal.throwIfAborted();
+    const selected = models.resolve(key);
+    try {
+      const result = await generateText({
+        model: wrapInvocationModel(writer, selected, step),
+        prompt: input.prompt,
+        ...input.settings,
+        maxRetries: 0,
+        abortSignal
+      });
+      return result.text;
+    } catch (error) {
+      if (!hasProviderOrigin(error) || abortSignal.aborted || step === input.models.length - 1)
+        throw error;
+    }
+  }
+  throw new Error("No completion model attempt available");
+}
+function createModelInvocationLedger(config) {
+  const { store } = config;
+  const appendOnce = store.appendEventOnce?.bind(store);
+  if (!appendOnce)
+    throw new TypeError("Model invocations require atomic store.appendEventOnce");
+  const maxPayloadBytes = z5.int().min(1024).max(64 * 1024 * 1024).parse(config.maxPayloadBytes ?? 4 * 1024 * 1024);
+  const payloads = createInvocationPayloads(store, config.payloadKey, maxPayloadBytes);
+  const authorize = async (input) => InvocationCallerSchema.parse(await config.authorize(input));
+  const start = async (input) => {
+    const trace = ModelInvocationTraceSchema.parse(input.trace);
+    const caller = await authorize({
+      context: input.context,
+      conversationId: input.conversationId,
+      action: input.mode === "completion" ? "complete" : "agent",
+      trace
+    });
+    const fingerprint = invocationHash({
+      mode: input.mode,
+      caller,
+      trace,
+      requested: input.requested
+    });
+    const identity = {
+      conversationId: input.conversationId,
+      invocationId: randomUUID3(),
+      operationId: trace.operationId,
+      ...input.runId && { runId: input.runId }
+    };
+    const started = InvocationStartedSchema.parse({
+      ...identity,
+      type: "invocation/started",
+      mode: input.mode,
+      trace,
+      caller,
+      executingProcess,
+      fingerprint,
+      requested: { models: input.models, payloadSha256: invocationHash(input.requested) }
+    });
+    const admission = await appendOnce({ conversationId: input.conversationId, kind: "invocation/started", payload: started }, input.key);
+    const previous = InvocationStartedSchema.parse(admission.event.payload);
+    if (previous.fingerprint !== fingerprint)
+      throw new Error("Invocation idempotency key conflicts with an existing request");
+    const writer = {
+      identity: { ...identity, invocationId: previous.invocationId },
+      process: executingProcess,
+      payloads,
+      onAttempt: config.onAttempt,
+      receiptErrors: [],
+      async append(record) {
+        const parsed = ModelInvocationRecordSchema.parse(record);
+        await store.appendEvent({
+          conversationId: input.conversationId,
+          kind: parsed.type,
+          payload: parsed
+        });
+      }
+    };
+    return { writer, duplicate: admission.outcome === "duplicate" };
+  };
+  const finish = (writer, status, failure) => writer.append({
+    ...writer.identity,
+    type: "invocation/finished",
+    status,
+    ...failure && { failure }
+  });
+  const ledger = {
+    async complete(rawInput, context, signal) {
+      const input = CompletionInvocationInputSchema.parse(rawInput);
+      const { writer, duplicate } = await start({
+        conversationId: input.conversationId,
+        key: `completion:${input.idempotencyKey}`,
+        trace: input.trace,
+        mode: "completion",
+        context,
+        requested: input,
+        models: input.models
+      });
+      const invocationId = writer.identity.invocationId;
+      if (duplicate)
+        return { invocationId, outcome: "duplicate" };
+      const deadline = AbortSignal.timeout(input.timeoutMs);
+      const abortSignal = signal ? AbortSignal.any([signal, deadline]) : deadline;
+      let text;
+      try {
+        text = await generateWithFallback(config.models, writer, input, abortSignal);
+      } catch (error) {
+        const status = abortSignal.aborted ? "cancelled" : "failed";
+        try {
+          const artifact = await payloads.write(writer.identity, { error });
+          await finish(writer, status, {
+            artifactId: artifact.artifactId,
+            payloadSha256: artifact.sha256
+          });
+        } catch (receiptError) {
+          writer.receiptErrors.push(receiptError);
+          await finish(writer, status).catch((error2) => {
+            writer.receiptErrors.push(error2);
+          });
+        }
+        return withReceipt({ invocationId, outcome: status }, writer);
+      }
+      try {
+        await finish(writer, "succeeded");
+      } catch (receiptError) {
+        writer.receiptErrors.push(receiptError);
+      }
+      return withReceipt({ invocationId, outcome: "succeeded", text }, writer);
+    },
+    async read(rawInput, context) {
+      const input = InvocationReadInputSchema.parse(rawInput);
+      await authorize({ context, conversationId: input.conversationId, action: "read" });
+      return readInvocationRecords(store, input);
+    },
+    async readPayload(input, context) {
+      await authorize({
+        context,
+        conversationId: input.conversationId,
+        action: "read-payload"
+      });
+      return readInvocationPayload(store, payloads, input);
+    }
+  };
+  agentBindings.set(ledger, {
+    store,
+    async start(input, context) {
+      const { conversationId, id: runId } = input.run;
+      const view = await store.loadRun({ conversationId, runId });
+      if (view?.run.state !== "running" || view.run.ownerId !== input.run.ownerId || view.run.fencingToken !== input.run.fencingToken) {
+        throw new Error("Invocation requires an owned running agent run");
+      }
+      const { writer } = await start({
+        conversationId,
+        runId,
+        trace: input.trace,
+        key: `agent:${runId}`,
+        context,
+        mode: "agent",
+        models: [],
+        requested: { runId }
+      });
+      return {
+        wrap: (selected, step, override) => wrapInvocationModel(writer, selected, step, override),
+        finish: (status) => finish(writer, status)
+      };
+    }
+  });
+  return ledger;
 }
 
 // src/agent-runtime/managed-tools.ts
@@ -632,9 +1515,9 @@ function createAgentToolFenceLifecycle(config) {
 }
 
 // src/agent-runtime/prompt.ts
-import { z } from "zod";
-var AgentTokenCountSchema = z.object({
-  value: z.int().nonnegative().optional(),
+import { z as z6 } from "zod";
+var AgentTokenCountSchema = z6.object({
+  value: z6.int().nonnegative().optional(),
   provenance: AgentProvenanceSchema.extract([
     "measured",
     "computed",
@@ -754,7 +1637,7 @@ function knownValue(value) {
 }
 function composeAgentPrompt(sections) {
   return async (options) => {
-    const event = z.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
+    const event = z6.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
     const rendered = [];
     let systemTotal = 0;
     let userTotal = 0;
@@ -957,7 +1840,7 @@ async function recordAgentRetryDecision(input) {
 }
 
 // src/agent-runtime/state-slots.ts
-import { z as z2 } from "zod";
+import { z as z7 } from "zod";
 function defineStateSlot(input) {
   if (input.name.length === 0)
     throw new TypeError("State slot name must not be empty");
@@ -972,11 +1855,11 @@ function defineStateSlot(input) {
     ...input.description && { description: input.description }
   };
 }
-var StateSetPayloadSchema = z2.object({
-  name: z2.string().min(1),
-  version: z2.int().positive(),
-  value: z2.json(),
-  actor: z2.enum(["agent", "human", "system"])
+var StateSetPayloadSchema = z7.object({
+  name: z7.string().min(1),
+  version: z7.int().positive(),
+  value: z7.json(),
+  actor: z7.enum(["agent", "human", "system"])
 }).strict();
 function slotRegistry(definitions) {
   const result = new Map;
@@ -1058,204 +1941,22 @@ function renderAgentStateSlots(values) {
 var agentGoalStateSlot = defineStateSlot({
   name: "goal",
   description: "The durable objective and lifecycle of this conversation.",
-  schema: z2.object({
-    objective: z2.string().min(1),
-    status: z2.enum(["active", "complete", "blocked"])
+  schema: z7.object({
+    objective: z7.string().min(1),
+    status: z7.enum(["active", "complete", "blocked"])
   }).strict()
 });
 var agentTodoStateSlot = defineStateSlot({
   name: "todo",
   description: "The durable ordered work plan for this conversation.",
-  schema: z2.object({
-    items: z2.array(z2.object({
-      step: z2.string().min(1),
-      status: z2.enum(["pending", "in_progress", "completed"])
+  schema: z7.object({
+    items: z7.array(z7.object({
+      step: z7.string().min(1),
+      status: z7.enum(["pending", "in_progress", "completed"])
     }).strict())
   }).strict()
 });
 
-// src/agent-runtime/runtime-internals.ts
-import { z as z3 } from "zod";
-function findRun(runs, runId) {
-  const run = runs.find((candidate) => candidate.id === runId);
-  if (!run)
-    throw new AgentRuntimeConflictError("run lookup");
-  return run;
-}
-function jsonValue(value) {
-  const parsed = z3.json().safeParse(value);
-  return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
-}
-function providerEnvelope(value) {
-  const parsed = AgentJsonObjectSchema.safeParse(value);
-  if (!parsed.success)
-    return;
-  return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
-}
-function providerResponseIdentity(id, provider) {
-  return AgentProviderResponseSchema.parse({
-    id,
-    ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
-  });
-}
-function appendText(parts, text) {
-  const previous = parts.at(-1);
-  if (previous?.type === "text") {
-    const next = AgentMessagePartSchema.parse({ ...previous, text: previous.text + text });
-    parts.splice(parts.length - 1, 1, next);
-    return;
-  }
-  parts.push(AgentMessagePartSchema.parse({ type: "text", text }));
-}
-function abortTerminalReason(signal) {
-  if (signal.reason === "shutdown")
-    return "shutdown";
-  if (signal.reason === "timeout")
-    return "timeout";
-  if (signal.reason === "supersede")
-    return "superseded";
-  return "interrupted";
-}
-function addUsage(total, step) {
-  const sum = (left, right) => {
-    if (left?.value === undefined && right?.value === undefined) {
-      return { provenance: "unavailable" };
-    }
-    if (left?.value === undefined)
-      return { ...right, provenance: "computed" };
-    if (right?.value === undefined)
-      return { ...left, provenance: "computed" };
-    return { value: left.value + right.value, provenance: "computed" };
-  };
-  const sumCost = (left, right) => {
-    if (left?.value === undefined || right?.value === undefined) {
-      return { provenance: "unavailable" };
-    }
-    if (left.currency !== right.currency)
-      return { provenance: "unavailable" };
-    return {
-      value: left.value + right.value,
-      ...left.currency && { currency: left.currency },
-      provenance: "computed"
-    };
-  };
-  if (!total)
-    return step;
-  const cost = sumCost(total.cost, step.cost);
-  return {
-    inputTokens: sum(total.inputTokens, step.inputTokens),
-    outputTokens: sum(total.outputTokens, step.outputTokens),
-    reasoningTokens: sum(total.reasoningTokens, step.reasoningTokens),
-    cacheReadTokens: sum(total.cacheReadTokens, step.cacheReadTokens),
-    cacheWriteTokens: sum(total.cacheWriteTokens, step.cacheWriteTokens),
-    ...cost && { cost }
-  };
-}
-function mergeModelTotals(sdkTotal, accumulated) {
-  const pick = (total, ours) => {
-    if (ours?.provenance === "unavailable")
-      return ours;
-    return total?.value !== undefined ? { value: total.value, provenance: "computed" } : ours ?? { provenance: "unavailable" };
-  };
-  return {
-    inputTokens: pick(sdkTotal.inputTokens, accumulated?.inputTokens),
-    outputTokens: pick(sdkTotal.outputTokens, accumulated?.outputTokens),
-    reasoningTokens: pick(sdkTotal.reasoningTokens, accumulated?.reasoningTokens),
-    cacheReadTokens: pick(sdkTotal.cacheReadTokens, accumulated?.cacheReadTokens),
-    cacheWriteTokens: pick(sdkTotal.cacheWriteTokens, accumulated?.cacheWriteTokens),
-    cost: accumulated?.cost ?? { provenance: "unavailable" }
-  };
-}
-function statedUsage(usage) {
-  const stated = (value) => value ?? { provenance: "unavailable" };
-  if (!usage)
-    return unknownUsage();
-  return {
-    inputTokens: stated(usage.inputTokens),
-    outputTokens: stated(usage.outputTokens),
-    reasoningTokens: stated(usage.reasoningTokens),
-    cacheReadTokens: stated(usage.cacheReadTokens),
-    cacheWriteTokens: stated(usage.cacheWriteTokens),
-    cost: stated(usage.cost)
-  };
-}
-function unknownUsage() {
-  const nothing = { provenance: "unavailable" };
-  return {
-    inputTokens: nothing,
-    outputTokens: nothing,
-    reasoningTokens: nothing,
-    cacheReadTokens: nothing,
-    cacheWriteTokens: nothing,
-    cost: nothing
-  };
-}
-function normalizeSdkUsage(value) {
-  const reported = (tokens) => tokens === undefined || !Number.isSafeInteger(tokens) || tokens < 0 ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
-  return {
-    inputTokens: reported(value.inputTokens),
-    outputTokens: reported(value.outputTokens),
-    reasoningTokens: reported(value.outputTokenDetails.reasoningTokens),
-    cacheReadTokens: reported(value.inputTokenDetails.cacheReadTokens),
-    cacheWriteTokens: reported(value.inputTokenDetails.cacheWriteTokens)
-  };
-}
-function createIdleDeadline(parent, timeoutMs) {
-  if (timeoutMs === undefined) {
-    const noop = () => {
-      return;
-    };
-    return {
-      signal: parent,
-      touch: noop,
-      start: noop,
-      stop: noop,
-      suspend: noop,
-      resume: noop,
-      dispose: noop
-    };
-  }
-  const controller = new AbortController;
-  let timer;
-  let active = false;
-  let suspended = 0;
-  const clear = () => {
-    if (timer !== undefined)
-      clearTimeout(timer);
-    timer = undefined;
-  };
-  const touch = () => {
-    clear();
-    if (!active || suspended > 0 || controller.signal.aborted)
-      return;
-    timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
-  };
-  return {
-    signal: AbortSignal.any([parent, controller.signal]),
-    touch,
-    start() {
-      active = true;
-      touch();
-    },
-    stop() {
-      active = false;
-      clear();
-    },
-    suspend() {
-      suspended += 1;
-      clear();
-    },
-    resume() {
-      suspended = Math.max(0, suspended - 1);
-      touch();
-    },
-    dispose() {
-      active = false;
-      clear();
-    }
-  };
-}
-
 // src/agent-runtime/runtime-control.ts
 async function interruptAgentRun(state, input) {
   const { store } = state.config;
@@ -1744,64 +2445,8 @@ function checkpoint(execution) {
   });
 }
 
-// src/agent-runtime/run-mutation-queue.ts
-function createRunMutationQueue() {
-  let tail = Promise.resolve();
-  return (mutation) => {
-    const result = tail.then(mutation, mutation);
-    tail = result.then(() => {
-      return;
-    }, () => {
-      return;
-    });
-    return result;
-  };
-}
-
-// src/agent-runtime/run-operation-lifecycle.ts
-import { wrapLanguageModel } from "ai";
-
-// src/agent-runtime/provider-origin.ts
-import {
-  InvalidToolApprovalError,
-  InvalidToolApprovalSignatureError,
-  ToolCallNotFoundForApprovalError
-} from "ai";
-var providerOrigin = new WeakSet;
-function isOwnInputRefusal(error) {
-  return InvalidToolApprovalSignatureError.isInstance(error) || InvalidToolApprovalError.isInstance(error) || ToolCallNotFoundForApprovalError.isInstance(error);
-}
-function markProviderOrigin(error) {
-  if (typeof error === "object" && error !== null)
-    providerOrigin.add(error);
-  return error;
-}
-function hasProviderOrigin(error) {
-  return typeof error === "object" && error !== null && providerOrigin.has(error);
-}
-function markProviderStream(stream) {
-  const reader = stream.getReader();
-  return new ReadableStream({
-    async pull(controller) {
-      let read;
-      try {
-        read = await reader.read();
-      } catch (error) {
-        controller.error(isOwnInputRefusal(error) ? error : markProviderOrigin(error));
-        return;
-      }
-      if (read.done)
-        controller.close();
-      else
-        controller.enqueue(read.value);
-    },
-    cancel(reason) {
-      return reader.cancel(reason);
-    }
-  });
-}
-
 // src/agent-runtime/run-operation-lifecycle.ts
+import { wrapLanguageModel as wrapLanguageModel2 } from "ai";
 function createAgentRunOperationLifecycle(config) {
   let active;
   let providerCallId;
@@ -1853,7 +2498,7 @@ function createAgentRunOperationLifecycle(config) {
         await startModelRequest(fallbackCallId, step);
         return model;
       }
-      return wrapLanguageModel({
+      return wrapLanguageModel2({
         model,
         middleware: {
           specificationVersion: "v4",
@@ -2029,7 +2674,7 @@ async function acquireRun(dependencies, input) {
     lastPromptTokens: { provenance: "unavailable" }
   };
   const idleDeadline = createIdleDeadline(input.signal, idleTimeoutMs);
-  const serialize = createRunMutationQueue();
+  const serialize = createMutationQueue();
   const operationLifecycle = createAgentRunOperationLifecycle({
     store: config.store,
     runtimeEpoch,
@@ -2057,6 +2702,8 @@ async function acquireRun(dependencies, input) {
 
 // src/agent-runtime/run-failure.ts
 function failureThisRuntimeOwns(error) {
+  if (error instanceof InvocationReceiptError)
+    return "runtime_failure";
   if (error instanceof AgentContextOverflowError)
     return "context_overflow";
   if (error instanceof AgentRuntimeConflictError)
@@ -2174,14 +2821,14 @@ async function* ownedProviderStream(input) {
 }
 
 // src/agent-runtime/run-provider-ledger.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function withoutBinaryParts(message) {
   const reference = (value) => {
     if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
       const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
       return {
         binary: true,
-        sha256: createHash("sha256").update(bytes).digest("hex"),
+        sha256: createHash3("sha256").update(bytes).digest("hex"),
         bytes: bytes.byteLength
       };
     }
@@ -2201,6 +2848,16 @@ function withoutBinaryParts(message) {
 }
 async function createRunProviderLedger(input) {
   const { store, state } = input;
+  if (input.audited) {
+    return {
+      async recordRequest() {},
+      async recordResponse(response) {
+        return providerResponseIdentity(response.id, state.selectedModel?.resolveResponseProvider?.({
+          providerMetadata: response.providerMetadata
+        }));
+      }
+    };
+  }
   const requestModelId = input.selectedModel.descriptor.modelId;
   const knownMessageShas = new Set;
   {
@@ -2226,7 +2883,7 @@ async function createRunProviderLedger(input) {
       const messageShas = [];
       for (const message of request.messages) {
         const body = canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(message))));
-        const sha256 = createHash("sha256").update(body).digest("hex");
+        const sha256 = createHash3("sha256").update(body).digest("hex");
         messageShas.push(sha256);
         if (knownMessageShas.has(sha256))
           continue;
@@ -2237,8 +2894,8 @@ async function createRunProviderLedger(input) {
         });
         knownMessageShas.add(sha256);
       }
-      const instructionsSha256 = createHash("sha256").update(typeof request.instructions === "string" ? request.instructions : canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(request.instructions))))).digest("hex");
-      const bodySha256 = createHash("sha256").update(instructionsSha256).update(messageShas.join(",")).digest("hex");
+      const instructionsSha256 = createHash3("sha256").update(typeof request.instructions === "string" ? request.instructions : canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(request.instructions))))).digest("hex");
+      const bodySha256 = createHash3("sha256").update(instructionsSha256).update(messageShas.join(",")).digest("hex");
       await store.appendEvent({
         conversationId: state.run.conversationId,
         kind: "provider/request",
@@ -2637,7 +3294,7 @@ async function prepareAttemptStep(context, attempt, options) {
     messages: [...prepared?.messages ?? options.messages, ...injected]
   };
   const providerMessages = preparedStep?.messages ?? options.messages;
-  const model = await execution.operationLifecycle.prepareModel(preparedStep?.model ?? turn.selectedModel.model, options.stepNumber, generateId());
+  const model = await execution.operationLifecycle.prepareModel(execution.invocation ? execution.invocation.wrap(turn.selectedModel, options.stepNumber, preparedStep?.model) : preparedStep?.model ?? turn.selectedModel.model, options.stepNumber, generateId());
   const override = preparedStep;
   if (override?.instructions !== undefined)
     loop.instructionsOverride = override.instructions;
@@ -2825,7 +3482,8 @@ async function runModelAttempts(execution, turn) {
   const ledger = await createRunProviderLedger({
     store: config.store,
     state,
-    selectedModel: turn.selectedModel
+    selectedModel: turn.selectedModel,
+    audited: execution.invocation !== undefined
   });
   const context = { execution, turn, loop, ledger };
   for (;; ) {
@@ -3008,7 +3666,7 @@ async function commitRunTerminal(execution) {
 }
 
 // src/agent-runtime/run-prompt-history.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function snapshotForRunPrompt(snapshot, runId) {
   const runIndex = snapshot.runs.findIndex((candidate) => candidate.id === runId);
   if (runIndex < 0)
@@ -3027,7 +3685,7 @@ var USER_INSTRUCTION_SEED_KEY = "prompt.user-instructions";
 function seededInstructionMessage(input) {
   return AgentMessageSchema.parse({
     schemaVersion: 1,
-    id: createHash2("sha256").update(`${input.conversationId}\x00${input.seedKey}\x00${input.index}`).digest("hex"),
+    id: createHash4("sha256").update(`${input.conversationId}\x00${input.seedKey}\x00${input.index}`).digest("hex"),
     conversationId: input.conversationId,
     role: "user",
     status: "committed",
@@ -3250,6 +3908,15 @@ function createRunExecutor(dependencies) {
       return acquisition.result;
     const { execution } = acquisition;
     try {
+      const invocations = dependencies.config.invocations;
+      if (invocations) {
+        const trace = await invocations.trace({
+          context: input.context,
+          conversationId: execution.state.run.conversationId,
+          run: execution.state.run
+        });
+        execution.invocation = await beginAgentInvocation(invocations.ledger, dependencies.config.store, { run: execution.state.run, trace }, input.context);
+      }
       const turn = await prepareTurn(execution);
       await runModelAttempts(execution, turn);
       await settleStreamOutcome(execution);
@@ -3258,7 +3925,9 @@ function createRunExecutor(dependencies) {
     } finally {
       execution.idleDeadline.dispose();
     }
-    return commitRunTerminal(execution);
+    const result = await commitRunTerminal(execution);
+    await execution.invocation?.finish(result.reason === "success" ? "succeeded" : ["interrupted", "cancelled", "timeout", "shutdown"].includes(result.reason) ? "cancelled" : "failed");
+    return result;
   };
 }
 
@@ -3641,4 +4310,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };
+export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, ModelInvocationTraceSchema, CompletionInvocationInputSchema, ModelInvocationRecordSchema, currentModelInvocationAttempt, createModelInvocationLedger, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };