@vellumai/assistant 0.12.3 → 0.12.4-staging.2

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

@@ -71,7 +71,8 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
   }
 
   /**
-   * Embed `inputs` in order. Runs of text inputs go through
+   * Embed `inputs` in order. Managed requests use single `embedContent`
+   * calls because Vertex does not expose the batch route. Direct text runs use
    * `batchEmbedContents`, {@link GEMINI_EMBED_BATCH_SIZE} texts per round
    * trip, so a corpus re-embed costs one request per hundred sections rather
    * than one per section; a lone text and every multimodal input take the
@@ -99,6 +100,7 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
       // Gather the run of text inputs starting here, up to one batch.
       let end = i;
       while (
+        !this.managed &&
         !this.batchRouteUnavailable &&
         end < normalized.length &&
         end - i < GEMINI_EMBED_BATCH_SIZE &&

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/plugin-api/model-profiles.ts

@@ -1,4 +1,4 @@
-import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
 import { getConfig } from "../config/loader.js";
 import { isDispatchableProfile } from "../config/profile-dispatchability.js";
 import { orderProfileKeys } from "../config/profile-order.js";
@@ -7,7 +7,9 @@ import type { ModelProfileInfo } from "./types.js";
 /**
  * List the workspace inference profiles a plugin can route to, in the order a
  * user-facing model picker presents them (`llm.profileOrder` first, then the
- * rest alphabetically). Managed backup routes are internal and omitted.
+ * rest alphabetically). Managed backup routes and the managed Jev profile
+ * are omitted with the rest of the conversation view: a plugin routes
+ * conversation turns, and a decision model cannot answer them.
  * Metadata-only entries without a provider, model, or mix are not routing
  * targets, so plugins never see them. Disabled profiles are included and flagged via
  * {@link ModelProfileInfo.isDisabled}; weighted "mix" profiles are included and
@@ -20,7 +22,7 @@ import type { ModelProfileInfo } from "./types.js";
 export function getModelProfiles(): ModelProfileInfo[] {
   const { llm } = getConfig();
   const { activeProfile } = llm;
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     llm.profiles,
     llm.defaultProvider ?? null,
   );

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/model-catalog.ts

@@ -1,7 +1,9 @@
 import { PLATFORM_PROVIDER_META } from "./platform-proxy/constants.js";
 
 export type LongContextMode =
-  "native-model" | "provider-request-option" | "unsupported";
+  | "native-model"
+  | "provider-request-option"
+  | "unsupported";
 
 export interface CatalogModelPricingTier {
   /**
@@ -2602,6 +2604,16 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] =
     supportsPlatformAuth: PLATFORM_PROVIDER_META[entry.id]?.managed === true,
   }));
 
+/**
+ * Providers that are routing identities rather than catalog owners. Mirrors
+ * `ROUTING_IDENTITY_PROVIDERS` in `inference/auth.ts`, which cannot be
+ * imported here without a cycle.
+ */
+const ROUTING_IDENTITY_PROVIDER_IDS: ReadonlySet<string> = new Set([
+  "vellum",
+  "chatgpt",
+]);
+
 /**
  * Whether a catalog model produces free-form chat text. Unlisted providers
  * and model ids default to true so custom endpoints and unknown snapshots
@@ -2614,9 +2626,16 @@ export function catalogModelSupportsText(
   if (typeof provider !== "string" || typeof modelId !== "string") {
     return true;
   }
-  const model = PROVIDER_CATALOG.find((p) => p.id === provider)?.models.find(
-    (m) => m.id === modelId,
-  );
+  // A routing identity ("vellum", "chatgpt") owns no catalog models of the
+  // upstream it dispatches to, so judge the model by its catalog owner: a
+  // managed Jev profile is `vellum` + `jev-latest`, and `jev-latest` opts out
+  // of text under `typesafe`.
+  const catalogProvider = ROUTING_IDENTITY_PROVIDER_IDS.has(provider)
+    ? (getCatalogProviderForModel(modelId) ?? provider)
+    : provider;
+  const model = PROVIDER_CATALOG.find(
+    (p) => p.id === catalogProvider,
+  )?.models.find((m) => m.id === modelId);
   return model?.supportsText !== false;
 }
 

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,