stitchkit 0.87.1 → 0.89.0

package/dist/{index-35aefxby.js → index-hw2chdvy.js}

@@ -4,7 +4,7 @@ import {
 import {
   AgentRuntimeEventSchema,
   agentDurableEventId
-} from "./index-hkm6wysp.js";
+} from "./index-y64k3s0h.js";
 import {
   advanceToolChronology,
   assistantStatus,
@@ -13,28 +13,30 @@ import {
   createToolChronology,
   isAssistantHistoryEvidence,
   isCompleteAgentHistoryTurn
-} from "./index-z1m86vc8.js";
+} from "./index-zwkgfq1s.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,
   AgentMessagePartSchema,
   AgentMessageSchema,
   AgentProvenanceSchema,
+  AgentProviderResponseSchema,
   AgentRunOperationSchema,
   AgentRunSchema,
   AgentSnapshotSchema,
   runStateForTerminalReason
-} from "./index-p1b1y93x.js";
+} from "./index-gtj3zc53.js";
 import {
   createBoundedSinkManager
 } from "./index-wnfk50r0.js";
 import {
+  createToolDurabilityContext,
   isAgentToolError
-} from "./index-3xnq72rz.js";
+} from "./index-7rkhw9ec.js";
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-wn9cb82y.js";
+} from "./index-zyvby92n.js";
 import {
   isRecord,
   transportResult
@@ -314,6 +316,479 @@ function createAgentSessionCoordinator() {
   };
 }
 
