convex-durable-agents 0.2.4 → 0.2.6

package/package.json

@@ -6,7 +6,7 @@
   "bugs": {
     "url": "https://github.com/ziegfried/convex-durable-agents/issues"
   },
-  "version": "0.2.4",
+  "version": "0.2.6",
   "license": "Apache-2.0",
   "keywords": [
     "convex",
@@ -83,38 +83,41 @@
     }
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.14",
-    "@convex-dev/eslint-plugin": "^1.1.1",
-    "@convex-dev/workpool": "^0.3.1",
+    "@biomejs/biome": "^2.4.14",
+    "@convex-dev/eslint-plugin": "^2.0.0",
+    "@convex-dev/workpool": "^0.4.6",
     "@edge-runtime/vm": "^5.0.0",
-    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/eslintrc": "^3.3.5",
     "@eslint/js": "9.39.2",
-    "@types/bun": "^1.3.8",
-    "@types/node": "^24.10.11",
-    "@types/react": "^19.2.13",
+    "@testing-library/react": "^16.3.2",
+    "@types/bun": "^1.3.13",
+    "@types/node": "^24.12.2",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^5.1.3",
-    "ai": "^6.0.75",
+    "@vitejs/plugin-react": "^6.0.1",
+    "ai": "^6.0.174",
     "chokidar-cli": "3.0.0",
-    "convex": "1.31.7",
-    "convex-test": "0.0.41",
+    "convex": "1.37.0",
+    "convex-test": "0.0.51",
     "cpy-cli": "^7.0.0",
     "eslint": "9.39.2",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^7.0.1",
-    "eslint-plugin-react-refresh": "^0.5.0",
-    "globals": "^17.3.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.6.0",
+    "happy-dom": "^20.9.0",
     "npm-run-all2": "8.0.4",
     "path-exists-cli": "2.0.0",
     "pkg-pr-new": "^0.0.63",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.54.0",
-    "vite": "7.3.1",
+    "typescript-eslint": "8.56.1",
+    "vite": "8.0.10",
     "vitest": "4.0.18",
-    "zod": "^4.3.6"
+    "zod": "^4.4.2"
   },
   "types": "./dist/client/index.d.ts",
-  "module": "./dist/client/index.js"
+  "module": "./dist/client/index.js",
+  "packageManager": "bun@1.3.9"
 }

package/src/client/handler.ts

@@ -13,6 +13,7 @@ import { v } from "convex/values";
 import type { ComponentApi } from "../component/_generated/component.js";
 import type { Id } from "../component/_generated/dataModel.js";
 import { Logger } from "../utils/logger.js";
