stitchkit 0.68.9 → 0.68.11

package/dist/agent-runtime.js

@@ -27,11 +27,18 @@ import {
 import {
   createBoundedSinkManager
 } from "./index-a59da114.js";
+import {
+  buildToolManifest,
+  mountAgent
+} from "./index-bt5179zb.js";
+import {
+  defineRuntimeTool
+} from "./index-eqqyd9v8.js";
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-04agqrs8.js";
-import"./index-51a19y3v.js";
+} from "./index-y2ctppmg.js";
+import"./index-f24xg2cw.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentControlPartSchema,
@@ -63,13 +70,15 @@ import {
   AgentUsageValueSchema,
   runStateForTerminalReason
 } from "./index-ysphyxax.js";
-import"./index-6djpbnda.js";
+import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
 import {
   childSpan,
   createTraceContext
-} from "./index-bmmtz6r9.js";
-import"./index-smpbdg6k.js";
+} from "./index-pgsyp3xh.js";
+import {
+  executableAgentRuntimeTools
+} from "./index-qyrqwr4c.js";
 import"./index-0w9abg87.js";
 import"./index-6k1937bx.js";
 
@@ -324,78 +333,462 @@ function createAgentSessionCoordinator() {
     }
   };
 }
-// src/agent-runtime/event-schema.ts
+// src/agent-runtime/deferred-tool-types.ts
 import { z } from "zod";
-var AgentAdmissionEventSchema = z.object({
-  type: z.literal("admission"),
+var DeferredAgentToolSearchInputSchema = z.object({
+  query: z.string().min(1),
+  reason: z.enum(["inactive_call"]).optional()
+});
+var DeferredAgentToolMatchSchema = z.object({
+  name: z.string(),
+  description: z.string()
+});
+var DeferredAgentToolReceiptSchema = z.object({
+  schemaVersion: z.literal(1),
+  kind: z.literal("stitchkit.deferred-tool-selection"),
+  status: z.enum(["SELECTED", "SEARCH_REQUIRED", "NO_MATCH", "SELECTION_REFUSED"]),
+  runId: z.string(),
+  surfaceKey: z.string(),
+  selected: z.array(z.string()),
+  matches: z.array(DeferredAgentToolMatchSchema),
+  truncated: z.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 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.";
+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-internal.ts
+var repairs = new WeakMap;
+var catalogs = new WeakMap;
+function registerDeferredToolRepair(prepareStep, repair) {
+  repairs.set(prepareStep, repair);
+}
+function deferredToolRepair(prepareStep) {
+  return prepareStep ? repairs.get(prepareStep) : undefined;
+}
+function registerDeferredToolCatalog(tools, searchName, names) {
+  const search = tools[searchName];
+  if (search && typeof search === "object")
+    catalogs.set(search, names);
+}
+function deferredToolCatalog(tools, searchName) {
+  const search = tools[searchName];
+  return search && typeof search === "object" ? catalogs.get(search) : undefined;
+}
+function repairedSearchCall(toolCall, searchName) {
+  return {
+    ...toolCall,
+    toolName: searchName,
+    input: JSON.stringify({ query: toolCall.toolName, reason: "inactive_call" })
+  };
+}
+
+// src/agent-runtime/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-schema.ts
+import { z as z2 } from "zod";
+var AgentAdmissionEventSchema = z2.object({
+  type: z2.literal("admission"),
   eventId: AgentRecordIdSchema,
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
   input: AgentMessageSchema,
   run: AgentRunSchema,
-  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
+  assistant: z2.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
   emittedAt: AgentTimestampSchema
 });
-var EventIdentitySchema = z.object({
+var EventIdentitySchema = z2.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   emittedAt: AgentTimestampSchema
 });
 var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z.literal("assistant-delta"),
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  textDelta: z.string()
+  type: z2.literal("assistant-delta"),
+  runtimeEpoch: z2.string().min(1),
+  sequence: z2.int().nonnegative(),
+  textDelta: z2.string()
 });
 var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
+  runtimeEpoch: z2.string().min(1),
+  sequence: z2.int().nonnegative(),
   provider: AgentProviderEnvelopeSchema.optional()
 });
 var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-start")
+  type: z2.literal("reasoning-start")
 });
 var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-delta"),
-  textDelta: z.string()
+  type: z2.literal("reasoning-delta"),
+  textDelta: z2.string()
 });
 var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-end")
