machine-bridge-mcp 3.0.0-beta.17 → 3.0.0-beta.21

package/src/worker/mcp-pending-call-storage.ts

@@ -0,0 +1,18 @@
+import {
+  streamKey,
+  validRecord,
+  type StreamIndexEntry,
+  type StreamRecord,
+} from "./mcp-resumption-records.ts";
+import type { PendingStreamCall } from "./mcp-pending-call-records.ts";
+
+export async function requiredPendingCallRecord(
+  transaction: Pick<DurableObjectTransaction, "get">,
+  entry: StreamIndexEntry & { call: PendingStreamCall },
+): Promise<StreamRecord & { call: PendingStreamCall }> {
+  const record = await transaction.get<unknown>(streamKey(entry.stream_id));
+  if (!validRecord(record) || !record.call || record.call.call_id !== entry.call.call_id) {
+    throw new Error("persisted pending call record is corrupt");
+  }
+  return record as StreamRecord & { call: PendingStreamCall };
+}

package/src/worker/mcp-pending-call-store.ts

@@ -0,0 +1,285 @@
+import {
+  STREAM_INDEX_KEY,
+  indexEntry,
+  readIndex,
+  streamKey,
+  validRecord,
+  type JsonRpcMessage,
+  type StreamIndex,
+  type StreamIndexEntry,
+  type StreamRecord,
+} from "./mcp-resumption-records.ts";
+import type { PendingStreamCall, PendingStreamTransform } from "./mcp-pending-call-records.ts";
+import {
+  extendAttachedCallExpiry,
+  extendDetachedCallExpiry,
+  positiveDelay,
+} from "./mcp-pending-call-expiry.ts";
+import { requiredPendingCallRecord } from "./mcp-pending-call-storage.ts";
+import {
+  activePendingCallCount,
+  pendingCallSnapshot,
+  type PendingStreamCallSnapshot,
+} from "./mcp-pending-call-inspection.ts";
+
+type PendingCallStorage = Pick<DurableObjectStorage, "get" | "put" | "transaction">;
+type CompleteStream = (
+  streamId: string,
+  message: JsonRpcMessage,
+  expected: { callId: string; connectionId?: string },
+) => Promise<boolean>;
+type StorageRowsWrittenListener = (rows: number) => void;
+
+export type PendingStreamCallView = PendingStreamCall & {
+  streamId: string;
+  requestId: string | number;
+};
+
+export class McpPendingCallLimitError extends Error {
+  constructor() {
+    super("too many concurrent daemon tool calls");
+    this.name = "McpPendingCallLimitError";
+  }
+}
+
+export class McpPendingCallConflictError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "McpPendingCallConflictError";
+  }
+}
+
+const DEFAULT_MAXIMUM_PENDING_CALLS = 32;
+
+export class McpPendingCallStore {
+  private readonly storage: PendingCallStorage;
+  private readonly now: () => number;
+  private readonly activateStream: (streamId: string) => void;
+  private readonly completeStream: CompleteStream;
+  private readonly onRowsWritten: StorageRowsWrittenListener;
+  private readonly terminalRetentionMs: number;
+
+  constructor(
+    storage: PendingCallStorage,
+    now: () => number,
+    activateStream: (streamId: string) => void,
+    completeStream: CompleteStream,
+    onRowsWritten: StorageRowsWrittenListener,
+    terminalRetentionMs: number,
+  ) {
+    this.storage = storage;
+    this.now = now;
+    this.activateStream = activateStream;
+    this.completeStream = completeStream;
+    this.onRowsWritten = onRowsWritten;
+    this.terminalRetentionMs = positiveDelay(terminalRetentionMs);
+  }
+
+  async activate(input: {
+    streamId: string;
+    callId: string;
+    daemonInstanceId: string;
+    connectionId: string;
+    clientRequestKey?: string;
+    tool: string;
+    timeoutMs: number;
+    transform?: PendingStreamTransform;
+    transientActiveCount?: number;
+    maximumPendingCalls?: number;
+  }): Promise<void> {
+    const now = this.now();
+    const timeoutMs = positiveDelay(input.timeoutMs);
+    const maximum = Math.max(1, Math.floor(input.maximumPendingCalls ?? DEFAULT_MAXIMUM_PENDING_CALLS));
+    const call: PendingStreamCall = {
+      call_id: input.callId,
+      daemon_instance_id: input.daemonInstanceId,
+      connection_id: input.connectionId,
+      ...(input.clientRequestKey ? { client_request_key: input.clientRequestKey } : {}),
+      tool: input.tool,
+      state: "attached",
+      started_at: now,
+      operation_deadline_at: now + timeoutMs,
+      remaining_timeout_ms: timeoutMs,
+      ...(input.transform ? { transform: structuredClone(input.transform) } : {}),
+    };
+    await this.storage.transaction(async (transaction) => {
+      const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
+      const activeCalls = index.entries.filter((entry) => entry.call).length;
+      if (activeCalls + Math.max(0, Math.floor(input.transientActiveCount ?? 0)) >= maximum) {
+        throw new McpPendingCallLimitError();
+      }
+      if (index.entries.some((entry) => entry.call?.call_id === input.callId)) {
+        throw new McpPendingCallConflictError("duplicate internal daemon call id");
+      }
+      if (input.clientRequestKey && index.entries.some((entry) => entry.call?.client_request_key === input.clientRequestKey)) {
+        throw new McpPendingCallConflictError("duplicate in-flight JSON-RPC request id within this MCP session");
+      }
+      const record = await transaction.get<unknown>(streamKey(input.streamId));
+      if (!validRecord(record) || record.status !== "pending") {
+        throw new Error("resumable MCP stream record is unavailable for activation");
+      }
+      if (record.call) throw new McpPendingCallConflictError("resumable MCP stream already has an active daemon call");
+      const updated: StreamRecord = {
+        ...record,
+        expires_at: extendAttachedCallExpiry(record.expires_at, call.operation_deadline_at, this.terminalRetentionMs),
+        call,
+      };
+      const entries = index.entries.map((entry) => entry.stream_id === input.streamId ? indexEntry(updated) : entry);
+      if (!entries.some((entry) => entry.stream_id === input.streamId)) {
+        throw new Error("resumable MCP stream index lost its record");
+      }
+      await transaction.put(streamKey(input.streamId), updated);
+      await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
+    });
+    this.onRowsWritten(2);
+    this.activateStream(input.streamId);
+  }
+
+  async activeCount(): Promise<number> {
+    return activePendingCallCount(readIndex(await this.storage.get<unknown>(STREAM_INDEX_KEY)).entries);
+  }
+
+  async get(callId: string): Promise<PendingStreamCallView | undefined> {
+    const index = readIndex(await this.storage.get<unknown>(STREAM_INDEX_KEY));
+    const entry = index.entries.find((candidate) => candidate.call?.call_id === callId);
+    return entry ? this.callView(entry) : undefined;
+  }
+
+  async getByRequestKey(requestKey: string): Promise<PendingStreamCallView | undefined> {
+    const index = readIndex(await this.storage.get<unknown>(STREAM_INDEX_KEY));
+    const entry = index.entries.find((candidate) => candidate.call?.client_request_key === requestKey);
+    return entry ? this.callView(entry) : undefined;
+  }
+
+  async snapshot(maximum = DEFAULT_MAXIMUM_PENDING_CALLS): Promise<PendingStreamCallSnapshot> {
+    const index = readIndex(await this.storage.get<unknown>(STREAM_INDEX_KEY));
+    return pendingCallSnapshot(index.entries, this.now(), maximum);
+  }
+
+  async nextDeadlineDelayMs(): Promise<number> {
+    const index = readIndex(await this.storage.get<unknown>(STREAM_INDEX_KEY));
+    const now = this.now();
+    return Math.min(Number.POSITIVE_INFINITY, ...index.entries.flatMap((entry) => {
+      if (!entry.call) return [];
+      const deadline = entry.call.state === "attached"
+        ? entry.call.operation_deadline_at
+        : entry.call.reconnect_deadline_at;
+      return Number.isSafeInteger(deadline) ? [Math.max(0, Number(deadline) - now)] : [];
+    }));
+  }
+
+  async due(now = this.now()): Promise<PendingStreamCallView[]> {
+    const index = readIndex(await this.storage.get<unknown>(STREAM_INDEX_KEY));
+    const due: PendingStreamCallView[] = [];
+    for (const entry of index.entries) {
+      const call = entry.call;
+      if (!call) continue;
+      const deadline = call.state === "attached" ? call.operation_deadline_at : call.reconnect_deadline_at;
+      if (Number.isSafeInteger(deadline) && Number(deadline) <= now) due.push(await this.callView(entry));
+    }
+    return due;
+  }
+
+  async detach(connectionId: string, graceMs: number): Promise<number> {
+    const now = this.now();
+    const reconnectDeadline = now + positiveDelay(graceMs);
+    let rows = 0;
+    const count = await this.storage.transaction(async (transaction) => {
+      const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
+      const entries = [...index.entries];
+      let changed = 0;
+      for (let position = 0; position < entries.length; position += 1) {
+        const entry = entries[position];
+        if (entry.call?.state !== "attached" || entry.call.connection_id !== connectionId) continue;
+        const record = await requiredPendingCallRecord(transaction, entry as StreamIndexEntry & { call: PendingStreamCall });
+        const remaining = Math.max(1, record.call.operation_deadline_at - now);
+        const updated: StreamRecord = {
+          ...record,
+          expires_at: extendDetachedCallExpiry(
+            record.expires_at,
+            reconnectDeadline,
+            remaining,
+            this.terminalRetentionMs,
+          ),
+          call: {
+            ...record.call,
+            state: "detached",
+            remaining_timeout_ms: remaining,
+            reconnect_deadline_at: reconnectDeadline,
+          },
+        };
+        await transaction.put(streamKey(entry.stream_id), updated);
+        entries[position] = indexEntry(updated);
+        changed += 1;
+      }
+      if (changed > 0) {
+        await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
+        rows = changed + 1;
+      }
+      return changed;
+    });
+    this.onRowsWritten(rows);
+    return count;
+  }
+
+  async rebind(daemonInstanceId: string, connectionId: string): Promise<string[]> {
+    if (!daemonInstanceId || !connectionId) return [];
+    const now = this.now();
+    let rows = 0;
+    const rebound = await this.storage.transaction(async (transaction) => {
+      const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
+      const entries = [...index.entries];
+      const ids: string[] = [];
+      for (let position = 0; position < entries.length; position += 1) {
+        const entry = entries[position];
+        if (!entry.call || entry.call.daemon_instance_id !== daemonInstanceId || entry.call.connection_id === connectionId) continue;
+        const record = await requiredPendingCallRecord(transaction, entry as StreamIndexEntry & { call: PendingStreamCall });
+        const remaining = record.call.state === "detached"
+          ? record.call.remaining_timeout_ms
+          : Math.max(1, record.call.operation_deadline_at - now);
+        const updatedCall: PendingStreamCall = {
+          ...record.call,
+          connection_id: connectionId,
+          state: "attached",
+          operation_deadline_at: now + remaining,
+          remaining_timeout_ms: remaining,
+        };
+        delete updatedCall.reconnect_deadline_at;
+        const updated: StreamRecord = {
+          ...record,
+          expires_at: extendAttachedCallExpiry(
+            record.expires_at,
+            updatedCall.operation_deadline_at,
+            this.terminalRetentionMs,
+          ),
+          call: updatedCall,
+        };
+        await transaction.put(streamKey(entry.stream_id), updated);
+        entries[position] = indexEntry(updated);
+        ids.push(updatedCall.call_id);
+      }
+      if (ids.length > 0) {
+        await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
+        rows = ids.length + 1;
+      }
+      return ids;
+    });
+    this.onRowsWritten(rows);
+    return rebound;
+  }
+
+  async complete(callId: string, connectionId: string | undefined, message: JsonRpcMessage): Promise<boolean> {
+    const view = await this.get(callId);
+    if (!view || (connectionId && view.connection_id !== connectionId)) return false;
+    return this.completeStream(view.streamId, message, { callId, connectionId });
+  }
+
+  private async callView(entry: StreamIndexEntry): Promise<PendingStreamCallView> {
+    if (!entry.call) throw new Error("stream index entry has no pending call");
+    const record = await this.storage.get<unknown>(streamKey(entry.stream_id));
+    if (!validRecord(record) || !record.call || record.call.call_id !== entry.call.call_id) {
+      throw new Error("persisted pending call record is corrupt");
+    }
+    return { ...structuredClone(record.call), streamId: record.stream_id, requestId: record.request_id };
+  }
+}

