@vellumai/assistant 0.12.3-staging.2 → 0.12.4-staging.1

package/src/persistence/embeddings/embedding-local.ts

@@ -7,6 +7,8 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
+import type { Subprocess } from "bun";
+
 import { getIsContainerized } from "../../config/env-registry.js";
 import { getLogger } from "../../util/logger.js";
 import {
@@ -22,6 +24,7 @@ import {
   listWorkerProcesses,
   pid1OwnsWorkers,
 } from "../../util/worker-ownership.js";
+import { writeWorkerLine } from "../../util/worker-pipe.js";
 import { EmbeddingRuntimeManager } from "./embedding-runtime-manager.js";
 import {
   type EmbeddingBackend,
@@ -106,9 +109,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   readonly provider = "local" as const;
   readonly model: string;
 
-  // Subprocess — typed loosely to avoid coupling to Bun's Subprocess generics
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private workerProc: any = null;
+  private workerProc: Subprocess<"pipe", "pipe", "pipe"> | null = null;
   private stdoutBuffer = "";
   private requestCounter = 0;
   private pendingRequests = new Map<
@@ -119,7 +120,10 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   >();
   private stdoutReaderActive = false;
   private activeEmbeds = 0;
+  /** Release the worker once idle. {@link forModel} withdraws the request. */
   private disposeRequested = false;
+  /** Set by {@link shutdown}. The process is exiting, so nothing reopens this. */
+  private processExiting = false;
 
   private readonly initGuard = new PromiseGuard<void>();
   private initInFlight: Promise<void> | null = null;
@@ -130,7 +134,67 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   /** Overridable so tests can exercise the escalation path without the wait. */
   private terminateGraceMs = WORKER_TERMINATE_GRACE_MS;
 
-  constructor(model: string) {
+  /**
+   * Every backend this process has handed out, one per model.
+   *
+   * {@link reclaimOwnedWorkers} terminates a same-model worker parented to this
+   * process that the instance holds no handle for. That is sound only while no
+   * other instance in this process can hold that worker, so instances come from
+   * {@link forModel} and are never constructed by callers.
+   *
+   * This is also the complete list of workers the process owns. The backend
+   * cache is not: it forgets a backend whose disposal is still pending.
+   */
+  private static readonly byModel = new Map<string, LocalEmbeddingBackend>();
+
+  /**
+   * The backend for `model`. A pending {@link dispose} is withdrawn, so embeds
+   * still running on the instance keep their worker.
+   */
+  static forModel(model: string): LocalEmbeddingBackend {
+    let backend = LocalEmbeddingBackend.byModel.get(model);
+    if (!backend) {
+      backend = new LocalEmbeddingBackend(model);
+      LocalEmbeddingBackend.byModel.set(model, backend);
+    }
+    if (!backend.processExiting) {
+      backend.disposeRequested = false;
+    }
+    return backend;
+  }
+
+  /** {@link shutdown} every backend, then reap any worker still parented here. */
+  static async shutdownAll(): Promise<void> {
+    await Promise.all(
+      [...LocalEmbeddingBackend.byModel.values()].map(async (backend) => {
+        try {
+          await backend.shutdown();
+          await backend.sweepOwnedWorkers();
+        } catch (err) {
+          log.warn(
+            { err, model: backend.model },
+            "Failed to shut down local embedding backend",
+          );
+        }
+      }),
+    );
+  }
+
+  /** {@link terminateNow} every backend. */
+  static terminateAllNow(): void {
+    for (const backend of LocalEmbeddingBackend.byModel.values()) {
+      try {
+        backend.terminateNow();
+      } catch (err) {
+        log.warn(
+          { err, model: backend.model },
+          "Failed to terminate local embedding worker",
+        );
+      }
+    }
+  }
+
+  private constructor(model: string) {
     this.model = model;
   }
 
@@ -193,19 +257,9 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
       }
       this.pendingRequests.set(id, { resolve });
 
-      // Writing to a worker that has already exited raises EPIPE. That must
-      // surface as an ordinary embed failure the caller can fall back from:
-      // an escaping EPIPE reaches the daemon's `unhandledRejection` handler,
-      // which tears down the whole process (JARVIS-1125).
-      //
-      // The guard covers `write` as well as `flush`: both are synchronous on
-      // Bun's FileSink, and `write` is the call that raises the broken pipe.
-      try {
-        proc.stdin.write(JSON.stringify({ id, texts }) + "\n");
-        proc.stdin.flush();
-      } catch (err) {
-        this.failPendingRequest(id, err);
-      }
+      writeWorkerLine(proc.stdin, JSON.stringify({ id, texts }), (err) =>
+        this.failPendingRequest(id, err),
+      );
     });
   }
 