+  type: z2.literal("reasoning-end")
 });
 var AgentCheckpointEventSchema = EventIdentitySchema.extend({
-  type: z.literal("assistant-checkpoint"),
+  type: z2.literal("assistant-checkpoint"),
   eventId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
   message: AgentMessageSchema,
   metrics: AgentRunMetricsSchema.optional()
 });
 var AgentRunStateEventSchema = EventIdentitySchema.extend({
-  type: z.literal("run-state"),
+  type: z2.literal("run-state"),
   eventId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
   state: AgentRunStateSchema
 });
 var AgentToolStatusEventSchema = EventIdentitySchema.extend({
-  type: z.literal("tool-status"),
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
+  type: z2.literal("tool-status"),
+  runtimeEpoch: z2.string().min(1),
+  sequence: z2.int().nonnegative(),
   callId: AgentRecordIdSchema,
-  toolName: z.string().min(1),
-  status: z.enum(["started", "completed", "failed", "interrupted"]),
-  input: z.json().optional(),
-  output: z.json().optional()
+  toolName: z2.string().min(1),
+  status: z2.enum(["started", "completed", "failed", "interrupted"]),
+  input: z2.json().optional(),
+  output: z2.json().optional()
 });
 var AgentTerminalEventSchema = EventIdentitySchema.extend({
-  type: z.literal("terminal"),
+  type: z2.literal("terminal"),
   eventId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z.string().min(1).optional(),
+  policyName: z2.string().min(1).optional(),
   message: AgentMessageSchema,
   metrics: AgentRunMetricsSchema.optional()
 });
-var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
+var AgentRuntimeEventSchema = z2.discriminatedUnion("type", [
   AgentAdmissionEventSchema,
   AgentTransientDeltaEventSchema,
   AgentReasoningStartEventSchema,
@@ -406,11 +799,11 @@ var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
   AgentToolStatusEventSchema,
   AgentTerminalEventSchema
 ]);
