stitchkit 0.56.1 → 0.56.2

package/dist/agent-runtime.js

@@ -0,0 +1,1931 @@
+import {
+  ToolExecutionControlError,
+  isToolExecutionControlError
+} from "./index-sa2mbwa7.js";
+import"./index-6djpbnda.js";
+import"./index-cby4ar3v.js";
+import {
+  createBoundedSinkManager
+} from "./index-0nc0cddp.js";
+import"./index-7c0gkyvj.js";
+import"./index-ps5pxp3h.js";
+import"./index-6k1937bx.js";
+import {
+  childSpan,
+  createTraceContext
+} from "./index-y2rb7dwx.js";
+import"./index-smpbdg6k.js";
+import"./index-1bx83sw4.js";
+
+// src/agent-runtime/compaction.ts
+function providerValidTurn(messages) {
+  if (messages[0]?.role !== "user")
+    return false;
+  const assistant = messages.find((message) => message.role === "assistant");
+  if (!assistant || assistant.status === "streaming" || assistant.status === "failed") {
+    return false;
+  }
+  const calls = new Set(assistant.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
+  const results = new Set(assistant.parts.filter((part) => part.type === "tool-result").map((part) => part.callId));
+  return [...calls].every((callId) => results.has(callId)) && [...results].every((callId) => calls.has(callId));
+}
+function groupProviderTurns(messages) {
+  const turns = [];
+  let current = [];
+  for (const message of messages) {
+    if (message.role === "user" && current.length > 0) {
+      turns.push({
+        messages: current,
+        complete: providerValidTurn(current)
+      });
+      current = [];
+    }
+    current.push(message);
+  }
+  if (current.length > 0) {
+    turns.push({
+      messages: current,
+      complete: providerValidTurn(current)
+    });
+  }
+  return turns;
+}
+function eligibleForCompaction(messages, keepRecentTurns) {
+  const withoutLeadingSummary = messages[0]?.role === "summary" ? messages.slice(1) : messages;
+  const turns = groupProviderTurns(withoutLeadingSummary);
+  const firstIncomplete = turns.findIndex((turn) => !turn.complete);
+  const completeTurns = firstIncomplete === -1 ? turns : turns.slice(0, firstIncomplete);
+  const eligibleCount = Math.max(0, completeTurns.length - keepRecentTurns);
+  return completeTurns.slice(0, eligibleCount).flatMap((turn) => turn.messages);
+}
+function mutationSnapshot(result, fallback) {
+  if (result.outcome === "applied" || result.outcome === "duplicate") {
+    return { outcome: "applied", snapshot: result.snapshot };
+  }
+  return { outcome: result.outcome, snapshot: fallback };
+}
+function structuredCompaction(config) {
+  if (!Number.isSafeInteger(config.keepRecentTurns) || config.keepRecentTurns < 1) {
+    throw new TypeError("keepRecentTurns must be a positive safe integer");
+  }
+  return async (input) => {
+    const snapshot = await input.store.loadSnapshot(input.conversationId);
+    if (!await config.threshold(snapshot))
+      return { outcome: "not_needed", snapshot };
+    const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns);
+    if (eligibleMessages.length === 0)
+      return { outcome: "nothing_eligible", snapshot };
+    const leadingSummary = snapshot.messages[0]?.role === "summary" ? snapshot.messages[0] : undefined;
+    const previousSummary = input.previousSummary ?? (leadingSummary && config.readPreviousSummary ? config.schema.parse(config.readPreviousSummary(leadingSummary)) : 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 previousSummaryMessage = previousSummary !== undefined && leadingSummary ? leadingSummary : undefined;
+    const applied = await input.store.replaceCompactedRange({
+      conversationId: input.conversationId,
+      expectedVersion: snapshot.version,
+      replacedMessageIds: [
+        ...previousSummaryMessage ? [previousSummaryMessage.id] : [],
+        ...eligibleMessages.map((message) => message.id)
+      ],
+      summary: summaryMessage
+    });
+    return mutationSnapshot(applied, snapshot);
+  };
+}
+// src/agent-runtime/coordinator.ts
+function createAgentSessionCoordinator() {
+  const lanes = new Map;
+  let closed = false;
+  const laneFor = (key) => {
+    const existing = lanes.get(key);
+    if (existing)
+      return existing;
+    const created = { queue: [] };
+    lanes.set(key, created);
+    return created;
+  };
+  const startNext = (key, lane) => {
+    if (lane.active)
+      return;
+    const next = lane.queue.shift();
+    if (!next) {
+      lanes.delete(key);
+      return;
+    }
+    next.start();
+  };
+  return {
+    submit(input) {
+      const accepted = Promise.withResolvers();
+      const result = Promise.withResolvers();
+      if (closed) {
+        const error = new Error("Agent session coordinator is closed");
+        accepted.reject(error);
+        result.reject(error);
+        return { accepted: accepted.promise, result: result.promise };
+      }
+      const lane = laneFor(input.key);
+      const pending = {
+        reject(reason) {
+          accepted.reject(reason);
+          result.reject(reason);
+        },
+        async start() {
+          const controller = new AbortController;
+          const settlement = Promise.withResolvers();
+          lane.active = { controller, settled: settlement.promise };
+          try {
+            const coordinated = await input.create(controller.signal);
+            accepted.resolve();
+            result.resolve(await coordinated.execute());
+          } catch (error) {
+            accepted.reject(error);
+            result.reject(error);
+          } finally {
+            settlement.resolve();
+            lane.active = undefined;
+            startNext(input.key, lane);
+          }
+        }
+      };
+      if (input.policy === "interrupt")
+        lane.active?.controller.abort("user-interrupt");
+      lane.queue.push(pending);
+      startNext(input.key, lane);
+      return { accepted: accepted.promise, result: result.promise };
+    },
+    stop(key, reason = "user-interrupt") {
+      const lane = lanes.get(key);
+      if (!lane?.active)
+        return false;
+      lane.active.controller.abort(reason);
+      return true;
+    },
+    async close(options = {}) {
+      closed = true;
+      const error = new Error("Agent session coordinator is closed");
+      for (const lane of lanes.values()) {
+        lane.active?.controller.abort("shutdown");
+        for (const pending of lane.queue.splice(0))
+          pending.reject(error);
+      }
+      const settlements = [...lanes.values()].map((lane) => lane.active?.settled).filter((settled) => settled !== undefined);
+      const drain = Promise.all(settlements).then(() => {
+        return;
+      });
+      if (options.drainTimeoutMs === undefined)
+        return drain;
+      await Promise.race([
+        drain,
+        new Promise((resolve) => setTimeout(resolve, options.drainTimeoutMs))
+      ]);
+    },
+    isRunning(key) {
+      return lanes.get(key)?.active !== undefined;
+    }
+  };
+}
+// src/agent-runtime/events.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/schemas.ts
+import { z } from "zod";
+var AgentRecordIdSchema = z.string().min(1);
+var AgentRecordVersionSchema = z.int().nonnegative();
+var AgentTimestampSchema = z.iso.datetime({ offset: true });
+var AgentJsonObjectSchema = z.record(z.string(), z.json());
+var AgentProviderEnvelopeSchema = z.object({
+  schemaVersion: z.int().positive(),
+  provider: z.string().min(1),
+  data: AgentJsonObjectSchema
+});
+var AgentTextPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+var AgentReasoningPartSchema = z.object({
+  type: z.literal("reasoning"),
+  text: z.string(),
+  provider: AgentProviderEnvelopeSchema.optional()
+});
+var AgentFilePartSchema = z.object({
+  type: z.literal("file"),
+  mediaType: z.string().min(1),
+  reference: z.string().min(1),
+  filename: z.string().min(1).optional()
+});
+var AgentSourcePartSchema = z.object({
+  type: z.literal("source"),
+  sourceId: z.string().min(1),
+  url: z.url().optional(),
+  title: z.string().optional()
+});
+var AgentToolCallPartSchema = z.object({
+  type: z.literal("tool-call"),
+  callId: z.string().min(1),
+  toolName: z.string().min(1),
+  input: z.json(),
+  provider: AgentProviderEnvelopeSchema.optional()
+});
+var AgentToolResultPartSchema = z.object({
+  type: z.literal("tool-result"),
+  callId: z.string().min(1),
+  toolName: z.string().min(1),
+  outcome: z.enum(["success", "error", "interrupted"]),
+  output: z.json().optional()
+});
+var AgentOpaquePartSchema = z.object({
+  type: z.literal("provider"),
+  envelope: AgentProviderEnvelopeSchema
+});
+var AgentControlPartSchema = z.object({
+  type: z.literal("control"),
+  reason: z.enum(["run-interrupted", "stale-run"])
+});
+var AgentMessagePartSchema = z.discriminatedUnion("type", [
+  AgentTextPartSchema,
+  AgentReasoningPartSchema,
+  AgentFilePartSchema,
+  AgentSourcePartSchema,
+  AgentToolCallPartSchema,
+  AgentToolResultPartSchema,
+  AgentOpaquePartSchema,
+  AgentControlPartSchema
+]);
+var AgentMessageRoleSchema = z.enum(["user", "assistant", "system", "summary"]);
+var AgentMessageStatusSchema = z.enum([
+  "committed",
+  "streaming",
+  "completed",
+  "interrupted",
+  "failed"
+]);
+var AgentMessageSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema.optional(),
+  role: AgentMessageRoleSchema,
+  status: AgentMessageStatusSchema,
+  parts: z.array(AgentMessagePartSchema),
+  metadata: AgentJsonObjectSchema.optional(),
+  createdAt: AgentTimestampSchema,
+  updatedAt: AgentTimestampSchema
+});
+var AgentRunStateSchema = z.enum([
+  "queued",
+  "running",
+  "interrupt_requested",
+  "completed",
+  "interrupted",
+  "failed",
+  "cancelled",
+  "abandoned"
+]);
+var AgentTerminalReasonSchema = z.enum([
+  "success",
+  "policy_stop",
+  "interrupted",
+  "cancelled",
+  "timeout",
+  "shutdown",
+  "provider_failure",
+  "tool_failure",
+  "abandoned"
+]);
+var AgentRunSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  inputMessageIds: z.array(AgentRecordIdSchema).min(1),
+  assistantMessageId: AgentRecordIdSchema,
+  state: AgentRunStateSchema,
+  revision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1).optional(),
+  terminalReason: AgentTerminalReasonSchema.optional(),
+  terminalPolicyName: z.string().min(1).optional(),
+  createdAt: AgentTimestampSchema,
+  updatedAt: AgentTimestampSchema
+});
+var AgentSnapshotSchema = z.object({
+  schemaVersion: z.literal(1),
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema,
+  messages: z.array(AgentMessageSchema),
+  runs: z.array(AgentRunSchema)
+});
+var AgentUsageValueSchema = z.object({
+  value: z.number().nonnegative().optional(),
+  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
+});
+var AgentCostValueSchema = z.object({
+  value: z.number().nonnegative().optional(),
+  currency: z.string().length(3).optional(),
+  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
+});
+var AgentUsageSchema = z.object({
+  inputTokens: AgentUsageValueSchema,
+  outputTokens: AgentUsageValueSchema,
+  reasoningTokens: AgentUsageValueSchema.optional(),
+  cacheReadTokens: AgentUsageValueSchema.optional(),
+  cacheWriteTokens: AgentUsageValueSchema.optional(),
+  cost: AgentCostValueSchema.optional()
+});
+
+// src/agent-runtime/events.ts
+var EventIdentitySchema = z2.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  emittedAt: AgentTimestampSchema
+});
+var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
+  type: z2.literal("assistant-delta"),
+  runtimeEpoch: z2.string().min(1),
+  sequence: z2.int().nonnegative(),
+  textDelta: z2.string()
+});
+var AgentCheckpointEventSchema = EventIdentitySchema.extend({
+  type: z2.literal("assistant-checkpoint"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  message: AgentMessageSchema
+});
+var AgentRunStateEventSchema = EventIdentitySchema.extend({
+  type: z2.literal("run-state"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  state: AgentRunStateSchema
+});
+var AgentToolStatusEventSchema = EventIdentitySchema.extend({
+  type: z2.literal("tool-status"),
+  runtimeEpoch: z2.string().min(1),
+  sequence: z2.int().nonnegative(),
+  callId: AgentRecordIdSchema,
+  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: z2.literal("terminal"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  reason: AgentTerminalReasonSchema,
+  policyName: z2.string().min(1).optional(),
+  message: AgentMessageSchema
+});
+var AgentRuntimeEventSchema = z2.discriminatedUnion("type", [
+  AgentTransientDeltaEventSchema,
+  AgentCheckpointEventSchema,
+  AgentRunStateEventSchema,
+  AgentToolStatusEventSchema,
+  AgentTerminalEventSchema
+]);
+// src/agent-runtime/history.ts
+import { modelMessageSchema } from "ai";
+function providerOptions(envelope) {
+  if (!envelope)
+    return;
+  return envelope.provider === "ai-sdk" ? envelope.data : { [envelope.provider]: envelope.data };
+}
+function textContent(parts) {
+  return parts.filter((part) => part.type === "text").map((part) => part.text).join(`
+`);
+}
+async function userMessage(message, options) {
+  const text = textContent(message.parts);
+  const content = [];
+  if (text)
+    content.push({ type: "text", text });
+  for (const part of message.parts) {
+    if (part.type !== "file")
+      continue;
+    if (options.resolveFile) {
+      content.push({
+        type: "file",
+        data: await options.resolveFile(part, message),
+        mediaType: part.mediaType,
+        ...part.filename && { filename: part.filename }
+      });
+      continue;
+    }
+    const fallback = options.unresolvedFile ?? "text";
+    if (fallback === "error") {
+      throw new Error(`No history file resolver configured for ${part.reference}`);
+    }
+    if (fallback === "text") {
+      content.push({ type: "text", text: `[attachment: ${part.reference}]` });
+    }
+  }
+  if (content.length === 0)
+    return;
+  return modelMessageSchema.parse({ role: "user", content });
+}
+function assistantMessages(message) {
+  const assistantContent = [];
+  const toolContent = [];
+  for (const part of message.parts) {
+    if (part.type === "text")
+      assistantContent.push({ type: "text", text: part.text });
+    if (part.type === "reasoning") {
+      assistantContent.push({
+        type: "reasoning",
+        text: part.text,
+        ...part.provider && { providerOptions: providerOptions(part.provider) }
+      });
+    }
+    if (part.type === "tool-call") {
+      assistantContent.push({
+        type: "tool-call",
+        toolCallId: part.callId,
+        toolName: part.toolName,
+        input: part.input,
+        ...part.provider && { providerOptions: providerOptions(part.provider) }
+      });
+    }
+    if (part.type === "tool-result") {
+      const output = part.outcome === "success" ? { type: "json", value: part.output ?? null } : { type: "error-json", value: part.output ?? { message: part.outcome } };
+      toolContent.push({
+        type: "tool-result",
+        toolCallId: part.callId,
+        toolName: part.toolName,
+        output
+      });
+    }
+  }
+  const messages = [];
+  if (assistantContent.length > 0) {
+    messages.push(modelMessageSchema.parse({ role: "assistant", content: assistantContent }));
+  }
+  if (toolContent.length > 0) {
+    messages.push(modelMessageSchema.parse({ role: "tool", content: toolContent }));
+  }
+  return messages;
+}
+async function projectAgentHistory(messages, options = {}) {
+  const projected = [];
+  for (const message of messages) {
+    if (message.status === "streaming" || message.status === "failed")
+      continue;
+    if (message.role === "user") {
+      const user = await userMessage(message, options);
+      if (user)
+        projected.push(user);
+      continue;
+    }
+    if (message.role === "system" || message.role === "summary") {
+      const content = textContent(message.parts);
+      if (content)
+        projected.push(modelMessageSchema.parse({ role: "system", content }));
+      continue;
+    }
+    projected.push(...assistantMessages(message));
+  }
+  return projected;
+}
+// src/agent-runtime/managed-tools.ts
+async function assertFence(config, input) {
+  const rejected = await config.assertCurrent(input);
+  if (rejected)
+    throw new ToolExecutionControlError(rejected);
+}
+function createAgentToolFenceLifecycle(config) {
+  const callContext = (ctx, endpoint) => ({
+    runId: config.runId,
+    ...config.context?.(ctx, endpoint)
+  });
+  return {
+    async beforeHandle(ctx, endpoint) {
+      await assertFence(config, callContext(ctx, endpoint));
+    },
+    async afterHandle(ctx, result, endpoint) {
+      const current = callContext(ctx, endpoint);
+      await assertFence(config, current);
+      await config.onSettled?.(current);
+      return result;
+    }
+  };
+}
+// src/agent-runtime/models.ts
+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()
+});
+function defineModelRegistry(config) {
+  const descriptors = new Map;
+  for (const key in config.models) {
+    const declaration = config.models[key];
+    if (declaration)
+      descriptors.set(key, AgentModelDescriptorSchema.parse(declaration));
+  }
+  const descriptor = (key) => {
+    const found = descriptors.get(key);
+    if (!found)
+      throw new Error(`Unknown agent model: ${key}`);
+    return found;
+  };
+  const supports = (key, capabilities) => {
+    const available = new Set(descriptor(key).capabilities);
+    return capabilities.every((capability) => available.has(capability));
+  };
+  return {
+    keys: () => [...descriptors.keys()],
+    descriptor,
+    supports,
+    resolve(key, required = []) {
+      const selected = descriptor(key);
+      if (!supports(key, required)) {
+        throw new Error(`Agent model ${key} does not satisfy required capabilities`);
+      }
+      const provider = config.providers[selected.provider];
+      if (!provider)
+        throw new Error(`Unknown agent model provider: ${selected.provider}`);
+      return {
+        descriptor: selected,
+        model: provider.create(selected.modelId),
+        ...provider.normalizeUsage && { normalizeUsage: provider.normalizeUsage }
+      };
+    }
+  };
+}
+// src/agent-runtime/observability.ts
+import { z as z4 } from "zod";
+var AgentRunEventSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  eventId: AgentRecordIdSchema,
+  type: z4.enum(["run-started", "step-finished", "run-terminal"]),
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  traceId: z4.string().min(1),
+  spanId: z4.string().min(1),
+  parentSpanId: z4.string().min(1).optional(),
+  state: AgentRunStateSchema,
+  terminalReason: AgentTerminalReasonSchema.optional(),
+  modelId: z4.string().min(1).optional(),
+  step: z4.int().nonnegative().optional(),
+  queueWaitMs: z4.number().nonnegative().optional(),
+  durationMs: z4.number().nonnegative().optional(),
+  ttftMs: z4.number().nonnegative().optional(),
+  usage: AgentUsageSchema.optional(),
+  internalCause: z4.unknown().optional(),
+  emittedAt: AgentTimestampSchema
+});
+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 }
+  });
+  return {
+    rootTrace(parent) {
+      const trace = parent ? childSpan(parent) : createTraceContext();
+      return trace;
+    },
+    emit(rawEvent) {
+      manager.submit(() => AgentRunEventSchema.parse(rawEvent));
+    },
+    flush: () => manager.flush(),
+    getStatus: () => manager.getStatus(),
+    close: () => manager.close()
+  };
+}
+// src/agent-runtime/prompt.ts
+import { z as z5 } from "zod";
+var AgentTokenCountSchema = z5.object({
+  value: z5.int().nonnegative().optional(),
+  provenance: z5.enum(["measured", "estimated", "unavailable"])
+});
+function knownValue(value) {
+  return value.provenance === "unavailable" ? undefined : value.value;
+}
+function composeAgentPrompt(sections) {
+  return async (options) => {
+    const rendered = [];
+    let total = 0;
+    let unavailable = false;
+    let estimated = false;
+    for (const section of sections) {
+      const text = await section.render({ context: options.context, signal: options.signal });
+      rendered.push({ name: section.name, stability: section.stability, text });
+      let count;
+      if (section.estimateTokens)
+        count = await section.estimateTokens(text);
+      else if (options.estimateFallback)
+        count = await options.estimateFallback(text);
+      else
+        count = { provenance: "unavailable" };
+      const value = knownValue(count);
+      if (value === undefined)
+        unavailable = true;
+      else
+        total += value;
+      if (count.provenance === "estimated")
+        estimated = true;
+    }
+    const instructionTokens = unavailable ? { provenance: "unavailable" } : { value: total, provenance: estimated ? "estimated" : "measured" };
+    let availableHistoryTokens;
+    let contextDecision = "unavailable";
+    if (options.budget) {
+      const reserveValues = [
+        options.budget.reservedOutput,
+        knownValue(options.budget.toolSchemas),
+        knownValue(options.budget.attachments),
+        knownValue(options.budget.providerOverhead),
+        knownValue(instructionTokens)
+      ];
+      if (reserveValues.every((value) => value !== undefined)) {
+        availableHistoryTokens = Math.max(0, options.budget.contextWindow - reserveValues.reduce((sum, value) => sum + (value ?? 0), 0));
+        const historyTokens = options.historyTokens ? knownValue(options.historyTokens) : undefined;
+        if (historyTokens !== undefined) {
+          if (historyTokens <= availableHistoryTokens)
+            contextDecision = "fits";
+          else
+            contextDecision = options.oversizePolicy === "compact" ? "requires-compaction" : "oversized";
+        }
+      }
+    }
+    const instructionText = rendered.map((section) => section.text).join(`
+
+`);
+    return {
+      instructions: options.adaptInstructions ? await options.adaptInstructions(instructionText) : instructionText,
+      sections: rendered,
+      instructionTokens,
+      contextDecision,
+      ...availableHistoryTokens !== undefined && { availableHistoryTokens }
+    };
+  };
+}
+// src/agent-runtime/protocol.ts
+function defineAgentProtocol(config) {
+  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)
+  };
+}
+// src/agent-runtime/runtime.ts
+import {
+  stepCountIs,
+  streamText
+} from "ai";
+import { z as z6 } from "zod";
+class AgentRuntimeConflictError extends Error {
+  constructor(operation) {
+    super(`Agent runtime store conflict during ${operation}`);
+    this.name = "AgentRuntimeConflictError";
+  }
+}
+function appliedSnapshot(result, operation) {
+  if (result.outcome === "applied" || result.outcome === "duplicate")
+    return result.snapshot;
+  throw new AgentRuntimeConflictError(operation);
+}
+function findRun(runs, runId) {
+  const run = runs.find((candidate) => candidate.id === runId);
+  if (!run)
+    throw new AgentRuntimeConflictError("run lookup");
+  return run;
+}
+function jsonValue(value) {
+  const parsed = z6.json().safeParse(value);
+  return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
+}
+function providerEnvelope(value) {
+  const parsed = AgentJsonObjectSchema.safeParse(value);
+  if (!parsed.success)
+    return;
+  return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
+}
+function appendText(parts, text) {
+  const previous = parts.at(-1);
+  if (previous?.type === "text") {
+    const next = AgentMessagePartSchema.parse({ ...previous, text: previous.text + text });
+    parts.splice(parts.length - 1, 1, next);
+    return;
+  }
+  parts.push(AgentMessagePartSchema.parse({ type: "text", text }));
+}
+function assistantStatus(reason) {
+  if (reason === "success" || reason === "policy_stop")
+    return "completed";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+function abortTerminalReason(signal) {
+  if (signal.reason === "shutdown")
+    return "shutdown";
+  if (signal.reason === "timeout")
+    return "timeout";
+  return "interrupted";
+}
+function normalizeSdkUsage(value) {
+  const reported = (tokens) => tokens === undefined ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
+  return {
+    inputTokens: reported(value.inputTokens),
+    outputTokens: reported(value.outputTokens),
+    reasoningTokens: reported(value.outputTokenDetails.reasoningTokens),
+    cacheReadTokens: reported(value.inputTokenDetails.cacheReadTokens),
+    cacheWriteTokens: reported(value.inputTokenDetails.cacheWriteTokens)
+  };
+}
+function createIdleDeadline(parent, timeoutMs) {
+  if (timeoutMs === undefined) {
+    const noop = () => {
+      return;
+    };
+    return { signal: parent, touch: noop, dispose: noop };
+  }
+  const controller = new AbortController;
+  let timer;
+  const touch = () => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  };
+  touch();
+  return {
+    signal: AbortSignal.any([parent, controller.signal]),
+    touch,
+    dispose() {
+      if (timer !== undefined)
+        clearTimeout(timer);
+    }
+  };
+}
+function createAgentRuntime(config) {
+  const coordinator = createAgentSessionCoordinator();
+  const tickets = new Map;
+  const generateId = config.generateId ?? (() => crypto.randomUUID());
+  const now = config.now ?? (() => new Date);
+  const runtimeEpoch = generateId();
+  const admissionLanes = new Map;
+  const reserveAdmission = (key, runId) => {
+    const existing = admissionLanes.get(key);
+    const lane = existing ?? { acceptanceTail: Promise.resolve() };
+    if (!existing)
+      admissionLanes.set(key, lane);
+    if (!lane.head) {
+      const admission = { runId, completion: Promise.withResolvers() };
+      admission.completion.promise.catch(() => {
+        return;
+      });
+      lane.head = admission;
+      return { lane, admission, shouldSchedule: true };
+    }
+    if (!lane.pending) {
+      const admission = { runId, completion: Promise.withResolvers() };
+      admission.completion.promise.catch(() => {
+        return;
+      });
+      lane.pending = admission;
+      return { lane, admission, shouldSchedule: true };
+    }
+    return { lane, admission: lane.pending, shouldSchedule: false };
+  };
+  const settleAdmission = (key, admission) => {
+    const lane = admissionLanes.get(key);
+    if (!lane)
+      return;
+    if (lane.head?.runId === admission.runId) {
+      lane.head = lane.pending;
+      lane.pending = undefined;
+    } else if (lane.pending?.runId === admission.runId) {
+      lane.pending = undefined;
+    }
+    if (!lane.head && !lane.pending)
+      admissionLanes.delete(key);
+  };
+  const waitForAdmissionAcceptances = async (lane) => {
+    while (true) {
+      const tail = lane.acceptanceTail;
+      await tail.catch(() => {
+        return;
+      });
+      if (tail === lane.acceptanceTail)
+        return;
+    }
+  };
+  const checkpointEveryEvents = config.loop?.checkpointEveryEvents ?? 20;
+  const maxSteps = config.loop?.maxSteps ?? 50;
+  const idleTimeoutMs = config.loop?.idleTimeoutMs;
+  if (!Number.isSafeInteger(checkpointEveryEvents) || checkpointEveryEvents < 1) {
+    throw new TypeError("checkpointEveryEvents must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(maxSteps) || maxSteps < 1) {
+    throw new TypeError("maxSteps must be a positive safe integer");
+  }
+  if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
+    throw new TypeError("idleTimeoutMs must be a positive safe integer");
+  }
+  const policyNames = new Set(["max-steps"]);
+  for (const policy of config.loop?.stopPolicies ?? []) {
+    if (!policy.name || policyNames.has(policy.name)) {
+      throw new TypeError("Agent stop policy names must be non-empty and unique");
+    }
+    policyNames.add(policy.name);
+  }
+  const publish = async (event) => {
+    try {
+      await config.publish?.(event);
+    } catch {}
+  };
+  const executeRun = async (input) => {
+    const queuedSnapshot = await config.store.loadSnapshot(input.acceptedRun.conversationId);
+    const queuedRun = findRun(queuedSnapshot.runs, input.acceptedRun.id);
+    const acquired = appliedSnapshot(await config.store.acquireRun({
+      conversationId: queuedRun.conversationId,
+      runId: queuedRun.id,
+      expectedRevision: queuedRun.revision,
+      ownerId: runtimeEpoch
+    }), "run acquisition");
+    let run = findRun(acquired.runs, input.acceptedRun.id);
+    await publish({
+      type: "run-state",
+      eventId: generateId(),
+      conversationId: run.conversationId,
+      runId: run.id,
+      snapshotVersion: acquired.version,
+      state: run.state,
+      emittedAt: now().toISOString()
+    });
+    const trace = config.observe?.rootTrace();
+    const runStartedAt = performance.now();
+    config.observe?.emit({
+      schemaVersion: 1,
+      eventId: generateId(),
+      type: "run-started",
+      conversationId: run.conversationId,
+      runId: run.id,
+      traceId: trace?.traceId ?? generateId(),
+      spanId: trace?.spanId ?? generateId(),
+      ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
+      state: run.state,
+      queueWaitMs: Math.max(0, now().getTime() - new Date(run.createdAt).getTime()),
+      emittedAt: now().toISOString()
+    });
+    let assistant = AgentMessageSchema.parse({
+      schemaVersion: 1,
+      id: run.assistantMessageId,
+      conversationId: run.conversationId,
+      runId: run.id,
+      role: "assistant",
+      status: "streaming",
+      parts: [],
+      createdAt: now().toISOString(),
+      updatedAt: now().toISOString()
+    });
+    let snapshot = appliedSnapshot(await config.store.checkpointRunAssistant({
+      conversationId: run.conversationId,
+      runId: run.id,
+      expectedRevision: run.revision,
+      ownerId: runtimeEpoch,
+      assistant
+    }), "assistant draft");
+    run = findRun(snapshot.runs, run.id);
+    const parts = [];
+    let eventCount = 0;
+    let sequence = 0;
+    let terminalReason = "success";
+    let usage;
+    let step = 0;
+    let selectedModel;
+    let internalCause;
+    let reasoningPartIndex;
+    let firstOutputAt;
+    let terminalPolicyName;
+    const idleDeadline = createIdleDeadline(input.signal, idleTimeoutMs);
+    const executionSignal = idleDeadline.signal;
+    const updateReasoning = (text, metadata) => {
+      const provider = providerEnvelope(metadata);
+      if (reasoningPartIndex === undefined) {
+        reasoningPartIndex = parts.length;
+        parts.push(AgentMessagePartSchema.parse({
+          type: "reasoning",
+          text,
+          ...provider && { provider }
+        }));
+        return;
+      }
+      const current = parts[reasoningPartIndex];
+      if (current?.type !== "reasoning") {
+        throw new AgentRuntimeConflictError("reasoning accumulator");
+      }
+      parts.splice(reasoningPartIndex, 1, AgentMessagePartSchema.parse({
+        ...current,
+        text: current.text + text,
+        ...provider && { provider }
+      }));
+    };
+    const checkpoint = async () => {
+      assistant = AgentMessageSchema.parse({
+        ...assistant,
+        parts,
+        updatedAt: now().toISOString()
+      });
+      snapshot = appliedSnapshot(await config.store.checkpointRunAssistant({
+        conversationId: run.conversationId,
+        runId: run.id,
+        expectedRevision: run.revision,
+        ownerId: runtimeEpoch,
+        assistant
+      }), "assistant checkpoint");
+      run = findRun(snapshot.runs, run.id);
+      await publish({
+        type: "assistant-checkpoint",
+        eventId: generateId(),
+        conversationId: run.conversationId,
+        runId: run.id,
+        snapshotVersion: snapshot.version,
+        message: assistant,
+        emittedAt: now().toISOString()
+      });
+    };
+    try {
+      if (config.history?.compact) {
+        const compacted = await config.history.compact({
+          conversationId: run.conversationId,
+          store: config.store,
+          signal: executionSignal
+        });
+        snapshot = compacted.snapshot;
+        run = findRun(snapshot.runs, run.id);
+      }
+      const assertCurrent = async () => {
+        if (executionSignal.aborted)
+          return "run_interrupted";
+        const current = await config.store.loadSnapshot(run.conversationId);
+        const currentRun = current.runs.find((candidate) => candidate.id === run.id);
+        if (!currentRun || currentRun.ownerId !== runtimeEpoch)
+          return "stale_run";
+        if (currentRun.state === "interrupt_requested")
+          return "run_interrupted";
+        if (currentRun.state !== "running")
+          return "stale_run";
+        return;
+      };
+      const toolFenceLifecycle = createAgentToolFenceLifecycle({
+        runId: run.id,
+        assertCurrent
+      });
+      const runtimeContext = {
+        context: input.context,
+        run,
+        signal: executionSignal,
+        toolFenceLifecycle
+      };
+      selectedModel = await config.models.resolve({
+        context: input.context,
+        conversationId: run.conversationId
+      });
+      const [prompt, tools] = await Promise.all([
+        config.prompt({
+          context: input.context,
+          signal: executionSignal,
+          model: selectedModel,
+          snapshot
+        }),
+        config.tools(runtimeContext)
+      ]);
+      if (prompt.contextDecision === "oversized") {
+        throw new Error("Agent context exceeds the configured model budget");
+      }
+      if (prompt.contextDecision === "requires-compaction") {
+        throw new Error("Agent context still exceeds the model budget after compaction");
+      }
+      const history = await (config.history?.project ? config.history.project(snapshot.messages) : projectAgentHistory(snapshot.messages, {
+        ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
+        ...config.history?.unresolvedFile && {
+          unresolvedFile: config.history.unresolvedFile
+        }
+      }));
+      const maxStepCondition = stepCountIs(maxSteps);
+      const stopConditions = [
+        async (options) => {
+          const stopped = await maxStepCondition(options);
+          if (stopped && terminalPolicyName === undefined)
+            terminalPolicyName = "max-steps";
+          return stopped;
+        }
+      ];
+      for (const policy of config.loop?.stopPolicies ?? []) {
+        stopConditions.push(async (options) => {
+          const stopped = await policy.when(options);
+          if (stopped && terminalPolicyName === undefined)
+            terminalPolicyName = policy.name;
+          return stopped;
+        });
+      }
+      const result = streamText({
+        model: selectedModel.model,
+        tools,
+        instructions: prompt.instructions,
+        messages: history,
+        abortSignal: executionSignal,
+        maxRetries: 0,
+        stopWhen: stopConditions,
+        ...config.loop?.prepareStep && {
+          prepareStep: (options) => config.loop?.prepareStep?.({ ...options, ...runtimeContext })
+        }
+      });
+      for await (const part of result.stream) {
+        idleDeadline.touch();
+        eventCount += 1;
+        sequence += 1;
+        if (firstOutputAt === undefined && ["text-delta", "reasoning-delta", "tool-call", "file", "source"].includes(part.type)) {
+          firstOutputAt = performance.now();
+        }
+        if (part.type === "text-delta") {
+          appendText(parts, part.text);
+          await publish({
+            type: "assistant-delta",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            textDelta: part.text,
+            emittedAt: now().toISOString()
+          });
+        } else if (part.type === "reasoning-start") {
+          reasoningPartIndex = undefined;
+          updateReasoning("", part.providerMetadata);
+        } else if (part.type === "reasoning-delta") {
+          updateReasoning(part.text, part.providerMetadata);
+        } else if (part.type === "reasoning-end") {
+          updateReasoning("", part.providerMetadata);
+          reasoningPartIndex = undefined;
+        } else if (part.type === "tool-call") {
+          const provider = providerEnvelope(part.providerMetadata);
+          parts.push(AgentMessagePartSchema.parse({
+            type: "tool-call",
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            input: jsonValue(part.input),
+            ...provider && { provider }
+          }));
+          await publish({
+            type: "tool-status",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            status: "started",
+            input: jsonValue(part.input),
+            emittedAt: now().toISOString()
+          });
+        } else if (part.type === "tool-result") {
+          parts.push(AgentMessagePartSchema.parse({
+            type: "tool-result",
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            outcome: "success",
+            output: jsonValue(part.output)
+          }));
+          await publish({
+            type: "tool-status",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            status: "completed",
+            output: jsonValue(part.output),
+            emittedAt: now().toISOString()
+          });
+        } else if (part.type === "tool-error") {
+          internalCause = part.error;
+          if (isToolExecutionControlError(part.error)) {
+            await publish({
+              type: "tool-status",
+              conversationId: run.conversationId,
+              runId: run.id,
+              runtimeEpoch,
+              sequence,
+              callId: part.toolCallId,
+              toolName: part.toolName,
+              status: "interrupted",
+              emittedAt: now().toISOString()
+            });
+            throw part.error;
+          }
+          parts.push(AgentMessagePartSchema.parse({
+            type: "tool-result",
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            outcome: "error",
+            output: { message: "Tool execution failed" }
+          }));
+          await publish({
+            type: "tool-status",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            status: "failed",
+            output: { message: "Tool execution failed" },
+            emittedAt: now().toISOString()
+          });
+        } else if (part.type === "tool-output-denied") {
+          parts.push(AgentMessagePartSchema.parse({
+            type: "tool-result",
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            outcome: "error",
+            output: { message: "Tool output denied" }
+          }));
+          await publish({
+            type: "tool-status",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            callId: part.toolCallId,
+            toolName: part.toolName,
+            status: "failed",
+            output: { message: "Tool output denied" },
+            emittedAt: now().toISOString()
+          });
+        } else if (part.type === "source") {
+          parts.push(AgentMessagePartSchema.parse({
+            type: "source",
+            sourceId: part.id,
+            ...part.sourceType === "url" && { url: part.url },
+            ...part.title && { title: part.title }
+          }));
+        } else if (part.type === "file" && config.persistGeneratedFile) {
+          const persisted = await config.persistGeneratedFile(part.file);
+          parts.push(AgentMessagePartSchema.parse({
+            type: "file",
+            mediaType: part.file.mediaType,
+            reference: persisted.reference,
+            ...persisted.filename && { filename: persisted.filename }
+          }));
+        } else if (part.type === "file") {
+          throw new Error("persistGeneratedFile is required for generated file output");
+        } else if (part.type === "reasoning-file" && config.persistGeneratedFile) {
+          const persisted = await config.persistGeneratedFile(part.file);
+          parts.push(AgentMessagePartSchema.parse({
+            type: "file",
+            mediaType: part.file.mediaType,
+            reference: persisted.reference,
+            ...persisted.filename && { filename: persisted.filename }
+          }));
+        } else if (part.type === "reasoning-file") {
+          throw new Error("persistGeneratedFile is required for generated reasoning files");
+        } else if (part.type === "tool-approval-request" || part.type === "tool-approval-response") {
+          throw new Error("Durable tool approval/resume is outside this runtime version");
+        } else if (part.type === "custom") {
+          const provider = providerEnvelope(part.providerMetadata);
+          parts.push(AgentMessagePartSchema.parse({
+            type: "provider",
+            envelope: {
+              schemaVersion: 1,
+              provider: "ai-sdk-custom",
+              data: { kind: part.kind, ...provider && { provider: provider.data } }
+            }
+          }));
+        } else if (part.type === "raw") {
+          parts.push(AgentMessagePartSchema.parse({
+            type: "provider",
+            envelope: {
+              schemaVersion: 1,
+              provider: "ai-sdk-raw",
+              data: { value: jsonValue(part.rawValue) }
+            }
+          }));
+        } else if (part.type === "abort") {
+          terminalReason = "interrupted";
+        } else if (part.type === "error") {
+          terminalReason = "provider_failure";
+          internalCause = part.error;
+        } else if (part.type === "finish-step") {
+          const stepTrace = trace ? config.observe?.rootTrace(trace) : undefined;
+          const stepUsage = selectedModel.normalizeUsage?.({
+            usage: part.usage,
+            providerMetadata: part.providerMetadata
+          }) ?? normalizeSdkUsage(part.usage);
+          usage = stepUsage;
+          config.observe?.emit({
+            schemaVersion: 1,
+            eventId: generateId(),
+            type: "step-finished",
+            conversationId: run.conversationId,
+            runId: run.id,
+            traceId: stepTrace?.traceId ?? trace?.traceId ?? generateId(),
+            spanId: stepTrace?.spanId ?? generateId(),
+            ...stepTrace?.parentSpanId && { parentSpanId: stepTrace.parentSpanId },
+            state: run.state,
+            modelId: selectedModel.descriptor.modelId,
+            step,
+            usage: stepUsage,
+            emittedAt: now().toISOString()
+          });
+          step += 1;
+        } else if (part.type === "finish" && part.finishReason !== "stop") {
+          terminalReason = "policy_stop";
+        }
+        if (part.type === "finish") {
+          const aggregate = normalizeSdkUsage(part.totalUsage);
+          usage = { ...aggregate, ...usage?.cost && { cost: usage.cost } };
+        }
+        if (eventCount % checkpointEveryEvents === 0)
+          await checkpoint();
+      }
+      if (terminalPolicyName !== undefined)
+        terminalReason = "policy_stop";
+      if (executionSignal.aborted)
+        terminalReason = abortTerminalReason(executionSignal);
+    } catch (error) {
+      internalCause = error;
+      const latest = await config.store.loadSnapshot(run.conversationId);
+      const latestRun = latest.runs.find((candidate) => candidate.id === run.id);
+      const durableInterrupt = latestRun?.ownerId === runtimeEpoch && latestRun.state === "interrupt_requested";
+      if (durableInterrupt && latestRun) {
+        snapshot = latest;
+        run = latestRun;
+      }
+      if (isToolExecutionControlError(error) || executionSignal.aborted || durableInterrupt) {
+        terminalReason = executionSignal.aborted ? abortTerminalReason(executionSignal) : "interrupted";
+        parts.push(AgentMessagePartSchema.parse({
+          type: "control",
+          reason: isToolExecutionControlError(error) && error.reason === "stale_run" ? "stale-run" : "run-interrupted"
+        }));
+      } else {
+        terminalReason = "provider_failure";
+      }
+    }
+    idleDeadline.dispose();
+    assistant = AgentMessageSchema.parse({
+      ...assistant,
+      status: assistantStatus(terminalReason),
+      parts,
+      updatedAt: now().toISOString()
+    });
+    snapshot = appliedSnapshot(await config.store.commitRunTerminal({
+      conversationId: run.conversationId,
+      runId: run.id,
+      expectedRevision: run.revision,
+      ownerId: runtimeEpoch,
+      assistant,
+      reason: terminalReason,
+      ...terminalPolicyName && { policyName: terminalPolicyName }
+    }), "terminal commit");
+    run = findRun(snapshot.runs, run.id);
+    config.observe?.emit({
+      schemaVersion: 1,
+      eventId: generateId(),
+      type: "run-terminal",
+      conversationId: run.conversationId,
+      runId: run.id,
+      traceId: trace?.traceId ?? generateId(),
+      spanId: trace?.spanId ?? generateId(),
+      ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
+      state: run.state,
+      terminalReason,
+      ...selectedModel && { modelId: selectedModel.descriptor.modelId },
+      durationMs: performance.now() - runStartedAt,
+      ...usage && { usage },
+      ...internalCause !== undefined && { internalCause },
+      ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
+      emittedAt: now().toISOString()
+    });
+    await publish({
+      type: "terminal",
+      eventId: generateId(),
+      conversationId: run.conversationId,
+      runId: run.id,
+      snapshotVersion: snapshot.version,
+      reason: terminalReason,
+      ...terminalPolicyName && { policyName: terminalPolicyName },
+      message: assistant,
+      emittedAt: now().toISOString()
+    });
+    return {
+      run,
+      message: assistant,
+      reason: terminalReason,
+      snapshotVersion: snapshot.version,
+      ...terminalPolicyName && { policyName: terminalPolicyName }
+    };
+  };
+  return {
+    submit(rawInput) {
+      const metadata = rawInput.metadata === undefined ? undefined : config.protocol.parseInputMetadata(rawInput.metadata);
+      const input = {
+        conversationId: rawInput.conversationId,
+        idempotencyKey: rawInput.idempotencyKey,
+        context: rawInput.context,
+        parts: rawInput.parts.map((part) => config.protocol.parsePart(part)),
+        ...metadata !== undefined && { metadata }
+      };
+      const context = config.protocol.parseContext(input.context);
+      const ticketKey = `${input.conversationId}\x00${input.idempotencyKey}`;
+      const existingTicket = tickets.get(ticketKey);
+      if (existingTicket)
+        return existingTicket;
+      const key = config.runs?.key?.(input) ?? input.conversationId;
+      const policy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
+      const nowIso = now().toISOString();
+      const inputMessageId = generateId();
+      const runId = generateId();
+      const assistantMessageId = generateId();
+      const userMessage2 = AgentMessageSchema.parse({
+        schemaVersion: 1,
+        id: inputMessageId,
+        conversationId: input.conversationId,
+        role: "user",
+        status: "committed",
+        parts: input.parts,
+        ...input.metadata && { metadata: input.metadata },
+        createdAt: nowIso,
+        updatedAt: nowIso
+      });
+      const queuedRun = AgentRunSchema.parse({
+        schemaVersion: 1,
+        id: runId,
+        conversationId: input.conversationId,
+        inputMessageIds: [inputMessageId],
+        assistantMessageId,
+        state: "queued",
+        revision: 0,
+        createdAt: nowIso,
+        updatedAt: nowIso
+      });
+      const outerAccepted = Promise.withResolvers();
+      const outerResult = Promise.withResolvers();
+      const reservation = config.runs?.coalescePending ? reserveAdmission(key, runId) : undefined;
+      const previousAcceptance = reservation?.lane.acceptanceTail ?? Promise.resolve();
+      const acceptanceDone = Promise.withResolvers();
+      if (reservation) {
+        reservation.lane.acceptanceTail = previousAcceptance.catch(() => {
+          return;
+        }).then(() => acceptanceDone.promise);
+      }
+      const publicTicket = { accepted: outerAccepted.promise, result: outerResult.promise };
+      tickets.set(ticketKey, publicTicket);
+      outerResult.promise.then(() => tickets.delete(ticketKey), () => tickets.delete(ticketKey));
+      (async () => {
+        try {
+          await previousAcceptance.catch(() => {
+            return;
+          });
+          const acceptance = await config.store.acceptInputAndAssignRun({
+            idempotencyKey: input.idempotencyKey,
+            input: userMessage2,
+            run: queuedRun,
+            ...reservation && !reservation.shouldSchedule && {
+              coalesceIntoRunId: reservation.admission.runId
+            }
+          });
+          const acceptedSnapshot = appliedSnapshot(acceptance, "input acceptance");
+          const assignedRunId = acceptance.outcome === "duplicate" ? acceptance.runId : reservation?.admission.runId ?? runId;
+          const acceptedRun = findRun(acceptedSnapshot.runs, assignedRunId);
+          await publish({
+            type: "run-state",
+            eventId: generateId(),
+            conversationId: acceptedRun.conversationId,
+            runId: acceptedRun.id,
+            snapshotVersion: acceptedSnapshot.version,
+            state: acceptedRun.state,
+            emittedAt: now().toISOString()
+          });
+          outerAccepted.resolve();
+          if (acceptance.outcome === "duplicate") {
+            if (!acceptedRun.terminalReason) {
+              const error = new Error("Duplicate input is already owned by another runtime execution");
+              outerResult.reject(error);
+              if (reservation?.shouldSchedule) {
+                reservation.admission.completion.reject(error);
+                settleAdmission(key, reservation.admission);
+              }
+              return;
+            }
+            const message = acceptedSnapshot.messages.find((candidate) => candidate.id === acceptedRun.assistantMessageId);
+            if (!message) {
+              const error = new Error("Duplicate terminal run has no assistant message");
+              outerResult.reject(error);
+              if (reservation?.shouldSchedule) {
+                reservation.admission.completion.reject(error);
+                settleAdmission(key, reservation.admission);
+              }
+              return;
+            }
+            outerResult.resolve({
+              run: acceptedRun,
+              message,
+              reason: acceptedRun.terminalReason,
+              snapshotVersion: acceptedSnapshot.version,
+              ...acceptedRun.terminalPolicyName && {
+                policyName: acceptedRun.terminalPolicyName
+              }
+            });
+            if (reservation?.shouldSchedule) {
+              reservation.admission.completion.reject(new Error("Reserved run resolved to a duplicate durable input"));
+              settleAdmission(key, reservation.admission);
+            }
+            return;
+          }
+          if (reservation && !reservation.shouldSchedule) {
+            reservation.admission.completion.promise.then(outerResult.resolve, outerResult.reject);
+            return;
+          }
+          const ticket = coordinator.submit({
+            key,
+            policy,
+            create: async (signal) => {
+              if (reservation)
+                await waitForAdmissionAcceptances(reservation.lane);
+              return {
+                runId: acceptedRun.id,
+                execute: () => executeRun({ acceptedRun, context, signal })
+              };
+            }
+          });
+          if (reservation) {
+            ticket.result.then(reservation.admission.completion.resolve, reservation.admission.completion.reject);
+            reservation.admission.completion.promise.then((value) => {
+              settleAdmission(key, reservation.admission);
+              outerResult.resolve(value);
+            }, (error) => {
+              settleAdmission(key, reservation.admission);
+              outerResult.reject(error);
+            });
+          } else {
+            ticket.result.then(outerResult.resolve, outerResult.reject);
+          }
+        } catch (error) {
+          outerAccepted.reject(error);
+          outerResult.reject(error);
+          if (reservation?.shouldSchedule) {
+            reservation.admission.completion.reject(error);
+            settleAdmission(key, reservation.admission);
+          }
+        } finally {
+          acceptanceDone.resolve();
+        }
+      })();
+      return publicTicket;
+    },
+    resume(rawInput) {
+      const context = config.protocol.parseContext(rawInput.context);
+      const accepted = Promise.withResolvers();
+      const result = Promise.withResolvers();
+      (async () => {
+        try {
+          const snapshot = await config.store.loadSnapshot(rawInput.conversationId);
+          const recoveredRun = findRun(snapshot.runs, rawInput.runId);
+          if (recoveredRun.state !== "queued") {
+            throw new Error("Only a queued recovered agent run can be resumed");
+          }
+          accepted.resolve();
+          const ticket = coordinator.submit({
+            key: rawInput.conversationKey ?? rawInput.conversationId,
+            policy: "queue",
+            create: (signal) => ({
+              runId: recoveredRun.id,
+              execute: () => executeRun({ acceptedRun: recoveredRun, context, signal })
+            })
+          });
+          ticket.result.then(result.resolve, result.reject);
+        } catch (error) {
+          accepted.reject(error);
+          result.reject(error);
+        }
+      })();
+      return { accepted: accepted.promise, result: result.promise };
+    },
+    async interrupt(input) {
+      const snapshot = await config.store.loadSnapshot(input.conversationId);
+      const run = findRun(snapshot.runs, input.runId);
+      const requested = await config.store.requestRunInterrupt({
+        conversationId: input.conversationId,
+        runId: input.runId,
+        expectedRevision: run.revision
+      });
+      if (requested.outcome === "applied") {
+        const interruptedRun = findRun(requested.snapshot.runs, input.runId);
+        await publish({
+          type: "run-state",
+          eventId: generateId(),
+          conversationId: interruptedRun.conversationId,
+          runId: interruptedRun.id,
+          snapshotVersion: requested.snapshot.version,
+          state: interruptedRun.state,
+          emittedAt: now().toISOString()
+        });
+        coordinator.stop(input.conversationKey ?? input.conversationId, "user-interrupt");
+      }
+      return requested;
+    },
+    stop: (conversationKey, reason) => coordinator.stop(conversationKey, reason),
+    close: (options) => coordinator.close(options)
+  };
+}
+// src/agent-runtime/store.ts
+import { z as z7 } from "zod";
+var AgentStoreConflictSchema = z7.object({
+  outcome: z7.literal("conflict"),
+  actualVersion: AgentRecordVersionSchema
+});
+var AgentStoreNotFoundSchema = z7.object({
+  outcome: z7.literal("not_found")
+});
+var AgentStoreAppliedSchema = z7.object({
+  outcome: z7.literal("applied"),
+  snapshot: AgentSnapshotSchema
+});
+var AgentStoreDuplicateSchema = z7.object({
+  outcome: z7.literal("duplicate"),
+  runId: AgentRecordIdSchema,
+  snapshot: AgentSnapshotSchema
+});
+var AgentStoreMutationResultSchema = z7.discriminatedUnion("outcome", [
+  AgentStoreAppliedSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreConflictSchema,
+  AgentStoreNotFoundSchema
+]);
+var AcceptInputAndAssignRunSchema = z7.object({
+  idempotencyKey: z7.string().min(1),
+  expectedVersion: AgentRecordVersionSchema.optional(),
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  coalesceIntoRunId: AgentRecordIdSchema.optional()
+});
+var AcquireAgentRunSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z7.string().min(1)
+});
+var CheckpointRunAssistantSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z7.string().min(1),
+  assistant: AgentMessageSchema
+});
+var CommitRunTerminalSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z7.string().min(1),
+  assistant: AgentMessageSchema,
+  reason: AgentTerminalReasonSchema,
+  policyName: z7.string().min(1).optional()
+});
+var RequestRunInterruptSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema
+});
+var RecoverAgentRunSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  action: z7.enum(["requeue", "abandon"]),
+  replaySafe: z7.boolean().optional()
+});
+var ReplaceCompactedRangeSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  expectedVersion: AgentRecordVersionSchema,
+  replacedMessageIds: z7.array(AgentRecordIdSchema).min(1),
+  summary: AgentMessageSchema
+});
+function emptySnapshot(conversationId) {
+  return AgentSnapshotSchema.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: 0,
+    messages: [],
+    runs: []
+  });
+}
+function cloneSnapshot(snapshot) {
+  return AgentSnapshotSchema.parse(structuredClone(snapshot));
+}
+function replaceRun(runs, next) {
+  return runs.map((run) => run.id === next.id ? next : run);
+}
+function replaceMessage(messages, next) {
+  const exists = messages.some((message) => message.id === next.id);
+  if (!exists)
+    return [...messages, next];
+  return messages.map((message) => message.id === next.id ? next : message);
+}
+function terminalState(reason) {
+  if (reason === "success" || reason === "policy_stop")
+    return "completed";
+  if (reason === "interrupted")
+    return "interrupted";
+  if (reason === "cancelled" || reason === "shutdown" || reason === "timeout") {
+    return "cancelled";
+  }
+  if (reason === "abandoned")
+    return "abandoned";
+  return "failed";
+}
+function terminalMessageStatus(reason) {
+  if (reason === "success" || reason === "policy_stop")
+    return "completed";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+function createMemoryAgentRuntimeStore() {
+  const conversations = new Map;
+  const get = (conversationId) => {
+    const existing = conversations.get(conversationId);
+    if (existing)
+      return existing;
+    const created = { snapshot: emptySnapshot(conversationId), idempotency: new Map };
+    conversations.set(conversationId, created);
+    return created;
+  };
+  const conflict = (actualVersion) => ({
+    outcome: "conflict",
+    actualVersion
+  });
+  const apply = (entry, snapshot) => {
+    entry.snapshot = AgentSnapshotSchema.parse(snapshot);
+    return { outcome: "applied", snapshot: cloneSnapshot(entry.snapshot) };
+  };
+  return {
+    async loadSnapshot(conversationId) {
+      return cloneSnapshot(get(conversationId).snapshot);
+    },
+    async acceptInputAndAssignRun(rawInput) {
+      const input = AcceptInputAndAssignRunSchema.parse(rawInput);
+      const entry = get(input.input.conversationId);
+      const duplicateRunId = entry.idempotency.get(input.idempotencyKey);
+      if (duplicateRunId !== undefined) {
+        return {
+          outcome: "duplicate",
+          runId: duplicateRunId,
+          snapshot: cloneSnapshot(entry.snapshot)
+        };
+      }
+      if (input.run.conversationId !== input.input.conversationId || input.run.inputMessageIds.length !== 1 || input.run.inputMessageIds[0] !== input.input.id || input.run.state !== "queued" || input.run.revision !== 0 || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" || input.input.status !== "committed" || input.input.runId !== undefined || entry.snapshot.messages.some((message) => message.id === input.input.id) || entry.snapshot.runs.some((candidate) => candidate.id === input.run.id)) {
+        throw new TypeError("Input and queued run do not form one valid assignment");
+      }
+      if (input.expectedVersion !== undefined && input.expectedVersion !== entry.snapshot.version) {
+        return conflict(entry.snapshot.version);
+      }
+      const coalescedRun = input.coalesceIntoRunId ? entry.snapshot.runs.find((candidate) => candidate.id === input.coalesceIntoRunId) : undefined;
+      if (input.coalesceIntoRunId !== undefined && (!coalescedRun || coalescedRun.conversationId !== input.input.conversationId || coalescedRun.state !== "queued" || coalescedRun.ownerId !== undefined || coalescedRun.terminalReason !== undefined)) {
+        return coalescedRun ? conflict(coalescedRun.revision) : { outcome: "not_found" };
+      }
+      const assignedRun = coalescedRun ? AgentRunSchema.parse({
+        ...coalescedRun,
+        inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
+        revision: coalescedRun.revision + 1,
+        updatedAt: new Date().toISOString()
+      }) : input.run;
+      const next = AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        messages: [...entry.snapshot.messages, input.input],
+        runs: coalescedRun ? replaceRun(entry.snapshot.runs, assignedRun) : [...entry.snapshot.runs, assignedRun]
+      });
+      entry.idempotency.set(input.idempotencyKey, assignedRun.id);
+      return apply(entry, next);
+    },
+    async acquireRun(rawInput) {
+      const input = AcquireAgentRunSchema.parse(rawInput);
+      const entry = get(input.conversationId);
+      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
+      if (!run)
+        return { outcome: "not_found" };
+      if (run.revision !== input.expectedRevision || run.state !== "queued") {
+        return conflict(run.revision);
+      }
+      const nextRun = AgentRunSchema.parse({
+        ...run,
+        state: "running",
+        ownerId: input.ownerId,
+        revision: run.revision + 1,
+        updatedAt: new Date().toISOString()
+      });
+      return apply(entry, AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        runs: replaceRun(entry.snapshot.runs, nextRun)
+      }));
+    },
+    async checkpointRunAssistant(rawInput) {
+      const input = CheckpointRunAssistantSchema.parse(rawInput);
+      const entry = get(input.conversationId);
+      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
+      if (!run)
+        return { outcome: "not_found" };
+      if (run.revision !== input.expectedRevision || run.state !== "running" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== "streaming") {
+        return conflict(run.revision);
+      }
+      const nextRun = AgentRunSchema.parse({
+        ...run,
+        revision: run.revision + 1,
+        updatedAt: new Date().toISOString()
+      });
+      return apply(entry, AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        messages: replaceMessage(entry.snapshot.messages, input.assistant),
+        runs: replaceRun(entry.snapshot.runs, nextRun)
+      }));
+    },
+    async requestRunInterrupt(rawInput) {
+      const input = RequestRunInterruptSchema.parse(rawInput);
+      const entry = get(input.conversationId);
+      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
+      if (!run)
+        return { outcome: "not_found" };
+      if (run.revision !== input.expectedRevision || run.state !== "running") {
+        return conflict(run.revision);
+      }
+      const nextRun = AgentRunSchema.parse({
+        ...run,
+        state: "interrupt_requested",
+        revision: run.revision + 1,
+        updatedAt: new Date().toISOString()
+      });
+      return apply(entry, AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        runs: replaceRun(entry.snapshot.runs, nextRun)
+      }));
+    },
+    async recoverRun(rawInput) {
+      const input = RecoverAgentRunSchema.parse(rawInput);
+      const entry = get(input.conversationId);
+      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
+      if (!run)
+        return { outcome: "not_found" };
+      if (run.revision !== input.expectedRevision || !["queued", "running", "interrupt_requested"].includes(run.state)) {
+        return conflict(run.revision);
+      }
+      if (input.action === "requeue" && run.state !== "queued" && input.replaySafe !== true) {
+        throw new TypeError("Recovering an acquired run requires explicit replaySafe evidence");
+      }
+      const nextRun = AgentRunSchema.parse({
+        schemaVersion: 1,
+        id: run.id,
+        conversationId: run.conversationId,
+        inputMessageIds: run.inputMessageIds,
+        assistantMessageId: run.assistantMessageId,
+        state: input.action === "requeue" ? "queued" : "abandoned",
+        revision: run.revision + 1,
+        ...input.action === "abandon" && { terminalReason: "abandoned" },
+        createdAt: run.createdAt,
+        updatedAt: new Date().toISOString()
+      });
+      return apply(entry, AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        runs: replaceRun(entry.snapshot.runs, nextRun)
+      }));
+    },
+    async commitRunTerminal(rawInput) {
+      const input = CommitRunTerminalSchema.parse(rawInput);
+      const entry = get(input.conversationId);
+      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
+      if (!run)
+        return { outcome: "not_found" };
+      if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== terminalMessageStatus(input.reason)) {
+        return conflict(run.revision);
+      }
+      const nextRun = AgentRunSchema.parse({
+        ...run,
+        state: terminalState(input.reason),
+        terminalReason: input.reason,
+        ...input.policyName && { terminalPolicyName: input.policyName },
+        revision: run.revision + 1,
+        updatedAt: new Date().toISOString()
+      });
+      return apply(entry, AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        messages: replaceMessage(entry.snapshot.messages, input.assistant),
+        runs: replaceRun(entry.snapshot.runs, nextRun)
+      }));
+    },
+    async replaceCompactedRange(rawInput) {
+      const input = ReplaceCompactedRangeSchema.parse(rawInput);
+      const entry = get(input.conversationId);
+      if (entry.snapshot.version !== input.expectedVersion) {
+        return conflict(entry.snapshot.version);
+      }
+      const replaced = new Set(input.replacedMessageIds);
+      if (!input.replacedMessageIds.every((id) => entry.snapshot.messages.some((m) => m.id === id))) {
+        return { outcome: "not_found" };
+      }
+      const positions = entry.snapshot.messages.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
+      const first = positions[0];
+      if (first === undefined || positions.some((position, offset) => position !== first + offset) || input.summary.conversationId !== input.conversationId || input.summary.runId !== undefined || input.summary.role !== "summary" || input.summary.status !== "committed") {
+        throw new TypeError("Compaction replacement must be one valid contiguous history range");
+      }
+      const before = entry.snapshot.messages.slice(0, first);
+      const after = entry.snapshot.messages.slice(first + positions.length);
+      return apply(entry, AgentSnapshotSchema.parse({
+        ...entry.snapshot,
+        version: entry.snapshot.version + 1,
+        messages: [...before, input.summary, ...after]
+      }));
+    },
+    async scanRecoverable() {
+      return [...conversations.values()].filter((entry) => entry.snapshot.runs.some((run) => ["queued", "running", "interrupt_requested"].includes(run.state))).map((entry) => cloneSnapshot(entry.snapshot));
+    }
+  };
+}
+export {
+  AcceptInputAndAssignRunSchema,
+  AcquireAgentRunSchema,
+  AgentCheckpointEventSchema,
+  AgentControlPartSchema,
+  AgentCostValueSchema,
+  AgentFilePartSchema,
+  AgentJsonObjectSchema,
+  AgentMessagePartSchema,
+  AgentMessageRoleSchema,
+  AgentMessageSchema,
+  AgentMessageStatusSchema,
+  AgentModelCapabilitySchema,
+  AgentModelDescriptorSchema,
+  AgentOpaquePartSchema,
+  AgentProviderEnvelopeSchema,
+  AgentReasoningPartSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunEventSchema,
+  AgentRunSchema,
+  AgentRunStateEventSchema,
+  AgentRunStateSchema,
+  AgentRuntimeEventSchema,
+  AgentSnapshotSchema,
+  AgentSourcePartSchema,
+  AgentStoreAppliedSchema,
+  AgentStoreConflictSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreMutationResultSchema,
+  AgentStoreNotFoundSchema,
+  AgentTerminalEventSchema,
+  AgentTerminalReasonSchema,
+  AgentTextPartSchema,
+  AgentTimestampSchema,
+  AgentTokenCountSchema,
+  AgentToolCallPartSchema,
+  AgentToolResultPartSchema,
+  AgentToolStatusEventSchema,
+  AgentTransientDeltaEventSchema,
+  AgentUsageSchema,
+  AgentUsageValueSchema,
+  CheckpointRunAssistantSchema,
+  CommitRunTerminalSchema,
+  RecoverAgentRunSchema,
+  ReplaceCompactedRangeSchema,
+  RequestRunInterruptSchema,
+  composeAgentPrompt,
+  createAgentObservability,
+  createAgentRuntime,
+  createAgentSessionCoordinator,
+  createAgentToolFenceLifecycle,
+  createMemoryAgentRuntimeStore,
+  defineAgentProtocol,
+  defineModelRegistry,
+  projectAgentHistory,
+  structuredCompaction
+};