package/src/worker/mcp-resumption-index.ts

@@ -0,0 +1,41 @@
+import {
+  streamKey,
+  type StreamIndexEntry,
+} from "./mcp-resumption-records.ts";
+
+type TransactionStorage = Pick<DurableObjectTransaction, "delete">;
+
+export async function pruneExpiredStreams(
+  storage: TransactionStorage,
+  entries: StreamIndexEntry[],
+  now: number,
+): Promise<{ entries: StreamIndexEntry[]; removedStreamIds: string[] }> {
+  const retained: StreamIndexEntry[] = [];
+  const removedStreamIds: string[] = [];
+  for (const entry of entries) {
+    if (entry.expires_at <= now) {
+      await storage.delete(streamKey(entry.stream_id));
+      removedStreamIds.push(entry.stream_id);
+    } else retained.push(entry);
+  }
+  return { entries: retained, removedStreamIds };
+}
+
+export async function freeCompletedStreamSlots(
+  storage: TransactionStorage,
+  entries: StreamIndexEntry[],
+  maximumRetained: number,
+): Promise<{ available: boolean; entries: StreamIndexEntry[]; removedStreamIds: string[] }> {
+  const retained = [...entries];
+  const removedStreamIds: string[] = [];
+  const completed = retained
+    .filter((entry) => entry.status === "ready")
+    .sort((left, right) => left.created_at - right.created_at);
+  for (const entry of completed) {
+    if (retained.length <= maximumRetained) break;
+    await storage.delete(streamKey(entry.stream_id));
+    retained.splice(retained.findIndex((candidate) => candidate.stream_id === entry.stream_id), 1);
+    removedStreamIds.push(entry.stream_id);
+  }
+  return { available: retained.length <= maximumRetained, entries: retained, removedStreamIds };
+}