-var AgentRuntimeEventCursorSchema = z.object({
+var AgentRuntimeEventCursorSchema = z2.object({
   snapshotVersion: AgentRecordVersionSchema.optional(),
-  durableEventIds: z.array(AgentRecordIdSchema).optional(),
-  runtimeEpoch: z.string().min(1).optional(),
-  sequence: z.int().nonnegative().optional()
+  durableEventIds: z2.array(AgentRecordIdSchema).optional(),
+  runtimeEpoch: z2.string().min(1).optional(),
+  sequence: z2.int().nonnegative().optional()
 });
 function isDurableEvent(event) {
   return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
@@ -723,22 +1116,22 @@ function createAgentToolFenceLifecycle(config) {
   };
 }
 // src/agent-runtime/models.ts
-import { z as z2 } from "zod";
-var AgentModelCapabilitySchema = z2.enum(["tools", "vision", "reasoning", "files"]);
-var AgentModelDescriptorSchema = z2.object({
-  provider: z2.string().min(1),
-  modelId: z2.string().min(1),
-  contextWindow: z2.int().positive(),
-  capabilities: z2.array(AgentModelCapabilitySchema),
-  observedAt: z2.iso.datetime({ offset: true }).optional(),
-  source: z2.string().min(1).optional(),
-  availability: z2.enum(["available", "unavailable"]).optional()
+import { z as z3 } from "zod";
+var AgentModelCapabilitySchema = z3.enum(["tools", "vision", "reasoning", "files"]);
+var AgentModelDescriptorSchema = z3.object({
+  provider: z3.string().min(1),
+  modelId: z3.string().min(1),
+  contextWindow: z3.int().positive(),
+  capabilities: z3.array(AgentModelCapabilitySchema),
+  observedAt: z3.iso.datetime({ offset: true }).optional(),
+  source: z3.string().min(1).optional(),
+  availability: z3.enum(["available", "unavailable"]).optional()
 });
-var AgentModelRegistrySnapshotSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  source: z2.string().min(1),
-  observedAt: z2.iso.datetime({ offset: true }),
-  models: z2.record(z2.string().min(1), AgentModelDescriptorSchema)
+var AgentModelRegistrySnapshotSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  source: z3.string().min(1),
+  observedAt: z3.iso.datetime({ offset: true }),
+  models: z3.record(z3.string().min(1), AgentModelDescriptorSchema)
 });
 function defineModelRegistry(config) {
   const descriptors = new Map;
@@ -809,38 +1202,38 @@ function validateAgentModelSnapshot(input, policy) {
   return snapshot;
 }
 // src/agent-runtime/observability.ts
-import { z as z3 } from "zod";
-var AgentRunEventBaseSchema = z3.object({
-  schemaVersion: z3.literal(1),
+import { z as z4 } from "zod";
+var AgentRunEventBaseSchema = z4.object({
+  schemaVersion: z4.literal(1),
   eventId: AgentRecordIdSchema,
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
-  traceId: z3.string().min(1),
-  spanId: z3.string().min(1),
-  parentSpanId: z3.string().min(1).optional(),
+  traceId: z4.string().min(1),
+  spanId: z4.string().min(1),
+  parentSpanId: z4.string().min(1).optional(),
   state: AgentRunStateSchema,
-  modelId: z3.string().min(1).optional(),
-  durationMs: z3.number().nonnegative().optional(),
+  modelId: z4.string().min(1).optional(),
+  durationMs: z4.number().nonnegative().optional(),
   emittedAt: AgentTimestampSchema
 });
 var AgentRunStartedEventSchema = AgentRunEventBaseSchema.extend({
-  type: z3.literal("run-started"),
-  queueWaitMs: z3.number().nonnegative().optional()
+  type: z4.literal("run-started"),
+  queueWaitMs: z4.number().nonnegative().optional()
 });
 var AgentStepFinishedEventSchema = AgentRunEventBaseSchema.extend({
-  type: z3.literal("step-finished"),
-  step: z3.int().nonnegative(),
-  ttftMs: z3.number().nonnegative().optional(),
+  type: z4.literal("step-finished"),
+  step: z4.int().nonnegative(),
+  ttftMs: z4.number().nonnegative().optional(),
   usage: AgentUsageSchema
 });
 var AgentRunTerminalEventSchema = AgentRunEventBaseSchema.extend({
-  type: z3.literal("run-terminal"),
+  type: z4.literal("run-terminal"),
   terminalReason: AgentTerminalReasonSchema,
-  ttftMs: z3.number().nonnegative().optional(),
-  internalCause: z3.unknown().optional(),
+  ttftMs: z4.number().nonnegative().optional(),
+  internalCause: z4.unknown().optional(),
   usage: AgentUsageSchema
 });
-var AgentRunEventSchema = z3.discriminatedUnion("type", [
+var AgentRunEventSchema = z4.discriminatedUnion("type", [
   AgentRunStartedEventSchema,
   AgentStepFinishedEventSchema,
   AgentRunTerminalEventSchema
@@ -889,9 +1282,9 @@ function createAgentObservability(config) {
   };
 }
 // src/agent-runtime/prompt.ts
-import { z as z4 } from "zod";
-var AgentTokenCountSchema = z4.object({
-  value: z4.int().nonnegative().optional(),
+import { z as z5 } from "zod";
+var AgentTokenCountSchema = z5.object({
+  value: z5.int().nonnegative().optional(),
   provenance: AgentProvenanceSchema.extract([
     "measured",
     "computed",
@@ -1206,7 +1599,7 @@ import {
 } from "ai";
 
 // src/agent-runtime/runtime-internals.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/agent-runtime/terminal-commit.ts
 class AgentRuntimeConflictError extends Error {
@@ -1339,7 +1732,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z5.json().safeParse(value);
+  const parsed = z6.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -1795,6 +2188,7 @@ function createRunExecutor(dependencies) {
         abortSignal: executionSignal,
         maxRetries: 0,
         stopWhen: stopConditions,
+        repairToolCall: deferredToolRepair(config.loop?.prepareStep),
         ...(config.loop?.prepareStep || injection) && {
           prepareStep: async (options) => {
             const prepared = await config.loop?.prepareStep?.({
@@ -2855,6 +3249,9 @@ export {
   AgentUsageValueSchema,
   CheckpointRunAssistantSchema,
   CommitRunTerminalSchema,
+  DeferredAgentToolMatchSchema,
+  DeferredAgentToolReceiptSchema,
+  DeferredAgentToolSearchInputSchema,
   RecoverAgentRunSchema,
   ReplaceCompactedRangeSchema,
   RequestRunInterruptSchema,
@@ -2867,6 +3264,7 @@ export {
   createAgentRuntimeStore,
   createAgentSessionCoordinator,
   createAgentToolFenceLifecycle,
+  createDeferredAgentToolSurface,
   createMemoryAgentRuntimeStore,
   defineAgentProtocol,
   defineModelRegistry,