stitchkit 0.93.0 → 0.94.1

package/dist/entrypoints/agent-runtime.js

@@ -0,0 +1,2670 @@
+import {
+  AgentContextOverflowError,
+  AgentProviderStreamCutError,
+  AgentRuntimeConflictError,
+  AgentTokenCountSchema,
+  agentGoalStateSlot,
+  agentTodoStateSlot,
+  classifyProviderFailure,
+  composeAgentPrompt,
+  createAgentRuntime,
+  createAgentRuntimeEventSink,
+  createAgentSessionCoordinator,
+  createAgentStateSlotStore,
+  createAgentToolFenceLifecycle,
+  deferredToolCatalog,
+  defineStateSlot,
+  isToolResultFailure,
+  normalizeSdkUsage,
+  projectAgentHistory,
+  projectAgentHistoryDetailed,
+  recordAgentRetryDecision,
+  registerDeferredToolCatalog,
+  registerDeferredToolRepair,
+  renderAgentStateSlots,
+  repairedSearchCall,
+  selectAgentHistory
+} from "../index-7f68ghdn.js";
+import"../index-83bdg97s.js";
+import {
+  AgentAdmissionEventSchema,
+  AgentAttemptResetEventSchema,
+  AgentCheckpointEventSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
+  AgentReasoningStartEventSchema,
+  AgentRunOperationEventSchema,
+  AgentRunStateEventSchema,
+  AgentRuntimeEventCursorSchema,
+  AgentRuntimeEventSchema,
+  AgentTerminalEventSchema,
+  AgentToolStatusEventSchema,
+  AgentTransientDeltaEventSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId
+} from "../index-y64k3s0h.js";
+import {
+  AgentModelCapabilitySchema,
+  AgentModelCatalogEntrySchema,
+  AgentModelCatalogSchema,
+  AgentModelDescriptorSchema,
+  AgentModelMetricSchema,
+  AgentModelPopularitySchema,
+  AgentModelPriceSchema,
+  AgentModelRegistrySnapshotSchema,
+  AgentModelSearchInputSchema,
+  AgentModelSearchResultSchema,
+  AgentModelSelectionSchema,
+  createMemoryAgentModelSelectionStore,
+  defineModelRegistry,
+  searchAgentModelCatalog,
+  validateAgentModelSnapshot
+} from "../index-mqv3b5rh.js";
+import {
+  AgentConversationMessagePageSchema,
+  AgentConversationPageSchema,
+  AgentConversationSummarySchema
+} from "../index-crykmqkr.js";
+import {
+  createBoundedSinkManager
+} from "../index-h6eeys1v.js";
+import {
+  AgentSandboxGradeSchema,
+  AgentSandboxRestrictionSchema,
+  missingSandboxRestrictions,
+  probeAgentProcessSandbox,
+  recordAgentSandboxProbe,
+  refuseUnknownSpillReference
+} from "../index-qmy6zq75.js";
+import {
+  createMemoryAgentRuntimeStore
+} from "../index-sp1tzwnb.js";
+import {
+  ACTIVE_AGENT_RUN_STATES,
+  AgentAdmissionReceiptSchema,
+  AgentConversationPurgeInputSchema,
+  AgentConversationPurgeResultSchema,
+  AgentConversationPurgedError,
+  AgentHistoryMutationSchema,
+  AgentRuntimeHeadSchema,
+  AgentSeedReceiptSchema,
+  AgentStoredRunSchema,
+  createAgentRuntimeStore,
+  purgeAgentConversation
+} from "../index-wsm5w4ee.js";
+import {
+  AcceptInputAndAssignRunSchema,
+  AcquireAgentRunSchema,
+  AgentConversationArchiveSchema,
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
+  AgentRunViewSchema,
+  AgentStoreAppliedSchema,
+  AgentStoreConflictSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventKindSchema,
+  AgentStoreEventPageSchema,
+  AgentStoreMutationResultSchema,
+  AgentStoreNotFoundSchema,
+  AgentStoreTransitionSchema,
+  AppendAgentStoreEventSchema,
+  CheckpointRunAssistantSchema,
+  CommitRunTerminalSchema,
+  ReadAgentStoreEventsSchema,
+  RecordRunOperationSchema,
+  RecoverAgentRunSchema,
+  ReplaceCompactedRangeSchema,
+  RequestRunInterruptSchema,
+  SeedConversationInputSchema,
+  canonicalAgentJson,
+  decodeAgentConversationArchive,
+  decodeAgentStoreEvent,
+  encodeAgentConversationArchive,
+  isAssistantHistoryEvidence,
+  isCompleteAgentHistoryTurn
+} from "../index-gxrt5h6v.js";
+import {
+  AgentAssistantPlaceholderSchema,
+  AgentControlPartSchema,
+  AgentCostValueSchema,
+  AgentFilePartSchema,
+  AgentJsonObjectSchema,
+  AgentMessagePartSchema,
+  AgentMessageRoleSchema,
+  AgentMessageSchema,
+  AgentMessageStatusSchema,
+  AgentOpaquePartSchema,
+  AgentProvenanceSchema,
+  AgentProviderEnvelopeSchema,
+  AgentProviderResponseSchema,
+  AgentReasoningPartSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunMetricsSchema,
+  AgentRunOperationKindSchema,
+  AgentRunOperationPhaseSchema,
+  AgentRunOperationSchema,
+  AgentRunQueuePrioritySchema,
+  AgentRunSchema,
+  AgentRunStateSchema,
+  AgentSnapshotSchema,
+  AgentSourcePartSchema,
+  AgentTerminalReasonSchema,
+  AgentTextPartSchema,
+  AgentTimestampSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
+  AgentToolCallPartSchema,
+  AgentToolResultPartSchema,
+  AgentUsageSchema,
+  AgentUsageValueSchema,
+  runStateForTerminalReason
+} from "../index-gtj3zc53.js";
+import {
+  buildToolManifest,
+  mountAgent
+} from "../index-863ea9jb.js";
+import {
+  DURABILITY_STEP_EVENT_KIND,
+  ParkAbortedError,
+  ParkRecordDecodeError,
+  StepAbortedError,
+  StepResultDecodeError,
+  StepResultNotSerializableError
+} from "../index-79z7m7dt.js";
+import"../index-hmp4800j.js";
+import"../index-khtgb21r.js";
+import"../index-55hkhm67.js";
+import"../index-zfrhfn82.js";
+import"../index-35mh5bhj.js";
+import {
+  childSpan,
+  createTraceContext
+} from "../index-zcgf3gqf.js";
+import"../index-1zbbzgfh.js";
+import {
+  defineRuntimeTool,
+  executableAgentRuntimeTools
+} from "../index-xw3s75nj.js";
+import"../index-np4m8hd3.js";
+import"../index-eqqvgdb3.js";
+import"../index-znfs20ss.js";
+import"../index-p5r7qpdd.js";
+import"../index-2vtcmrj9.js";
+import"../index-k5hsfc3j.js";
+import"../index-kzfs85xp.js";
+import"../index-hffjpmq9.js";
+
+// src/agent-runtime/child-tools.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/agent-tool.ts
+function defineAgentTool(definition) {
+  return {
+    ...definition,
+    handler: (context) => definition.handler(context)
+  };
+}
+
+// src/agent-runtime/children-contract.ts
+import { z } from "zod";
+var AgentChildBudgetSchema = z.object({
+  usd: z.number().positive().optional(),
+  tokens: z.int().positive().optional(),
+  milliseconds: z.int().positive().optional()
+}).strict();
+var AgentChildStateSchema = z.enum([
+  "spawned",
+  "running",
+  "finished",
+  "stopped",
+  "lost"
+]);
+var AgentChildRecordSchema = z.object({
+  parentConversationId: z.string().min(1),
+  childConversationId: z.string().min(1),
+  seedUptoSeq: z.int().nonnegative(),
+  state: AgentChildStateSchema,
+  budget: AgentChildBudgetSchema,
+  usage: z.object({
+    tokens: z.int().nonnegative(),
+    usd: z.number().nonnegative(),
+    milliseconds: z.int().nonnegative()
+  }).strict(),
+  resultReference: z.string().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+}).strict();
+var AgentChildBlockingKindSchema = z.enum(["approval", "input"]);
+var AgentChildBlockingSourceSchema = z.object({
+  approvalId: z.string().min(1),
+  callId: z.string().min(1),
+  toolName: z.string().min(1),
+  input: z.json(),
+  kind: AgentChildBlockingKindSchema.default("approval"),
+  batchId: z.string().min(1).optional()
+}).strict();
+var AgentChildBlockingEventSchema = z.object({
+  parentConversationId: z.string().min(1),
+  childConversationId: z.string().min(1),
+  kind: AgentChildBlockingKindSchema,
+  approvalId: z.string().min(1),
+  childApprovalId: z.string().min(1),
+  callId: z.string().min(1),
+  toolName: z.string().min(1),
+  input: z.json(),
+  batchId: z.string().min(1),
+  presentedAt: z.string()
+}).strict();
+var ChildBlockingDecisionSchema = z.union([
+  z.object({
+    approvalId: z.string().min(1),
+    approved: z.boolean(),
+    reason: z.string().optional()
+  }).strict(),
+  z.object({ approvalId: z.string().min(1), value: z.json() }).strict()
+]);
+var ChildRowSchema = z.object({
+  parent_conversation_id: z.string(),
+  child_conversation_id: z.string(),
+  seed_upto_seq: z.int().nonnegative(),
+  state: AgentChildStateSchema,
+  budget_payload: z.string(),
+  usage_payload: z.string(),
+  result_reference: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+function parseChild(raw) {
+  const row = ChildRowSchema.parse(raw);
+  return AgentChildRecordSchema.parse({
+    parentConversationId: row.parent_conversation_id,
+    childConversationId: row.child_conversation_id,
+    seedUptoSeq: row.seed_upto_seq,
+    state: row.state,
+    budget: JSON.parse(row.budget_payload),
+    usage: JSON.parse(row.usage_payload),
+    ...row.result_reference && { resultReference: row.result_reference },
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  });
+}
+function usageNumbers(usage) {
+  const inputTokens = usage.inputTokens.value;
+  const outputTokens = usage.outputTokens.value;
+  return {
+    ...inputTokens !== undefined && outputTokens !== undefined ? { tokens: inputTokens + outputTokens } : {},
+    ...usage.cost?.currency === "USD" && usage.cost.value !== undefined ? { usd: usage.cost.value } : {}
+  };
+}
+
+// src/agent-runtime/child-blocking.ts
+function createChildBlockingRelay(input) {
+  const { store, now, handles, listChildren, activeChild, bounded } = input;
+  const presentedBlocking = new Map;
+  const retiredBlocking = new Set;
+  let blockingQueue = Promise.resolve();
+  const serializeBlocking = (work) => {
+    const run = blockingQueue.then(work, work);
+    blockingQueue = run.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return run;
+  };
+  const childScopedBlockingId = (childConversationId, childApprovalId) => `${encodeURIComponent(childConversationId)}:${encodeURIComponent(childApprovalId)}`;
+  const retireChildBlocking = (childConversationId) => {
+    for (const [id, entry] of presentedBlocking) {
+      if (entry.event.childConversationId === childConversationId) {
+        presentedBlocking.delete(id);
+        retiredBlocking.add(id);
+      }
+    }
+  };
+  const listChildBlockingInner = async (parentConversationId) => {
+    const live = listChildren(parentConversationId).filter((record) => record.state === "spawned" || record.state === "running");
+    for (const record of live) {
+      const handle = handles.get(record.childConversationId);
+      if (!handle?.blockingEvents)
+        continue;
+      const reported = await bounded(Promise.resolve(handle.blockingEvents()), []);
+      const fresh = reported.map((source) => AgentChildBlockingSourceSchema.parse(source)).filter((source) => {
+        const id = childScopedBlockingId(record.childConversationId, source.approvalId);
+        return !presentedBlocking.has(id) && !retiredBlocking.has(id);
+      });
+      if (fresh.length === 0)
+        continue;
+      const presentedAt = now().toISOString();
+      for (const source of fresh) {
+        const approvalId = childScopedBlockingId(record.childConversationId, source.approvalId);
+        const batchId = source.batchId ? `${record.childConversationId}:${source.batchId}` : approvalId;
+        const event = AgentChildBlockingEventSchema.parse({
+          parentConversationId,
+          childConversationId: record.childConversationId,
+          kind: source.kind,
+          approvalId,
+          childApprovalId: source.approvalId,
+          callId: source.callId,
+          toolName: source.toolName,
+          input: source.input,
+          batchId,
+          presentedAt
+        });
+        await store.appendEvent({
+          conversationId: parentConversationId,
+          kind: "child/state",
+          occurredAt: presentedAt,
+          payload: {
+            action: "blocking-presented",
+            childConversationId: event.childConversationId,
+            approvalId: event.approvalId,
+            childApprovalId: event.childApprovalId,
+            kind: event.kind,
+            callId: event.callId,
+            toolName: event.toolName,
+            input: event.input,
+            batchId: event.batchId,
+            presentedAt
+          }
+        });
+        presentedBlocking.set(approvalId, { event, batchId });
+      }
+    }
+    return [...presentedBlocking.values()].map((entry) => entry.event).filter((event) => event.parentConversationId === parentConversationId);
+  };
+  const listChildBlocking = (parentConversationId) => serializeBlocking(() => listChildBlockingInner(parentConversationId));
+  const respondToChildBlockingInner = async (parentConversationId, decision) => {
+    const entry = presentedBlocking.get(decision.approvalId);
+    if (!entry || entry.event.parentConversationId !== parentConversationId) {
+      throw new TypeError("Child blocking request is missing, stale or already answered");
+    }
+    const { handle } = activeChild(parentConversationId, entry.event.childConversationId);
+    if (!handle.respondToBlocking) {
+      throw new TypeError("Child host cannot answer blocking requests");
+    }
+    const parsed = ChildBlockingDecisionSchema.parse(decision);
+    if (entry.event.kind === "input" !== "value" in parsed)
+      throw new TypeError("Child response kind does not match the pending request");
+    await handle.respondToBlocking({ ...parsed, approvalId: entry.event.childApprovalId });
+    presentedBlocking.delete(decision.approvalId);
+    retiredBlocking.add(decision.approvalId);
+    await store.appendEvent({
+      conversationId: parentConversationId,
+      kind: "child/state",
+      payload: {
+        action: "blocking-resolved",
+        childConversationId: entry.event.childConversationId,
+        approvalId: entry.event.approvalId,
+        batchId: entry.batchId,
+        ..."approved" in parsed ? { approved: parsed.approved } : { kind: "input" }
+      }
+    });
+  };
+  const respondToChildBlocking = (parentConversationId, decision) => serializeBlocking(() => respondToChildBlockingInner(parentConversationId, decision));
+  return { retireChildBlocking, listChildBlocking, respondToChildBlocking };
+}
+
+// src/agent-runtime/children-state.ts
+function createChildManagerState(config) {
+  return {
+    config,
+    database: config.sqlite.database,
+    store: config.sqlite.store,
+    now: config.now ?? (() => new Date),
+    handles: new Map,
+    settlements: new Map
+  };
+}
+function currentState(state, childConversationId) {
+  const raw = state.database.prepare("SELECT state FROM stitchkit_agent_runtime_children WHERE child_conversation_id = ?").get(childConversationId);
+  return raw === null || raw === undefined ? undefined : AgentChildStateSchema.parse(raw.state);
+}
+function isLive(state, childConversationId) {
+  const current = currentState(state, childConversationId);
+  return current === "spawned" || current === "running";
+}
+function settleable(state, childConversationId) {
+  const current = currentState(state, childConversationId);
+  return current === undefined || current === "spawned" || current === "running";
+}
+var STOP_BOUND_MS = 1e4;
+async function bounded(work, fallback) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve(work),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(fallback), STOP_BOUND_MS);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function listChildren(state, parentConversationId) {
+  return state.database.prepare(`
+        SELECT parent_conversation_id, child_conversation_id, seed_upto_seq, state,
+          budget_payload, usage_payload, result_reference, created_at, updated_at
+        FROM stitchkit_agent_runtime_children
+        WHERE parent_conversation_id = ? ORDER BY created_at, child_conversation_id
+      `).all(parentConversationId).map(parseChild);
+}
+async function updateState(state, record, next, resultReference, details = {}) {
+  const updatedAt = state.now().toISOString();
+  const payload = {
+    childConversationId: record.childConversationId,
+    state: next,
+    ...resultReference && { resultReference },
+    ...details
+  };
+  const childPayload = {
+    parentConversationId: record.parentConversationId,
+    state: next,
+    ...resultReference && { resultReference },
+    ...details
+  };
+  const write = (audience) => state.config.sqlite.transaction(async (scope) => {
+    scope.database.prepare(`
+            UPDATE stitchkit_agent_runtime_children
+            SET state = ?, result_reference = ?, updated_at = ? WHERE child_conversation_id = ?
+          `).run(next, resultReference ?? null, updatedAt, record.childConversationId);
+    if (audience === "both") {
+      await scope.appendEvent({
+        conversationId: record.parentConversationId,
+        kind: "child/state",
+        occurredAt: updatedAt,
+        payload
+      });
+    }
+    if (audience !== "row") {
+      await scope.appendEvent({
+        conversationId: record.childConversationId,
+        kind: "child/state",
+        occurredAt: updatedAt,
+        payload: childPayload
+      });
+    }
+  });
+  try {
+    await write("both");
+  } catch (error) {
+    if (!(error instanceof AgentConversationPurgedError))
+      throw error;
+    try {
+      await write("child");
+    } catch (inner) {
+      if (!(inner instanceof AgentConversationPurgedError))
+        throw inner;
+      await write("row");
+    }
+  }
+}
+function activeChild(state, parentConversationId, childConversationId) {
+  const child = listChildren(state, parentConversationId).find((record) => record.childConversationId === childConversationId);
+  if (!child)
+    throw new TypeError("Unknown child conversation for this parent");
+  if (child.state !== "running" && child.state !== "spawned") {
+    throw new TypeError("Child conversation is not active");
+  }
+  const handle = state.handles.get(childConversationId);
+  if (!handle)
+    throw new TypeError("Child host handle is unavailable");
+  return { child, handle };
+}
+
+// src/agent-runtime/children-control.ts
+async function stopChildren(state, retireChildBlocking, parentConversationId) {
+  const records = listChildren(state, parentConversationId).filter((record) => record.state === "spawned" || record.state === "running");
+  await Promise.all(records.map((record) => stopChild(state, retireChildBlocking, record)));
+}
+async function stopChild(state, retireChildBlocking, record) {
+  const startedAt = performance.now();
+  const handle = state.handles.get(record.childConversationId);
+  const reachable = handle ? handle.reachable ? await bounded(handle.reachable(), false) : true : false;
+  if (!reachable) {
+    if (isLive(state, record.childConversationId)) {
+      await updateState(state, record, "lost", undefined, {
+        stopDurationMs: Math.max(0, performance.now() - startedAt)
+      });
+    }
+    retireChildBlocking(record.childConversationId);
+    return;
+  }
+  await bounded(Promise.resolve(handle?.stopPolicy("parent-stopped")).then(() => true), false);
+  if (!isLive(state, record.childConversationId))
+    return;
+  await updateState(state, record, "stopped", undefined, {
+    stopDurationMs: Math.max(0, performance.now() - startedAt)
+  });
+  retireChildBlocking(record.childConversationId);
+}
+async function sendMessage(state, parentConversationId, childConversationId, message) {
+  const { handle } = activeChild(state, parentConversationId, childConversationId);
+  if (!handle.sendMessage)
+    throw new TypeError("Child host does not support messages");
+  await handle.sendMessage(message);
+  await state.store.appendEvent({
+    conversationId: parentConversationId,
+    kind: "child/state",
+    payload: { childConversationId, action: "message-sent" }
+  });
+}
+async function interruptChild(state, retireChildBlocking, parentConversationId, childConversationId) {
+  const { child, handle } = activeChild(state, parentConversationId, childConversationId);
+  const startedAt = performance.now();
+  await handle.stopPolicy("parent-interrupt");
+  await updateState(state, child, "stopped", undefined, {
+    policyName: "parent-interrupt",
+    stopDurationMs: Math.max(0, performance.now() - startedAt)
+  });
+  retireChildBlocking(childConversationId);
+}
+
+// src/agent-runtime/children-spawn.ts
+import { randomUUID } from "node:crypto";
+async function grantedBudget(state, request) {
+  const requestedBudget = AgentChildBudgetSchema.parse(request.budget);
+  const remaining = state.config.remainingBudget ? AgentChildBudgetSchema.parse(await state.config.remainingBudget(request.parentConversationId)) : undefined;
+  const bounded2 = (requested, available) => {
+    if (requested === undefined)
+      return available;
+    if (available === undefined)
+      return requested;
+    return Math.min(requested, available);
+  };
+  const usd = bounded2(requestedBudget.usd, remaining?.usd);
+  const tokens = bounded2(requestedBudget.tokens, remaining?.tokens);
+  const milliseconds = bounded2(requestedBudget.milliseconds, remaining?.milliseconds);
+  return AgentChildBudgetSchema.parse({
+    ...usd !== undefined && { usd },
+    ...tokens !== undefined && { tokens },
+    ...milliseconds !== undefined && { milliseconds }
+  });
+}
+async function readSeedEvents(state, request) {
+  const events = [];
+  let cursor = 1;
+  for (;; ) {
+    const page = await state.store.readEvents({
+      conversationId: request.parentConversationId,
+      fromSeq: cursor,
+      ...request.seedUptoSeq !== undefined && { toSeq: request.seedUptoSeq },
+      limit: 1000
+    });
+    events.push(...page.items);
+    if (page.nextSeq === undefined)
+      break;
+    cursor = page.nextSeq;
+  }
+  return events;
+}
+async function persistSpawn(state, record, handle) {
+  const { childConversationId, createdAt } = record;
+  try {
+    await state.config.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_children (
+            parent_conversation_id, child_conversation_id, seed_upto_seq, state,
+            budget_payload, usage_payload, result_reference, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)
+        `).run(record.parentConversationId, record.childConversationId, record.seedUptoSeq, record.state, JSON.stringify(record.budget), JSON.stringify(record.usage), createdAt, createdAt);
+      await scope.appendEvent({
+        conversationId: record.parentConversationId,
+        kind: "child/spawned",
+        occurredAt: createdAt,
+        payload: {
+          childConversationId,
+          seedUptoSeq: record.seedUptoSeq,
+          budget: record.budget
+        }
+      });
+    });
+    await updateState(state, record, "running");
+  } catch (cause) {
+    try {
+      await handle.stopPolicy("spawn-persistence-failed");
+    } catch (cleanup) {
+      throw new AggregateError([cause, cleanup], "Child persistence and stop both failed");
+    }
+    try {
+      if (isLive(state, childConversationId))
+        await updateState(state, record, "lost", undefined, {
+          reason: "spawn-persistence-failed"
+        });
+    } catch (cleanup) {
+      throw new AggregateError([cause, cleanup], "Child stopped but persistence reconciliation failed");
+    }
+    throw cause;
+  }
+}
+function watchSettlement(state, record, handle, retireChildBlocking) {
+  const { childConversationId } = record;
+  state.handles.set(childConversationId, handle);
+  const settlement = handle.result.then(async (result) => {
+    state.handles.delete(childConversationId);
+    retireChildBlocking(childConversationId);
+    if (settleable(state, childConversationId)) {
+      await updateState(state, record, "finished", result.resultReference);
+    }
+  }, async () => {
+    state.handles.delete(childConversationId);
+    retireChildBlocking(childConversationId);
+    if (settleable(state, childConversationId))
+      await updateState(state, record, "stopped");
+  });
+  state.settlements.set(childConversationId, settlement);
+  settlement.catch(() => {
+    return;
+  });
+}
+async function spawnChild(state, retireChildBlocking, request) {
+  const budget = await grantedBudget(state, request);
+  const events = await readSeedEvents(state, request);
+  const seedUptoSeq = events.at(-1)?.seq ?? 0;
+  const childConversationId = request.childConversationId ?? randomUUID();
+  const createdAt = state.now().toISOString();
+  const record = AgentChildRecordSchema.parse({
+    parentConversationId: request.parentConversationId,
+    childConversationId,
+    seedUptoSeq,
+    state: "spawned",
+    budget,
+    usage: { tokens: 0, usd: 0, milliseconds: 0 },
+    createdAt,
+    updatedAt: createdAt
+  });
+  const seedArchive = encodeAgentConversationArchive({
+    format: "stitchkit.agent-conversation",
+    formatVersion: 1,
+    conversationId: request.parentConversationId,
+    events,
+    projections: [],
+    spills: []
+  });
+  const handle = await state.config.spawn({
+    parentConversationId: record.parentConversationId,
+    childConversationId,
+    seedArchive,
+    childInput: request.childInput,
+    budget
+  });
+  handle.result.catch(() => {
+    return;
+  });
+  await persistSpawn(state, record, handle);
+  watchSettlement(state, record, handle, retireChildBlocking);
+  return { ...record, state: "running", updatedAt: state.now().toISOString() };
+}
+
+// src/agent-runtime/children-usage.ts
+async function recordStepUsage(state, request) {
+  const { database, handles, now } = state;
+  const raw = database.prepare(`
+      SELECT parent_conversation_id, child_conversation_id, seed_upto_seq, state,
+        budget_payload, usage_payload, result_reference, created_at, updated_at
+      FROM stitchkit_agent_runtime_children WHERE child_conversation_id = ?
+    `).get(request.childConversationId);
+  if (raw === null || raw === undefined)
+    throw new TypeError("Unknown child conversation");
+  const record = parseChild(raw);
+  const measured = usageNumbers(request.usage);
+  if (record.budget.tokens !== undefined && measured.tokens === undefined) {
+    throw new TypeError("Cannot enforce child token budget without measured token usage");
+  }
+  if (record.budget.usd !== undefined && measured.usd === undefined) {
+    throw new TypeError("Cannot enforce child USD budget without USD usage");
+  }
+  const usage = {
+    tokens: record.usage.tokens + (measured.tokens ?? 0),
+    usd: record.usage.usd + (measured.usd ?? 0),
+    milliseconds: record.usage.milliseconds + request.elapsedMs
+  };
+  const updatedAt = now().toISOString();
+  const overrun = {
+    tokens: Math.max(0, usage.tokens - (record.budget.tokens ?? Number.POSITIVE_INFINITY)),
+    usd: Math.max(0, usage.usd - (record.budget.usd ?? Number.POSITIVE_INFINITY)),
+    milliseconds: Math.max(0, usage.milliseconds - (record.budget.milliseconds ?? Number.POSITIVE_INFINITY))
+  };
+  const stop = record.budget.tokens !== undefined && usage.tokens >= record.budget.tokens || record.budget.usd !== undefined && usage.usd >= record.budget.usd || record.budget.milliseconds !== undefined && usage.milliseconds >= record.budget.milliseconds;
+  const handle = handles.get(request.childConversationId);
+  let enforced = false;
+  if (stop && handle) {
+    enforced = await bounded(Promise.resolve().then(() => handle.stopPolicy("child-budget")).then(() => true, () => false), false);
+  }
+  const payload = {
+    childConversationId: record.childConversationId,
+    state: "running",
+    usage,
+    overrun,
+    ...stop && { policyName: "child-budget", enforced }
+  };
+  await state.config.sqlite.transaction(async (scope) => {
+    scope.database.prepare("UPDATE stitchkit_agent_runtime_children SET usage_payload = ?, updated_at = ? WHERE child_conversation_id = ?").run(JSON.stringify(usage), updatedAt, request.childConversationId);
+    await scope.appendEvent({
+      conversationId: record.parentConversationId,
+      kind: "child/state",
+      occurredAt: updatedAt,
+      payload
+    });
+    await scope.appendEvent({
+      conversationId: record.childConversationId,
+      kind: "child/state",
+      occurredAt: updatedAt,
+      payload: { parentConversationId: record.parentConversationId, ...payload }
+    });
+  });
+  return { stop, enforced, ...stop && { policyName: "child-budget" }, overrun };
+}
+// src/agent-runtime/child-budget-policy.ts
+function agentChildBudgetStopPolicy(input) {
+  let stepsSeen = 0;
+  let lastBoundary = performance.now();
+  return {
+    name: "child-budget",
+    when: async ({ steps }) => {
+      const step = steps.at(-1);
+      if (!step || steps.length <= stepsSeen)
+        return false;
+      stepsSeen = steps.length;
+      const elapsedMs = Math.max(0, performance.now() - lastBoundary);
+      lastBoundary = performance.now();
+      const usage = normalizeSdkUsage(step.usage);
+      const cost = input.cost?.({ usage: step.usage });
+      const boundary = await input.manager.recordStepUsage({
+        childConversationId: input.childConversationId,
+        usage: { ...usage, ...cost && { cost } },
+        elapsedMs
+      });
+      return boundary.stop;
+    }
+  };
+}
+
+// src/agent-runtime/children.ts
+function createSqliteAgentChildManager(input) {
+  const state = createChildManagerState(input);
+  const list = (parentConversationId) => listChildren(state, parentConversationId);
+  const { retireChildBlocking, listChildBlocking, respondToChildBlocking } = createChildBlockingRelay({
+    store: state.store,
+    now: state.now,
+    handles: state.handles,
+    listChildren: list,
+    activeChild: (parentConversationId, childConversationId) => activeChild(state, parentConversationId, childConversationId),
+    bounded
+  });
+  return {
+    spawnChild: (request) => spawnChild(state, retireChildBlocking, request),
+    listChildren: list,
+    recordStepUsage: (request) => recordStepUsage(state, request),
+    stopChildren: (parentConversationId) => stopChildren(state, retireChildBlocking, parentConversationId),
+    sendMessage: (parentConversationId, childConversationId, message) => sendMessage(state, parentConversationId, childConversationId, message),
+    interruptChild: (parentConversationId, childConversationId) => interruptChild(state, retireChildBlocking, parentConversationId, childConversationId),
+    waitChild: async (childConversationId) => {
+      await state.settlements.get(childConversationId);
+    },
+    listChildBlocking,
+    respondToChildBlocking
+  };
+}
+
+// src/agent-runtime/child-tools.ts
+function childTool(manager, fork) {
+  return defineAgentTool({
+    name: fork ? "subagent_fork" : "subagent",
+    description: fork ? "Run a child conversation seeded from the parent through one exact event sequence." : "Run a child conversation seeded from the current durable parent history.",
+    identity: {
+      serviceName: "agent-children",
+      action: fork ? "fork" : "spawn",
+      method: "POST"
+    },
+    input: z2.object({
+      parentConversationId: z2.string().min(1),
+      childInput: z2.json(),
+      budget: AgentChildBudgetSchema,
+      seedUptoSeq: z2.int().positive().optional()
+    }).strict(),
+    output: z2.object({
+      childConversationId: z2.string(),
+      state: z2.string(),
+      resultReference: z2.string().optional()
+    }),
+    transports: ["AGENT"],
+    handler: async ({ input }) => {
+      if (fork && input.seedUptoSeq === undefined) {
+        throw new TypeError("subagent_fork requires seedUptoSeq");
+      }
+      const child = await manager.spawnChild({
+        parentConversationId: input.parentConversationId,
+        childInput: input.childInput,
+        budget: input.budget,
+        ...input.seedUptoSeq !== undefined && { seedUptoSeq: input.seedUptoSeq }
+      });
+      await manager.waitChild(child.childConversationId);
+      const finished = manager.listChildren(input.parentConversationId).find((record) => record.childConversationId === child.childConversationId);
+      if (!finished)
+        throw new Error("Child record disappeared after settlement");
+      return {
+        childConversationId: finished.childConversationId,
+        state: finished.state,
+        ...finished.resultReference && { resultReference: finished.resultReference }
+      };
+    }
+  });
+}
+function createAgentChildTools(manager) {
+  return [
+    childTool(manager, false),
+    childTool(manager, true),
+    defineAgentTool({
+      name: "list_agents",
+      description: "List the durable child graph for one parent conversation.",
+      identity: { serviceName: "agent-children", action: "list", method: "GET" },
+      input: z2.object({ parentConversationId: z2.string().min(1) }).strict(),
+      output: z2.object({ children: z2.array(AgentChildRecordSchema) }),
+      transports: ["AGENT"],
+      handler: ({ input }) => ({
+        children: [...manager.listChildren(input.parentConversationId)]
+      })
+    }),
+    defineAgentTool({
+      name: "send_message",
+      description: "Send one follow-up input to an active child conversation.",
+      identity: { serviceName: "agent-children", action: "message", method: "POST" },
+      input: z2.object({
+        parentConversationId: z2.string().min(1),
+        childConversationId: z2.string().min(1),
+        input: z2.json()
+      }).strict(),
+      output: z2.object({ sent: z2.literal(true) }),
+      transports: ["AGENT"],
+      handler: async ({ input }) => {
+        await manager.sendMessage(input.parentConversationId, input.childConversationId, input.input);
+        return { sent: true };
+      }
+    }),
+    defineAgentTool({
+      name: "interrupt_agent",
+      description: "Stop one active child conversation at a durable policy boundary.",
+      identity: { serviceName: "agent-children", action: "interrupt", method: "POST" },
+      input: z2.object({
+        parentConversationId: z2.string().min(1),
+        childConversationId: z2.string().min(1)
+      }).strict(),
+      output: z2.object({ interrupted: z2.literal(true) }),
+      transports: ["AGENT"],
+      handler: async ({ input }) => {
+        await manager.interruptChild(input.parentConversationId, input.childConversationId);
+        return { interrupted: true };
+      }
+    })
+  ];
+}
+// src/agent-runtime/compaction.ts
+function groupProviderTurns(messages, evidencePolicy) {
+  const turns = [];
+  let current = [];
+  for (const message of messages) {
+    if (message.role === "user" && current.length > 0) {
+      turns.push({
+        messages: current,
+        complete: isCompleteAgentHistoryTurn(current, evidencePolicy)
+      });
+      current = [];
+    }
+    current.push(message);
+  }
+  if (current.length > 0) {
+    turns.push({
+      messages: current,
+      complete: isCompleteAgentHistoryTurn(current, evidencePolicy)
+    });
+  }
+  return turns;
+}
+function selectCompactableHistory(options) {
+  if (!Number.isSafeInteger(options.keepRecentTurns) || options.keepRecentTurns < 0) {
+    throw new TypeError("keepRecentTurns must be a non-negative safe integer");
+  }
+  const leadingSummary = options.messages[0]?.role === "summary" ? options.messages[0] : undefined;
+  const rest = leadingSummary ? options.messages.slice(1) : options.messages;
+  const turns = groupProviderTurns(rest, options.evidencePolicy);
+  const firstIncomplete = turns.findIndex((turn) => !turn.complete);
+  const completeTurns = firstIncomplete === -1 ? turns : turns.slice(0, firstIncomplete);
+  const eligibleCount = Math.max(0, completeTurns.length - options.keepRecentTurns);
+  const compactable = completeTurns.slice(0, eligibleCount).flatMap((turn) => turn.messages);
+  return {
+    ...leadingSummary !== undefined && { leadingSummary },
+    compactable,
+    retained: rest.slice(compactable.length)
+  };
+}
+function mutationSnapshot(result, fallback, attempts) {
+  if (result.outcome === "applied" || result.outcome === "duplicate") {
+    return { outcome: "applied", snapshot: result.snapshot, attempts };
+  }
+  return { outcome: result.outcome, snapshot: fallback, attempts };
+}
+function structuredCompaction(config) {
+  if (!Number.isSafeInteger(config.keepRecentTurns) || config.keepRecentTurns < 1) {
+    throw new TypeError("keepRecentTurns must be a positive safe integer");
+  }
+  const maxAttempts = config.maxAttempts ?? 1;
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new TypeError("maxAttempts must be a positive safe integer");
+  }
+  return async (input) => {
+    let lastSnapshot = await input.store.loadSnapshot(input.conversationId);
+    for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+      const snapshot = attempt === 1 ? lastSnapshot : await input.store.loadSnapshot(input.conversationId);
+      lastSnapshot = snapshot;
+      if (!await config.threshold(snapshot)) {
+        return { outcome: "not_needed", snapshot, attempts: attempt };
+      }
+      const { leadingSummary, compactable: eligibleMessages } = selectCompactableHistory({
+        messages: snapshot.messages,
+        keepRecentTurns: config.keepRecentTurns,
+        ...config.evidencePolicy !== undefined && { evidencePolicy: config.evidencePolicy }
+      });
+      if (eligibleMessages.length === 0) {
+        return { outcome: "nothing_eligible", snapshot, attempts: attempt };
+      }
+      const previousSummary = leadingSummary && config.readPreviousSummary ? config.schema.parse(config.readPreviousSummary(leadingSummary)) : attempt === 1 ? input.previousSummary : undefined;
+      const rawSummary = await config.summarize({
+        conversationId: input.conversationId,
+        snapshot,
+        eligibleMessages,
+        ...previousSummary !== undefined && { previousSummary },
+        signal: input.signal
+      });
+      const summary = config.schema.parse(rawSummary);
+      if (input.signal.aborted)
+        throw input.signal.reason;
+      const summaryMessage = config.createSummaryMessage({
+        conversationId: input.conversationId,
+        summary,
+        compactedMessages: eligibleMessages
+      });
+      if (summaryMessage.role !== "summary" || summaryMessage.status !== "committed") {
+        throw new TypeError("Compaction summary must be one committed summary message");
+      }
+      const applied = await input.store.replaceCompactedRange({
+        conversationId: input.conversationId,
+        expectedVersion: snapshot.version,
+        replacedMessageIds: [
+          ...leadingSummary ? [leadingSummary.id] : [],
+          ...eligibleMessages.map((message) => message.id)
+        ],
+        summary: summaryMessage
+      });
+      if (applied.outcome !== "conflict" || attempt === maxAttempts) {
+        return mutationSnapshot(applied, snapshot, attempt);
+      }
+    }
+    return { outcome: "conflict", snapshot: lastSnapshot, attempts: maxAttempts };
+  };
+}
+// src/agent-runtime/deferred-tool-types.ts
+import { z as z3 } from "zod";
+var DeferredAgentToolSearchInputSchema = z3.object({
+  query: z3.string().min(1).describe("An exact tool name, or words describing the tool. Matched as one phrase first, then word by word."),
+  reason: z3.enum(["inactive_call"]).optional()
+});
+var DeferredAgentToolMatchSchema = z3.object({
+  name: z3.string(),
+  description: z3.string()
+});
+var DeferredAgentToolReceiptSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  kind: z3.literal("stitchkit.deferred-tool-selection"),
+  status: z3.enum(["SELECTED", "SEARCH_REQUIRED", "NO_MATCH", "SELECTION_REFUSED"]),
+  runId: z3.string(),
+  surfaceKey: z3.string(),
+  selected: z3.array(z3.string()),
+  matches: z3.array(DeferredAgentToolMatchSchema),
+  truncated: z3.boolean()
+}).superRefine((receipt, context) => {
+  const selected = receipt.status === "SELECTED" || receipt.status === "SEARCH_REQUIRED";
+  if (selected !== receipt.selected.length > 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["selected"],
+      message: `${receipt.status} receipt has inconsistent selected tools`
+    });
+  }
+});
+
+// src/agent-runtime/deferred-tool-selection.ts
+var encoder = new TextEncoder;
+function utf8Bytes(value) {
+  return encoder.encode(typeof value === "string" ? value : JSON.stringify(value)).byteLength;
+}
+function positive(name, value) {
+  if (!Number.isInteger(value) || value <= 0)
+    throw new Error(`${name} must be a positive integer`);
+}
+function uniqueKnown(names, surface) {
+  const seen = new Set;
+  let rejected = 0;
+  for (const name of names) {
+    if (seen.has(name) || !surface.byName.has(name)) {
+      rejected += 1;
+      continue;
+    }
+    seen.add(name);
+  }
+  return { names: [...seen], rejected };
+}
+function schemaBytes(names, surface) {
+  let bytes = 0;
+  for (const name of names) {
+    const entry = name === surface.searchEntry.name ? surface.searchEntry : surface.byName.get(name);
+    if (entry)
+      bytes += utf8Bytes(entry);
+  }
+  return bytes;
+}
+function ranked(query, manifest) {
+  const phrase = rankedByPhrase(query, manifest);
+  return phrase.length > 0 ? phrase : rankedByWords(query, manifest);
+}
+function rankedByWords(query, manifest) {
+  const words = [
+    ...new Set(query.trim().toLocaleLowerCase().split(/\s+/u).filter((word) => word.length > 0))
+  ];
+  if (words.length < 2)
+    return [];
+  return manifest.map((entry, order) => {
+    const haystack = `${entry.name} ${entry.description}`.toLocaleLowerCase();
+    const hits = words.filter((word) => haystack.includes(word)).length;
+    return { name: entry.name, order, hits };
+  }).filter((entry) => entry.hits > 0).sort((left, right) => right.hits - left.hits || left.order - right.order).map((entry) => entry.name);
+}
+function rankedByPhrase(query, manifest) {
+  const needle = query.trim().toLocaleLowerCase();
+  return manifest.map((entry, order) => {
+    const name = entry.name.toLocaleLowerCase();
+    const description = entry.description.toLocaleLowerCase();
+    const score = name === needle ? 0 : name.startsWith(needle) ? 1 : name.split(/[_-]/u).some((token) => token.startsWith(needle)) ? 2 : name.includes(needle) ? 3 : description.includes(needle) ? 4 : 5;
+    return { name: entry.name, order, score };
+  }).filter((entry) => entry.score < 5).sort((left, right) => left.score - right.score || left.order - right.order).map((entry) => entry.name);
+}
+function latestSelection(messages, searchName, runId, surface, maxSelectedTools) {
+  let selected = [];
+  let found = false;
+  for (const message of messages) {
+    if (message.role !== "tool" || typeof message.content === "string")
+      continue;
+    const replacement = [];
+    let validReceipts = 0;
+    for (const part of message.content) {
+      if (part.type !== "tool-result" || part.toolName !== searchName)
+        continue;
+      if (part.output.type !== "json")
+        continue;
+      const parsed = DeferredAgentToolReceiptSchema.safeParse(part.output.value);
+      if (!parsed.success || parsed.data.runId !== runId || parsed.data.surfaceKey !== surface.key)
+        continue;
+      const known = uniqueKnown(parsed.data.selected, surface);
+      if (known.rejected > 0 || known.names.length !== parsed.data.selected.length)
+        continue;
+      replacement.push(...known.names);
+      validReceipts += 1;
+    }
+    if (validReceipts > 0) {
+      const merged = uniqueKnown(replacement, surface).names;
+      if (merged.length > maxSelectedTools)
+        continue;
+      selected = merged;
+      found = true;
+    }
+  }
+  return { selected, source: found ? "durable" : "catalog" };
+}
+
+// src/agent-runtime/deferred-tool-search.ts
+var description = "Search the available tool catalog and select exact tools for the next step. " + "The query is matched as one phrase against tool names and descriptions; " + "if nothing matches the phrase, its individual words are matched and the " + "tools matching the most words rank first. An exact tool name always wins, " + "so prefer one when you know it.";
+function placeholderDeferredSearch(name) {
+  return defineRuntimeTool({
+    name,
+    description,
+    identity: { serviceName: "agent-runtime", action: "deferred-tool-search", method: "POST" },
+    input: DeferredAgentToolSearchInputSchema,
+    output: DeferredAgentToolReceiptSchema,
+    transports: ["AGENT"],
+    handler: () => ({
+      schemaVersion: 1,
+      kind: "stitchkit.deferred-tool-selection",
+      status: "NO_MATCH",
+      runId: "construction",
+      surfaceKey: "construction",
+      selected: [],
+      matches: [],
+      truncated: false
+    })
+  });
+}
+function createDeferredSearchTool(config, runContext, surface) {
+  return defineRuntimeTool({
+    name: config.search.name,
+    description,
+    identity: { serviceName: "agent-runtime", action: "deferred-tool-search", method: "POST" },
+    input: DeferredAgentToolSearchInputSchema,
+    output: DeferredAgentToolReceiptSchema,
+    transports: ["AGENT"],
+    handler: async ({ input }) => {
+      const queryOversized = utf8Bytes(input.query) > config.search.maxQueryBytes;
+      const proposed = queryOversized ? [] : input.reason === "inactive_call" ? [input.query] : config.search.select ? await config.search.select({
+        query: input.query,
+        manifest: surface.manifest,
+        context: runContext.context,
+        runId: runContext.run.id,
+        surfaceKey: surface.key
+      }) : ranked(input.query, surface.manifest);
+      const known = uniqueKnown(proposed, surface);
+      const selected = known.names.slice(0, config.search.maxResults);
+      const candidateActive = [config.search.name, ...surface.alwaysOn, ...selected];
+      const refused = queryOversized || selected.length > config.activation.maxSelectedTools || candidateActive.length > config.activation.maxActiveTools || schemaBytes(candidateActive, surface) > config.activation.maxSchemaBytes;
+      const admitted = refused ? [] : selected;
+      const matches = [];
+      let truncated = known.names.length > selected.length;
+      for (const name of selected) {
+        const entry = surface.byName.get(name);
+        if (!entry)
+          continue;
+        const next = [...matches, { name, description: entry.description }];
+        if (utf8Bytes({
+          schemaVersion: 1,
+          kind: "stitchkit.deferred-tool-selection",
+          status: "SELECTED",
+          runId: runContext.run.id,
+          surfaceKey: surface.key,
+          selected: admitted,
+          matches: next,
+          truncated
+        }) > config.search.maxResultBytes) {
+          truncated = true;
+          break;
+        }
+        matches.push({ name, description: entry.description });
+      }
+      const status = refused ? "SELECTION_REFUSED" : input.reason === "inactive_call" && admitted.length > 0 ? "SEARCH_REQUIRED" : admitted.length > 0 ? "SELECTED" : "NO_MATCH";
+      let receipt = {
+        schemaVersion: 1,
+        kind: "stitchkit.deferred-tool-selection",
+        status,
+        runId: runContext.run.id,
+        surfaceKey: surface.key,
+        selected: admitted,
+        matches,
+        truncated
+      };
+      if (utf8Bytes(receipt) > config.search.maxResultBytes) {
+        receipt = {
+          schemaVersion: 1,
+          kind: "stitchkit.deferred-tool-selection",
+          status: "SELECTION_REFUSED",
+          runId: runContext.run.id,
+          surfaceKey: surface.key,
+          selected: [],
+          matches: [],
+          truncated: true
+        };
+      }
+      if (utf8Bytes(receipt) > config.search.maxResultBytes) {
+        throw new AgentContextOverflowError("Deferred Agent search receipt exceeds its byte ceiling");
+      }
+      config.observe?.({
+        schemaVersion: 1,
+        type: "search",
+        runId: runContext.run.id,
+        surfaceKey: surface.key,
+        catalogTools: surface.manifest.length,
+        baseTools: surface.alwaysOn.length + 1,
+        pinnedTools: 0,
+        selectedTools: receipt.selected.length,
+        activeTools: surface.alwaysOn.length + receipt.selected.length + 1,
+        activeSchemaBytes: schemaBytes([config.search.name, ...surface.alwaysOn, ...receipt.selected], surface),
+        rejectedNames: known.rejected,
+        replacementTools: receipt.selected.length,
+        source: "current"
+      });
+      return receipt;
+    }
+  });
+}
+
+// src/agent-runtime/deferred-tools.ts
+function configuredSurfaces(config) {
+  return "surfaces" in config ? config.surfaces : { default: config };
+}
+function resolveSurface(config, surfaces, runContext) {
+  const key = "surfaces" in config ? config.selectSurface(runContext) : "default";
+  const surface = surfaces.get(key);
+  if (!surface)
+    throw new Error(`Unknown deferred Agent tool surface "${key}"`);
+  return surface;
+}
+function resolveAllSurfaces(config) {
+  const placeholderSearch = placeholderDeferredSearch(config.search.name);
+  const surfaces = new Map;
+  for (const [key, definition] of Object.entries(configuredSurfaces(config))) {
+    const runtimeTools = executableAgentRuntimeTools(definition.runtimeTools ?? []);
+    const fullManifest = buildToolManifest({
+      ...definition,
+      runtimeTools: [...runtimeTools, placeholderSearch],
+      transport: "AGENT"
+    });
+    const searchEntry = fullManifest.find((entry) => entry.name === config.search.name);
+    if (!searchEntry)
+      throw new Error(`Search tool "${config.search.name}" is not Agent-exposed`);
+    const manifest = fullManifest.filter((entry) => entry.name !== config.search.name);
+    const byName = new Map(manifest.map((entry) => [entry.name, entry]));
+    const provisional = {
+      key,
+      definition,
+      manifest,
+      byName,
+      searchEntry,
+      alwaysOn: []
+    };
+    const alwaysOn = uniqueKnown(definition.alwaysOn ?? [], provisional);
+    if (alwaysOn.rejected > 0)
+      throw new Error(`Surface "${key}" has an unknown or duplicate alwaysOn tool`);
+    surfaces.set(key, { ...provisional, alwaysOn: alwaysOn.names });
+  }
+  if (surfaces.size === 0)
+    throw new Error("Deferred Agent tool surface registry must not be empty");
+  return surfaces;
+}
+function assertConstructionBudgets(config, surfaces) {
+  for (const surface of surfaces.values()) {
+    const base = [...surface.alwaysOn, config.search.name];
+    if (base.length > config.activation.maxActiveTools) {
+      throw new Error(`Surface "${surface.key}" base tools exceed maxActiveTools`);
+    }
+    if (schemaBytes(base, surface) > config.activation.maxSchemaBytes) {
+      throw new Error(`Surface "${surface.key}" base tools exceed maxSchemaBytes`);
+    }
+  }
+  const minimumReceipt = {
+    schemaVersion: 1,
+    kind: "stitchkit.deferred-tool-selection",
+    status: "NO_MATCH",
+    runId: "run",
+    surfaceKey: "surface",
+    selected: [],
+    matches: [],
+    truncated: false
+  };
+  if (config.search.maxResultBytes < utf8Bytes(minimumReceipt)) {
+    throw new Error("search.maxResultBytes cannot contain the minimum search receipt");
+  }
+}
+function assertActiveBudget(config, names, surface) {
+  if (names.length > config.activation.maxActiveTools) {
+    throw new AgentContextOverflowError("Deferred Agent active-tool ceiling exceeded");
+  }
+  const bytes = schemaBytes(names, surface);
+  if (bytes > config.activation.maxSchemaBytes) {
+    throw new AgentContextOverflowError("Deferred Agent schema-byte ceiling exceeded");
+  }
+  return bytes;
+}
+function createDeferredAgentToolSurface(config) {
+  positive("search.maxQueryBytes", config.search.maxQueryBytes);
+  positive("search.maxResults", config.search.maxResults);
+  positive("search.maxResultBytes", config.search.maxResultBytes);
+  positive("activation.maxSelectedTools", config.activation.maxSelectedTools);
+  positive("activation.maxActiveTools", config.activation.maxActiveTools);
+  positive("activation.maxSchemaBytes", config.activation.maxSchemaBytes);
+  const surfaces = resolveAllSurfaces(config);
+  assertConstructionBudgets(config, surfaces);
+  return {
+    mount(runContext, mountConfig = {}) {
+      const surface = resolveSurface(config, surfaces, runContext);
+      const runtimeTools = [
+        ...executableAgentRuntimeTools(surface.definition.runtimeTools ?? []),
+        createDeferredSearchTool(config, runContext, surface)
+      ];
+      const tools = mountAgent([...surface.definition.services ?? []], {
+        ...mountConfig,
+        runtimeTools
+      });
+      registerDeferredToolCatalog(tools, config.search.name, new Set(surface.byName.keys()));
+      return tools;
+    },
+    prepareStep(applicationPrepareStep) {
+      const prepared = async (input) => {
+        const application = await applicationPrepareStep?.(input);
+        const surface = resolveSurface(config, surfaces, input);
+        const selection = latestSelection(input.messages, config.search.name, input.run.id, surface, config.activation.maxSelectedTools);
+        const currentSelection = latestSelection(input.responseMessages, config.search.name, input.run.id, surface, config.activation.maxSelectedTools);
+        const pins = uniqueKnown(config.pins?.(input) ?? [], surface);
+        if (pins.rejected > 0) {
+          throw new AgentContextOverflowError("Deferred Agent pins contain unknown or duplicate tools");
+        }
+        const selected = uniqueKnown(selection.selected, surface);
+        const names = uniqueKnown([config.search.name, ...surface.alwaysOn, ...pins.names, ...selected.names], surface).names;
+        if (!names.includes(config.search.name))
+          names.unshift(config.search.name);
+        const bytes = assertActiveBudget(config, names, surface);
+        config.observe?.({
+          schemaVersion: 1,
+          type: "step",
+          runId: input.run.id,
+          surfaceKey: surface.key,
+          catalogTools: surface.manifest.length,
+          baseTools: surface.alwaysOn.length + 1,
+          pinnedTools: pins.names.length,
+          selectedTools: selected.names.length,
+          activeTools: names.length,
+          activeSchemaBytes: bytes,
+          rejectedNames: selected.rejected,
+          replacementTools: selected.names.length,
+          source: currentSelection.source === "durable" ? "current" : selection.source
+        });
+        return { ...application, activeTools: names };
+      };
+      const repair = async ({ toolCall, tools, error }) => {
+        const catalog = deferredToolCatalog(tools, config.search.name);
+        if (!("toolName" in error) || !catalog?.has(toolCall.toolName) || toolCall.toolName in tools) {
+          return null;
+        }
+        return repairedSearchCall(toolCall, config.search.name);
+      };
+      registerDeferredToolRepair(prepared, repair);
+      return prepared;
+    }
+  };
+}
+// src/agent-runtime/event-search.ts
+import { z as z4 } from "zod";
+var AgentEventSearchResultSchema = z4.object({
+  conversationId: z4.string().min(1),
+  seq: z4.int().positive(),
+  occurredAt: z4.string(),
+  snippet: z4.string()
+}).strict();
+var SearchRowSchema = z4.object({
+  conversation_id: z4.string(),
+  event_seq: z4.int().positive(),
+  occurred_at: z4.string(),
+  snippet: z4.string()
+});
+function literalFtsQuery(query) {
+  const terms = query.split(/\s+/u).filter((term) => /[\p{L}\p{N}]/u.test(term));
+  if (terms.length === 0)
+    throw new TypeError("Event search query must contain searchable terms");
+  return terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" AND ");
+}
+function createSqliteAgentEventSearch(input) {
+  return async (request) => {
+    if (request.query.trim().length === 0)
+      throw new TypeError("Event search query must not be empty");
+    const limit = Math.min(request.limit ?? 20, 200);
+    const target = request.conversationId ?? (input.authorizeConversation ? undefined : request.requestingConversationId);
+    const values = [literalFtsQuery(request.query)];
+    const targetClause = target ? "AND f.conversation_id = ?" : "";
+    if (target)
+      values.push(target);
+    const sinceClause = request.since ? "AND f.occurred_at >= ?" : "";
+    if (request.since)
+      values.push(z4.iso.datetime({ offset: true }).parse(request.since));
+    const page = limit * 4;
+    const candidatesFrom = (offset2) => input.database.prepare(`
+          SELECT f.conversation_id, f.event_seq, f.occurred_at,
+            snippet(stitchkit_agent_runtime_events_fts, 3, '[', ']', ' … ', 24) AS snippet
+          FROM stitchkit_agent_runtime_events_fts AS f
+          WHERE stitchkit_agent_runtime_events_fts MATCH ? ${targetClause} ${sinceClause}
+          ORDER BY bm25(stitchkit_agent_runtime_events_fts), f.occurred_at DESC, f.rowid
+          LIMIT ? OFFSET ?
+        `).all(...values, page, offset2).map((row) => SearchRowSchema.parse(row));
+    const authorization = new Map;
+    const results = [];
+    let offset = 0;
+    let candidates = candidatesFrom(offset);
+    while (candidates.length > 0 && results.length < limit) {
+      for (const row of candidates) {
+        if (row.conversation_id !== request.requestingConversationId) {
+          let allowed = authorization.get(row.conversation_id);
+          if (allowed === undefined) {
+            allowed = input.authorizeConversation ? await input.authorizeConversation({
+              requestingConversationId: request.requestingConversationId,
+              targetConversationId: row.conversation_id
+            }) : false;
+            authorization.set(row.conversation_id, allowed);
+          }
+          if (!allowed)
+            continue;
+        }
+        results.push(AgentEventSearchResultSchema.parse({
+          conversationId: row.conversation_id,
+          seq: row.event_seq,
+          occurredAt: row.occurred_at,
+          snippet: row.snippet
+        }));
+        if (results.length === limit)
+          break;
+      }
+      offset += page;
+      candidates = results.length < limit ? candidatesFrom(offset) : [];
+    }
+    return results;
+  };
+}
+// src/agent-runtime/event-search-tools.ts
+import { z as z5 } from "zod";
+function createAgentEventSearchTools(input) {
+  const EventAddressSchema = z5.object({ conversationId: z5.string(), seq: z5.int().positive() }).strict();
+  const EventOutputSchema = z5.object({
+    conversationId: z5.string(),
+    seq: z5.int().positive(),
+    kind: z5.string(),
+    occurredAt: z5.string(),
+    payload: z5.json()
+  }).strict();
+  const readExact = async (address) => {
+    if (address.conversationId !== input.conversationId) {
+      const allowed = await input.authorizeConversation?.({
+        requestingConversationId: input.conversationId,
+        targetConversationId: address.conversationId
+      });
+      if (!allowed)
+        throw new TypeError("Event address is outside the authorized conversation");
+    }
+    const page = await input.store.readEvents({
+      conversationId: address.conversationId,
+      fromSeq: address.seq,
+      toSeq: address.seq,
+      limit: 1
+    });
+    const event = page.items[0];
+    if (!event || event.seq !== address.seq)
+      throw new TypeError("Unknown event address");
+    return {
+      conversationId: event.conversationId,
+      seq: event.seq,
+      kind: event.kind,
+      occurredAt: event.occurredAt,
+      payload: event.payload
+    };
+  };
+  return [
+    defineAgentTool({
+      name: "session_search",
+      description: "Search authorized durable conversation events and return exact addresses.",
+      identity: { serviceName: "agent-events", action: "search", method: "POST" },
+      input: z5.object({
+        query: z5.string().min(1),
+        conversationId: z5.string().min(1).optional(),
+        since: z5.iso.datetime({ offset: true }).optional(),
+        limit: z5.int().positive().max(200).optional()
+      }).strict(),
+      output: z5.object({ results: z5.array(AgentEventSearchResultSchema) }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => ({
+        results: [
+          ...await input.search({
+            requestingConversationId: input.conversationId,
+            ...request
+          })
+        ]
+      })
+    }),
+    defineAgentTool({
+      name: "session_trace",
+      description: "Read a bounded contiguous slice of this conversation event trace.",
+      identity: { serviceName: "agent-events", action: "trace", method: "GET" },
+      input: z5.object({
+        fromSeq: z5.int().positive().optional(),
+        toSeq: z5.int().positive().optional(),
+        limit: z5.int().positive().max(1000).default(100)
+      }).strict(),
+      output: z5.object({ events: z5.array(EventOutputSchema), nextSeq: z5.number().optional() }),
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        const page = await input.store.readEvents({
+          conversationId: input.conversationId,
+          ...request
+        });
+        return {
+          events: page.items.map((event) => ({
+            conversationId: event.conversationId,
+            seq: event.seq,
+            kind: event.kind,
+            occurredAt: event.occurredAt,
+            payload: event.payload
+          })),
+          ...page.nextSeq !== undefined && { nextSeq: page.nextSeq }
+        };
+      }
+    }),
+    defineAgentTool({
+      name: "session_event",
+      description: "Read one durable event by exact conversation and sequence address.",
+      identity: { serviceName: "agent-events", action: "read", method: "GET" },
+      input: EventAddressSchema,
+      output: EventOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input: request }) => readExact(request)
+    })
+  ];
+}
+// src/agent-runtime/observability.ts
+import { z as z6 } from "zod";
+var AgentRunEventBaseSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  eventId: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  traceId: z6.string().min(1),
+  spanId: z6.string().min(1),
+  parentSpanId: z6.string().min(1).optional(),
+  state: AgentRunStateSchema,
+  modelId: z6.string().min(1).optional(),
+  durationMs: z6.number().nonnegative().optional(),
+  emittedAt: AgentTimestampSchema
+});
+var AgentRunStartedEventSchema = AgentRunEventBaseSchema.extend({
+  type: z6.literal("run-started"),
+  queueWaitMs: z6.number().nonnegative().optional()
+});
+var AgentStepFinishedEventSchema = AgentRunEventBaseSchema.extend({
+  type: z6.literal("step-finished"),
+  step: z6.int().nonnegative(),
+  ttftMs: z6.number().nonnegative().optional(),
+  usage: AgentUsageSchema,
+  response: AgentProviderResponseSchema
+});
+var AgentRunTerminalEventSchema = AgentRunEventBaseSchema.extend({
+  type: z6.literal("run-terminal"),
+  terminalReason: AgentTerminalReasonSchema,
+  ttftMs: z6.number().nonnegative().optional(),
+  internalCause: z6.unknown().optional(),
+  usage: AgentUsageSchema
+});
+var AgentRunEventSchema = z6.discriminatedUnion("type", [
+  AgentRunStartedEventSchema,
+  AgentStepFinishedEventSchema,
+  AgentRunTerminalEventSchema
+]);
+function createAgentObservability(config) {
+  const manager = createBoundedSinkManager({
+    write: config.write,
+    ...config.filter && { filter: config.filter },
+    ...config.maxPending !== undefined && { maxPending: config.maxPending },
+    ...config.onSinkError && { onSinkError: config.onSinkError },
+    ...config.onDrop && { onDrop: config.onDrop }
+  });
+  const DEDUPLICATION_WINDOW = 1e4;
+  const emitted = new Set;
+  const ring = new Array(DEDUPLICATION_WINDOW).fill(undefined);
+  let cursor = 0;
+  const remember = (eventId) => {
+    emitted.add(eventId);
+    const evicted = ring[cursor];
+    ring[cursor] = eventId;
+    cursor = (cursor + 1) % DEDUPLICATION_WINDOW;
+    if (evicted !== undefined)
+      emitted.delete(evicted);
+  };
+  return {
+    rootTrace(parent) {
+      const trace = parent ? childSpan(parent) : createTraceContext();
+      return trace;
+    },
+    emit(rawEvent) {
+      const parsed = AgentRunEventSchema.parse(rawEvent);
+      if ((config.deduplicate ?? true) && emitted.has(parsed.eventId))
+        return;
+      remember(parsed.eventId);
+      manager.submit(() => {
+        if (config.includeInternalCause)
+          return parsed;
+        if (parsed.type !== "run-terminal")
+          return parsed;
+        return AgentRunTerminalEventSchema.omit({ internalCause: true }).parse(parsed);
+      });
+    },
+    flush: (bound) => manager.flush(bound),
+    getStatus: () => manager.getStatus(),
+    close: (bound) => manager.close(bound)
+  };
+}
+// src/agent-runtime/projections.ts
+import { z as z7 } from "zod";
+function defineAgentProjection(definition) {
+  if (definition.name.length === 0)
+    throw new TypeError("Projection name must not be empty");
+  if (!Number.isInteger(definition.version) || definition.version < 1) {
+    throw new TypeError("Projection version must be a positive integer");
+  }
+  definition.schema.parse(definition.initial());
+  return definition;
+}
+function createAgentProjectionRegistry(definitions) {
+  const registry = new Map;
+  for (const definition of definitions) {
+    const previous = registry.get(definition.name);
+    if (previous)
+      throw new TypeError(`Duplicate agent projection: ${definition.name}`);
+    registry.set(definition.name, definition);
+  }
+  return registry;
+}
+var ProjectionRowSchema = z7.object({
+  conversation_id: z7.string().optional(),
+  version: z7.int().positive(),
+  upto_seq: z7.int().nonnegative(),
+  payload: z7.string(),
+  updated_at: z7.string()
+});
+function projectionPayload(value) {
+  return JSON.parse(value);
+}
+function createSqliteAgentProjectionStore(input) {
+  const database = input.sqlite.database;
+  const store = input.sqlite.store;
+  const load = (conversationId, definition) => {
+    const raw = database.prepare(`
+        SELECT version, upto_seq, payload, updated_at
+        FROM stitchkit_agent_runtime_projections
+        WHERE conversation_id = ? AND name = ?
+      `).get(conversationId, definition.name);
+    if (raw === null || raw === undefined)
+      return;
+    const row = ProjectionRowSchema.parse(raw);
+    if (row.version !== definition.version)
+      return;
+    return {
+      name: definition.name,
+      version: row.version,
+      uptoSeq: row.upto_seq,
+      updatedAt: row.updated_at,
+      value: definition.schema.parse(projectionPayload(row.payload))
+    };
+  };
+  const advance = async (conversationId, definition) => {
+    const current = load(conversationId, definition);
+    let value = current?.value ?? definition.initial();
+    let uptoSeq = current?.uptoSeq ?? 0;
+    let cursor = uptoSeq + 1;
+    let updatedAt = current?.updatedAt ?? new Date(0).toISOString();
+    for (;; ) {
+      const page = await store.readEvents({
+        conversationId,
+        fromSeq: cursor,
+        limit: 1000
+      });
+      for (const event of page.items) {
+        value = definition.schema.parse(definition.fold(value, event));
+        uptoSeq = event.seq;
+        updatedAt = event.occurredAt;
+      }
+      if (page.nextSeq === undefined)
+        break;
+      cursor = page.nextSeq;
+    }
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_projections
+            (conversation_id, name, version, upto_seq, payload, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT (conversation_id, name) DO UPDATE SET
+            version = excluded.version,
+            upto_seq = excluded.upto_seq,
+            payload = excluded.payload,
+            updated_at = excluded.updated_at
+        `).run(conversationId, definition.name, definition.version, uptoSeq, JSON.stringify(value), updatedAt);
+    });
+    return { name: definition.name, version: definition.version, uptoSeq, updatedAt, value };
+  };
+  const list = (definition) => database.prepare(`
+        SELECT conversation_id, version, upto_seq, payload, updated_at
+        FROM stitchkit_agent_runtime_projections
+        WHERE name = ? AND version = ? ORDER BY updated_at DESC, conversation_id
+      `).all(definition.name, definition.version).map((raw) => {
+    const row = ProjectionRowSchema.parse(raw);
+    if (!row.conversation_id)
+      throw new TypeError("Projection list row has no conversation id");
+    return {
+      conversationId: row.conversation_id,
+      projection: {
+        name: definition.name,
+        version: row.version,
+        uptoSeq: row.upto_seq,
+        updatedAt: row.updated_at,
+        value: definition.schema.parse(projectionPayload(row.payload))
+      }
+    };
+  });
+  return { load, advance, list };
+}
+var ConversationCardSchema = z7.object({
+  eventCount: z7.int().nonnegative(),
+  lastKind: z7.string().optional(),
+  lastOccurredAt: z7.string().optional()
+});
+var agentConversationCardProjection = defineAgentProjection({
+  name: "conversation-card",
+  version: 1,
+  schema: ConversationCardSchema,
+  initial: () => ({ eventCount: 0 }),
+  fold: (state, event) => ({
+    eventCount: state.eventCount + 1,
+    lastKind: event.kind,
+    lastOccurredAt: event.occurredAt
+  })
+});
+var StateSlotsProjectionSchema = z7.record(z7.string(), z7.json());
+var agentStateSlotsProjection = defineAgentProjection({
+  name: "state-slots",
+  version: 1,
+  schema: StateSlotsProjectionSchema,
+  initial: () => ({}),
+  fold: (state, event) => {
+    if (event.kind !== "state/set")
+      return state;
+    const payload = z7.object({ name: z7.string().min(1), value: z7.json() }).passthrough().parse(event.payload);
+    return { ...state, [payload.name]: payload.value };
+  }
+});
+var ScheduleSummarySchema = z7.object({
+  scheduled: z7.int().nonnegative(),
+  fired: z7.int().nonnegative(),
+  cancelled: z7.int().nonnegative(),
+  late: z7.int().nonnegative()
+});
+var agentScheduleSummaryProjection = defineAgentProjection({
+  name: "schedule-summary",
+  version: 1,
+  schema: ScheduleSummarySchema,
+  initial: () => ({ scheduled: 0, fired: 0, cancelled: 0, late: 0 }),
+  fold: (state, event) => {
+    if (event.kind === "schedule/set")
+      return { ...state, scheduled: state.scheduled + 1 };
+    if (event.kind === "schedule/fired")
+      return { ...state, fired: state.fired + 1 };
+    if (event.kind === "schedule/cancelled")
+      return { ...state, cancelled: state.cancelled + 1 };
+    if (event.kind === "schedule/late")
+      return { ...state, late: state.late + 1 };
+    return state;
+  }
+});
+var RuntimeSummarySchema = z7.object({
+  eventCount: z7.int().nonnegative(),
+  lastSeq: z7.int().nonnegative(),
+  lastKind: z7.string().optional(),
+  lastOccurredAt: z7.string().optional(),
+  lastModelId: z7.string().optional()
+}).strict();
+var agentSummaryProjection = defineAgentProjection({
+  name: "summary",
+  version: 1,
+  schema: RuntimeSummarySchema,
+  initial: () => ({ eventCount: 0, lastSeq: 0 }),
+  fold: (state, event) => {
+    const request = event.kind === "provider/request" ? z7.object({ modelId: z7.string().optional() }).passthrough().safeParse(event.payload) : undefined;
+    return {
+      eventCount: state.eventCount + 1,
+      lastSeq: event.seq,
+      lastKind: event.kind,
+      lastOccurredAt: event.occurredAt,
+      ...request?.success && request.data.modelId ? { lastModelId: request.data.modelId } : state.lastModelId ? { lastModelId: state.lastModelId } : {}
+    };
+  }
+});
+var RuntimeUsageSchema = z7.object({
+  inputTokens: z7.number().nonnegative(),
+  outputTokens: z7.number().nonnegative(),
+  cost: z7.number().nonnegative(),
+  sources: z7.array(z7.string())
+}).strict();
+var agentUsageProjection = defineAgentProjection({
+  name: "usage",
+  version: 1,
+  schema: RuntimeUsageSchema,
+  initial: () => ({ inputTokens: 0, outputTokens: 0, cost: 0, sources: [] }),
+  fold: (state, event) => {
+    const parsed = z7.object({
+      inputTokens: z7.number().nonnegative().optional(),
+      outputTokens: z7.number().nonnegative().optional(),
+      cost: z7.number().nonnegative().optional(),
+      source: z7.string().min(1).optional()
+    }).passthrough().safeParse(event.payload);
+    if (!parsed.success)
+      return state;
+    const source = parsed.data.source;
+    return {
+      inputTokens: state.inputTokens + (parsed.data.inputTokens ?? 0),
+      outputTokens: state.outputTokens + (parsed.data.outputTokens ?? 0),
+      cost: state.cost + (parsed.data.cost ?? 0),
+      sources: source && !state.sources.includes(source) ? [...state.sources, source] : state.sources
+    };
+  }
+});
+var RuntimeOutlineSchema = z7.object({
+  requests: z7.array(z7.object({
+    seq: z7.int().positive(),
+    occurredAt: z7.string(),
+    runId: z7.string().optional()
+  }).strict())
+}).strict();
+var agentOutlineProjection = defineAgentProjection({
+  name: "outline",
+  version: 1,
+  schema: RuntimeOutlineSchema,
+  initial: () => ({ requests: [] }),
+  fold: (state, event) => {
+    if (event.kind !== "provider/request")
+      return state;
+    const payload = z7.object({ runId: z7.string().optional() }).passthrough().parse(event.payload);
+    return {
+      requests: [
+        ...state.requests,
+        {
+          seq: event.seq,
+          occurredAt: event.occurredAt,
+          ...payload.runId && { runId: payload.runId }
+        }
+      ]
+    };
+  }
+});
+// src/agent-runtime/protocol.ts
+function hasAgentTerminalOutput(input) {
+  for (const part of input.message.parts) {
+    if (part.type === "text" && part.text.trim().length > 0)
+      return true;
+    if (part.type === "file" || part.type === "provider")
+      return true;
+    if (input.reason === "policy_stop" && (part.type === "tool-call" || part.type === "tool-result")) {
+      return true;
+    }
+  }
+  return false;
+}
+function defineAgentProtocol(config) {
+  const acceptance = config.terminalAcceptance;
+  return {
+    contextSchema: config.context,
+    inputMetadataSchema: config.inputMetadata,
+    parseContext: (input) => config.context.parse(input),
+    parseInputMetadata: (input) => AgentJsonObjectSchema.parse(config.inputMetadata.parse(input)),
+    parseMessage: (input) => AgentMessageSchema.parse(input),
+    parsePart: (input) => AgentMessageSchema.shape.parts.element.parse(input),
+    ...acceptance !== undefined && acceptance !== "allow-empty" && {
+      acceptTerminal: acceptance === "require-output" ? hasAgentTerminalOutput : acceptance
+    }
+  };
+}
+// src/agent-runtime/schedule-tools.ts
+import { z as z8 } from "zod";
+var ScheduledOutputSchema = z8.object({ scheduleId: z8.string(), nextAt: z8.string() }).strict();
+var ConversationInputSchema = z8.object({ conversationId: z8.string().min(1) }).strict();
+function createAgentScheduleTools(service) {
+  const schedule = async (request) => {
+    const result = await service.scheduleInput(request);
+    return { scheduleId: result.id, nextAt: result.nextAt };
+  };
+  return [
+    defineAgentTool({
+      name: "schedule_after",
+      description: "Schedule durable input after a relative delay.",
+      identity: { serviceName: "agent-schedules", action: "after", method: "POST" },
+      input: z8.object({
+        conversationId: z8.string().min(1),
+        input: z8.json(),
+        afterMs: z8.int().positive()
+      }).strict(),
+      output: ScheduledOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input }) => schedule(input)
+    }),
+    defineAgentTool({
+      name: "schedule_at",
+      description: "Schedule durable input at an absolute timestamp with an explicit offset.",
+      identity: { serviceName: "agent-schedules", action: "at", method: "POST" },
+      input: z8.object({ conversationId: z8.string().min(1), input: z8.json(), at: z8.string().min(1) }).strict(),
+      output: ScheduledOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input }) => schedule(input)
+    }),
+    defineAgentTool({
+      name: "schedule_every",
+      description: "Schedule recurring durable input in an explicit conversation timezone.",
+      identity: { serviceName: "agent-schedules", action: "every", method: "POST" },
+      input: z8.object({
+        conversationId: z8.string().min(1),
+        input: z8.json(),
+        everyMs: z8.int().positive(),
+        timeZone: z8.string().min(1)
+      }).strict(),
+      output: ScheduledOutputSchema,
+      transports: ["AGENT"],
+      handler: ({ input }) => schedule(input)
+    }),
+    defineAgentTool({
+      name: "schedule_list",
+      description: "List durable schedules for one conversation.",
+      identity: { serviceName: "agent-schedules", action: "list", method: "GET" },
+      input: ConversationInputSchema,
+      output: z8.object({ schedules: z8.array(z8.json()) }).strict(),
+      transports: ["AGENT"],
+      handler: ({ input }) => ({
+        schedules: [...service.listSchedules(input.conversationId)]
+      })
+    }),
+    defineAgentTool({
+      name: "schedule_cancel",
+      description: "Cancel one durable deferred-input schedule.",
+      identity: { serviceName: "agent-schedules", action: "cancel", method: "POST" },
+      input: z8.object({ conversationId: z8.string().min(1), scheduleId: z8.string().min(1) }).strict(),
+      output: z8.object({ cancelled: z8.boolean() }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input }) => ({
+        cancelled: await service.cancelSchedule(input.conversationId, input.scheduleId)
+      })
+    })
+  ];
+}
+// src/agent-runtime/schedules.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { z as z10 } from "zod";
+
+// src/agent-runtime/schedule-records.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { z as z9 } from "zod";
+function newSchedule(request, observedAt) {
+  const modes = [
+    request.at !== undefined,
+    request.afterMs !== undefined,
+    request.everyMs !== undefined
+  ];
+  if (modes.filter(Boolean).length !== 1)
+    throw new TypeError("Declare exactly one schedule mode");
+  if (request.everyMs !== undefined && !request.timeZone) {
+    throw new TypeError("Repeating schedules require an explicit timeZone");
+  }
+  if (request.timeZone) {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: request.timeZone }).format(new Date(0));
+    } catch {
+      throw new TypeError(`Unknown schedule timeZone: ${request.timeZone}`);
+    }
+  }
+  const kind = request.at !== undefined ? "at" : request.afterMs !== undefined ? "after" : "every";
+  const intervalMs = request.everyMs;
+  const delay = request.afterMs ?? request.everyMs;
+  if (delay !== undefined && (!Number.isSafeInteger(delay) || delay < 1)) {
+    throw new TypeError("Schedule delay must be a positive safe integer");
+  }
+  const nextAt = request.at ? new Date(z9.iso.datetime({ offset: true }).parse(request.at)).toISOString() : new Date(observedAt.getTime() + (delay ?? 0)).toISOString();
+  const schedule = AgentScheduleSchema.parse({
+    id: randomUUID2(),
+    conversationId: request.conversationId,
+    kind,
+    nextAt,
+    ...intervalMs !== undefined && { intervalMs },
+    ...request.timeZone && { timeZone: request.timeZone },
+    input: z9.json().parse(request.input),
+    state: "scheduled",
+    occurrence: 0,
+    createdAt: observedAt.toISOString(),
+    updatedAt: observedAt.toISOString()
+  });
+  return schedule;
+}
+async function insertSchedule(sqlite, schedule) {
+  await sqlite.transaction(async (scope) => {
+    scope.database.prepare(`
+        INSERT INTO stitchkit_agent_runtime_schedules (
+          id, conversation_id, kind, next_at, interval_ms, time_zone,
+          input_payload, state, occurrence, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'scheduled', 0, ?, ?)
+      `).run(schedule.id, schedule.conversationId, schedule.kind, schedule.nextAt, schedule.intervalMs ?? null, schedule.timeZone ?? null, JSON.stringify(schedule.input), schedule.createdAt, schedule.updatedAt);
+    await scope.appendEvent({
+      conversationId: schedule.conversationId,
+      kind: "schedule/set",
+      occurredAt: schedule.createdAt,
+      payload: { id: schedule.id, kind: schedule.kind, nextAt: schedule.nextAt }
+    });
+  });
+}
+async function recordDispatchFailure(sqlite, { schedule, occurrence, at, owner }, error) {
+  await sqlite.transaction(async (scope) => {
+    scope.database.prepare(`
+        UPDATE stitchkit_agent_runtime_schedules
+        SET claim_owner = NULL, claim_until = NULL, updated_at = ?
+        WHERE id = ? AND claim_owner = ?
+      `).run(at, schedule.id, owner);
+    await scope.appendEvent({
+      conversationId: schedule.conversationId,
+      kind: "schedule/failed",
+      occurredAt: at,
+      payload: {
+        id: schedule.id,
+        occurrence,
+        message: error instanceof Error ? error.message : String(error)
+      }
+    });
+  });
+}
+async function settleFiring(sqlite, { schedule, occurrence, at, owner }, observedAt, lateByMs) {
+  let nextAt = schedule.nextAt;
+  if (schedule.kind === "every" && schedule.intervalMs) {
+    let next = new Date(schedule.nextAt).getTime() + schedule.intervalMs;
+    while (next <= observedAt.getTime())
+      next += schedule.intervalMs;
+    nextAt = new Date(next).toISOString();
+  }
+  const state = schedule.kind === "every" ? "scheduled" : "completed";
+  await sqlite.transaction(async (scope) => {
+    const held = scope.database.prepare(`
+        SELECT state, claim_owner FROM stitchkit_agent_runtime_schedules WHERE id = ?
+      `).get(schedule.id);
+    const settled = held !== null && held !== undefined && (() => {
+      const row = FinalizeRowSchema.parse(held);
+      return row.state === "scheduled" && row.claim_owner === owner;
+    })();
+    if (settled) {
+      scope.database.prepare(`
+          UPDATE stitchkit_agent_runtime_schedules
+          SET state = ?, occurrence = ?, next_at = ?, updated_at = ?,
+            claim_owner = NULL, claim_until = NULL
+          WHERE id = ?
+        `).run(state, occurrence, nextAt, at, schedule.id);
+    }
+    if (lateByMs > 0) {
+      await scope.appendEvent({
+        conversationId: schedule.conversationId,
+        kind: "schedule/late",
+        occurredAt: at,
+        payload: { id: schedule.id, occurrence, lateByMs }
+      });
+    }
+    await scope.appendEvent({
+      conversationId: schedule.conversationId,
+      kind: "schedule/fired",
+      occurredAt: at,
+      payload: {
+        id: schedule.id,
+        occurrence,
+        lateByMs,
+        nextAt,
+        state: settled ? state : "cancelled"
+      }
+    });
+  });
+}
+function claimSchedule(sqlite, owner, id, until, at) {
+  return sqlite.transaction(async (scope) => {
+    const raw = scope.database.prepare(`
+        SELECT state, claim_until FROM stitchkit_agent_runtime_schedules WHERE id = ?
+      `).get(id);
+    if (raw === null || raw === undefined)
+      return false;
+    const row = ClaimRowSchema.parse(raw);
+    if (row.state !== "scheduled")
+      return false;
+    if (row.claim_until !== null && row.claim_until >= at)
+      return false;
+    scope.database.prepare(`
+        UPDATE stitchkit_agent_runtime_schedules
+        SET claim_owner = ?, claim_until = ?, updated_at = ?
+        WHERE id = ?
+      `).run(owner, until, at, id);
+    return true;
+  });
+}
+
+// src/agent-runtime/schedules.ts
+var AgentScheduleSchema = z10.object({
+  id: z10.string().min(1),
+  conversationId: z10.string().min(1),
+  kind: z10.enum(["at", "after", "every"]),
+  nextAt: z10.iso.datetime({ offset: true }),
+  intervalMs: z10.int().positive().optional(),
+  timeZone: z10.string().min(1).optional(),
+  input: z10.json(),
+  state: z10.enum(["scheduled", "cancelled", "completed"]),
+  occurrence: z10.int().nonnegative(),
+  createdAt: z10.iso.datetime({ offset: true }),
+  updatedAt: z10.iso.datetime({ offset: true })
+}).strict();
+var ScheduleRowSchema = z10.object({
+  id: z10.string(),
+  conversation_id: z10.string(),
+  kind: z10.enum(["at", "after", "every"]),
+  next_at: z10.string(),
+  interval_ms: z10.number().int().positive().nullable(),
+  time_zone: z10.string().nullable(),
+  input_payload: z10.string(),
+  state: z10.enum(["scheduled", "cancelled", "completed"]),
+  occurrence: z10.int().nonnegative(),
+  created_at: z10.string(),
+  updated_at: z10.string()
+});
+var ClaimRowSchema = z10.object({
+  state: z10.enum(["scheduled", "cancelled", "completed"]),
+  claim_until: z10.string().nullable()
+});
+var FinalizeRowSchema = z10.object({
+  state: z10.enum(["scheduled", "cancelled", "completed"]),
+  claim_owner: z10.string().nullable()
+});
+var StateRowSchema = z10.object({
+  state: z10.enum(["scheduled", "cancelled", "completed"])
+});
+function parseSchedule(raw) {
+  const row = ScheduleRowSchema.parse(raw);
+  return AgentScheduleSchema.parse({
+    id: row.id,
+    conversationId: row.conversation_id,
+    kind: row.kind,
+    nextAt: row.next_at,
+    ...row.interval_ms !== null && { intervalMs: row.interval_ms },
+    ...row.time_zone !== null && { timeZone: row.time_zone },
+    input: JSON.parse(row.input_payload),
+    state: row.state,
+    occurrence: row.occurrence,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  });
+}
+function createAgentScheduleService(input) {
+  const onError = input.onError ?? ((error) => {
+    console.error("[stitchkit] agent schedule tick failed", error);
+  });
+  const now = input.now ?? (() => new Date);
+  const database = input.sqlite.database;
+  const setTimer = input.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
+  const clearTimer = input.clearTimer ?? clearTimeout;
+  let timer;
+  let closed = false;
+  const listSchedules = (conversationId) => database.prepare(`
+        SELECT id, conversation_id, kind, next_at, interval_ms, time_zone,
+          input_payload, state, occurrence, created_at, updated_at
+        FROM stitchkit_agent_runtime_schedules
+        WHERE conversation_id = ? ORDER BY created_at, id
+      `).all(conversationId).map(parseSchedule);
+  const arm = () => {
+    if (timer)
+      clearTimer(timer);
+    if (closed)
+      return;
+    try {
+      armNext();
+    } catch (error) {
+      onError(error);
+    }
+  };
+  const armNext = () => {
+    const raw = database.prepare(`
+        SELECT MAX(next_at, COALESCE(claim_until, next_at)) AS due_at
+        FROM stitchkit_agent_runtime_schedules
+        WHERE state = 'scheduled' ORDER BY due_at, id LIMIT 1
+      `).get();
+    if (raw === null || raw === undefined || typeof raw.due_at !== "string")
+      return;
+    const delay = Math.max(0, new Date(raw.due_at).getTime() - now().getTime());
+    timer = setTimer(() => void tick(), Math.min(delay, 2147483647));
+  };
+  const owner = randomUUID3();
+  const CLAIM_MS = 60000;
+  let ticking;
+  const claim = (id, until, at) => claimSchedule(input.sqlite, owner, id, until, at);
+  const runTick = async () => {
+    if (closed)
+      return;
+    const observedAt = now();
+    const due = database.prepare(`
+        SELECT id, conversation_id, kind, next_at, interval_ms, time_zone,
+          input_payload, state, occurrence, created_at, updated_at
+        FROM stitchkit_agent_runtime_schedules
+        WHERE state = 'scheduled' AND next_at <= ? ORDER BY next_at, id
+      `).all(observedAt.toISOString()).map(parseSchedule);
+    for (const schedule of due) {
+      const at = observedAt.toISOString();
+      if (!await claim(schedule.id, new Date(observedAt.getTime() + CLAIM_MS).toISOString(), at)) {
+        continue;
+      }
+      const occurrence = schedule.occurrence + 1;
+      const lateByMs = Math.max(0, observedAt.getTime() - new Date(schedule.nextAt).getTime());
+      try {
+        await input.dispatch({
+          conversationId: schedule.conversationId,
+          idempotencyKey: `schedule:${schedule.id}:${occurrence}`,
+          input: schedule.input,
+          schedule: { id: schedule.id, occurrence, lateByMs }
+        });
+      } catch (error) {
+        await recordDispatchFailure(input.sqlite, { schedule, occurrence, at, owner }, error);
+        continue;
+      }
+      await settleFiring(input.sqlite, { schedule, occurrence, at, owner }, observedAt, lateByMs);
+    }
+  };
+  const tick = () => {
+    if (ticking)
+      return ticking;
+    ticking = runTick().catch(onError).finally(() => {
+      ticking = undefined;
+      arm();
+    });
+    return ticking;
+  };
+  const scheduleInput = async (request) => {
+    const schedule = newSchedule(request, now());
+    await insertSchedule(input.sqlite, schedule);
+    arm();
+    return schedule;
+  };
+  const cancelSchedule = async (conversationId, id) => {
+    const observedAt = now().toISOString();
+    const changed = await input.sqlite.transaction(async (scope) => {
+      const raw = scope.database.prepare(`
+          SELECT state FROM stitchkit_agent_runtime_schedules
+          WHERE id = ? AND conversation_id = ?
+        `).get(id, conversationId);
+      if (raw === null || raw === undefined)
+        return false;
+      if (StateRowSchema.parse(raw).state !== "scheduled")
+        return false;
+      scope.database.prepare(`
+          UPDATE stitchkit_agent_runtime_schedules SET state = 'cancelled', updated_at = ?
+          WHERE id = ? AND conversation_id = ?
+        `).run(observedAt, id, conversationId);
+      await scope.appendEvent({
+        conversationId,
+        kind: "schedule/cancelled",
+        occurredAt: observedAt,
+        payload: { id }
+      });
+      return true;
+    });
+    if (changed)
+      arm();
+    return changed;
+  };
+  return {
+    scheduleInput,
+    cancelSchedule,
+    listSchedules,
+    tick,
+    start: arm,
+    close() {
+      closed = true;
+      if (timer)
+        clearTimer(timer);
+    }
+  };
+}
+// src/agent-runtime/spill.ts
+import { createHash, randomUUID as randomUUID4 } from "node:crypto";
+import { z as z11 } from "zod";
+var SpillRowSchema = z11.object({
+  payload: z11.instanceof(Uint8Array),
+  bytes: z11.int().nonnegative(),
+  authorization_payload: z11.string().nullable()
+});
+var SpillMetadataRowSchema = z11.object({
+  reference_id: z11.string(),
+  bytes: z11.int().nonnegative(),
+  created_at: z11.string()
+});
+function decodeAuthorization(value) {
+  if (value === null)
+    return;
+  return JSON.parse(value);
+}
+function createSqliteAgentSpillStore(input) {
+  const now = input.now ?? (() => new Date);
+  const database = input.sqlite.database;
+  const rowFor = (reference) => {
+    const raw = database.prepare(`
+        SELECT payload, bytes, authorization_payload
+        FROM stitchkit_agent_runtime_spills
+        WHERE reference_id = ? AND conversation_id = ?
+      `).get(reference, input.conversationId);
+    if (raw === null || raw === undefined)
+      refuseUnknownSpillReference(reference);
+    return SpillRowSchema.parse(raw);
+  };
+  const authorization = (reference) => decodeAuthorization(rowFor(reference).authorization_payload);
+  const write = async (request) => {
+    const reference = randomUUID4();
+    const createdAt = now();
+    const expiresAt = input.retentionMs ? new Date(createdAt.getTime() + input.retentionMs).toISOString() : null;
+    const sha256 = createHash("sha256").update(request.data).digest("hex");
+    await input.sqlite.transaction(async (scope) => {
+      scope.database.prepare(`
+          INSERT INTO stitchkit_agent_runtime_spills (
+            reference_id, conversation_id, run_id, tool_call_id, media_type,
+            bytes, sha256, created_at, expires_at, payload, authorization_payload
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(reference, input.conversationId, input.runId ?? null, input.toolCallId ?? null, request.mediaType, request.data.byteLength, sha256, createdAt.toISOString(), expiresAt, request.data, request.authorization ? JSON.stringify(request.authorization) : null);
+      await scope.appendEvent({
+        conversationId: input.conversationId,
+        kind: "spill/created",
+        occurredAt: createdAt.toISOString(),
+        payload: { reference, bytes: request.data.byteLength, sha256 }
+      });
+    });
+    return { reference };
+  };
+  const read = async (request) => {
+    const row = rowFor(request.reference);
+    return {
+      data: row.payload.slice(request.offset, request.offset + request.maxBytes),
+      totalBytes: row.bytes,
+      ...decodeAuthorization(row.authorization_payload) && {
+        authorization: decodeAuthorization(row.authorization_payload)
+      }
+    };
+  };
+  const search = (request) => {
+    const row = rowFor(request.reference);
+    const matches = [];
+    new TextDecoder("utf-8", { fatal: true }).decode(row.payload).split(`
+`).forEach((text, index) => {
+      if (matches.length < request.maxMatches && text.includes(request.query)) {
+        matches.push({ line: index + 1, text });
+      }
+    });
+    return matches;
+  };
+  const cleanup = async () => {
+    const expired = database.prepare(`
+        SELECT reference_id, bytes, created_at
+        FROM stitchkit_agent_runtime_spills
+        WHERE conversation_id = ? AND expires_at IS NOT NULL AND expires_at <= ?
+        ORDER BY created_at, reference_id
+      `).all(input.conversationId, now().toISOString()).map((row) => SpillMetadataRowSchema.parse(row));
+    let bytes = 0;
+    for (const spill of expired) {
+      await input.sqlite.transaction(async (scope) => {
+        scope.database.prepare("DELETE FROM stitchkit_agent_runtime_spills WHERE reference_id = ?").run(spill.reference_id);
+        await scope.appendEvent({
+          conversationId: input.conversationId,
+          kind: "spill/deleted",
+          payload: { reference: spill.reference_id, bytes: spill.bytes }
+        });
+      });
+      bytes += spill.bytes;
+    }
+    return { deleted: expired.length, bytes };
+  };
+  return { authorization, write, read, search, cleanup };
+}
+// src/agent-runtime/state-tools.ts
+import { z as z12 } from "zod";
+var GoalSchema = z12.object({
+  objective: z12.string().min(1),
+  status: z12.enum(["active", "complete", "blocked"])
+}).strict();
+var TodoItemSchema = z12.object({
+  step: z12.string().min(1),
+  status: z12.enum(["pending", "in_progress", "completed"])
+}).strict();
+function createAgentStateTools(input) {
+  const writeGoal = async (value) => {
+    const stored = await input.state.set({
+      conversationId: input.conversationId,
+      name: "goal",
+      value,
+      actor: "agent"
+    });
+    return GoalSchema.parse(stored.value);
+  };
+  return [
+    defineAgentTool({
+      name: "create_goal",
+      description: "Create the durable objective for this conversation.",
+      identity: { serviceName: "agent-state", action: "create-goal", method: "POST" },
+      input: z12.object({ objective: z12.string().min(1) }).strict(),
+      output: GoalSchema,
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        if (await input.state.get(input.conversationId, "goal")) {
+          throw new TypeError("A durable goal already exists for this conversation");
+        }
+        return writeGoal({ objective: request.objective, status: "active" });
+      }
+    }),
+    defineAgentTool({
+      name: "update_goal",
+      description: "Update the durable objective or lifecycle status.",
+      identity: { serviceName: "agent-state", action: "update-goal", method: "POST" },
+      input: z12.object({
+        objective: z12.string().min(1).optional(),
+        status: z12.enum(["active", "complete", "blocked"]).optional()
+      }).strict().refine((request) => request.objective !== undefined || request.status !== undefined, {
+        message: "At least one goal field must be supplied"
+      }),
+      output: GoalSchema,
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        const current = await input.state.get(input.conversationId, "goal");
+        if (!current)
+          throw new TypeError("No durable goal exists for this conversation");
+        const goal = GoalSchema.parse(current.value);
+        return writeGoal({ ...goal, ...request });
+      }
+    }),
+    defineAgentTool({
+      name: "get_goal",
+      description: "Read the durable objective for this conversation.",
+      identity: { serviceName: "agent-state", action: "get-goal", method: "GET" },
+      input: z12.object({}).strict(),
+      output: z12.object({ goal: GoalSchema.optional() }).strict(),
+      transports: ["AGENT"],
+      handler: async () => {
+        const current = await input.state.get(input.conversationId, "goal");
+        return { ...current && { goal: GoalSchema.parse(current.value) } };
+      }
+    }),
+    defineAgentTool({
+      name: "todo_write",
+      description: "Replace the durable ordered work plan for this conversation.",
+      identity: { serviceName: "agent-state", action: "write-todo", method: "POST" },
+      input: z12.object({ items: z12.array(TodoItemSchema) }).strict(),
+      output: z12.object({ items: z12.array(TodoItemSchema) }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input: request }) => {
+        const stored = await input.state.set({
+          conversationId: input.conversationId,
+          name: "todo",
+          value: request,
+          actor: "agent"
+        });
+        return z12.object({ items: z12.array(TodoItemSchema) }).strict().parse(stored.value);
+      }
+    })
+  ];
+}
+export {
+  validateAgentModelSnapshot,
+  structuredCompaction,
+  selectCompactableHistory,
+  selectAgentHistory,
+  searchAgentModelCatalog,
+  runStateForTerminalReason,
+  renderAgentStateSlots,
+  recordAgentSandboxProbe,
+  recordAgentRetryDecision,
+  purgeAgentConversation,
+  projectAgentHistoryDetailed,
+  projectAgentHistory,
+  probeAgentProcessSandbox,
+  missingSandboxRestrictions,
+  isToolResultFailure,
+  isAssistantHistoryEvidence,
+  hasAgentTerminalOutput,
+  encodeAgentConversationArchive,
+  defineStateSlot,
+  defineModelRegistry,
+  defineAgentProtocol,
+  defineAgentProjection,
+  decodeAgentStoreEvent,
+  decodeAgentConversationArchive,
+  createSqliteAgentSpillStore,
+  createSqliteAgentProjectionStore,
+  createSqliteAgentEventSearch,
+  createSqliteAgentChildManager,
+  createMemoryAgentRuntimeStore,
+  createMemoryAgentModelSelectionStore,
+  createDeferredAgentToolSurface,
+  createAgentToolFenceLifecycle,
+  createAgentStateTools,
+  createAgentStateSlotStore,
+  createAgentSessionCoordinator,
+  createAgentScheduleTools,
+  createAgentScheduleService,
+  createAgentRuntimeStore,
+  createAgentRuntimeEventSink,
+  createAgentRuntime,
+  createAgentProjectionRegistry,
+  createAgentObservability,
+  createAgentEventSearchTools,
+  createAgentChildTools,
+  composeAgentPrompt,
+  classifyProviderFailure,
+  canonicalAgentJson,
+  agentUsageProjection,
+  agentTodoStateSlot,
+  agentSummaryProjection,
+  agentStateSlotsProjection,
+  agentScheduleSummaryProjection,
+  agentOutlineProjection,
+  agentGoalStateSlot,
+  agentDurableEventId,
+  agentConversationCardProjection,
+  agentChildBudgetStopPolicy,
+  advanceAgentRuntimeEventCursor,
+  StepResultNotSerializableError,
+  StepResultDecodeError,
+  StepAbortedError,
+  SeedConversationInputSchema,
+  RequestRunInterruptSchema,
+  ReplaceCompactedRangeSchema,
+  RecoverAgentRunSchema,
+  RecordRunOperationSchema,
+  ReadAgentStoreEventsSchema,
+  ParkRecordDecodeError,
+  ParkAbortedError,
+  DeferredAgentToolSearchInputSchema,
+  DeferredAgentToolReceiptSchema,
+  DeferredAgentToolMatchSchema,
+  DURABILITY_STEP_EVENT_KIND,
+  CommitRunTerminalSchema,
+  CheckpointRunAssistantSchema,
+  AppendAgentStoreEventSchema,
+  AgentUsageValueSchema,
+  AgentUsageSchema,
+  AgentTransientDeltaEventSchema,
+  AgentToolStatusEventSchema,
+  AgentToolResultPartSchema,
+  AgentToolCallPartSchema,
+  AgentToolApprovalResponsePartSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentTokenCountSchema,
+  AgentTimestampSchema,
+  AgentTextPartSchema,
+  AgentTerminalReasonSchema,
+  AgentTerminalEventSchema,
+  AgentStoredRunSchema,
+  AgentStoreTransitionSchema,
+  AgentStoreNotFoundSchema,
+  AgentStoreMutationResultSchema,
+  AgentStoreEventPageSchema,
+  AgentStoreEventKindSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreConflictSchema,
+  AgentStoreAppliedSchema,
+  AgentStepFinishedEventSchema,
+  AgentSourcePartSchema,
+  AgentSnapshotSchema,
+  AgentSeedReceiptSchema,
+  AgentScheduleSchema,
+  AgentSandboxRestrictionSchema,
+  AgentSandboxGradeSchema,
+  AgentRuntimeHeadSchema,
+  AgentRuntimeEventSchema,
+  AgentRuntimeEventCursorSchema,
+  AgentRuntimeConflictError,
+  AgentRunViewSchema,
+  AgentRunTerminalEventSchema,
+  AgentRunStateSchema,
+  AgentRunStateEventSchema,
+  AgentRunStartedEventSchema,
+  AgentRunSchema,
+  AgentRunQueuePrioritySchema,
+  AgentRunOperationSchema,
+  AgentRunOperationPhaseSchema,
+  AgentRunOperationKindSchema,
+  AgentRunOperationEventSchema,
+  AgentRunMetricsSchema,
+  AgentRunEventSchema,
+  AgentRecoverablePageSchema,
+  AgentRecoverableDescriptorSchema,
+  AgentRecordVersionSchema,
+  AgentRecordIdSchema,
+  AgentReasoningStartEventSchema,
+  AgentReasoningPartSchema,
+  AgentReasoningEndEventSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentProviderStreamCutError,
+  AgentProviderResponseSchema,
+  AgentProviderEnvelopeSchema,
+  AgentProvenanceSchema,
+  AgentOpaquePartSchema,
+  AgentModelSelectionSchema,
+  AgentModelSearchResultSchema,
+  AgentModelSearchInputSchema,
+  AgentModelRegistrySnapshotSchema,
+  AgentModelPriceSchema,
+  AgentModelPopularitySchema,
+  AgentModelMetricSchema,
+  AgentModelDescriptorSchema,
+  AgentModelCatalogSchema,
+  AgentModelCatalogEntrySchema,
+  AgentModelCapabilitySchema,
+  AgentMessageStatusSchema,
+  AgentMessageSchema,
+  AgentMessageRoleSchema,
+  AgentMessagePartSchema,
+  AgentJsonObjectSchema,
+  AgentHistoryMutationSchema,
+  AgentFilePartSchema,
+  AgentEventSearchResultSchema,
+  AgentCostValueSchema,
+  AgentConversationSummarySchema,
+  AgentConversationPurgedError,
+  AgentConversationPurgeResultSchema,
+  AgentConversationPurgeInputSchema,
+  AgentConversationPageSchema,
+  AgentConversationMessagePageSchema,
+  AgentConversationArchiveSchema,
+  AgentControlPartSchema,
+  AgentContextOverflowError,
+  AgentChildStateSchema,
+  AgentChildRecordSchema,
+  AgentChildBudgetSchema,
+  AgentChildBlockingSourceSchema,
+  AgentChildBlockingKindSchema,
+  AgentChildBlockingEventSchema,
+  AgentCheckpointEventSchema,
+  AgentAttemptResetEventSchema,
+  AgentAssistantPlaceholderSchema,
+  AgentAdmissionReceiptSchema,
+  AgentAdmissionEventSchema,
+  AcquireAgentRunSchema,
+  AcceptInputAndAssignRunSchema,
+  ACTIVE_AGENT_RUN_STATES
+};