package/src/worker/mcp-resumption-records.ts

@@ -1,4 +1,5 @@
 import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { validPendingStreamCall, type PendingStreamCall } from "./mcp-pending-call-records.ts";
 export type JsonRpcMessage = Record<string, unknown> | null;
 export type StreamStatus = "pending" | "ready";
 export type StreamIndexEntry = {
@@ -6,6 +7,7 @@ export type StreamIndexEntry = {
   status: StreamStatus;
   created_at: number;
   expires_at: number;
+  call?: PendingStreamCall;
 };
 export type StreamIndex = { schema_version: 1; entries: StreamIndexEntry[] };
 export type StreamRecord = StreamIndexEntry & {
@@ -55,6 +57,7 @@ export function validRecord(value: unknown): value is StreamRecord {
     return false;
   }
   if (record.status === "pending") return record.message_json === undefined && record.message_sha256 === undefined;
+  if (record.call !== undefined) return false;
   return typeof record.message_json === "string"
     && new TextEncoder().encode(record.message_json).byteLength <= DEFAULT_MAXIMUM_MESSAGE_BYTES
     && typeof record.message_sha256 === "string"
@@ -67,6 +70,7 @@ export function indexEntry(record: StreamRecord): StreamIndexEntry {
     status: record.status,
     created_at: record.created_at,
     expires_at: record.expires_at,
+    ...(record.call ? { call: structuredClone(record.call) } : {}),
   };
 }
 
@@ -90,8 +94,9 @@ export function readyRecord(
   messageSha256: string,
   expiresAt: number,
 ): StreamRecord {
+  const { call: _call, ...base } = record;
   return {
-    ...record,
+    ...base,
     status: "ready",
     expires_at: expiresAt,
     message_json: messageJson,
@@ -150,7 +155,8 @@ function validIndexEntry(value: unknown): value is StreamIndexEntry {
   return typeof entry.stream_id === "string" && isStreamId(entry.stream_id)
     && (entry.status === "pending" || entry.status === "ready")
     && Number.isSafeInteger(entry.created_at) && Number.isSafeInteger(entry.expires_at)
-    && entry.expires_at! > entry.created_at!;
+    && entry.expires_at! > entry.created_at!
+    && (entry.call === undefined || (entry.status === "pending" && validPendingStreamCall(entry.call)));
 }
 
 function storedIntegrityMessage(requestId: string | number): Record<string, unknown> {

package/src/worker/mcp-resumption.ts

@@ -13,27 +13,32 @@ import {
   workerRestartMessage,
   type JsonRpcMessage,
   type StreamIndex,
-  type StreamIndexEntry,
   type StreamRecord,
 } from "./mcp-resumption-records.ts";
+import { McpPendingCallStore } from "./mcp-pending-call-store.ts";
+import { freeCompletedStreamSlots, pruneExpiredStreams } from "./mcp-resumption-index.ts";
 import { resumptionLimits, type McpResumptionOptions } from "./mcp-resumption-config.ts";
 export type { JsonRpcMessage } from "./mcp-resumption-records.ts";
+
 type ResumptionStorage = Pick<DurableObjectStorage, "get" | "put" | "delete" | "transaction">;
-type TransactionStorage = Pick<DurableObjectTransaction, "get" | "put" | "delete">;
 type StreamReadyListener = (streamId: string, message: JsonRpcMessage) => void;
+type StorageRowsWrittenListener = (rows: number) => void;
 export type StreamResumeResult =
   | { kind: "invalid" | "not_found" | "expired" }
   | { kind: "complete"; streamId: string }
   | { kind: "message"; streamId: string };
+
 export class McpStreamLimitError extends Error {
   constructor() {
     super("too many resumable MCP streams are active");
     this.name = "McpStreamLimitError";
   }
 }
+
 const EVENT_ID_PATTERN = /^(stream_[A-Za-z0-9_-]{43}):([01])$/;
+
 export class McpResumptionStore {
-  private readonly storage: ResumptionStorage;
+  readonly calls: McpPendingCallStore;
   private readonly active = new Set<string>();
   private readonly transientReady = new Map<string, JsonRpcMessage>();
   private readonly now: () => number;
@@ -41,17 +46,35 @@ export class McpResumptionStore {
   private readonly pendingRetentionMs: number;
   private readonly maximumStreams: number;
   private readonly maximumMessageBytes: number;
+  private readonly storage: ResumptionStorage;
   private readonly onReady: StreamReadyListener;
-  constructor(storage: ResumptionStorage, options: McpResumptionOptions = {}, onReady: StreamReadyListener = () => {}) {
+  private readonly onRowsWritten: StorageRowsWrittenListener;
+
+  constructor(
+    storage: ResumptionStorage,
+    options: McpResumptionOptions = {},
+    onReady: StreamReadyListener = () => {},
+    onRowsWritten: StorageRowsWrittenListener = () => {},
+  ) {
     this.storage = storage;
-    this.now = options.now ?? Date.now;
     this.onReady = onReady;
+    this.onRowsWritten = onRowsWritten;
+    this.now = options.now ?? Date.now;
     const limits = resumptionLimits(options);
     this.retentionMs = limits.retentionMs;
     this.pendingRetentionMs = limits.pendingRetentionMs;
     this.maximumStreams = limits.maximumStreams;
     this.maximumMessageBytes = limits.maximumMessageBytes;
+    this.calls = new McpPendingCallStore(
+      storage,
+      this.now,
+      (streamId) => this.activate(streamId),
+      (streamId, message, expected) => this.completeInternal(streamId, message, expected),
+      onRowsWritten,
+      this.retentionMs,
+    );
   }
+
   async begin(input: {
     streamId: string;
     tokenKey: string;
@@ -72,14 +95,15 @@ export class McpResumptionStore {
     };
     const removedStreamIds = await this.storage.transaction(async (transaction) => {
       const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
-      const pruned = await pruneExpired(transaction, index.entries, now);
-      const freed = await freeCompletedSlots(transaction, pruned.entries, this.maximumStreams - 1);
+      const pruned = await pruneExpiredStreams(transaction, index.entries, now);
+      const freed = await freeCompletedStreamSlots(transaction, pruned.entries, this.maximumStreams - 1);
       if (!freed.available) throw new McpStreamLimitError();
       const entries = [...freed.entries, indexEntry(record)];
       await transaction.put(streamKey(input.streamId), record);
       await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
       return [...pruned.removedStreamIds, ...freed.removedStreamIds];
     });
+    this.onRowsWritten(2 + removedStreamIds.length);
     for (const removedStreamId of removedStreamIds) this.clearMemory(removedStreamId);
   }
 
@@ -90,43 +114,12 @@ export class McpResumptionStore {
   }
 
   async complete(streamId: string, message: JsonRpcMessage): Promise<void> {
-    try {
-      const initial = await this.storage.get<unknown>(streamKey(streamId));
-      if (initial === undefined) throw new Error("resumable MCP stream record disappeared before completion");
-      if (!validRecord(initial)) throw new Error("resumable MCP stream record is corrupt");
-      const messageJson = resumableMessageJson(message, initial.request_id, this.maximumMessageBytes);
-      const digest = await messageSha256(messageJson);
-      const expiresAt = this.now() + this.retentionMs;
-      const completed = await this.storage.transaction(async (transaction) => {
-        const record = await transaction.get<unknown>(streamKey(streamId));
-        if (record === undefined) return false;
-        if (!validRecord(record)) throw new Error("resumable MCP stream record is corrupt");
-        if (record.status === "ready") return true;
-        const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
-        if (!index.entries.some((candidate) => candidate.stream_id === streamId)) {
-          throw new Error("resumable MCP stream index lost its record");
-        }
-        const ready = readyRecord(record, messageJson, digest, expiresAt);
-        const entries = index.entries.map((candidate) => candidate.stream_id === streamId
-          ? indexEntry(ready)
-          : candidate);
-        await transaction.put(streamKey(streamId), ready);
-        await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
-        return true;
-      });
-      if (!completed) throw new Error("resumable MCP stream record disappeared during completion");
-      this.transientReady.delete(streamId);
-    } catch (error) {
-      this.transientReady.set(streamId, message);
-      throw error;
-    } finally {
-      this.active.delete(streamId);
-      // Persistent state remains authoritative if a disconnected subscriber misses this push.
-      try { this.onReady(streamId, message); } catch { /* resume/poll remains available */ }
-    }
+    await this.completeInternal(streamId, message);
   }
 
-  async pollMessage(streamId: string): Promise<{ kind: "pending" } | { kind: "not_found" } | { kind: "message"; message: JsonRpcMessage }> {
+  async pollMessage(streamId: string): Promise<
+    { kind: "pending" } | { kind: "not_found" } | { kind: "message"; message: JsonRpcMessage }
+  > {
     if (!isStreamId(streamId)) return { kind: "not_found" };
     const transient = this.transientReady.get(streamId);
     if (transient) return { kind: "message", message: transient };
@@ -138,18 +131,13 @@ export class McpResumptionStore {
       return { kind: "not_found" };
     }
     if (record.status === "ready") return { kind: "message", message: await storedMessage(record) };
-    if (this.active.has(streamId)) return { kind: "pending" };
-
+    if (record.call || this.active.has(streamId)) return { kind: "pending" };
     const unavailable = workerRestartMessage(record.request_id);
     await this.complete(streamId, unavailable);
     return { kind: "message", message: unavailable };
   }
 
-  async resume(input: {
-    lastEventId: string;
-    tokenKey: string;
-    sessionId: string;
-  }): Promise<StreamResumeResult> {
+  async resume(input: { lastEventId: string; tokenKey: string; sessionId: string }): Promise<StreamResumeResult> {
     const event = parseStreamEventId(input.lastEventId);
     if (!event) return { kind: "invalid" };
     const record = await this.storage.get<unknown>(streamKey(event.streamId));
@@ -161,15 +149,59 @@ export class McpResumptionStore {
       return { kind: "expired" };
     }
     if (event.sequence >= 1) return { kind: "complete", streamId: event.streamId };
-    if (record.status === "ready" || this.transientReady.has(event.streamId) || this.active.has(event.streamId)) {
+    if (record.status === "ready" || this.transientReady.has(event.streamId) || record.call || this.active.has(event.streamId)) {
       return { kind: "message", streamId: event.streamId };
     }
-
     const unavailable = workerRestartMessage(record.request_id);
     await this.complete(event.streamId, unavailable);
     return { kind: "message", streamId: event.streamId };
   }
 
+  private async completeInternal(
+    streamId: string,
+    message: JsonRpcMessage,
+    expected?: { callId: string; connectionId?: string },
+  ): Promise<boolean> {
+    try {
+      const initial = await this.storage.get<unknown>(streamKey(streamId));
+      if (initial === undefined) throw new Error("resumable MCP stream record disappeared before completion");
+      if (!validRecord(initial)) throw new Error("resumable MCP stream record is corrupt");
+      const messageJson = resumableMessageJson(message, initial.request_id, this.maximumMessageBytes);
+      const digest = await messageSha256(messageJson);
+      const expiresAt = this.now() + this.retentionMs;
+      const rowsWritten = await this.storage.transaction(async (transaction) => {
+        const record = await transaction.get<unknown>(streamKey(streamId));
+        if (record === undefined) return -1;
+        if (!validRecord(record)) throw new Error("resumable MCP stream record is corrupt");
+        if (record.status === "ready") return 0;
+        if (expected && (
+          record.call?.call_id !== expected.callId
+          || (expected.connectionId && record.call.connection_id !== expected.connectionId)
+        )) return -2;
+        const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
+        if (!index.entries.some((candidate) => candidate.stream_id === streamId)) {
+          throw new Error("resumable MCP stream index lost its record");
+        }
+        const ready = readyRecord(record, messageJson, digest, expiresAt);
+        const entries = index.entries.map((candidate) => candidate.stream_id === streamId ? indexEntry(ready) : candidate);
+        await transaction.put(streamKey(streamId), ready);
+        await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
+        return 2;
+      });
+      if (rowsWritten < -1) return false;
+      if (rowsWritten < 0) throw new Error("resumable MCP stream record disappeared during completion");
+      this.onRowsWritten(rowsWritten);
+      if (rowsWritten === 0) return false;
+      this.clearMemory(streamId);
+      try { this.onReady(streamId, message); } catch { /* Persistent state remains authoritative. */ }
+      return true;
+    } catch (error) {
+      this.transientReady.set(streamId, message);
+      try { this.onReady(streamId, message); } catch { /* In-memory terminal state remains available. */ }
+      throw error;
+    }
+  }
+
   private async remove(streamId: string): Promise<void> {
     await this.storage.transaction(async (transaction) => {
       const index = readIndex(await transaction.get<unknown>(STREAM_INDEX_KEY));
@@ -178,6 +210,7 @@ export class McpResumptionStore {
       if (entries.length === 0) await transaction.delete(STREAM_INDEX_KEY);
       else await transaction.put(STREAM_INDEX_KEY, { schema_version: 1, entries } satisfies StreamIndex);
     });
+    this.onRowsWritten(2);
     this.clearMemory(streamId);
   }
 
@@ -197,38 +230,3 @@ export function parseStreamEventId(value: string): { streamId: string; sequence:
   if (!match) return null;
   return { streamId: match[1], sequence: Number(match[2]) as 0 | 1 };
 }
-
-async function pruneExpired(
-  storage: TransactionStorage,
-  entries: StreamIndexEntry[],
-  now: number,
-): Promise<{ entries: StreamIndexEntry[]; removedStreamIds: string[] }> {
-  const retained: StreamIndexEntry[] = [];
-  const removedStreamIds: string[] = [];
-  for (const entry of entries) {
-    if (entry.expires_at <= now) {
-      await storage.delete(streamKey(entry.stream_id));
-      removedStreamIds.push(entry.stream_id);
-    } else retained.push(entry);
-  }
-  return { entries: retained, removedStreamIds };
-}
-
-async function freeCompletedSlots(
-  storage: TransactionStorage,
-  entries: StreamIndexEntry[],
-  maximumRetained: number,
-): Promise<{ available: boolean; entries: StreamIndexEntry[]; removedStreamIds: string[] }> {
-  const retained = [...entries];
-  const removedStreamIds: string[] = [];
-  const completed = retained
-    .filter((entry) => entry.status === "ready")
-    .sort((left, right) => left.created_at - right.created_at);
-  for (const entry of completed) {
-    if (retained.length <= maximumRetained) break;
-    await storage.delete(streamKey(entry.stream_id));
-    retained.splice(retained.findIndex((candidate) => candidate.stream_id === entry.stream_id), 1);
-    removedStreamIds.push(entry.stream_id);
-  }
-  return { available: retained.length <= maximumRetained, entries: retained, removedStreamIds };
-}