@@ -929,6 +983,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
    * the OS confirms the worker is gone.
    */
   async shutdown(): Promise<void> {
+    this.processExiting = true;
     this.disposeRequested = true;
 
     // An initialization already in flight has not necessarily assigned

package/src/persistence/embeddings/embedding-types.ts

@@ -113,25 +113,6 @@ export interface EmbeddingBackend {
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]>;
   dispose?(): void;
-  /**
-   * Deterministic teardown for daemon shutdown: release any OS resources the
-   * backend owns (e.g. a worker subprocess) and resolve only once they are
-   * confirmed gone. Unlike {@link dispose}, which may defer while embeds are
-   * in flight, this must not leave a child process behind.
-   */
-  shutdown?(): Promise<void>;
-  /**
-   * Release owned OS resources synchronously, for a process that must exit this
-   * tick. Unlike {@link shutdown} it cannot wait for confirmation, so it uses
-   * the uncatchable signal rather than the graceful one.
-   */
-  terminateNow?(): void;
-  /**
-   * Reap any owned child still attributable to this process, without needing a
-   * handle for it. Backstop for a teardown that could not resolve its handle in
-   * time.
-   */
-  sweepOwnedWorkers?(): Promise<void>;
 }
 
 /**

package/src/plugins/defaults/memory/__tests__/memory-retrospective-skill-card.test.ts

@@ -238,6 +238,7 @@ describe("memory-retrospective skill card", () => {
       metadata: { kind: "skill-authored-card", automated: true },
       skipIndexing: true,
       clientMessageId: "skill-card-run-conv-1",
+      skipResurface: true,
     });
     // Disk view sync mirrors the wake-persist path, then clients are told to
     // refetch the message list.
@@ -423,6 +424,7 @@ describe("memory-retrospective skill card", () => {
       metadata: { kind: "skill-authored-card", automated: true },
       skipIndexing: true,
       clientMessageId: "skill-card-run-conv-1",
+      skipResurface: true,
     });
     expect(syncedToDisk).toHaveLength(1);
     expect(publishedConversationIds).toEqual(["src-conv-9"]);

package/src/plugins/defaults/memory/memory-retrospective-skill-card.ts

@@ -321,6 +321,11 @@ async function insertOrDeferSkillCard(
       metadata: { kind: SKILL_CARD_MESSAGE_KIND, automated: true },
       skipIndexing: true,
       clientMessageId: surfaceId,
+      // The card is what the pass learned about this conversation, not new
+      // activity in it, and a pass runs once the conversation has gone idle.
+      // That is exactly when the user has just marked it done, so a card that
+      // resurfaced would bounce fresh done chats back into the sidebar.
+      skipResurface: true,
     },
   );
   if (persisted.deduplicated) {

package/src/providers/gemini/client.ts

@@ -16,6 +16,10 @@ import {
 } from "../content-block-size.js";
 import { fileBlockToProviderText } from "../file-block-text.js";
 import { unsignedThoughtSignatureFallback } from "../gemini-thought-signature.js";
+import {
+  isMalformedToolCallFinishReason,
+  malformedToolCallError,
+} from "../malformed-tool-call.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
@@ -577,6 +581,18 @@ export class GeminiProvider implements Provider {
         cleanupTimeout();
       }
 
+      if (isMalformedToolCallFinishReason(finishReason)) {
+        log.warn(
+          {
+            model: responseModel,
+            finishReason,
+            streamedTextLength: fullText.length,
+          },
+          "Gemini response ended on a malformed tool call",
+        );
+        throw malformedToolCallError("gemini", finishReason);
+      }
+
       // Build content blocks
       const content: ContentBlock[] = [];
       if (fullText) {
@@ -649,7 +665,7 @@ export class GeminiProvider implements Provider {
           error.status,
           // Skip reason on caller-abort: abortReason already carries the intent
           // and short-circuits classification/retry (mirrors the Anthropic client).
-        abortReason
+          abortReason
             ? { abortReason, rawRequest: inspectableRequest }
             : {
                 reason: deriveGeminiReason(error),

package/src/providers/malformed-tool-call.ts

@@ -0,0 +1,55 @@
+/**
+ * Upstream finish reasons that mean the model tried to call a tool but the
+ * call did not parse.
+ *
+ * Gemini reports these as `MALFORMED_FUNCTION_CALL` (the call was not valid)
+ * and `UNEXPECTED_TOOL_CALL` (a call the request did not allow). The native
+ * Gemini API returns them as `candidate.finishReason`; OpenRouter normalizes
+ * them away in `finish_reason` and passes the raw value through in
+ * `native_finish_reason`. Such responses often carry the tail of the broken
+ * call as plain assistant text, so they must never be taken as a final answer.
+ * Providers throw a status-less `ProviderError` carrying
+ * {@link MALFORMED_TOOL_CALL_MESSAGE}, which the retry layer (`retry.ts`)
+ * resends once with a corrective note.
+ */
+
+import { ProviderError } from "../util/errors.js";
+
+/** Message fragment shared by the provider throw sites and the retry classifier. */
+export const MALFORMED_TOOL_CALL_MESSAGE =
+  "Model emitted a malformed tool call";
+
+const MALFORMED_TOOL_CALL_FINISH_REASONS = new Set([
+  "MALFORMED_FUNCTION_CALL",
+  "UNEXPECTED_TOOL_CALL",
+]);
+
+/**
+ * Whether an upstream finish reason denotes a malformed tool call.
+ * Case- and whitespace-insensitive; a `null`/`undefined`/empty reason is false.
+ */
+export function isMalformedToolCallFinishReason(
+  finishReason: string | null | undefined,
+): boolean {
+  if (!finishReason) {
+    return false;
+  }
+  return MALFORMED_TOOL_CALL_FINISH_REASONS.has(
+    finishReason.trim().toUpperCase(),
+  );
+}
+
+/**
+ * Status-less provider error for a response that ended on a malformed tool
+ * call. The absent status marks it as a stream-content failure, which the
+ * retry layer classifies by message.
+ */
+export function malformedToolCallError(
+  provider: string,
+  finishReason: string,
+): ProviderError {
+  return new ProviderError(
+    `${MALFORMED_TOOL_CALL_MESSAGE} (finish reason: ${finishReason})`,
+    provider,
+  );
+}

