stitchkit 0.93.0 → 0.94.1

package/dist/agent-runtime.js

@@ -1,2607 +0,0 @@
-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-vk3kq9sb.js";
-import"./index-p13mwz16.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 {
-  ACTIVE_AGENT_RUN_STATES,
-  AgentAdmissionReceiptSchema,
-  AgentConversationPurgeInputSchema,
-  AgentConversationPurgeResultSchema,
-  AgentConversationPurgedError,
-  AgentHistoryMutationSchema,
-  AgentRuntimeHeadSchema,
-  AgentSeedReceiptSchema,
-  AgentStoredRunSchema,
-  createAgentRuntimeStore,
-  createMemoryAgentRuntimeStore,
-  purgeAgentConversation
-} from "./index-hrbajay7.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-zwkgfq1s.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 {
-  createBoundedSinkManager
-} from "./index-wnfk50r0.js";
-import {
-  AgentSandboxGradeSchema,
-  AgentSandboxRestrictionSchema,
-  missingSandboxRestrictions,
-  probeAgentProcessSandbox,
-  recordAgentSandboxProbe,
-  refuseUnknownSpillReference
-} from "./index-qmy6zq75.js";
-import {
-  buildToolManifest,
-  mountAgent
-} from "./index-e42wzzz5.js";
-import {
-  DURABILITY_STEP_EVENT_KIND,
-  ParkAbortedError,
-  ParkRecordDecodeError,
-  StepAbortedError,
-  StepResultDecodeError,
-  StepResultNotSerializableError,
-  createLocalStepDurability
-} from "./index-kw9t5ayn.js";
-import"./index-2c2bjw3s.js";
-import"./index-mzvgxp0n.js";
-import"./index-yn8remb1.js";
-import"./index-tmwcrptx.js";
-import"./index-f9mb610r.js";
-import"./index-e0znv5gn.js";
-import"./index-0a349c33.js";
-import"./index-rxfy4cq7.js";
-import"./index-6k1937bx.js";
-import {
-  childSpan,
-  createTraceContext
-} from "./index-zcgf3gqf.js";
-import"./index-7zbps32p.js";
-import {
-  defineRuntimeTool
-} from "./index-vjpvjqpn.js";
-import"./index-h9etkkyk.js";
-import"./index-cby4ar3v.js";
-import"./index-2vtcmrj9.js";
-import"./index-kzfs85xp.js";
-import {
-  executableAgentRuntimeTools
-} from "./index-77fekveh.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.ts
-import { randomUUID } from "node:crypto";
-
-// 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/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 now = input.now ?? (() => new Date);
-  const database = input.sqlite.database;
-  const store = input.sqlite.store;
-  const handles = new Map;
-  const settlements = new Map;
-  const currentState = (childConversationId) => {
-    const raw = 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);
-  };
-  const isLive = (childConversationId) => {
-    const state = currentState(childConversationId);
-    return state === "spawned" || state === "running";
-  };
-  const settleable = (childConversationId) => {
-    const state = currentState(childConversationId);
-    return state === undefined || state === "spawned" || state === "running";
-  };
-  const STOP_BOUND_MS = 1e4;
-  const bounded = async (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);
-    }
-  };
-  const listChildren = (parentConversationId) => 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);
-  const updateState = async (record, state, resultReference, details = {}) => {
-    const updatedAt = now().toISOString();
-    const payload = {
-      childConversationId: record.childConversationId,
-      state,
-      ...resultReference && { resultReference },
-      ...details
-    };
-    const childPayload = {
-      parentConversationId: record.parentConversationId,
-      state,
-      ...resultReference && { resultReference },
-      ...details
-    };
-    const write = (audience) => input.sqlite.transaction(async (scope) => {
-      scope.database.prepare(`
-            UPDATE stitchkit_agent_runtime_children
-            SET state = ?, result_reference = ?, updated_at = ? WHERE child_conversation_id = ?
-          `).run(state, 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");
-      }
-    }
-  };
-  const spawnChild = async (request) => {
-    const requestedBudget = AgentChildBudgetSchema.parse(request.budget);
-    const remaining = input.remainingBudget ? AgentChildBudgetSchema.parse(await input.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);
-    const budget = AgentChildBudgetSchema.parse({
-      ...usd !== undefined && { usd },
-      ...tokens !== undefined && { tokens },
-      ...milliseconds !== undefined && { milliseconds }
-    });
-    const events = [];
-    let cursor = 1;
-    for (;; ) {
-      const page = await 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;
-    }
-    const seedUptoSeq = events.at(-1)?.seq ?? 0;
-    const childConversationId = request.childConversationId ?? randomUUID();
-    const createdAt = 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 input.spawn({
-      parentConversationId: record.parentConversationId,
-      childConversationId,
-      seedArchive,
-      childInput: request.childInput,
-      budget
-    });
-    handle.result.catch(() => {
-      return;
-    });
-    try {
-      await input.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, budget }
-        });
-      });
-      await updateState(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(childConversationId))
-          await updateState(record, "lost", undefined, { reason: "spawn-persistence-failed" });
-      } catch (cleanup) {
-        throw new AggregateError([cause, cleanup], "Child stopped but persistence reconciliation failed");
-      }
-      throw cause;
-    }
-    handles.set(childConversationId, handle);
-    const settlement = handle.result.then(async (result) => {
-      handles.delete(childConversationId);
-      retireChildBlocking(childConversationId);
-      if (settleable(childConversationId)) {
-        await updateState(record, "finished", result.resultReference);
-      }
-    }, async () => {
-      handles.delete(childConversationId);
-      retireChildBlocking(childConversationId);
-      if (settleable(childConversationId))
-        await updateState(record, "stopped");
-    });
-    settlements.set(childConversationId, settlement);
-    settlement.catch(() => {
-      return;
-    });
-    return { ...record, state: "running", updatedAt: now().toISOString() };
-  };
-  const recordStepUsage = async (request) => {
-    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 input.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 };
-  };
-  const stopChildren = async (parentConversationId) => {
-    const records = listChildren(parentConversationId).filter((record) => record.state === "spawned" || record.state === "running");
-    await Promise.all(records.map(async (record) => {
-      const startedAt = performance.now();
-      const handle = handles.get(record.childConversationId);
-      const reachable = handle ? handle.reachable ? await bounded(handle.reachable(), false) : true : false;
-      if (!reachable) {
-        if (isLive(record.childConversationId)) {
-          await updateState(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(record.childConversationId))
-        return;
-      await updateState(record, "stopped", undefined, {
-        stopDurationMs: Math.max(0, performance.now() - startedAt)
-      });
-      retireChildBlocking(record.childConversationId);
-    }));
-  };
-  const activeChild = (parentConversationId, childConversationId) => {
-    const child = listChildren(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 = handles.get(childConversationId);
-    if (!handle)
-      throw new TypeError("Child host handle is unavailable");
-    return { child, handle };
-  };
-  const { retireChildBlocking, listChildBlocking, respondToChildBlocking } = createChildBlockingRelay({ store, now, handles, listChildren, activeChild, bounded });
-  const sendMessage = async (parentConversationId, childConversationId, message) => {
-    const { handle } = activeChild(parentConversationId, childConversationId);
-    if (!handle.sendMessage)
-      throw new TypeError("Child host does not support messages");
-    await handle.sendMessage(message);
-    await store.appendEvent({
-      conversationId: parentConversationId,
-      kind: "child/state",
-      payload: { childConversationId, action: "message-sent" }
-    });
-  };
-  const interruptChild = async (parentConversationId, childConversationId) => {
-    const { child, handle } = activeChild(parentConversationId, childConversationId);
-    const startedAt = performance.now();
-    await handle.stopPolicy("parent-interrupt");
-    await updateState(child, "stopped", undefined, {
-      policyName: "parent-interrupt",
-      stopDurationMs: Math.max(0, performance.now() - startedAt)
-    });
-    retireChildBlocking(childConversationId);
-  };
-  const waitChild = async (childConversationId) => {
-    await settlements.get(childConversationId);
-  };
-  return {
-    spawnChild,
-    listChildren,
-    recordStepUsage,
-    stopChildren,
-    sendMessage,
-    interruptChild,
-    waitChild,
-    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 randomUUID2 } from "node:crypto";
-import { z as z9 } from "zod";
-var AgentScheduleSchema = z9.object({
-  id: z9.string().min(1),
-  conversationId: z9.string().min(1),
-  kind: z9.enum(["at", "after", "every"]),
-  nextAt: z9.iso.datetime({ offset: true }),
-  intervalMs: z9.int().positive().optional(),
-  timeZone: z9.string().min(1).optional(),
-  input: z9.json(),
-  state: z9.enum(["scheduled", "cancelled", "completed"]),
-  occurrence: z9.int().nonnegative(),
-  createdAt: z9.iso.datetime({ offset: true }),
-  updatedAt: z9.iso.datetime({ offset: true })
-}).strict();
-var ScheduleRowSchema = z9.object({
-  id: z9.string(),
-  conversation_id: z9.string(),
-  kind: z9.enum(["at", "after", "every"]),
-  next_at: z9.string(),
-  interval_ms: z9.number().int().positive().nullable(),
-  time_zone: z9.string().nullable(),
-  input_payload: z9.string(),
-  state: z9.enum(["scheduled", "cancelled", "completed"]),
-  occurrence: z9.int().nonnegative(),
-  created_at: z9.string(),
-  updated_at: z9.string()
-});
-var ClaimRowSchema = z9.object({
-  state: z9.enum(["scheduled", "cancelled", "completed"]),
-  claim_until: z9.string().nullable()
-});
-var FinalizeRowSchema = z9.object({
-  state: z9.enum(["scheduled", "cancelled", "completed"]),
-  claim_owner: z9.string().nullable()
-});
-var StateRowSchema = z9.object({
-  state: z9.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 = randomUUID2();
-  const CLAIM_MS = 60000;
-  let ticking;
-  const claim = (id, until, at) => input.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;
-  });
-  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 input.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)
-            }
-          });
-        });
-        continue;
-      }
-      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 input.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"
-          }
-        });
-      });
-    }
-  };
-  const tick = () => {
-    if (ticking)
-      return ticking;
-    ticking = runTick().catch(onError).finally(() => {
-      ticking = undefined;
-      arm();
-    });
-    return ticking;
-  };
-  const scheduleInput = async (request) => {
-    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 observedAt = now();
-    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()
-    });
-    await input.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 }
-      });
-    });
-    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 randomUUID3 } from "node:crypto";
-import { z as z10 } from "zod";
-var SpillRowSchema = z10.object({
-  payload: z10.instanceof(Uint8Array),
-  bytes: z10.int().nonnegative(),
-  authorization_payload: z10.string().nullable()
-});
-var SpillMetadataRowSchema = z10.object({
-  reference_id: z10.string(),
-  bytes: z10.int().nonnegative(),
-  created_at: z10.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 = randomUUID3();
-    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 z11 } from "zod";
-var GoalSchema = z11.object({
-  objective: z11.string().min(1),
-  status: z11.enum(["active", "complete", "blocked"])
-}).strict();
-var TodoItemSchema = z11.object({
-  step: z11.string().min(1),
-  status: z11.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: z11.object({ objective: z11.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: z11.object({
-        objective: z11.string().min(1).optional(),
-        status: z11.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: z11.object({}).strict(),
-      output: z11.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: z11.object({ items: z11.array(TodoItemSchema) }).strict(),
-      output: z11.object({ items: z11.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 z11.object({ items: z11.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,
-  createLocalStepDurability,
-  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
-};