stitchkit 0.118.1 → 0.119.0

package/dist/{index-hdjmdwsj.js → index-x8d9fdeg.js}

@@ -14,7 +14,7 @@ import {
 import {
   ToolExecutionControlError2,
   isToolExecutionControlError2
-} from "./index-v6vb5qx8.js";
+} from "./index-s3yxw6kt.js";
 import {
   agentDurableEventId2
 } from "./index-mnkk1ffz.js";
@@ -35,7 +35,7 @@ import {
   ProviderJournalRequestSchema,
   ProviderJournalResponseSchema,
   isActiveRunState
-} from "./index-xx1j310k.js";
+} from "./index-8yxgcyt6.js";
 import {
   messageOf
 } from "./index-g149e9pk.js";
@@ -53,6 +53,9 @@ import {
   transportResult
 } from "./index-9jfdm5tg.js";
 
+// src/agent-runtime/runtime-internals.ts
+import { z } from "zod";
+
 // src/agent-runtime/run-store-retry.ts
 var STORE_RETRY_DELAYS_MS = [25, 100, 400];
 function storeRetryDelay(failures) {
@@ -249,6 +252,187 @@ async function commitAgentRunTerminal(input) {
   throw new AgentRuntimeConflictError2("terminal commit");
 }
 
+// src/agent-runtime/runtime-internals.ts
+function findRun(runs, runId) {
+  const run = runs.find((candidate) => candidate.id === runId);
+  if (!run)
+    throw new AgentRuntimeConflictError2("run lookup");
+  return run;
+}
+function jsonValue(value) {
+  const parsed = z.json().safeParse(value);
+  return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
+}
+function providerEnvelope(value) {
+  const parsed = AgentJsonObjectSchema2.safeParse(value);
+  if (!parsed.success)
+    return;
+  return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
+}
+function providerResponseIdentity(id, provider) {
+  return AgentProviderResponseSchema2.parse({
+    id,
+    ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
+  });
+}
+function appendText(parts, text) {
+  const previous = parts.at(-1);
+  if (previous?.type === "text") {
+    const next = AgentMessagePartSchema2.parse({ ...previous, text: previous.text + text });
+    parts.splice(parts.length - 1, 1, next);
+    return;
+  }
+  parts.push(AgentMessagePartSchema2.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/context-refusal.ts
 class AgentContextOverflowError2 extends Error {
   name = "AgentContextOverflowError";
@@ -400,6 +584,32 @@ function createAgentSessionCoordinator2() {
   };
 }
 
+// src/agent-runtime/deferred-tools-internal.ts
+var repairs = new WeakMap;
+var catalogs = new WeakMap;
+function registerDeferredToolRepair(prepareStep, repair) {
+  repairs.set(prepareStep, repair);
+}
+function deferredToolRepair(prepareStep) {
+  return prepareStep ? repairs.get(prepareStep) : undefined;
+}
+function registerDeferredToolCatalog(tools, searchName, names) {
+  const search = tools[searchName];
+  if (search && typeof search === "object")
+    catalogs.set(search, names);
+}
+function deferredToolCatalog(tools, searchName) {
+  const search = tools[searchName];
+  return search && typeof search === "object" ? catalogs.get(search) : undefined;
+}
+function repairedSearchCall(toolCall, searchName) {
+  return {
+    ...toolCall,
+    toolName: searchName,
+    input: JSON.stringify({ query: toolCall.toolName, reason: "inactive_call" })
+  };
+}
+
 // src/agent-runtime/history.ts
 import { modelMessageSchema as modelMessageSchema2 } from "ai";
 
@@ -669,90 +879,120 @@ async function projectAgentHistory2(messages, options = {}) {
   return [...(await projectAgentHistoryDetailed2(messages, options)).messages];
 }
 
+// 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 z3 } from "zod";
+
 // 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 ModelInvocationTraceSchema2 = z.object({
+import { z as z2 } from "zod";
+var Id = z2.string().min(1).max(512);
+var Hash = z2.string().regex(/^[a-f0-9]{64}$/);
+var ModelInvocationTraceSchema2 = z2.object({
   operationId: Id,
   purpose: Id,
   project: Id,
-  parent: z.object({ traceId: Id, invocationId: Id.optional() }).strict().optional(),
+  parent: z2.object({ traceId: Id, invocationId: Id.optional() }).strict().optional(),
   experiment: Id.optional(),
   case: Id.optional(),
   profile: Id.optional()
 }).strict();
-var CompletionInvocationInputSchema2 = z.object({
+var CompletionInvocationInputSchema2 = z2.object({
   conversationId: Id,
   idempotencyKey: Id,
   trace: ModelInvocationTraceSchema2,
-  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()
+  prompt: z2.string().min(1),
+  models: z2.array(Id).min(1).max(8),
+  settings: z2.object({
+    maxOutputTokens: z2.int().positive().optional(),
+    temperature: z2.number().finite().optional(),
+    topP: z2.number().min(0).max(1).optional(),
+    seed: z2.int().optional()
   }).strict().optional(),
-  timeoutMs: z.int().positive().max(3600000)
+  timeoutMs: z2.int().positive().max(3600000)
 }).strict();
-var Identity = z.object({
+var Identity = z2.object({
   provider: Id.nullable(),
   modelId: Id.nullable(),
   responseId: Id.nullable()
 }).strict();
-var InvocationCallerSchema = z.object({ subject: Id }).strict();
-var InvocationProcessSchema = z.object({
+var InvocationCallerSchema = z2.object({ subject: Id }).strict();
+var InvocationProcessSchema = z2.object({
   instanceId: Id,
-  pid: z.int().positive(),
+  pid: z2.int().positive(),
   hostname: Id
 }).strict();
-var Base = z.object({
+var Base = z2.object({
   conversationId: Id,
   invocationId: Id,
   operationId: Id,
   runId: Id.optional()
 });
 var InvocationStartedSchema = Base.extend({
-  type: z.literal("invocation/started"),
-  mode: z.enum(["completion", "agent"]),
+  type: z2.literal("invocation/started"),
+  mode: z2.enum(["completion", "agent"]),
   trace: ModelInvocationTraceSchema2,
   caller: InvocationCallerSchema,
   executingProcess: InvocationProcessSchema,
   fingerprint: Hash,
-  requested: z.object({ models: z.array(Id), payloadSha256: Hash }).strict()
+  requested: z2.object({ models: z2.array(Id), payloadSha256: Hash }).strict()
 }).strict();
 var InvocationAttemptContextSchema = Base.extend({
   attemptId: Id,
-  step: z.int().nonnegative()
+  step: z2.int().nonnegative()
 }).strict();
-var Attempt = Base.extend({ attemptId: Id, step: z.int().nonnegative() });
+var Attempt = Base.extend({ attemptId: Id, step: z2.int().nonnegative() });
 var InvocationRequestSchema = Attempt.extend({
-  type: z.literal("provider/request"),
-  requested: z.object({ modelId: Id, provider: Id }).strict(),
+  type: z2.literal("provider/request"),
+  requested: z2.object({ modelId: Id, provider: Id }).strict(),
   executingProcess: InvocationProcessSchema,
-  sent: z.object({
+  sent: z2.object({
     modelId: Id,
     provider: Id,
     payloadSha256: Hash,
     artifactId: Id,
-    tools: z.int().nonnegative()
+    tools: z2.int().nonnegative()
   }).strict()
 }).strict();
 var InvocationResponseSchema = Attempt.extend({
-  type: z.literal("provider/response"),
-  status: z.enum(["succeeded", "failed", "cancelled"]),
+  type: z2.literal("provider/response"),
+  status: z2.enum(["succeeded", "failed", "cancelled"]),
   effective: Identity,
   usage: AgentUsageSchema2,
   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"])
+  type: z2.literal("invocation/finished"),
+  failure: z2.object({ artifactId: Id, payloadSha256: Hash }).strict().optional(),
+  status: z2.enum(["succeeded", "failed", "cancelled"])
 }).strict();
-var ModelInvocationRecordSchema2 = z.discriminatedUnion("type", [
+var ModelInvocationRecordSchema2 = z2.discriminatedUnion("type", [
   InvocationStartedSchema,
   InvocationRequestSchema,
   InvocationResponseSchema,
@@ -761,44 +1001,16 @@ var ModelInvocationRecordSchema2 = z.discriminatedUnion("type", [
 var InvocationPayloadSchema = Base.extend({
   artifactId: Id,
   sha256: Hash,
-  bytes: z.int().nonnegative(),
-  iv: z.string(),
-  tag: z.string(),
-  ciphertext: z.string()
+  bytes: z2.int().nonnegative(),
+  iv: z2.string(),
+  tag: z2.string(),
+  ciphertext: z2.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) => {
+  return z3.json().parse(JSON.parse(JSON.stringify(value, (_key, item) => {
     if (item instanceof Uint8Array)
       return { base64: Buffer.from(item).toString("base64") };
     if (item instanceof ArrayBuffer)
@@ -842,253 +1054,71 @@ function createInvocationPayloads(store, key, maxBytes) {
           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 AgentRuntimeConflictError2("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 = AgentJsonObjectSchema2.safeParse(value);
-  if (!parsed.success)
-    return;
-  return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
-}
-function providerResponseIdentity(id, provider) {
-  return AgentProviderResponseSchema2.parse({
-    id,
-    ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
-  });
-}
-function appendText(parts, text) {
-  const previous = parts.at(-1);
-  if (previous?.type === "text") {
-    const next = AgentMessagePartSchema2.parse({ ...previous, text: previous.text + text });
-    parts.splice(parts.length - 1, 1, next);
-    return;
-  }
-  parts.push(AgentMessagePartSchema2.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" }
+          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 z3.json().parse(JSON.parse(data.toString("utf8")));
+    }
   };
 }
-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)
-  };
+
+// 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 unknownUsage() {
-  const nothing = { provenance: "unavailable" };
-  return {
-    inputTokens: nothing,
-    outputTokens: nothing,
-    reasoningTokens: nothing,
-    cacheReadTokens: nothing,
-    cacheWriteTokens: nothing,
-    cost: nothing
-  };
+function markProviderOrigin(error) {
+  if (typeof error === "object" && error !== null)
+    providerOrigin.add(error);
+  return error;
 }
-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 hasProviderOrigin(error) {
+  return typeof error === "object" && error !== null && providerOrigin.has(error);
 }
-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();
+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);
     },
-    dispose() {
-      active = false;
-      clear();
+    cancel(reason) {
+      return reader.cancel(reason);
     }
-  };
+  });
 }
 
 // src/agent-runtime/invocation-attempt.ts
@@ -1833,184 +1863,66 @@ function classifyProviderFailure2(error) {
   if (error instanceof AgentProviderStreamCutError2) {
     return { reason: "stream-cut", retryable: true, evidence: "none" };
   }
-  const status = statusOf(error);
-  const byStatus = status === undefined ? undefined : BY_STATUS[status];
-  if (byStatus) {
-    return {
-      reason: byStatus,
-      status,
-      retryable: RETRYABLE.has(byStatus),
-      evidence: "status"
-    };
-  }
-  const message = messageOf(error);
-  for (const [pattern, reason] of BY_MESSAGE) {
-    if (pattern.test(message)) {
-      return {
-        reason,
-        ...status !== undefined && { status },
-        retryable: RETRYABLE.has(reason),
-        evidence: "message"
-      };
-    }
-  }
-  return {
-    reason: "unknown",
-    ...status !== undefined && { status },
-    retryable: false,
-    evidence: "none"
-  };
-}
-function isToolResultFailure2(output) {
-  const parsed = typeof output === "string" ? parseJson(output) : output;
-  if (!isRecord(parsed))
-    return false;
-  if ("error" in parsed)
-    return true;
-  return isRecord(parsed.value) && "error" in parsed.value;
-}
-function parseJson(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return;
-  }
-}
-
-// src/agent-runtime/retry-policy.ts
-async function recordAgentRetryDecision2(input) {
-  const retry = input.failure.retryable && input.attempt < input.policy.maxAttempts;
-  const delayMs = retry ? input.policy.delayMs({ attempt: input.attempt, failure: input.failure }) : 0;
-  if (!Number.isInteger(delayMs) || delayMs < 0) {
-    throw new TypeError("Retry delay must be a non-negative integer");
-  }
-  if (retry) {
-    await input.store.appendEvent({
-      conversationId: input.conversationId,
-      kind: "retry/scheduled",
-      payload: { attempt: input.attempt + 1, delayMs, reason: input.failure.reason }
-    });
-  }
-  return { retry, delayMs };
-}
-
-// src/agent-runtime/state-slots.ts
-import { z as z7 } from "zod";
-function defineStateSlot2(input) {
-  if (input.name.length === 0)
-    throw new TypeError("State slot name must not be empty");
-  const version = input.version ?? 1;
-  if (!Number.isInteger(version) || version < 1) {
-    throw new TypeError("State slot version must be a positive integer");
-  }
-  return {
-    name: input.name,
-    version,
-    schema: input.schema,
-    ...input.description && { description: input.description }
-  };
-}
-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;
-  for (const definition of definitions) {
-    if (result.has(definition.name))
-      throw new TypeError(`Duplicate state slot: ${definition.name}`);
-    result.set(definition.name, definition);
-  }
-  return result;
-}
-function createAgentStateSlotStore2(input) {
-  const definitions = slotRegistry(input.definitions);
-  const set = async (request) => {
-    const definition = definitions.get(request.name);
-    if (!definition)
-      throw new TypeError(`Unknown state slot: ${request.name}`);
-    const value = definition.schema.parse(request.value);
-    const payload = StateSetPayloadSchema.parse({
-      name: definition.name,
-      version: definition.version,
-      value,
-      actor: request.actor
-    });
-    const event = await input.store.appendEvent({
-      conversationId: request.conversationId,
-      kind: "state/set",
-      payload
-    });
-    return {
-      name: definition.name,
-      version: definition.version,
-      value,
-      updatedAt: event.occurredAt,
-      seq: event.seq
+  const status = statusOf(error);
+  const byStatus = status === undefined ? undefined : BY_STATUS[status];
+  if (byStatus) {
+    return {
+      reason: byStatus,
+      status,
+      retryable: RETRYABLE.has(byStatus),
+      evidence: "status"
     };
-  };
-  const list = async (conversationId) => {
-    const values = new Map;
-    let cursor = 1;
-    for (;; ) {
-      const page = await input.store.readEvents({
-        conversationId,
-        fromSeq: cursor,
-        limit: 1000
-      });
-      for (const event of page.items) {
-        if (event.kind !== "state/set")
-          continue;
-        const payload = StateSetPayloadSchema.parse(event.payload);
-        const definition = definitions.get(payload.name);
-        if (!definition || definition.version !== payload.version)
-          continue;
-        values.set(payload.name, {
-          name: payload.name,
-          version: payload.version,
-          value: definition.schema.parse(payload.value),
-          updatedAt: event.occurredAt,
-          seq: event.seq
-        });
-      }
-      if (page.nextSeq === undefined)
-        break;
-      cursor = page.nextSeq;
+  }
+  const message = messageOf(error);
+  for (const [pattern, reason] of BY_MESSAGE) {
+    if (pattern.test(message)) {
+      return {
+        reason,
+        ...status !== undefined && { status },
+        retryable: RETRYABLE.has(reason),
+        evidence: "message"
+      };
     }
-    return [...values.values()].sort((left, right) => left.name.localeCompare(right.name));
+  }
+  return {
+    reason: "unknown",
+    ...status !== undefined && { status },
+    retryable: false,
+    evidence: "none"
   };
-  const get = async (conversationId, name) => (await list(conversationId)).find((value) => value.name === name);
-  return { set, get, list };
 }
-function renderAgentStateSlots2(values) {
-  if (values.length === 0)
+function isToolResultFailure2(output) {
+  const parsed = typeof output === "string" ? parseJson(output) : output;
+  if (!isRecord(parsed))
+    return false;
+  if ("error" in parsed)
+    return true;
+  return isRecord(parsed.value) && "error" in parsed.value;
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
     return;
-  return [
-    "Durable conversation state (authoritative; newer than compacted history):",
-    ...values.map((slot) => `${slot.name}: ${JSON.stringify(slot.value)}`)
-  ].join(`
-`);
+  }
+}
+
+// src/agent-runtime/retry-policy.ts
+async function recordAgentRetryDecision2(input) {
+  const retry = input.failure.retryable && input.attempt < input.policy.maxAttempts;
+  const delayMs = retry ? input.policy.delayMs({ attempt: input.attempt, failure: input.failure }) : 0;
+  if (!Number.isInteger(delayMs) || delayMs < 0) {
+    throw new TypeError("Retry delay must be a non-negative integer");
+  }
+  if (retry) {
+    await input.store.appendEvent({
+      conversationId: input.conversationId,
+      kind: "retry/scheduled",
+      payload: { attempt: input.attempt + 1, delayMs, reason: input.failure.reason }
+    });
+  }
+  return { retry, delayMs };
 }
-var agentGoalStateSlot2 = defineStateSlot2({
-  name: "goal",
-  description: "The durable objective and lifecycle of this conversation.",
-  schema: z7.object({
-    objective: z7.string().min(1),
-    status: z7.enum(["active", "complete", "blocked"])
-  }).strict()
-});
-var agentTodoStateSlot2 = defineStateSlot2({
-  name: "todo",
-  description: "The durable ordered work plan for this conversation.",
-  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-control.ts
 async function interruptAgentRun(state, input) {
@@ -2823,32 +2735,6 @@ import {
   stepCountIs
 } from "ai";
 
-// src/agent-runtime/deferred-tools-internal.ts
-var repairs = new WeakMap;
-var catalogs = new WeakMap;
-function registerDeferredToolRepair(prepareStep, repair) {
-  repairs.set(prepareStep, repair);
-}
-function deferredToolRepair(prepareStep) {
-  return prepareStep ? repairs.get(prepareStep) : undefined;
-}
-function registerDeferredToolCatalog(tools, searchName, names) {
-  const search = tools[searchName];
-  if (search && typeof search === "object")
-    catalogs.set(search, names);
-}
-function deferredToolCatalog(tools, searchName) {
-  const search = tools[searchName];
-  return search && typeof search === "object" ? catalogs.get(search) : undefined;
-}
-function repairedSearchCall(toolCall, searchName) {
-  return {
-    ...toolCall,
-    toolName: searchName,
-    input: JSON.stringify({ query: toolCall.toolName, reason: "inactive_call" })
-  };
-}
-
 // src/agent-runtime/owned-provider-stream.ts
 var DEFAULT_CLEANUP_TIMEOUT_MS = 1000;
 async function settleCleanup(operation, timeoutMs) {
@@ -3739,6 +3625,126 @@ async function commitRunTerminal(execution) {
 
 // src/agent-runtime/run-prompt-history.ts
 import { createHash as createHash4 } from "node:crypto";
+
+// src/agent-runtime/state-slots.ts
+import { z as z7 } from "zod";
+function defineStateSlot2(input) {
+  if (input.name.length === 0)
+    throw new TypeError("State slot name must not be empty");
+  const version = input.version ?? 1;
+  if (!Number.isInteger(version) || version < 1) {
+    throw new TypeError("State slot version must be a positive integer");
+  }
+  return {
+    name: input.name,
+    version,
+    schema: input.schema,
+    ...input.description && { description: input.description }
+  };
+}
+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;
+  for (const definition of definitions) {
+    if (result.has(definition.name))
+      throw new TypeError(`Duplicate state slot: ${definition.name}`);
+    result.set(definition.name, definition);
+  }
+  return result;
+}
+function createAgentStateSlotStore2(input) {
+  const definitions = slotRegistry(input.definitions);
+  const set = async (request) => {
+    const definition = definitions.get(request.name);
+    if (!definition)
+      throw new TypeError(`Unknown state slot: ${request.name}`);
+    const value = definition.schema.parse(request.value);
+    const payload = StateSetPayloadSchema.parse({
+      name: definition.name,
+      version: definition.version,
+      value,
+      actor: request.actor
+    });
+    const event = await input.store.appendEvent({
+      conversationId: request.conversationId,
+      kind: "state/set",
+      payload
+    });
+    return {
+      name: definition.name,
+      version: definition.version,
+      value,
+      updatedAt: event.occurredAt,
+      seq: event.seq
+    };
+  };
+  const list = async (conversationId) => {
+    const values = new Map;
+    let cursor = 1;
+    for (;; ) {
+      const page = await input.store.readEvents({
+        conversationId,
+        fromSeq: cursor,
+        limit: 1000
+      });
+      for (const event of page.items) {
+        if (event.kind !== "state/set")
+          continue;
+        const payload = StateSetPayloadSchema.parse(event.payload);
+        const definition = definitions.get(payload.name);
+        if (!definition || definition.version !== payload.version)
+          continue;
+        values.set(payload.name, {
+          name: payload.name,
+          version: payload.version,
+          value: definition.schema.parse(payload.value),
+          updatedAt: event.occurredAt,
+          seq: event.seq
+        });
+      }
+      if (page.nextSeq === undefined)
+        break;
+      cursor = page.nextSeq;
+    }
+    return [...values.values()].sort((left, right) => left.name.localeCompare(right.name));
+  };
+  const get = async (conversationId, name) => (await list(conversationId)).find((value) => value.name === name);
+  return { set, get, list };
+}
+function renderAgentStateSlots2(values) {
+  if (values.length === 0)
+    return;
+  return [
+    "Durable conversation state (authoritative; newer than compacted history):",
+    ...values.map((slot) => `${slot.name}: ${JSON.stringify(slot.value)}`)
+  ].join(`
+`);
+}
+var agentGoalStateSlot2 = defineStateSlot2({
+  name: "goal",
+  description: "The durable objective and lifecycle of this conversation.",
+  schema: z7.object({
+    objective: z7.string().min(1),
+    status: z7.enum(["active", "complete", "blocked"])
+  }).strict()
+});
+var agentTodoStateSlot2 = defineStateSlot2({
+  name: "todo",
+  description: "The durable ordered work plan for this conversation.",
+  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/run-prompt-history.ts
 function snapshotForRunPrompt(snapshot, runId) {
   const runIndex = snapshot.runs.findIndex((candidate) => candidate.id === runId);
   if (runIndex < 0)