+// src/agent-runtime/durability-contract.ts
+import { z } from "zod";
+var DURABILITY_STEP_EVENT_KIND = "durability/step";
+var DURABILITY_PARK_EVENT_KIND = "durability/park";
+var DURABILITY_EVENT_EVENT_KIND = "durability/event";
+var StepEventPayloadSchema = z.object({
+  runId: z.string().min(1),
+  stepName: z.string().min(1),
+  encoded: z.string()
+});
+var SleepParkSchema = z.object({
+  runId: z.string().min(1),
+  kind: z.literal("sleep"),
+  name: z.string().min(1),
+  deadline: z.number()
+});
+var WaitParkSchema = z.object({
+  runId: z.string().min(1),
+  kind: z.literal("wait"),
+  event: z.string().min(1),
+  id: z.string().min(1)
+});
+var ParkEventPayloadSchema = z.discriminatedUnion("kind", [
+  SleepParkSchema,
+  WaitParkSchema
+]);
+var DeliveredEventPayloadSchema = z.object({
+  runId: z.string().min(1),
+  event: z.string().min(1),
+  id: z.string().min(1),
+  encoded: z.string()
+});
+
+class StepResultDecodeError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StepResultDecodeError";
+  }
+}
+
+class StepResultNotSerializableError extends Error {
+  constructor(stepName, cause) {
+    super(`Step "${stepName}" returned a value that is not JSON-serializable`, {
+      cause
+    });
+    this.name = "StepResultNotSerializableError";
+  }
+}
+
+class StepAbortedError extends Error {
+  constructor(stepName) {
+    super(`Step "${stepName}" was aborted before it started`);
+    this.name = "StepAbortedError";
+  }
+}
+
+class ParkRecordDecodeError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ParkRecordDecodeError";
+  }
+}
+
+class ParkAbortedError extends Error {
+  constructor(park) {
+    super(`Park "${park}" was aborted before it was satisfied`);
+    this.name = "ParkAbortedError";
+  }
+}
+
+// src/agent-runtime/durability-json.ts
+import { z as z2 } from "zod";
+function losslessJson(value, ancestors = new Set, depth = 0) {
+  if (depth > 100)
+    return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value) && !Object.is(value, -0);
+  if (typeof value !== "object" || ancestors.has(value))
+    return false;
+  const array = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+    return false;
+  ancestors.add(value);
+  try {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors);
+    if (array && keys.length !== value.length + 1)
+      return false;
+    for (const key of keys) {
+      if (array && key === "length")
+        continue;
+      if (typeof key !== "string")
+        return false;
+      if (array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length))
+        return false;
+      const descriptor = descriptors[key];
+      if (!descriptor?.enumerable || !("value" in descriptor))
+        return false;
+      if (!losslessJson(descriptor.value, ancestors, depth + 1))
+        return false;
+    }
+    return true;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+var DurableJsonSchema = z2.custom((value) => losslessJson(value), "Expected lossless JSON data (finite numbers, plain objects and dense arrays; no accessors)");
+
+// src/agent-runtime/durability-ledger.ts
+function stepKey(conversationId, runId, stepName) {
+  return JSON.stringify([conversationId, runId, stepName]);
+}
+function sleepParkKey(conversationId, runId, name) {
+  return JSON.stringify([conversationId, runId, "sleep", name]);
+}
+function waitParkKey(conversationId, runId, event, id) {
+  return JSON.stringify([conversationId, runId, "wait", event, id]);
+}
+function parkEventKey(conversationId, payload) {
+  return payload.kind === "sleep" ? sleepParkKey(conversationId, payload.runId, payload.name) : waitParkKey(conversationId, payload.runId, payload.event, payload.id);
+}
+function encodeStepResult(stepName, value) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(DurableJsonSchema.parse(value));
+  } catch (cause) {
+    throw new StepResultNotSerializableError(stepName, cause);
+  }
+  if (encoded === undefined) {
+    throw new StepResultNotSerializableError(stepName, value);
+  }
+  return encoded;
+}
+function encodeDeliveredPayload(event, id, payload) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(DurableJsonSchema.parse(payload === undefined ? null : payload));
+  } catch (cause) {
+    throw new TypeError(`Delivered event "${event}#${id}" payload is not JSON-serializable`, {
+      cause
+    });
+  }
+  if (encoded === undefined) {
+    throw new TypeError(`Delivered event "${event}#${id}" payload is not JSON-serializable`);
+  }
+  return encoded;
+}
+function decodeStepPayload(event) {
+  const parsed = StepEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new StepResultDecodeError(`Recorded step event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+function decodeRecordedResult(payload, event) {
+  try {
+    return DurableJsonSchema.parse(JSON.parse(payload.encoded));
+  } catch (cause) {
+    throw new StepResultDecodeError(`Recorded result for step "${payload.stepName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+  }
+}
+function decodeParkPayload(event) {
+  const parsed = ParkEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new ParkRecordDecodeError(`Recorded park event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+function decodeDeliveredPayload(event) {
+  const parsed = DeliveredEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new ParkRecordDecodeError(`Delivered event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+function decodeDeliveredResult(payload, event) {
+  try {
+    return JSON.parse(payload.encoded);
+  } catch (cause) {
+    throw new ParkRecordDecodeError(`Delivered payload for "${payload.event}#${payload.id}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+  }
+}
+async function readDurabilityLedger(store, conversationId, view) {
+  const { steps, parks, deliveries } = view;
+  let fromSeq = view.nextSeq;
+  for (;; ) {
+    const page = await store.readEvents({
+      conversationId,
+      ...fromSeq !== undefined && { fromSeq },
+      limit: 1e4
+    });
+    for (const event of page.items) {
+      if (event.kind === DURABILITY_STEP_EVENT_KIND) {
+        const payload = decodeStepPayload(event);
+        steps.set(stepKey(event.conversationId, payload.runId, payload.stepName), decodeRecordedResult(payload, event));
+      } else if (event.kind === DURABILITY_PARK_EVENT_KIND) {
+        const payload = decodeParkPayload(event);
+        parks.set(parkEventKey(event.conversationId, payload), payload);
+      } else if (event.kind === DURABILITY_EVENT_EVENT_KIND) {
+        const payload = decodeDeliveredPayload(event);
+        const key = waitParkKey(event.conversationId, payload.runId, payload.event, payload.id);
+        if (!deliveries.has(key))
+          deliveries.set(key, decodeDeliveredResult(payload, event));
+      }
+    }
+    const last = page.items.at(-1);
+    if (last)
+      view.nextSeq = last.seq + 1;
+    if (page.nextSeq === undefined)
+      break;
+    fromSeq = page.nextSeq;
+  }
+  return view;
+}
+
+// src/agent-runtime/durability-scheduler.ts
+var systemClock = {
+  now: () => Date.now(),
+  schedule(callback, delayMs) {
+    const timer = setTimeout(callback, Math.min(delayMs, 2147483647));
+    timer.unref();
+    return { cancel: () => clearTimeout(timer) };
+  }
+};
+var stores = new WeakMap;
+function notifyWaiters(parkWaiters, key) {
+  const waiters = parkWaiters.get(key);
+  if (!waiters)
+    return;
+  for (const wake of [...waiters])
+    wake();
+}
+function waitForTimer(clock, delayMs, signal) {
+  return new Promise((resolve) => {
+    let timer;
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      timer?.cancel();
+      signal?.removeEventListener("abort", onAbort);
+      resolve(outcome);
+    };
+    const onAbort = () => finish("aborted");
+    timer = clock.schedule(() => finish("elapsed"), delayMs);
+    if (signal) {
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+async function waitForDeadline(clock, deadline, park, signal) {
+  for (;; ) {
+    if (signal?.aborted)
+      throw new ParkAbortedError(park);
+    const remaining = deadline - clock.now();
+    if (remaining <= 0)
+      return;
+    const outcome = await waitForTimer(clock, remaining, signal);
+    if (outcome === "aborted")
+      throw new ParkAbortedError(park);
+  }
+}
+function createParkWaiter(parkWaiters, key, signal) {
+  const waiters = parkWaiters.get(key) ?? new Set;
+  parkWaiters.set(key, waiters);
+  let settle;
+  const outcome = new Promise((resolve) => {
+    settle = resolve;
+  });
+  let settled = false;
+  const cleanup = () => {
+    waiters.delete(onWake);
+    if (waiters.size === 0)
+      parkWaiters.delete(key);
+    signal?.removeEventListener("abort", onAbort);
+  };
+  const finish = (result) => {
+    if (settled)
+      return;
+    settled = true;
+    cleanup();
+    settle(result);
+  };
+  const onWake = () => finish("woke");
+  const onAbort = () => finish("aborted");
+  waiters.add(onWake);
+  if (signal) {
+    if (signal.aborted)
+      onAbort();
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return { outcome, cancel: cleanup };
+}
+
+// src/agent-runtime/durability.ts
+function releaseSettled(registry, key, pending) {
+  const release = () => {
+    if (registry.get(key) === pending)
+      registry.delete(key);
+  };
+  pending.then(release, release);
+}
+function detachedResult(pending) {
+  return pending.then((value) => JSON.parse(JSON.stringify(value)));
+}
+function createLocalStepDurability(options) {
+  const { store, conversationId, runId } = options;
+  const inFlight = stores.get(store) ?? {
+    steps: new Map,
+    parks: new Map,
+    waiters: new Map
+  };
+  stores.set(store, inFlight);
+  const { steps: inFlightSteps, parks: inFlightParks, waiters: parkWaiters } = inFlight;
+  const clock = options.clock ?? systemClock;
+  const view = {
+    steps: new Map,
+    parks: new Map,
+    deliveries: new Map,
+    nextSeq: 1
+  };
+  let reading = Promise.resolve(view);
+  const readLedger = () => {
+    reading = reading.catch(() => view).then(() => readDurabilityLedger(store, conversationId, view));
+    return reading;
+  };
+  const readRecordedStep = async (name) => {
+    const key = stepKey(conversationId, runId, name);
+    const records = await readLedger();
+    const value = records.steps.get(key);
+    return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  };
+  const execute = async (name, body, runOptions) => {
+    const recorded = await readRecordedStep(name);
+    if (recorded !== undefined) {
+      return recorded;
+    }
+    if (runOptions?.signal?.aborted || options.signal?.aborted)
+      throw new StepAbortedError(name);
+    const value = await body();
+    const encoded = encodeStepResult(name, value);
+    await store.appendEvent({
+      conversationId,
+      kind: DURABILITY_STEP_EVENT_KIND,
+      payload: { runId, stepName: name, encoded }
+    });
+    return JSON.parse(encoded);
+  };
+  const step = (name, body, runOptions) => {
+    const key = stepKey(conversationId, runId, name);
+    const existing = inFlightSteps.get(key);
+    if (existing) {
+      return detachedResult(existing);
+    }
+    const pending = execute(name, body, runOptions);
+    inFlightSteps.set(key, pending);
+    releaseSettled(inFlightSteps, key, pending);
+    return detachedResult(pending);
+  };
+  const executeSleep = async (name, seconds, runOptions) => {
+    const key = sleepParkKey(conversationId, runId, name);
+    const signal = options.signal && runOptions?.signal ? AbortSignal.any([options.signal, runOptions.signal]) : runOptions?.signal ?? options.signal;
+    const ledger = await readLedger();
+    const existing = ledger.parks.get(key);
+    let deadline;
+    if (existing) {
+      if (existing.kind !== "sleep") {
+        throw new ParkRecordDecodeError(`Recorded park "${name}" is not a sleep record`);
+      }
+      deadline = existing.deadline;
+    } else {
+      deadline = clock.now() + seconds * 1000;
+      if (!Number.isSafeInteger(Math.ceil(deadline)))
+        throw new TypeError("Sleep deadline exceeds the supported clock range");
+      await store.appendEvent({
+        conversationId,
+        kind: DURABILITY_PARK_EVENT_KIND,
+        payload: { runId, kind: "sleep", name, deadline }
+      });
+    }
+    if (signal?.aborted)
+      throw new ParkAbortedError(name);
+    await waitForDeadline(clock, deadline, name, signal);
+  };
+  const sleep = (input, runOptions) => {
+    const { seconds } = input;
+    if (!Number.isFinite(seconds) || seconds < 0) {
+      throw new TypeError(`sleep seconds must be a non-negative finite number, got ${String(seconds)}`);
+    }
+    const name = input.name ?? `sleep:${seconds}`;
+    const key = sleepParkKey(conversationId, runId, name);
+    const existing = inFlightParks.get(key);
+    if (existing) {
+      return existing;
+    }
+    const pending = executeSleep(name, seconds, runOptions);
+    inFlightParks.set(key, pending);
+    releaseSettled(inFlightParks, key, pending);
+    return pending;
+  };
+  const executeWait = async (eventName, id, runOptions) => {
+    const key = waitParkKey(conversationId, runId, eventName, id);
+    const park = `${eventName}#${id}`;
+    const signal = options.signal && runOptions?.signal ? AbortSignal.any([options.signal, runOptions.signal]) : runOptions?.signal ?? options.signal;
+    for (;; ) {
+      if (signal?.aborted)
+        throw new ParkAbortedError(park);
+      const waiter = createParkWaiter(parkWaiters, key, signal);
+      let unsubscribe;
+      try {
+        unsubscribe = options.subscribe?.(() => notifyWaiters(parkWaiters, key));
+        const ledger = await readLedger();
+        if (ledger.deliveries.has(key)) {
+          return JSON.parse(JSON.stringify(ledger.deliveries.get(key)));
+        }
+        if (!ledger.parks.has(key)) {
+          await store.appendEvent({
+            conversationId,
+            kind: DURABILITY_PARK_EVENT_KIND,
+            payload: { runId, kind: "wait", event: eventName, id }
+          });
+        }
+        const outcome = await waiter.outcome;
+        if (outcome === "aborted")
+          throw new ParkAbortedError(park);
+      } finally {
+        waiter.cancel();
+        unsubscribe?.();
+      }
+    }
+  };
+  const waitFor = (input, runOptions) => {
+    const key = waitParkKey(conversationId, runId, input.event, input.id);
+    const existing = inFlightParks.get(key);
+    if (existing) {
+      return detachedResult(existing);
+    }
+    const pending = executeWait(input.event, input.id, runOptions);
+    inFlightParks.set(key, pending);
+    releaseSettled(inFlightParks, key, pending);
+    return detachedResult(pending);
+  };
+  const deliver = async (input) => {
+    const key = waitParkKey(conversationId, runId, input.event, input.id);
+    const ledger = await readLedger();
+    if (!ledger.deliveries.has(key)) {
+      const encoded = encodeDeliveredPayload(input.event, input.id, input.payload);
+      await store.appendEvent({
+        conversationId,
+        kind: DURABILITY_EVENT_EVENT_KIND,
+        payload: { runId, event: input.event, id: input.id, encoded }
+      });
+    }
+    notifyWaiters(parkWaiters, key);
+  };
+  return {
+    step,
+    readRecordedStep,
+    hasRecordedStep: async (name) => await readRecordedStep(name) !== undefined,
+    sleep,
+    waitFor,
+    deliver
+  };
+}
+
 // src/agent-runtime/events.ts
 function createAgentRuntimeEventSink(config) {
   const manager = createBoundedSinkManager({
@@ -629,9 +1104,9 @@ function createAgentToolFenceLifecycle(config) {
 }
 
 // src/agent-runtime/prompt.ts
-import { z } from "zod";
-var AgentTokenCountSchema = z.object({
-  value: z.int().nonnegative().optional(),
+import { z as z3 } from "zod";
+var AgentTokenCountSchema = z3.object({
+  value: z3.int().nonnegative().optional(),
   provenance: AgentProvenanceSchema.extract([
     "measured",
     "computed",
@@ -751,13 +1226,22 @@ function knownValue(value) {
 }
 function composeAgentPrompt(sections) {
   return async (options) => {
+    const event = z3.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
     const rendered = [];
-    let total = 0;
-    let unavailable = false;
-    let estimated = false;
+    let systemTotal = 0;
+    let userTotal = 0;
+    let systemUnavailable = false;
+    let userUnavailable = false;
+    let systemEstimated = false;
+    let userEstimated = 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 });
+      const role = section.role ?? "system";
+      const text = await section.render({
+        context: options.context,
+        signal: options.signal,
+        event
+      });
+      rendered.push({ name: section.name, stability: section.stability, role, text });
       let count;
       if (section.estimateTokens) {
         count = AgentTokenCountSchema.parse(await section.estimateTokens(text));
@@ -766,14 +1250,24 @@ function composeAgentPrompt(sections) {
       } else
         count = { provenance: "unavailable" };
       const value = knownValue(count);
-      if (value === undefined)
-        unavailable = true;
-      else
-        total += value;
-      if (count.provenance === "estimated")
-        estimated = true;
+      if (role === "user") {
+        if (value === undefined)
+          userUnavailable = true;
+        else
+          userTotal += value;
+        if (count.provenance === "estimated")
+          userEstimated = true;
+      } else {
+        if (value === undefined)
+          systemUnavailable = true;
+        else
+          systemTotal += value;
+        if (count.provenance === "estimated")
+          systemEstimated = true;
+      }
     }
-    const instructionTokens = unavailable ? { provenance: "unavailable" } : { value: total, provenance: estimated ? "estimated" : "computed" };
+    const instructionTokens = systemUnavailable ? { provenance: "unavailable" } : { value: systemTotal, provenance: systemEstimated ? "estimated" : "computed" };
+    const userInstructionTokens = userUnavailable ? { provenance: "unavailable" } : { value: userTotal, provenance: userEstimated ? "estimated" : "computed" };
     let availableHistoryTokens;
     let contextDecision = "unavailable";
     if (options.budget) {
@@ -800,13 +1294,25 @@ function composeAgentPrompt(sections) {
         }
       }
     }
-    const instructionText = rendered.map((section) => section.text).join(`
+    const instructionText = rendered.filter((section) => section.role === "system").map((section) => section.text).join(`
 
 `);
+    const userInstructions = rendered.filter((section) => section.role === "user" && section.text.trim().length > 0).map((section) => ({ name: section.name, text: section.text }));
     return {
       instructions: options.adaptInstructions ? await options.adaptInstructions(instructionText) : instructionText,
       sections: rendered,
+      userInstructions,
       instructionTokens,
+      userInstructionTokens,
+      finalizeSeed: (inserted) => {
+        const seedTokens = inserted ? knownValue(userInstructionTokens) : 0;
+        if (availableHistoryTokens === undefined || seedTokens === undefined)
+          return { contextDecision: "unavailable" };
+        const available = availableHistoryTokens - seedTokens;
+        const history = options.historyTokens ? knownValue(options.historyTokens) : undefined;
+        const decision = history === undefined ? "unavailable" : available < 0 ? "oversized" : history <= available ? "fits" : options.oversizePolicy === "compact" ? "requires-compaction" : "oversized";
+        return { availableHistoryTokens: available, contextDecision: decision };
+      },
       contextDecision,
       ...availableHistoryTokens !== undefined && { availableHistoryTokens }
     };
@@ -923,7 +1429,7 @@ async function recordAgentRetryDecision(input) {
 }
 
 // src/agent-runtime/state-slots.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 function defineStateSlot(input) {
   if (input.name.length === 0)
     throw new TypeError("State slot name must not be empty");
@@ -938,11 +1444,11 @@ function defineStateSlot(input) {
     ...input.description && { description: input.description }
   };
 }
-var StateSetPayloadSchema = z2.object({
-  name: z2.string().min(1),
-  version: z2.int().positive(),
-  value: z2.json(),
-  actor: z2.enum(["agent", "human", "system"])
+var StateSetPayloadSchema = z4.object({
+  name: z4.string().min(1),
+  version: z4.int().positive(),
+  value: z4.json(),
+  actor: z4.enum(["agent", "human", "system"])
 }).strict();
 function slotRegistry(definitions) {
   const result = new Map;
@@ -1024,18 +1530,18 @@ function renderAgentStateSlots(values) {
 var agentGoalStateSlot = defineStateSlot({
   name: "goal",
   description: "The durable objective and lifecycle of this conversation.",
-  schema: z2.object({
-    objective: z2.string().min(1),
-    status: z2.enum(["active", "complete", "blocked"])
+  schema: z4.object({
+    objective: z4.string().min(1),
+    status: z4.enum(["active", "complete", "blocked"])
   }).strict()
 });
 var agentTodoStateSlot = defineStateSlot({
   name: "todo",
   description: "The durable ordered work plan for this conversation.",
-  schema: z2.object({
-    items: z2.array(z2.object({
-      step: z2.string().min(1),
-      status: z2.enum(["pending", "in_progress", "completed"])
+  schema: z4.object({
+    items: z4.array(z4.object({
+      step: z4.string().min(1),
+      status: z4.enum(["pending", "in_progress", "completed"])
     }).strict())
   }).strict()
 });
@@ -1167,6 +1673,47 @@ function repairedSearchCall(toolCall, searchName) {
   };
 }
 
+// src/agent-runtime/owned-provider-stream.ts
+var DEFAULT_CLEANUP_TIMEOUT_MS = 1000;
+async function settleCleanup(operation, timeoutMs) {
+  let timeout;
+  const deadline = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => reject(new Error(`Provider stream cleanup exceeded ${timeoutMs} ms`)), timeoutMs);
+  });
+  try {
+    await Promise.race([operation, deadline]);
+  } finally {
+    if (timeout !== undefined)
+      clearTimeout(timeout);
+  }
+}
+async function* ownedProviderStream(input) {
+  const iterator = input.stream[Symbol.asyncIterator]();
+  let completed = false;
+  try {
+    for (;; ) {
+      const next = await iterator.next();
+      if (next.done) {
+        completed = true;
+        return;
+      }
+      yield next.value;
+    }
+  } finally {
+    if (!completed) {
+      input.abort();
+      const cleanup = iterator.return?.();
+      if (cleanup) {
+        try {
+          await settleCleanup(cleanup, input.cleanupTimeoutMs ?? DEFAULT_CLEANUP_TIMEOUT_MS);
+        } catch (error) {
+          input.onCleanupFailure(error);
+        }
+      }
+    }
+  }
+}
+
 // src/agent-runtime/provider-origin.ts
 import {
   InvalidToolApprovalError,
@@ -1204,7 +1751,7 @@ function createRunMutationQueue() {
 import { wrapLanguageModel } from "ai";
 
 // src/agent-runtime/runtime-internals.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -1212,7 +1759,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z3.json().safeParse(value);
+  const parsed = z5.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -1221,6 +1768,12 @@ function providerEnvelope(value) {
     return;
   return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
 }
+function providerResponseIdentity(id, provider) {
+  return AgentProviderResponseSchema.parse({
+    id,
+    ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
+  });
+}
 function appendText(parts, text) {
   const previous = parts.at(-1);
   if (previous?.type === "text") {
@@ -1324,22 +1877,53 @@ function createIdleDeadline(parent, timeoutMs) {
     const noop = () => {
       return;
     };
-    return { signal: parent, touch: noop, dispose: noop };
+    return {
+      signal: parent,
+      touch: noop,
+      start: noop,
+      stop: noop,
+      suspend: noop,
+      resume: noop,
+      dispose: noop
+    };
   }
   const controller = new AbortController;
   let timer;
-  const touch = () => {
+  let active = false;
+  let suspended = 0;
+  const clear = () => {
     if (timer !== undefined)
       clearTimeout(timer);
+    timer = undefined;
+  };
+  const touch = () => {
+    clear();
+    if (!active || suspended > 0 || controller.signal.aborted)
+      return;
     timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
   };
-  touch();
   return {
     signal: AbortSignal.any([parent, controller.signal]),
     touch,
+    start() {
+      active = true;
+      touch();
+    },
+    stop() {
+      active = false;
+      clear();
+    },
+    suspend() {
+      suspended += 1;
+      clear();
+    },
+    resume() {
+      suspended = Math.max(0, suspended - 1);
+      touch();
+    },
     dispose() {
-      if (timer !== undefined)
-        clearTimeout(timer);
+      active = false;
+      clear();
     }
   };
 }
@@ -1476,6 +2060,19 @@ function snapshotForRunPrompt(snapshot, runId) {
     messages: snapshot.messages.filter((message) => !ownedIds.has(message.id) || eligibleIds.has(message.id))
   });
 }
+var USER_INSTRUCTION_SEED_KEY = "prompt.user-instructions";
+function seededInstructionMessage(input) {
+  return AgentMessageSchema.parse({
+    schemaVersion: 1,
+    id: createHash("sha256").update(`${input.conversationId}\x00${input.seedKey}\x00${input.index}`).digest("hex"),
+    conversationId: input.conversationId,
+    role: "user",
+    status: "committed",
+    parts: [{ type: "text", text: input.text }],
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt
+  });
+}
 function failureThisRuntimeOwns(error) {
   if (error instanceof AgentContextOverflowError)
     return "context_overflow";
@@ -1620,6 +2217,7 @@ function createRunExecutor(dependencies) {
     let step = 0;
     let selectedModel;
     let internalCause;
+    let providerStreamCleanupFailure;
     let reasoningPartIndex;
     let firstOutputAt;
     let terminalPolicyName;
@@ -1770,16 +2368,42 @@ function createRunExecutor(dependencies) {
         run,
         snapshot
       });
-      const promptSnapshot = snapshotForRunPrompt(snapshot, run.id);
-      const [prompt, tools] = await Promise.all([
+      let promptSnapshot = snapshotForRunPrompt(snapshot, run.id);
+      const [composedPrompt, tools] = await Promise.all([
         config.prompt({
           context: input.context,
           signal: executionSignal,
+          event: promptSnapshot.runs[0]?.id === run.id ? "session.started" : "turn.started",
           model: selectedModel,
           snapshot: promptSnapshot
         }),
         config.tools(runtimeContext)
       ]);
+      let prompt = composedPrompt;
+      let userInstructionsInserted = false;
+      if (prompt.userInstructions && prompt.userInstructions.length > 0) {
+        const seededAt = now().toISOString();
+        const seeded = await config.store.seedConversationInput({
+          conversationId: run.conversationId,
+          seedKey: USER_INSTRUCTION_SEED_KEY,
+          inputs: prompt.userInstructions.map((section, index) => seededInstructionMessage({
+            conversationId: run.conversationId,
+            seedKey: USER_INSTRUCTION_SEED_KEY,
+            index,
+            text: section.text,
+            createdAt: seededAt
+          }))
+        });
+        const seededSnapshot = appliedSnapshot(seeded, "user instruction seed");
+        const previousIds = new Set(snapshot.messages.map((message) => message.id));
+        userInstructionsInserted = seededSnapshot.messages.some((message) => !previousIds.has(message.id) && message.role === "user" && message.runId === undefined);
+        snapshot = seededSnapshot;
+        observedVersion = snapshot.version;
+        run = findRun(snapshot.runs, run.id);
+        promptSnapshot = snapshotForRunPrompt(snapshot, run.id);
+      }
+      if (prompt.finalizeSeed)
+        prompt = { ...prompt, ...prompt.finalizeSeed(userInstructionsInserted) };
       if (prompt.contextDecision === "oversized") {
         throw new AgentContextOverflowError;
       }
@@ -1839,7 +2463,8 @@ function createRunExecutor(dependencies) {
         });
         return [...detailed.messages];
       };
-      const history = await projectHistory(promptSnapshot);
+      const projectedHistory = await projectHistory(promptSnapshot);
+      const history = [...projectedHistory];
       const withCarriedSystem = (instructions) => {
         if (carriedSystem.length === 0)
           return instructions;
@@ -1935,21 +2560,67 @@ function createRunExecutor(dependencies) {
           }
         });
       };
+      const recordProviderResponse = async (response) => {
+        const identity = providerResponseIdentity(response.id, selectedModel?.resolveResponseProvider?.({
+          providerMetadata: response.providerMetadata
+        }));
+        await config.store.appendEvent({
+          conversationId: run.conversationId,
+          kind: "provider/response",
+          payload: {
+            runId: run.id,
+            attempt: response.attempt,
+            stepNumber: response.stepNumber,
+            response: identity
+          }
+        });
+        return identity;
+      };
       for (;; ) {
         const attemptPartStart = parts.length;
         let retrying = false;
         let draining = false;
+        const providerAttempt = retryAttempt;
+        const attemptAbort = new AbortController;
+        const attemptSignal = AbortSignal.any([executionSignal, attemptAbort.signal]);
         const result = streamAgentTextBoundary({
           model: fallbackModel,
           tools,
+          ...config.durability && {
+            toolsContext: Object.fromEntries(Object.keys(tools).map((toolName) => [
+              toolName,
+              createToolDurabilityContext((toolCallId, signal) => {
+                const port = config.durability;
+                if (typeof port === "function")
+                  return port({
+                    store: config.store,
+                    conversationId: run.conversationId,
+                    runId: run.id,
+                    toolName,
+                    toolCallId,
+                    signal
+                  });
+                return createLocalStepDurability({
+                  store: config.store,
+                  conversationId: run.conversationId,
+                  runId: JSON.stringify([run.id, toolName, toolCallId]),
+                  signal
+                });
+              })
+            ]))
+          },
           instructions: withCarriedSystem(prompt.instructions),
           messages: history,
-          abortSignal: executionSignal,
+          abortSignal: attemptSignal,
           maxRetries: 0,
           stopWhen: stopConditions,
           onLanguageModelCallStart: (event) => {
+            idleDeadline.start();
             operationLifecycle.noteProviderCall(event.callId);
           },
+          onLanguageModelCallEnd: () => idleDeadline.stop(),
+          onToolExecutionStart: () => idleDeadline.suspend(),
+          onToolExecutionEnd: () => idleDeadline.resume(),
           repairToolCall: deferredToolRepair(config.loop?.prepareStep),
           ...config.loop?.toolApproval && {
             toolApproval: config.loop.toolApproval,
@@ -1984,17 +2655,29 @@ function createRunExecutor(dependencies) {
               instructionsOverride = override.system;
             await recordProviderRequest({
               stepNumber: options.stepNumber,
-              attempt: retryAttempt,
+              attempt: providerAttempt,
               instructions: instructionsOverride ?? withCarriedSystem(prompt.instructions),
               messages: providerMessages
             });
             return { ...preparedStep, model };
           }
         });
-        for await (const part of result.stream) {
+        for await (const part of ownedProviderStream({
+          stream: result.stream,
+          abort: () => attemptAbort.abort(new Error("Agent runtime released provider stream")),
+          onCleanupFailure: (error) => {
+            providerStreamCleanupFailure = error;
+          }
+        })) {
           idleDeadline.touch();
           if (draining) {
             if (part.type === "finish-step") {
+              await recordProviderResponse({
+                id: part.response.id,
+                providerMetadata: part.providerMetadata,
+                stepNumber: step,
+                attempt: providerAttempt
+              });
               const failedStepUsage = selectedModel.normalizeUsage?.({
                 usage: part.usage,
                 providerMetadata: part.providerMetadata
@@ -2267,6 +2950,12 @@ function createRunExecutor(dependencies) {
             terminalReason = failureThisRuntimeOwns(part.error) ?? "provider_failure";
             internalCause = part.error;
           } else if (part.type === "finish-step") {
+            const response = await recordProviderResponse({
+              id: part.response.id,
+              providerMetadata: part.providerMetadata,
+              stepNumber: step,
+              attempt: providerAttempt
+            });
             await operationLifecycle.finish(part.finishReason === "error" ? "failed" : "completed");
             const stepTrace = trace ? config.observe?.rootTrace(trace) : undefined;
             const stepUsage = selectedModel.normalizeUsage?.({
@@ -2289,6 +2978,7 @@ function createRunExecutor(dependencies) {
               modelId: selectedModel.descriptor.modelId,
               step,
               usage: stepUsage,
+              response,
               emittedAt: now().toISOString()
             });
             step += 1;
@@ -2357,7 +3047,7 @@ function createRunExecutor(dependencies) {
       }
     } catch (error) {
       operationLifecycle.failStepCheckpoints(error);
-      internalCause = error;
+      internalCause = providerStreamCleanupFailure === undefined ? error : new AggregateError([error, providerStreamCleanupFailure], `${error instanceof Error ? error.message : String(error)} (provider stream cleanup also failed: ${providerStreamCleanupFailure instanceof Error ? providerStreamCleanupFailure.message : String(providerStreamCleanupFailure)})`);
       const latest = await config.store.loadRun({
         conversationId: run.conversationId,
         runId: run.id
@@ -2935,6 +3625,35 @@ function createAgentRuntime(config) {
       }
       return requested;
     },
+    async abandon(input) {
+      if (input.staleOwner !== true) {
+        throw new TypeError("Abandoning a run requires explicit staleOwner evidence");
+      }
+      const releaseAdmission = beginAdmission();
+      try {
+        const abandoned = await config.store.recoverRun({
+          conversationId: input.conversationId,
+          runId: input.runId,
+          expectedRevision: input.expectedRevision,
+          action: "abandon"
+        });
+        if (abandoned.outcome === "applied") {
+          const abandonedRun = findRun(abandoned.snapshot.runs, input.runId);
+          await publish({
+            type: "run-state",
+            eventId: agentDurableEventId("run-state", abandonedRun.id, abandoned.snapshot.version),
+            conversationId: abandonedRun.conversationId,
+            runId: abandonedRun.id,
+            snapshotVersion: abandoned.snapshot.version,
+            state: abandonedRun.state,
+            emittedAt: now().toISOString()
+          });
+        }
+        return abandoned;
+      } finally {
+        releaseAdmission();
+      }
+    },
     async recover(options) {
       if (admissionClosed)
         throw closedError();
@@ -3094,4 +3813,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };
+export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, DURABILITY_STEP_EVENT_KIND, StepResultDecodeError, StepResultNotSerializableError, StepAbortedError, ParkRecordDecodeError, ParkAbortedError, createLocalStepDurability, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };