@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/__tests__/conversation-resurface-done.test.ts

@@ -0,0 +1,289 @@
+/**
+ * A Done conversation comes back to the list when a message the user reads
+ * lands in it.
+ *
+ * Two seams enforce the rule: `insertMessageCore`, where every durable append
+ * lands, and the turn's finalize effect, where a streamed reply becomes
+ * readable. These tests drive the insert seam the way each ingest path does,
+ * with `addMessage` and that path's row shape, and drive the finalize seam
+ * through `resurfaceArchivedConversation` itself, which is all the finalize
+ * effect adds to the reserved row.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+mock.module("../persistence/embeddings/qdrant-client.js", () => ({
+  getQdrantClient: () => ({
+    searchWithFilter: async () => [],
+    hybridSearch: async () => [],
+    upsertPoints: async () => {},
+    deletePoints: async () => {},
+  }),
+  initQdrantClient: () => {},
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
+}));
+
+let sidebarDoneEnabled = true;
+mock.module("../config/sidebar-done-gate.js", () => ({
+  SIDEBAR_DONE_FLAG_KEY: "sidebar-done",
+  isSidebarDoneEnabled: () => sidebarDoneEnabled,
+}));
+
+const listInvalidations: Array<{ reason: string; conversationIds: unknown }> =
+  [];
+const actualSyncEvents =
+  await import("../runtime/sync/resource-sync-events.js");
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  ...actualSyncEvents,
+  publishConversationListAndMetadataChanged: (
+    reason: string,
+    conversationIds: unknown,
+  ) => {
+    listInvalidations.push({ reason, conversationIds });
+  },
+}));
+
+import {
+  addMessage,
+  archiveConversation,
+  getConversation,
+  reserveMessage,
+  resurfaceArchivedConversation,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations, messages } from "../persistence/schema/index.js";
+import {
+  MEMORY_RETROSPECTIVE_INSTRUCTION_KIND,
+  SKILL_CARD_MESSAGE_KIND,
+} from "../plugins/defaults/memory/memory-retrospective-constants.js";
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("memory", { extraction: { useLLM: false } });
+
+await initializeDb();
+
+const DONE_CONVERSATION_ID = "conv-done";
+const RETRO_FORK_ID = "conv-done-retro-fork";
+
+function insertConversation(id: string): void {
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({
+      id,
+      title: null,
+      createdAt: now,
+      updatedAt: now,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      contextCompactedAt: null,
+    })
+    .run();
+}
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  insertConversation(DONE_CONVERSATION_ID);
+  insertConversation(RETRO_FORK_ID);
+  archiveConversation(DONE_CONVERSATION_ID);
+  listInvalidations.length = 0;
+}
+
+function archivedAtOf(id: string): number | null | undefined {
+  return getConversation(id)?.archivedAt;
+}
+
+function blocks(text: string): string {
+  return JSON.stringify([{ type: "text", text }]);
+}
+
+describe("Done conversations and new activity", () => {
+  beforeEach(() => {
+    sidebarDoneEnabled = true;
+    resetTables();
+  });
+
+  test("assistant output from a scheduled run brings the conversation back", async () => {
+    // The wake persists its `<background_event>` trigger first. That row is
+    // dropped from the transcript, so it must not resurface anything on its
+    // own: the run has produced nothing the user can read yet.
+    await addMessage(
+      DONE_CONVERSATION_ID,
+      "user",
+      blocks(
+        '<background_event source="schedule">Daily digest</background_event>',
+      ),
+      {
+        metadata: {
+          kind: "background-event",
+          backgroundEventSource: "schedule",
+          automated: true,
+        },
+        skipIndexing: true,
+      },
+    );
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+
+    // The run's own output is what the user reads.
+    await addMessage(
+      DONE_CONVERSATION_ID,
+      "assistant",
+      blocks("Here is today's digest."),
+      { metadata: { automated: true }, skipIndexing: true },
+    );
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).toBeNull();
+    expect(listInvalidations).toEqual([
+      { reason: "reordered", conversationIds: DONE_CONVERSATION_ID },
+    ]);
+  });
+
+  test("the empty row an LLM call reserves leaves the conversation Done", async () => {
+    const reserved = await reserveMessage(
+      DONE_CONVERSATION_ID,
+      "assistant",
+      undefined,
+      "inflight/ref.jsonl",
+    );
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+
+    // The finalize seam is what resurfaces it, once the row holds content.
+    expect(
+      resurfaceArchivedConversation(DONE_CONVERSATION_ID, reserved.createdAt),
+    ).toBe(true);
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).toBeNull();
+    expect(listInvalidations).toHaveLength(1);
+  });
+
+  test("a Done mark made after the activity wins over the resurface", () => {
+    const activityAt = Date.now() - 60_000;
+
+    expect(
+      resurfaceArchivedConversation(DONE_CONVERSATION_ID, activityAt),
+    ).toBe(false);
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+  });
+
+  test("an inbound channel message from a person brings the conversation back", async () => {
+    await addMessage(DONE_CONVERSATION_ID, "user", "any updates?", {
+      metadata: {
+        userMessageChannel: "slack",
+        provenanceSourceChannel: "slack",
+      },
+      skipIndexing: true,
+    });
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).toBeNull();
+    expect(listInvalidations).toHaveLength(1);
+  });
+
+  test("rows that never render leave the conversation Done", async () => {
+    await addMessage(DONE_CONVERSATION_ID, "user", "internal signal", {
+      metadata: { hidden: true },
+      skipIndexing: true,
+    });
+    await addMessage(DONE_CONVERSATION_ID, "user", "subagent finished", {
+      metadata: { subagentNotification: { subagentId: "sub-1" } },
+      skipIndexing: true,
+    });
+    await addMessage(DONE_CONVERSATION_ID, "user", "acp session update", {
+      metadata: { acpNotification: { sessionId: "acp-1" } },
+      skipIndexing: true,
+    });
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+  });
+
+  test("a memory retrospective leaves the conversation it reviews Done", async () => {
+    // A retrospective runs in a fork: its instruction and its whole pass are
+    // appended to the fork, never to the conversation under review.
+    await addMessage(RETRO_FORK_ID, "user", "Review the transcript.", {
+      metadata: { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
+      skipIndexing: true,
+    });
+    await addMessage(RETRO_FORK_ID, "assistant", blocks("Saved one fact."), {
+      metadata: { automated: true },
+      skipIndexing: true,
+    });
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+  });
+
+  test("a row its producer marked as bookkeeping leaves the conversation Done", async () => {
+    // The retrospective skill card, written the way
+    // `memory-retrospective-skill-card.ts` writes it. Persistence cannot
+    // import the memory plugin (`persistence-layering-guard`), so the producer
+    // declares the row instead of the seam recognising its kind.
+    await addMessage(
+      DONE_CONVERSATION_ID,
+      "assistant",
+      JSON.stringify([
+        {
+          type: "ui_surface",
+          surfaceId: "surface-1",
+          surfaceType: "skill_card",
+          title: "I just learned how to do expense filing",
+          display: "inline",
+          data: { skills: [] },
+        },
+        {
+          type: "text",
+          text: "I just learned how to do expense filing",
+          _surfaceFallback: true,
+        },
+      ]),
+      {
+        metadata: { kind: SKILL_CARD_MESSAGE_KIND, automated: true },
+        skipIndexing: true,
+        clientMessageId: "surface-1",
+        skipResurface: true,
+      },
+    );
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+  });
+
+  test("the flag off keeps every append from clearing archived_at", async () => {
+    sidebarDoneEnabled = false;
+
+    await addMessage(DONE_CONVERSATION_ID, "user", "any updates?", {
+      metadata: {
+        userMessageChannel: "slack",
+        provenanceSourceChannel: "slack",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(
+      DONE_CONVERSATION_ID,
+      "assistant",
+      blocks("Here is today's digest."),
+      { metadata: { automated: true }, skipIndexing: true },
+    );
+
+    expect(archivedAtOf(DONE_CONVERSATION_ID)).not.toBeNull();
+    expect(listInvalidations).toHaveLength(0);
+    expect(
+      getDb()
+        .select()
+        .from(messages)
+        .where(eq(messages.conversationId, DONE_CONVERSATION_ID))
+        .all(),
+    ).toHaveLength(2);
+  });
+});

package/src/__tests__/default-profile-catalog-fallback.test.ts

@@ -116,6 +116,7 @@ describe("managed-column-only scoping", () => {
     expect(Object.keys(MANAGED_PROFILE_TEMPLATES)).toEqual([
       ...DEFAULT_PROFILE_KEYS,
       ...BACKUP_PROFILE_KEYS,
+      "jev-managed",
     ]);
   });
 

package/src/__tests__/gemini-provider.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { MALFORMED_TOOL_CALL_MESSAGE } from "../providers/malformed-tool-call.js";
 import type {
   ContentBlock,
   Message,
@@ -209,6 +210,36 @@ describe("GeminiProvider", () => {
     expect(result.stopReason).toBe("STOP");
   });
 
+  test("throws a status-less malformed tool-call error on MALFORMED_FUNCTION_CALL", async () => {
+    fakeChunks = [
+      textChunk(",featuredImage:{_type:image},patch:true}]})"),
+      finishChunk("MALFORMED_FUNCTION_CALL", 10, 5),
+    ];
+
+    const error = await provider
+      .sendMessage([{ role: "user", content: [{ type: "text", text: "Hi" }] }])
+      .then(
+        () => undefined,
+        (e: unknown) => e,
+      );
+
+    expect(error).toBeInstanceOf(ProviderError);
+    const providerError = error as ProviderError;
+    expect(providerError.statusCode).toBeUndefined();
+    expect(providerError.message).toContain(MALFORMED_TOOL_CALL_MESSAGE);
+    expect(providerError.message).toContain("MALFORMED_FUNCTION_CALL");
+  });
+
+  test("throws a malformed tool-call error on UNEXPECTED_TOOL_CALL", async () => {
+    fakeChunks = [finishChunk("UNEXPECTED_TOOL_CALL", 10, 0)];
+
+    await expect(
+      provider.sendMessage([
+        { role: "user", content: [{ type: "text", text: "Hi" }] },
+      ]),
+    ).rejects.toThrow(MALFORMED_TOOL_CALL_MESSAGE);
+  });
+
   // -----------------------------------------------------------------------
   // Streaming events
   // -----------------------------------------------------------------------

package/src/__tests__/inference-profile-validation-jev.test.ts

@@ -0,0 +1,17 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { validateInferenceProfileKey } from "../config/inference-profile-validation.js";
+import { setConfig } from "./helpers/set-config.js";
+
+describe("validateInferenceProfileKey and the managed Jev profile", () => {
+  beforeEach(() => {
+    setConfig("llm", { profiles: {} });
+  });
+
+  test("a schedule or subagent turn cannot run on the verdict model", () => {
+    expect(validateInferenceProfileKey("balanced")).toBeNull();
+    expect(validateInferenceProfileKey("jev-managed")).toContain(
+      "is not defined in llm.profiles",
+    );
+  });
+});

package/src/__tests__/job-handler-registration-guard.test.ts

@@ -35,6 +35,7 @@ const MEMORY_JOB_TYPES = [
   "memory_retrospective",
   "memory_retrospective_sweep",
   "skill_card_insert",
+  "skill_update_receipt",
   "pkb_filing",
   "pkb_compaction",
 ].sort();

package/src/__tests__/llm-catalog-parity.test.ts

@@ -235,6 +235,10 @@ describe("LLM catalog parity: daemon vs client", () => {
 
   test("jev-latest opts out of chat text generation", () => {
     expect(catalogModelSupportsText("typesafe", "jev-latest")).toBe(false);
+    // A managed Jev profile is configured as `vellum`; the routing identity
+    // owns no catalog models, so the lookup must judge by the catalog owner.
+    expect(catalogModelSupportsText("vellum", "jev-latest")).toBe(false);
+    expect(catalogModelSupportsText("vellum", "claude-opus-5")).toBe(true);
     expect(catalogModelSupportsText("anthropic", "claude-opus-4-8")).toBe(true);
     expect(catalogModelSupportsText("openai-compatible", "local-model")).toBe(
       true,

package/src/__tests__/llm-resolver-override-or-default.test.ts

@@ -225,6 +225,49 @@ describe("composeCallSiteTweak", () => {
 });
 
 describe("shipped call-site tuning", () => {
+  test("the escalation judge uses managed Jev by default", () => {
+    const resolved = resolveCallSiteConfig(
+      "voiceEscalationJudge",
+      LLMSchema.parse({}),
+    );
+
+    expect(resolved.provider).toBe("vellum");
+    expect(resolved.provider_connection).toBeUndefined();
+    expect(resolved.model).toBe("jev-latest");
+  });
+
+  test("the escalation judge falls through on a BYOK default provider", () => {
+    const resolved = resolveCallSiteConfig(
+      "voiceEscalationJudge",
+      LLMSchema.parse(anthropicDp),
+    );
+
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).not.toBe("jev-latest");
+  });
+
+  test("a BYOK Jev call-site override replaces the managed default", () => {
+    const llm = LLMSchema.parse({
+      ...anthropicDp,
+      profiles: {
+        jev: {
+          ...completeCustom,
+          provider: "typesafe",
+          provider_connection: "typesafe-personal",
+          model: "jev-latest",
+        },
+      },
+      callSites: {
+        voiceEscalationJudge: { profile: "jev" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("voiceEscalationJudge", llm);
+
+    expect(resolved.provider).toBe("typesafe");
+    expect(resolved.provider_connection).toBe("typesafe-personal");
+    expect(resolved.model).toBe("jev-latest");
+  });
+
   // A workspace entry that only repoints the profile must not cost the call
   // site the tuning it ships with. `recall` carries a full set: a token
   // budget, effort, sampling, thinking, and cache posture.

package/src/__tests__/openai-responses-prompt-cache.test.ts

@@ -446,7 +446,7 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
     expect(JSON.stringify(messages)).not.toContain("prompt_cache_breakpoint");
   });
 
-  test("catalog flags GPT-5.6 and GPT-6 Astra direct-openai rows", () => {
+  test("catalog flags GPT-5.6 and GPT-6 direct-openai rows", () => {
     const openai = PROVIDER_CATALOG.find((p) => p.id === "openai");
     const flagged = (openai?.models ?? [])
       .filter((m) => m.supportsPromptCacheBreakpoints)
@@ -457,6 +457,8 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
       "gpt-5.6-sol",
       "gpt-5.6-terra",
       "gpt-6-astra",
+      "gpt-6-luna",
+      "gpt-6-sol",
     ]);
   });
 });

package/src/__tests__/platform-callback-registration.test.ts

@@ -11,6 +11,7 @@ let mockVelayWebhooksEnabled = false;
 let mockPlatformBaseUrl = "";
 let mockPlatformAssistantId = "";
 let mockSecureKeys: Record<string, string> = {};
+let mockSecureKeysUnreachable = false;
 let mockConfig: { ingress?: { publicBaseUrl?: string; enabled?: boolean } } =
   {};
 
@@ -65,7 +66,12 @@ mock.module("../ipc/gateway-client.js", () => ({
 const actualSecureKeys = await import("../security/secure-keys.js");
 mock.module("../security/secure-keys.js", () => ({
   ...actualSecureKeys,
-  getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? undefined,
+  getSecureKeyAsync: async (key: string) =>
+    mockSecureKeysUnreachable ? undefined : (mockSecureKeys[key] ?? undefined),
+  getSecureKeyResultAsync: async (key: string) =>
+    mockSecureKeysUnreachable
+      ? { value: undefined, unreachable: true }
+      : { value: mockSecureKeys[key] ?? undefined, unreachable: false },
 }));
 
 const actualLoader = await import("../config/loader.js");
@@ -92,6 +98,7 @@ describe("platform callback registration", () => {
     mockPlatformBaseUrl = "";
     mockPlatformAssistantId = "";
     mockSecureKeys = {};
+    mockSecureKeysUnreachable = false;
     mockConfig = {};
     setIngressPublicBaseUrl(undefined);
     delete process.env.ASSISTANT_API_KEY;
@@ -156,6 +163,43 @@ describe("platform callback registration", () => {
     expect(context.authHeader).toBe("Api-Key env-key");
   });
 
+  test("reports the key as missing when the store answers and holds none", async () => {
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockPlatformAssistantId = "44444444-5555-4666-8777-888888888888";
+
+    const context = await resolvePlatformCallbackRegistrationContext();
+
+    expect(context.hasAssistantApiKey).toBe(false);
+    expect(context.authHeader).toBeNull();
+    expect(context.enabled).toBe(false);
+  });
+
+  test("reports the key state as unknown when the store did not answer", async () => {
+    // A client that provisions a key when it sees none must not be told
+    // "none" by a daemon whose store did not answer.
+    mockSecureKeysUnreachable = true;
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockPlatformAssistantId = "44444444-5555-4666-8777-888888888888";
+
+    const context = await resolvePlatformCallbackRegistrationContext();
+
+    expect(context.hasAssistantApiKey).toBeNull();
+    expect(context.authHeader).toBeNull();
+    expect(context.enabled).toBe(false);
+  });
+
+  test("an environment key counts as present even when the store did not answer", async () => {
+    mockSecureKeysUnreachable = true;
+    process.env.ASSISTANT_API_KEY = "env-key";
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockPlatformAssistantId = "44444444-5555-4666-8777-888888888888";
+
+    const context = await resolvePlatformCallbackRegistrationContext();
+
+    expect(context.hasAssistantApiKey).toBe(true);
+    expect(context.authHeader).toBe("Api-Key env-key");
+  });
+
   test("registerCallbackRoute falls back to assistant API key auth", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
@@ -402,6 +446,7 @@ describe("resolveCallbackUrl resolution order", () => {
     mockPlatformBaseUrl = "";
     mockPlatformAssistantId = "";
     mockSecureKeys = {};
+    mockSecureKeysUnreachable = false;
     mockConfig = {};
     setIngressPublicBaseUrl(undefined);
     delete process.env.ASSISTANT_API_KEY;

package/src/__tests__/plugin-api-model-profiles.test.ts

@@ -40,6 +40,13 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({});
   });
 
+  test("omits the managed Jev profile, whose model returns verdicts rather than text", () => {
+    writeFixtureConfig({});
+    const keys = getModelProfiles().map((p) => p.key);
+    expect(keys).toContain("balanced");
+    expect(keys).not.toContain("jev-managed");
+  });
+
   test("orders profiles by profileOrder then the remaining keys alphabetically", () => {
     // GIVEN a workspace whose profileOrder names some keys, with a duplicate
     // ("balanced") and a key that resolves to no profile ("ghost").

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -196,6 +196,9 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../daemon/trust-context.js",
     "../../../home/job-handlers/conversation-starters.js",
     "../../../media/job-handlers/media-processing.js",
+    // The skill-update receipt job announces a burst through the
+    // notification pipeline's single entry point. No plugin-api equivalent.
+    "../../../notifications/emit-signal.js",
     "../../../permissions/types.js",
     "../../../persistence/auto-analysis-constants.js",
     "../../../persistence/checkpoints.js",

package/src/__tests__/pricing.test.ts

@@ -135,6 +135,39 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBeCloseTo(0.5 + 0.625 + 0.05, 10);
     });
 
+    test("bills GPT-6 Sol at published short-context rates", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-sol", {
+        directInputTokens: 50_000,
+        outputTokens: 50_000,
+        cacheCreationInputTokens: 50_000,
+        cacheReadInputTokens: 50_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // 0.05M x $2 direct + 0.05M x $2.5 write + 0.05M x $0.2 read
+      // + 0.05M x $10 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(0.1 + 0.125 + 0.01 + 0.5, 10);
+    });
+
+    test("bills GPT-6 Luna at the long-context tier above 272k", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-luna", {
+        directInputTokens: 500_000,
+        outputTokens: 1_000_000,
+        cacheCreationInputTokens: 500_000,
+        cacheReadInputTokens: 1_000_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // Tier rates: 0.5M x $0.2 direct + 0.5M x $0.25 write + 1M x $0.02 read
+      // + 1M x $0.75 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(
+        0.1 + 0.125 + 0.02 + 0.75,
+        10,
+      );
+    });
+
     test("bills GPT-6 Astra at the long-context tier above 272k", () => {
       const result = resolvePricingForUsage("openai", "gpt-6-astra", {
         directInputTokens: 500_000,

package/src/__tests__/provider-error-scenarios.test.ts

@@ -118,6 +118,7 @@ mock.module("../util/retry.js", () => {
   };
 });
 
+import { malformedToolCallError } from "../providers/malformed-tool-call.js";
 import { RetryProvider } from "../providers/retry.js";
 import { createStreamTimeout } from "../providers/stream-timeout.js";
 import {
@@ -941,6 +942,51 @@ describe("RetryProvider — streaming corruption retries", () => {
     }
   });
 
+  test("malformed tool-call finishes retry once with a corrective note", async () => {
+    const providerError = malformedToolCallError(
+      "openrouter",
+      "MALFORMED_FUNCTION_CALL",
+    );
+    // Providers wrap stream-loop throws in their generic catch.
+    const wrapped = new ProviderError(
+      `OpenRouter request failed: ${providerError.message}`,
+      "openrouter",
+      undefined,
+      { cause: providerError },
+    );
+    const inner = makeCapturingFlaky(1, wrapped);
+    const provider = new RetryProvider(inner);
+
+    await provider.sendMessage(MESSAGES);
+
+    expect(inner.calls).toBe(2);
+    expect(inner.seen[0]).toBe(MESSAGES);
+    const retried = inner.seen[1]!;
+    const lastMessage = retried[retried.length - 1]!;
+    expect(lastMessage.role).toBe("user");
+    expect(lastMessage.content).toHaveLength(2);
+    const hint = lastMessage.content[1] as { type: string; text: string };
+    expect(hint.type).toBe("text");
+    expect(hint.text).toContain("did not parse");
+    expect(MESSAGES[MESSAGES.length - 1]!.content).toHaveLength(1);
+  });
+
+  test("a malformed tool-call message with an HTTP status is not retried", async () => {
+    const inner = makeFailing(
+      new ProviderError(
+        malformedToolCallError("gemini", "MALFORMED_FUNCTION_CALL").message,
+        "gemini",
+        400,
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "malformed tool call",
+    );
+    expect(inner.calls).toBe(1);
+  });
+
   test("other stream-corruption retries resend the messages untouched", async () => {
     const inner = makeCapturingFlaky(
       1,