package/src/providers/openai/__tests__/chat-completions-malformed-tool-call.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import { ProviderError } from "../../../util/errors.js";
+import { MALFORMED_TOOL_CALL_MESSAGE } from "../../malformed-tool-call.js";
+import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
+
+type MockChunk = {
+  choices: Array<{
+    delta: { content?: string | null };
+    finish_reason?: string | null;
+    native_finish_reason?: string | null;
+  }>;
+  usage?: { prompt_tokens: number; completion_tokens: number };
+};
+
+const MESSAGES = [
+  {
+    role: "user" as const,
+    content: [{ type: "text" as const, text: "upload the cover image" }],
+  },
+];
+
+function stubProvider(chunks: MockChunk[]): OpenAIChatCompletionsProvider {
+  const provider = new OpenAIChatCompletionsProvider(
+    "test-key",
+    "google/gemini-3.8-flash",
+  );
+  (provider as unknown as { client: unknown }).client = {
+    baseURL: "https://openrouter.example.com/api/v1",
+    chat: {
+      completions: {
+        create: async () => ({
+          async *[Symbol.asyncIterator]() {
+            for (const c of chunks) {
+              yield c;
+            }
+          },
+        }),
+      },
+    },
+  };
+  return provider;
+}
+
+function finishChunks(
+  text: string,
+  finishReason: string,
+  nativeFinishReason: string,
+): MockChunk[] {
+  return [
+    { choices: [{ delta: { content: text } }] },
+    {
+      choices: [
+        {
+          delta: {},
+          finish_reason: finishReason,
+          native_finish_reason: nativeFinishReason,
+        },
+      ],
+      usage: { prompt_tokens: 1, completion_tokens: 2 },
+    },
+  ];
+}
+
+describe("OpenAIChatCompletionsProvider malformed tool-call finish", () => {
+  test("throws a status-less malformed tool-call error on native MALFORMED_FUNCTION_CALL", async () => {
+    const provider = stubProvider(
+      finishChunks(
+        ",featuredImage:{_type:image},patch:true}]})",
+        "stop",
+        "MALFORMED_FUNCTION_CALL",
+      ),
+    );
+
+    const error = await provider.sendMessage(MESSAGES).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 on native UNEXPECTED_TOOL_CALL", async () => {
+    const provider = stubProvider(
+      finishChunks("{}", "error", "UNEXPECTED_TOOL_CALL"),
+    );
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      MALFORMED_TOOL_CALL_MESSAGE,
+    );
+  });
+
+  test("returns the response normally on native STOP", async () => {
+    const provider = stubProvider(finishChunks("All done.", "stop", "STOP"));
+
+    const response = await provider.sendMessage(MESSAGES);
+
+    expect(response.stopReason).toBe("stop");
+    expect(response.content).toEqual([{ type: "text", text: "All done." }]);
+  });
+});