+import { endsWithAssistantMessage } from "../utils/msg.js";
 import {
   clampDelayMs,
   classifyRetryErrorDefault,
@@ -38,6 +39,8 @@ import { getStreamTextProviderMetadata, getStreamTextUsage, type UsageInfo } fro
 export type StreamingOptions = {
   throttleMs?: number;
   returnImmediately?: boolean;
+  /** Include tool-input-delta chunks in the stream, enabling incremental tool call input on the client. Default: false */
+  includeToolInputDeltas?: boolean;
 };
 
 const DEFAULT_STREAMING_OPTIONS: StreamingOptions = {
@@ -92,6 +95,8 @@ export type ErrorHandlerCallback = (ctx: ActionCtx, args: ErrorHandlerArgs) => v
 
 export type StreamHandlerArgs = Omit<Parameters<typeof streamText>[0], "tools" | "messages" | "prompt"> & {
   tools: Record<string, DurableTool<unknown, unknown>>;
+  /** Optional: provider-native tools that should be passed through directly to streamText */
+  providerTools?: NonNullable<Parameters<typeof streamText>[0]["tools"]>;
   /** Optional: Save streaming deltas to the database for real-time client updates */
   saveStreamDeltas?: boolean | StreamingOptions;
   /** Optional: Transform the messages before sending them to the model */
@@ -195,6 +200,7 @@ export function streamHandlerAction(
         typeof argsOrFactory === "function" ? await argsOrFactory(ctx as ActionCtx, args.threadId) : argsOrFactory;
       const {
         tools,
+        providerTools,
         saveStreamDeltas,
         transformMessages = (messages) => messages,
         onMessageComplete: usageHandlerCallback,
@@ -214,6 +220,7 @@ export function streamHandlerAction(
         threadId: args.threadId as Id<"threads">,
         streamId: args.streamId as Id<"streams">,
         lockId,
+        includeToolInputDeltas: streamingOptions.includeToolInputDeltas ?? false,
       });
       logger.debug("Acquiring stream lock...");
       const stream = await streamer.acquireLock().catch((e) => {
@@ -249,13 +256,19 @@ export function streamHandlerAction(
 
         // Build tool definitions for AI SDK (without execute functions)
         const handlerlessTools: Record<string, Tool> = {};
+        const durableToolNames = new Set<string>();
         for (const toolDef of toolDefinitions) {
+          durableToolNames.add(toolDef.name);
           handlerlessTools[toolDef.name] = tool({
             description: toolDef.description,
             inputSchema: jsonSchema(toolDef.parameters as Parameters<typeof jsonSchema>[0]),
             // No execute function - we handle tool calls manually
           });
         }
+        const modelTools = {
+          ...handlerlessTools,
+          ...(providerTools ?? {}),
+        };
 
         const thread = await ctx.runQuery(component.threads.get, {
           threadId: args.threadId as Id<"threads">,
@@ -275,7 +288,19 @@ export function streamHandlerAction(
 
         const uiMessages = messages.map((m) => messageDocToUIMessage(m));
         logger.debug(`Converted ${uiMessages.length} UI messages, transforming to model messages...`);
-        const modelMessages = transformMessages(await convertToModelMessages(uiMessages, { tools: handlerlessTools }));
+        const modelMessages = transformMessages(await convertToModelMessages(uiMessages, { tools: modelTools }));
+        if (endsWithAssistantMessage(modelMessages)) {
+          logger.warn(
+            "Skipping streamText because transformed messages end with an assistant turn; no user/tool turn available",
+          );
+          finalStatus = "completed";
+          await streamer.finish();
+          await ctx.runMutation(component.threads.clearRetryState, {
+            threadId: args.threadId as Id<"threads">,
+          });
+          logger.debug("Stream handler completed without generation due to trailing assistant message");
+          return null;
+        }
         logger.debug(`Model messages ready (${modelMessages.length} messages), starting streamText...`);
 
         let toolCallCount = 0;
@@ -285,7 +310,7 @@ export function streamHandlerAction(
             ...streamTextArgs,
             prompt: undefined,
             messages: modelMessages,
-            tools: handlerlessTools,
+            tools: modelTools,
           });
 
           let finishReason: string | undefined;
@@ -328,6 +353,12 @@ export function streamHandlerAction(
                 logger.debug(
                   `Stream part: tool-input-available (tool=${part.toolName}, callId=${part.toolCallId}, count=${toolCallCount})`,
                 );
+                if (!durableToolNames.has(part.toolName)) {
+                  logger.debug(
+                    `Skipping scheduling for provider tool call: ${part.toolName} (callId=${part.toolCallId})`,
+                  );
+                  break;
+                }
                 await scheduleToolCall(
                   ctx,
                   {

package/src/client/streamer.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it, vi } from "vitest";
+import type { UIMessageChunk } from "ai";
+import { joinAdjacentDeltas, Streamer } from "./streamer.js";
+
+/**
+ * Minimal mocks for testing the Streamer in isolation.
+ * We only need the mutation calls the Streamer makes.
+ */
+function createMockCtx() {
+  return {
+    runQuery: vi.fn().mockResolvedValue(null),
+    runMutation: vi.fn().mockResolvedValue(null),
+    runAction: vi.fn().mockResolvedValue(null),
+    storage: {} as any,
+    auth: {} as any,
+    scheduler: { runAfter: vi.fn() } as any,
+  };
+}
+
+function createMockComponent() {
+  return {
+    streams: {
+      take: "streams:take" as any,
+      addDelta: "streams:addDelta" as any,
+      finish: "streams:finish" as any,
+      abort: "streams:abort" as any,
+      heartbeat: "streams:heartbeat" as any,
+    },
+  } as any;
+}
+
+function createStreamer(ctx = createMockCtx(), component = createMockComponent()) {
+  const streamer = new Streamer(component, ctx, {
+    throttleMs: 50,
+    heartbeatMs: 60_000,
+    lockId: "test-lock",
+    threadId: "test-thread" as any,
+    streamId: "test-stream" as any,
+    includeToolInputDeltas: false,
+  });
+  return { streamer, ctx, component };
+}
+
+describe("Streamer", () => {
+  describe("fail() cancels pending flush timeout", () => {
+    it("should not write deltas after fail() is called", async () => {
+      const { streamer, ctx } = createStreamer();
+      streamer.enableDeltaStreaming();
+      await streamer.setMessageId("msg-1", false);
+
+      // Queue some parts via process() — this schedules a throttled flush
+      await streamer.process({ type: "text-delta" as any, id: "t1", delta: "hello " });
+      await streamer.process({ type: "text-delta" as any, id: "t1", delta: "world" });
+
+      // Now call fail() — this should cancel the pending flush
+      await streamer.fail("Provider connection lost");
+
+      // Verify abort was called
+      expect(ctx.runMutation).toHaveBeenCalledWith("streams:abort", {
+        streamId: "test-stream",
+        reason: "Provider connection lost",
+      });
+
+      // Wait longer than the throttle interval to give the (cancelled) timeout
+      // a chance to fire if it wasn't properly cancelled
+      await new Promise((resolve) => setTimeout(resolve, 150));
+
+      // addDelta should NEVER have been called — the flush was cancelled
+      const addDeltaCalls = ctx.runMutation.mock.calls.filter(
+        (call) => call[0] === "streams:addDelta",
+      );
+      expect(addDeltaCalls).toHaveLength(0);
+    });
+
+    it("should still flush deltas on finish() (happy path)", async () => {
+      const { streamer, ctx } = createStreamer();
+      streamer.enableDeltaStreaming();
+      await streamer.setMessageId("msg-1", false);
+
+      await streamer.process({ type: "text-delta" as any, id: "t1", delta: "hello" });
+
+      await streamer.finish();
+
+      // finish() should flush remaining deltas then mark stream finished
+      const addDeltaCalls = ctx.runMutation.mock.calls.filter(
+        (call) => call[0] === "streams:addDelta",
+      );
+      expect(addDeltaCalls).toHaveLength(1);
+
+      expect(ctx.runMutation).toHaveBeenCalledWith("streams:finish", {
+        streamId: "test-stream",
+      });
+    });
+  });
+});
+
+describe("joinAdjacentDeltas", () => {
+  it("returns empty array for empty input", () => {
+    expect(joinAdjacentDeltas([])).toEqual([]);
+  });
+
+  it("joins adjacent text-delta chunks with the same id", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "text-delta", id: "a", delta: " world" },
+      { type: "text-delta", id: "a", delta: "!" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual([{ type: "text-delta", id: "a", delta: "Hello world!" }]);
+  });
+
+  it("joins adjacent reasoning-delta chunks with the same id", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "reasoning-delta", id: "r1", delta: "Let me " },
+      { type: "reasoning-delta", id: "r1", delta: "think" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual([{ type: "reasoning-delta", id: "r1", delta: "Let me think" }]);
+  });
+
+  it("does not join text-delta chunks with different ids", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "text-delta", id: "b", delta: " world" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual([
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "text-delta", id: "b", delta: " world" },
+    ]);
+  });
+
+  it("does not join text-delta and reasoning-delta even with same id", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "reasoning-delta", id: "a", delta: "think" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual([
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "reasoning-delta", id: "a", delta: "think" },
+    ]);
+  });
+
+  it("does not join non-adjacent same-type chunks", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "text-start", id: "b" },
+      { type: "text-delta", id: "a", delta: " world" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual([
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "text-start", id: "b" },
+      { type: "text-delta", id: "a", delta: " world" },
+    ]);
+  });
+
+  it("passes through non-delta chunk types unchanged", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "text-start", id: "a" },
+      { type: "text-end", id: "a" },
+      { type: "start" },
+      { type: "finish" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual(chunks);
+  });
+
+  it("handles mixed delta and non-delta chunks", () => {
+    const chunks: Array<UIMessageChunk> = [
+      { type: "text-start", id: "a" },
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "text-delta", id: "a", delta: " world" },
+      { type: "text-end", id: "a" },
+      { type: "reasoning-start", id: "r1" },
+      { type: "reasoning-delta", id: "r1", delta: "Step " },
+      { type: "reasoning-delta", id: "r1", delta: "1" },
+    ];
+    expect(joinAdjacentDeltas(chunks)).toEqual([
+      { type: "text-start", id: "a" },
+      { type: "text-delta", id: "a", delta: "Hello world" },
+      { type: "text-end", id: "a" },
+      { type: "reasoning-start", id: "r1" },
+      { type: "reasoning-delta", id: "r1", delta: "Step 1" },
+    ]);
+  });
+
+  it("handles a single chunk", () => {
+    const chunks: Array<UIMessageChunk> = [{ type: "text-delta", id: "a", delta: "Hello" }];
+    expect(joinAdjacentDeltas(chunks)).toEqual([{ type: "text-delta", id: "a", delta: "Hello" }]);
+  });
+});

package/src/client/streamer.ts

@@ -24,6 +24,7 @@ export class Streamer {
       lockId: string;
       threadId: Id<"threads">;
       streamId: Id<"streams">;
+      includeToolInputDeltas: boolean;
     },
   ) {
     this.#logger = new Logger(`streamer:${config.streamId}`);
@@ -129,7 +130,7 @@ export class Streamer {
     try {
       const queue = this.#queue;
       this.#queue = [];
-      const compacted = compactQueue(queue);
+      const compacted = compactQueue(queue, this.config.includeToolInputDeltas);
       if (compacted.length === 0) {
         this.#logger.debug(`Skipping delta write: seq=${this.#seq}, rawParts=${queue.length}, compactedParts=0`);
         return;
@@ -169,6 +170,11 @@ export class Streamer {
 
   async fail(reason: string): Promise<void> {
     try {
+      if (this.#flushTimeout != null) {
+        clearTimeout(this.#flushTimeout);
+        this.#flushTimeout = undefined;
+      }
+      this.#queue = [];
       this.#logger.debug(`Aborting stream: ${reason}`);
       await this.ctx.runMutation(this.component.streams.abort, {
         streamId: this.config.streamId,
@@ -181,8 +187,9 @@ export class Streamer {
   }
 }
 
-export function compactQueue(queue: Array<UIMessageChunk>): Array<UIMessageChunk> {
-  return joinAdjacentDeltas(queue.filter((part) => !(part.type === "tool-input-delta")).map(dropUnnecessaryInfo));
+export function compactQueue(queue: Array<UIMessageChunk>, includeToolInputDeltas = false): Array<UIMessageChunk> {
+  const filtered = includeToolInputDeltas ? queue : queue.filter((part) => part.type !== "tool-input-delta");
+  return joinAdjacentDeltas(filtered.map(dropUnnecessaryInfo));
 }
 
 export function dropUnnecessaryInfo(chunk: UIMessageChunk): UIMessageChunk {

package/src/client/tools.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import type { FunctionReference } from "convex/server";
+import { z } from "zod";
+import { createActionTool } from "./tools";
+
+const fakeHandler = "internal:fake.handler" as unknown as FunctionReference<"action", "internal" | "public">;
+
+describe("createActionTool", () => {
+  it("normalizes retry=true into enabled retry policy", () => {
+    const tool = createActionTool({
+      description: "test",
+      args: z.object({ value: z.string() }),
+      handler: fakeHandler,
+      retry: true,
+    });
+
+    expect(tool.retry).toEqual({ enabled: true });
+  });
+
+  it("preserves custom retry policy", () => {
+    const tool = createActionTool({
+      description: "test",
+      args: z.object({ value: z.string() }),
+      handler: fakeHandler,
+      retry: {
+        enabled: true,
+        maxAttempts: 5,
+        backoff: { strategy: "fixed", delayMs: 250, jitter: false },
+      },
+    });
+
+    expect(tool.retry).toEqual({
+      enabled: true,
+      maxAttempts: 5,
+      backoff: { strategy: "fixed", delayMs: 250, jitter: false },
+    });
+  });
+
+  it("omits retry policy when not provided", () => {
+    const tool = createActionTool({
+      description: "test",
+      args: z.object({ value: z.string() }),
+      handler: fakeHandler,
+    });
+
+    expect(tool.retry).toBeUndefined();
+  });
+});

package/src/component/messages.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { isToolInputAvailablePart } from "./messages";
+
+describe("isToolInputAvailablePart", () => {
+  it("returns true for tool input available objects", () => {
+    expect(
+      isToolInputAvailablePart({
+        toolCallId: "tool-call-1",
+        state: "input-available",
+      }),
+    ).toBe(true);
+  });
+
+  it("returns false for non-object values", () => {
+    expect(isToolInputAvailablePart(null)).toBe(false);
+    expect(isToolInputAvailablePart("tool-call-1")).toBe(false);
+    expect(isToolInputAvailablePart(123)).toBe(false);
+    expect(isToolInputAvailablePart(true)).toBe(false);
+  });
+
+  it("returns false when required fields are missing or invalid", () => {
+    expect(
+      isToolInputAvailablePart({
+        state: "input-available",
+      }),
+    ).toBe(false);
+    expect(
+      isToolInputAvailablePart({
+        toolCallId: 123,
+        state: "input-available",
+      }),
+    ).toBe(false);
+    expect(
+      isToolInputAvailablePart({
+        toolCallId: "tool-call-1",
+        state: "output-available",
+      }),
+    ).toBe(false);
+  });
+});

package/src/component/streams.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import type { UIMessageChunk } from "ai";
+import { STREAM_HEARTBEAT_INTERVAL_MS, STREAM_LIVENESS_THRESHOLD_MS } from "../utils/streaming";
+import { isAlive, replacePartIds } from "./streams";
+
+describe("isAlive", () => {
+  it("uses a liveness threshold greater than the heartbeat interval", () => {
+    expect(STREAM_LIVENESS_THRESHOLD_MS).toBeGreaterThan(STREAM_HEARTBEAT_INTERVAL_MS);
+  });
+
+  it("returns true for a recent streaming heartbeat", () => {
+    const stream = {
+      state: {
+        kind: "streaming",
+        lockId: "lock-id",
+        lastHeartbeat: Date.now(),
+      },
+    } as Exclude<Parameters<typeof isAlive>[0], null>;
+    expect(isAlive(stream)).toBe(true);
+  });
+
+  it("returns false for an old streaming heartbeat", () => {
+    const stream = {
+      state: {
+        kind: "streaming",
+        lockId: "lock-id",
+        lastHeartbeat: Date.now() - STREAM_LIVENESS_THRESHOLD_MS - 1,
+      },
+    } as Exclude<Parameters<typeof isAlive>[0], null>;
+    expect(isAlive(stream)).toBe(false);
+  });
+});
+
+describe("replacePartIds", () => {
+  it("returns empty array for empty input", () => {
+    expect(replacePartIds([], new Map(), new Set())).toEqual([]);
+  });
+
+  it("assigns sequential ids starting from 0", () => {
+    const parts: UIMessageChunk[] = [
+      { type: "text-delta", id: "orig-a", delta: "Hello" },
+      { type: "text-delta", id: "orig-b", delta: " world" },
+    ];
+    const result = replacePartIds(parts, new Map(), new Set());
+    expect(result).toEqual([
+      { type: "text-delta", id: "0", delta: "Hello" },
+      { type: "text-delta", id: "1", delta: " world" },
+    ]);
+  });
+
+  it("reuses mapped id for parts with the same original id", () => {
+    const parts: UIMessageChunk[] = [
+      { type: "text-delta", id: "orig-a", delta: "Hello" },
+      { type: "text-delta", id: "orig-a", delta: " again" },
+    ];
+    const result = replacePartIds(parts, new Map(), new Set());
+    expect(result).toEqual([
+      { type: "text-delta", id: "0", delta: "Hello" },
+      { type: "text-delta", id: "0", delta: " again" },
+    ]);
+  });
+
+  it("uses pre-existing newIds mapping", () => {
+    const newIds = new Map([["orig-a", "42"]]);
+    const parts: UIMessageChunk[] = [{ type: "text-delta", id: "orig-a", delta: "Hello" }];
+    const result = replacePartIds(parts, newIds, new Set());
+    expect(result).toEqual([{ type: "text-delta", id: "42", delta: "Hello" }]);
+  });
+
+  it("skips ids that are already in prevIds", () => {
+    const prevIds = new Set(["0", "1"]);
+    const parts: UIMessageChunk[] = [{ type: "text-delta", id: "orig-a", delta: "Hello" }];
+    const result = replacePartIds(parts, new Map(), prevIds);
+    expect(result).toEqual([{ type: "text-delta", id: "2", delta: "Hello" }]);
+  });
+
+  it("adds generated ids to prevIds", () => {
+    const prevIds = new Set<string>();
+    const parts: UIMessageChunk[] = [{ type: "text-delta", id: "orig-a", delta: "Hello" }];
+    replacePartIds(parts, new Map(), prevIds);
+    expect(prevIds.has("0")).toBe(true);
+  });
+
+  it("records new mappings in newIds", () => {
+    const newIds = new Map<string, string>();
+    const parts: UIMessageChunk[] = [{ type: "text-delta", id: "orig-a", delta: "Hello" }];
+    replacePartIds(parts, newIds, new Set());
+    expect(newIds.get("orig-a")).toBe("0");
+  });
+
+  it("passes through parts without an id field unchanged", () => {
+    const parts: UIMessageChunk[] = [{ type: "tool-input-delta", toolCallId: "tc1", inputTextDelta: "some input" }];
+    const result = replacePartIds(parts, new Map(), new Set());
+    expect(result).toEqual([{ type: "tool-input-delta", toolCallId: "tc1", inputTextDelta: "some input" }]);
+  });
+
+  it("passes through parts with a falsy id unchanged", () => {
+    const parts: UIMessageChunk[] = [{ type: "text-delta", id: "", delta: "Hello" }];
+    const result = replacePartIds(parts, new Map(), new Set());
+    expect(result).toEqual([{ type: "text-delta", id: "", delta: "Hello" }]);
+  });
+
+  it("handles a mix of parts with and without ids", () => {
+    const parts: UIMessageChunk[] = [
+      { type: "text-delta", id: "a", delta: "Hello" },
+      { type: "tool-input-delta", toolCallId: "tc1", inputTextDelta: "input" },
+      { type: "reasoning-delta", id: "b", delta: "thinking" },
+      { type: "text-delta", id: "a", delta: " world" },
+    ];
+    const result = replacePartIds(parts, new Map(), new Set());
+    expect(result).toEqual([
+      { type: "text-delta", id: "0", delta: "Hello" },
+      { type: "tool-input-delta", toolCallId: "tc1", inputTextDelta: "input" },
+      { type: "reasoning-delta", id: "1", delta: "thinking" },
+      { type: "text-delta", id: "0", delta: " world" },
+    ]);
+  });
+});

package/src/component/threads.test.ts

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { resetFinalizerMismatchAlertState, trackFinalizerMismatchRate } from "./threads";
+
+describe("trackFinalizerMismatchRate", () => {
+  beforeEach(() => {
+    resetFinalizerMismatchAlertState();
+  });
+
+  it("alerts when mismatch threshold is reached within the window", () => {
+    const now = 1_000_000;
+    expect(trackFinalizerMismatchRate("thread-a", now)).toEqual({
+      windowStartedAt: now,
+      count: 1,
+      shouldAlert: false,
+    });
+    expect(trackFinalizerMismatchRate("thread-a", now + 1_000)).toEqual({
+      windowStartedAt: now,
+      count: 2,
+      shouldAlert: false,
+    });
+    expect(trackFinalizerMismatchRate("thread-a", now + 2_000)).toEqual({
+      windowStartedAt: now,
+      count: 3,
+      shouldAlert: true,
+    });
+    expect(trackFinalizerMismatchRate("thread-a", now + 3_000)).toEqual({
+      windowStartedAt: now,
+      count: 4,
+      shouldAlert: false,
+    });
+  });
+
+  it("resets the counter outside the alert window and isolates by thread", () => {
+    const now = 2_000_000;
+    trackFinalizerMismatchRate("thread-a", now);
+    trackFinalizerMismatchRate("thread-a", now + 1_000);
+    expect(trackFinalizerMismatchRate("thread-b", now + 1_500)).toEqual({
+      windowStartedAt: now + 1_500,
+      count: 1,
+      shouldAlert: false,
+    });
+    expect(trackFinalizerMismatchRate("thread-a", now + 6 * 60 * 1_000)).toEqual({
+      windowStartedAt: now + 6 * 60 * 1_000,
+      count: 1,
+      shouldAlert: false,
+    });
+  });
+});