package/src/providers/openai/chat-completions-provider.ts

@@ -12,6 +12,10 @@ import { partialTagSuffix as sharedPartialTagSuffix } from "../../util/think-tag
 import { clampProviderString } from "../content-block-size.js";
 import { fileBlockToProviderText } from "../file-block-text.js";
 import { requestSupportsInlineAudio } from "../inline-audio-support.js";
+import {
+  isMalformedToolCallFinishReason,
+  malformedToolCallError,
+} from "../malformed-tool-call.js";
 import {
   base64Source,
   mediaSourceByteLength,
@@ -1150,6 +1154,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
       >();
       const toolProgress = createToolProgressEmitter(onEvent);
       let finishReason = "unknown";
+      let upstreamFinishReason: string | undefined;
       let responseModel = modelOverride ?? this.model;
       let promptTokens = 0;
       let completionTokens = 0;
@@ -1318,6 +1323,14 @@ export class OpenAIChatCompletionsProvider implements Provider {
             if (choice.finish_reason) {
               finishReason = choice.finish_reason;
             }
+            // OpenRouter normalizes upstream finish reasons and carries the
+            // raw value in `native_finish_reason`.
+            const nativeFinishReason = (
+              choice as { native_finish_reason?: string | null }
+            ).native_finish_reason;
+            if (nativeFinishReason) {
+              upstreamFinishReason = nativeFinishReason;
+            }
           }
 
           if (chunk.usage) {
@@ -1353,6 +1366,23 @@ export class OpenAIChatCompletionsProvider implements Provider {
         cleanupTimeout();
       }
 
+      const malformedFinishReason = [upstreamFinishReason, finishReason].find(
+        isMalformedToolCallFinishReason,
+      );
+      if (malformedFinishReason) {
+        log.warn(
+          {
+            provider: this.name,
+            model: responseModel,
+            finishReason,
+            upstreamFinishReason,
+            streamedTextLength: contentText.length,
+          },
+          "Response ended on a malformed tool call",
+        );
+        throw malformedToolCallError(this.name, malformedFinishReason);
+      }
+
       if (this.parseThinkTags && pendingContent) {
         flushPendingContent(true);
       }

package/src/providers/platform-proxy/constants.ts

@@ -56,6 +56,11 @@ export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
     managed: true,
     proxyPath: "/v1/runtime-proxy/vellum",
   },
+  typesafe: {
+    name: "typesafe",
+    managed: true,
+    proxyPath: "/v1/runtime-proxy/typesafe",
+  },
   poolside: {
     name: "poolside",
     managed: false,

package/src/providers/retry.ts

@@ -36,6 +36,7 @@ import {
   tryAcquireRecoveryProbe,
 } from "./fallback-breaker.js";
 import { resolveLogitBiasPreset } from "./inference/logit-bias.js";
+import { MALFORMED_TOOL_CALL_MESSAGE } from "./malformed-tool-call.js";
 import {
   isAdaptiveThinkingOnlyModel,
   isAdaptiveThinkingUnsupportedModel,
@@ -165,18 +166,22 @@ const RETRYABLE_STREAM_PATTERNS = [
   // Anthropic client salvages most of these into a `_raw`-wrapped tool call
   // before they surface (see anthropic/stream-content-shadow.ts); ones that
   // still reach here retry with a corrective note
-  // (`withUnparseableToolArgsHint`) because the malformation can be
-  // conditioned on the request context — a byte-identical resend can
-  // reproduce it indefinitely.
+  // (`correctiveRetryHint`) because the malformation can be conditioned on
+  // the request context: a byte-identical resend can reproduce it
+  // indefinitely.
   UNPARSEABLE_TOOL_ARGS_SDK_MESSAGE,
+  // The response ended on a tool call the model emitted but that did not
+  // parse (Gemini `MALFORMED_FUNCTION_CALL` / `UNEXPECTED_TOOL_CALL`). Its
+  // text is the broken call's tail, so it retries with a corrective note too.
+  MALFORMED_TOOL_CALL_MESSAGE,
 ];
 
 /**
- * One-shot note appended to the retried request after a tool-argument JSON
- * parse failure. Appended as a trailing text block on the latest user
- * message: the request tail sits after every prompt-cache anchor, so the
- * hint costs no cache reuse (a system-prompt edit would invalidate the whole
- * cached prefix).
+ * One-shot notes appended to a retried request after the model's output was
+ * malformed in a way a byte-identical resend can reproduce. Appended as a
+ * trailing text block on the latest user message: the request tail sits
+ * after every prompt-cache anchor, so the hint costs no cache reuse (a
+ * system-prompt edit would invalidate the whole cached prefix).
  */
 const UNPARSEABLE_TOOL_ARGS_RETRY_HINT =
   "[assistant runtime] The previous attempt at this response was discarded: " +
@@ -185,23 +190,51 @@ const UNPARSEABLE_TOOL_ARGS_RETRY_HINT =
   "every string value double-quoted, including values that begin with '[' " +
   "or '{'.";
 
-function isUnparseableToolArgsError(error: unknown): boolean {
+const MALFORMED_TOOL_CALL_RETRY_HINT =
+  "[assistant runtime] The previous attempt at this response was discarded: " +
+  "it ended on a tool call that did not parse. Respond again. To call a " +
+  "tool, emit one complete, well-formed tool call through the tool-calling " +
+  "interface, never as text.";
+
+const CORRECTIVE_RETRY_HINTS: ReadonlyArray<{
+  pattern: string;
+  hint: string;
+}> = [
+  {
+    pattern: UNPARSEABLE_TOOL_ARGS_SDK_MESSAGE,
+    hint: UNPARSEABLE_TOOL_ARGS_RETRY_HINT,
+  },
+  {
+    pattern: MALFORMED_TOOL_CALL_MESSAGE,
+    hint: MALFORMED_TOOL_CALL_RETRY_HINT,
+  },
+];
+
+/**
+ * The corrective note a retry of `error` carries, or `undefined` when the
+ * error is not a request-conditioned output malformation. Only status-less
+ * provider errors qualify: those come from content the upstream streamed
+ * after accepting the request.
+ */
+function correctiveRetryHint(error: unknown): string | undefined {
   if (!(error instanceof ProviderError)) {
-    return false;
+    return undefined;
   }
   if (error.statusCode !== undefined) {
-    return false;
+    return undefined;
   }
-  return error.message.includes(UNPARSEABLE_TOOL_ARGS_SDK_MESSAGE);
+  return CORRECTIVE_RETRY_HINTS.find(({ pattern }) =>
+    error.message.includes(pattern),
+  )?.hint;
 }
 
 /**
- * Copy of `messages` with the corrective note appended to the latest user
- * message. When the request doesn't end on a user message (assistant
- * prefill), returns `messages` unchanged — appending anything there would
- * change prefill semantics.
+ * Copy of `messages` with `hint` appended to the latest user message. When
+ * the request doesn't end on a user message (assistant prefill), returns
+ * `messages` unchanged, since appending anything there would change prefill
+ * semantics.
  */
-function withUnparseableToolArgsHint(messages: Message[]): Message[] {
+function withRetryHint(messages: Message[], hint: string): Message[] {
   const last = messages[messages.length - 1];
   if (last === undefined || last.role !== "user") {
     return messages;
@@ -210,10 +243,7 @@ function withUnparseableToolArgsHint(messages: Message[]): Message[] {
     ...messages.slice(0, -1),
     {
       ...last,
-      content: [
-        ...last.content,
-        { type: "text", text: UNPARSEABLE_TOOL_ARGS_RETRY_HINT },
-      ],
+      content: [...last.content, { type: "text", text: hint }],
     },
   ];
 }
@@ -1393,12 +1423,10 @@ export class RetryProvider implements Provider {
             // outage the route had nothing to do with. Skipped when the hint
             // has nowhere to go (an assistant prefill tail), since an
             // unchanged resend would only cost another round trip.
-            if (
-              !correctiveResendAttempted &&
-              isUnparseableToolArgsError(error)
-            ) {
+            const hint = correctiveRetryHint(error);
+            if (!correctiveResendAttempted && hint !== undefined) {
               correctiveResendAttempted = true;
-              const repaired = withUnparseableToolArgsHint(messages);
+              const repaired = withRetryHint(messages, hint);
               if (repaired !== messages) {
                 messagesForAttempt = repaired;
                 continue;
@@ -1522,12 +1550,13 @@ export class RetryProvider implements Provider {
         }
 
         if (retryAttempt < DEFAULT_MAX_RETRIES && isRetryableError(error)) {
-          // Malformed tool-argument JSON is conditioned on the request, so
-          // resend with the corrective note. Built from the original
-          // `messages` each time — the note appears exactly once no matter
-          // how many attempts fail this way.
-          if (isUnparseableToolArgsError(error)) {
-            messagesForAttempt = withUnparseableToolArgsHint(messages);
+          // A malformed tool call is conditioned on the request, so resend
+          // with the corrective note. Built from the original `messages`
+          // each time, so the note appears exactly once no matter how many
+          // attempts fail this way.
+          const hint = correctiveRetryHint(error);
+          if (hint !== undefined) {
+            messagesForAttempt = withRetryHint(messages, hint);
           }
           // Prefer server-provided Retry-After; fall back to exponential backoff.
           const { delay, retryAfterHeader } = retryPlan(error, retryAttempt);
@@ -1587,9 +1616,11 @@ export class RetryProvider implements Provider {
         ) {
           fallbackAttempted = true;
           // What the failure indicts: the whole upstream for an outage, only
-          // this model for a retirement or rename.
+          // this model for a retirement or rename. A malformed output that
+          // takes a corrective hint indicts neither: it is conditioned on this
+          // request, so the backup may serve it without diverting the route.
           const failedRoute =
-            breakerRoute === null
+            breakerRoute === null || correctiveRetryHint(error) !== undefined
               ? null
               : failureBreakerRoute(breakerRoute, error);
           let failureObservation: BreakerObservation | undefined;
@@ -1730,8 +1761,9 @@ export class RetryProvider implements Provider {
         }
         // Built from the original `messages` each time, so the corrective note
         // appears exactly once however many attempts fail this way.
-        if (isUnparseableToolArgsError(error)) {
-          messagesForAttempt = withUnparseableToolArgsHint(messages);
+        const hint = correctiveRetryHint(error);
+        if (hint !== undefined) {
+          messagesForAttempt = withRetryHint(messages, hint);
         }
         const { delay, retryAfterHeader } = retryPlan(error, attempt);
         log.warn(

package/src/providers/vellum-model-routing.test.ts

@@ -73,6 +73,7 @@ describe("vellum-model-routing", () => {
       "gemini",
       "openai",
       "together",
+      "typesafe",
       "vellum",
     ]);
   });