@vellumai/assistant 0.12.0 → 0.12.1-staging.1

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -39,6 +39,7 @@ import type {
   SendMessageOptions,
 } from "@vellumai/plugin-api";
 
+import { OpenRouterProvider } from "../../../../../providers/openrouter/client.js";
 import { ProviderError } from "../../../../../util/errors.js";
 import { sectionHeadLine } from "../sections.js";
 import type { MemoryRoutingTurn, Section } from "../types.js";
@@ -843,3 +844,91 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// selectPool: cataloged thinking and forced-tool compatibility.
+// ---------------------------------------------------------------------------
+
+describe("selectPool: cataloged thinking and forced-tool compatibility", () => {
+  test("OpenRouter Kimi K2.6 omits the forced choice and yields a structured selection", async () => {
+    // A real OpenAI chat-completions provider stands in for the cataloged
+    // OpenRouter Kimi profile. The request succeeds without a reactive retry
+    // because the forced select_pages choice is omitted before dispatch.
+    const wireRequests: unknown[] = [];
+    const kimi = new OpenRouterProvider(
+      "test-key",
+      "moonshotai/kimi-k2.6-20260420",
+    );
+    (kimi as unknown as { client: unknown }).client = {
+      chat: {
+        completions: {
+          create: async (params: unknown) => {
+            wireRequests.push(JSON.parse(JSON.stringify(params)));
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield {
+                  choices: [
+                    {
+                      delta: {
+                        tool_calls: [
+                          {
+                            index: 0,
+                            id: "call-1",
+                            function: {
+                              name: "select_pages",
+                              arguments: '{"ids":[3]}',
+                            },
+                          },
+                        ],
+                      },
+                      finish_reason: "tool_calls",
+                    },
+                  ],
+                  usage: { prompt_tokens: 10, completion_tokens: 2 },
+                };
+              },
+            };
+          },
+        },
+      },
+    };
+
+    // The profile layer injects the thinking effort onto the call config in
+    // production; emulate that here so the forced tool_choice rides alongside
+    // reasoning on the wire.
+    providerStub = {
+      name: "kimi-openai-compat",
+      sendMessage: (messages: Message[], options?: SendMessageOptions) =>
+        kimi.sendMessage(messages, {
+          ...options,
+          config: {
+            ...options?.config,
+            effort: "high",
+            thinking: { enabled: true },
+          },
+        }),
+    };
+
+    const selection = await selectPool(makePool(), makeTurn("rollout?"));
+
+    // The preflight path avoids an incompatible first request, and the
+    // pool-level re-prompt loop never engages.
+    expect(wireRequests).toHaveLength(1);
+    const first = wireRequests[0] as {
+      tool_choice?: unknown;
+      reasoning?: { effort?: string; summary?: string };
+    };
+    expect(first.tool_choice).toBeUndefined();
+    expect(first.reasoning).toMatchObject({
+      effort: "high",
+      summary: "detailed",
+    });
+    expect(
+      warnPayloads().filter((p) => p.reason === "provider_error"),
+    ).toEqual([]);
+
+    // Structured selection survived: ids [3] is the topic-x finder line.
+    expect(selection.keptAll).toBe(false);
+    expect(selection.pages).toEqual([{ slug: "topic-x", sections: [] }]);
+  });
+});

package/src/plugins/defaults/memory/worker.ts

@@ -16,6 +16,10 @@ import { getConfig } from "../../../config/loader.js";
 import { isMemoryEnabled } from "../../../config/memory-v3-gate.js";
 import { rehydratePlatformCredentials } from "../../../config/platform-rehydration.js";
 import { startConversationEvictor } from "../../../daemon/conversation-evictor.js";
+import {
+  startWorkspaceSkillMdMtimePoll,
+  stopWorkspaceSkillMdMtimePoll,
+} from "../../../daemon/skill-memory-refresh.js";
 import { resetDb } from "../../../persistence/db-connection.js";
 import {
   EMBEDDING_SHUTDOWN_BUDGET_MS,
@@ -108,6 +112,7 @@ async function main(): Promise<void> {
     shuttingDown = true;
     log.info({ signal }, "Memory worker process shutting down");
     worker?.stop();
+    stopWorkspaceSkillMdMtimePoll();
     if (keepAlive != null) {
       clearInterval(keepAlive);
     }
@@ -161,6 +166,7 @@ async function main(): Promise<void> {
   }
 
   worker = startMemoryJobsWorkerLoop();
+  startWorkspaceSkillMdMtimePoll();
 
   // Keep-alive: the worker's setTimeout timers are unref'd, so without
   // this interval the process would exit immediately.

package/src/plugins/mcp-servers.ts

@@ -14,7 +14,7 @@
  * This module reads those files and projects each entry onto the
  * assistant's own `McpServerConfig` shape, so a plugin-declared server can
  * flow through the same surfaces as one configured in the workspace
- * `config.json`.
+ * `mcp.json`.
  *
  * Failure isolation follows the spec: an invalid top-level `mcp.json`
  * disables MCP for that plugin only, and an invalid individual server
@@ -39,17 +39,17 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { z } from "zod";
-
 import {
   type AllPluginInfo,
   listAllPlugins,
   type ListInstalledPluginsOptions,
 } from "../cli/lib/list-installed-plugins.js";
-import type {
-  McpTransport,
-  ResolvedMcpServerConfig,
-} from "../config/schemas/mcp.js";
+import type { ResolvedMcpServerConfig } from "../config/schemas/mcp.js";
+import {
+  projectSpecServerToTransport,
+  SpecMcpDocumentSchema,
+  SpecMcpServerSchema,
+} from "../mcp/spec-schema.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("plugin-mcp-servers");
@@ -77,45 +77,6 @@ export const PLUGIN_MCP_MANIFEST = "mcp.json";
  * origin risk.
  */
 
-// ---------------------------------------------------------------------------
-// Wire schema (Agent Plugins 1.0.0)
-// ---------------------------------------------------------------------------
-
-const PluginStdioServerSchema = z.object({
-  type: z.literal("stdio"),
-  command: z.string().min(1),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  cwd: z.string().optional(),
-});
-
-/**
- * Remote MCP entry. Agent Plugins 1.0.0 requires `type` and names no
- * default. MCP's current remote transport is Streamable HTTP, so this
- * host fills omitted `type` and the Claude-style `http` alias as
- * `streamable-http`. `sse` stays explicit.
- */
-const PluginHttpServerSchema = z.object({
-  type: z
-    .union([
-      z.literal("streamable-http"),
-      z.literal("sse"),
-      z.literal("http").transform(() => "streamable-http" as const),
-    ])
-    .default("streamable-http"),
-  url: z.string().min(1),
-  headers: z.record(z.string(), z.string()).optional(),
-});
-
-const PluginMcpServerSchema = z.union([
-  PluginStdioServerSchema,
-  PluginHttpServerSchema,
-]);
-
-const PluginMcpManifestSchema = z.object({
-  mcpServers: z.record(z.string(), z.unknown()),
-});
-
 // ---------------------------------------------------------------------------
 // Public shape
 // ---------------------------------------------------------------------------
@@ -251,7 +212,7 @@ export function readPluginMcpServers(
         continue;
       }
 
-      const entry = PluginMcpServerSchema.safeParse(raw);
+      const entry = SpecMcpServerSchema.safeParse(raw);
       if (!entry.success) {
         issues.push({
           pluginName: plugin.name,
@@ -325,7 +286,7 @@ function parseManifest(
     };
   }
 
-  const manifest = PluginMcpManifestSchema.safeParse(json);
+  const manifest = SpecMcpDocumentSchema.safeParse(json);
   if (!manifest.success) {
     return {
       error: `${PLUGIN_MCP_MANIFEST} is missing a valid "mcpServers" object`,
@@ -334,33 +295,12 @@ function parseManifest(
   return { mcpServers: manifest.data.mcpServers };
 }
 
-/**
- * Project one spec-shaped entry onto the assistant's transport union. The
- * two vocabularies already agree on type names and required fields, so this
- * is a field copy plus path interpolation for the stdio case.
- */
 function projectTransport(
-  entry: z.infer<typeof PluginMcpServerSchema>,
+  entry: Parameters<typeof projectSpecServerToTransport>[0],
   pluginRoot: string,
-): McpTransport {
-  if (entry.type === "stdio") {
-    const pluginData = join(pluginRoot, "data");
-    const expand = (v: string): string =>
-      interpolatePluginPaths(v, pluginRoot, pluginData);
-    return {
-      type: "stdio",
-      command: entry.command,
-      args: (entry.args ?? []).map(expand),
-      ...(entry.env && {
-        env: Object.fromEntries(
-          Object.entries(entry.env).map(([k, v]) => [k, expand(v)]),
-        ),
-      }),
-    };
-  }
-  return {
-    type: entry.type,
-    url: entry.url,
-    ...(entry.headers && { headers: entry.headers }),
-  };
+) {
+  const pluginData = join(pluginRoot, "data");
+  return projectSpecServerToTransport(entry, (value) =>
+    interpolatePluginPaths(value, pluginRoot, pluginData),
+  );
 }

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -50,6 +50,8 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-nano")).toBe(false);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.5-pro")).toBe(false);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.3-codex")).toBe(false);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(false);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-mini")).toBe(false);
   });
 
   test("oauth_subscription connection is compatible with a Codex model", () => {
@@ -59,8 +61,6 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-terra")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-luna")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.5")).toBe(true);
-    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(true);
-    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-mini")).toBe(true);
   });
 
   test("undefined model applies no gating (compatible)", () => {
@@ -165,7 +165,7 @@ describe("auto-resolution skips oauth_subscription connections for non-Codex mod
 
   test("Codex model can select the oauth_subscription connection", async () => {
     registerConnections([OPENAI_CODEX, OPENAI_KEY]);
-    setOpenAiProfile("gpt-5.4");
+    setOpenAiProfile("gpt-5.5");
 
     const result = await getConfiguredProvider("mainAgent", {
       overrideProfile: "openai-any",

package/src/providers/gemini/client.ts

@@ -15,6 +15,7 @@ import {
   keepFileAsWorkspaceRef,
 } from "../content-block-size.js";
 import { fileBlockToProviderText } from "../file-block-text.js";
+import { unsignedThoughtSignatureFallback } from "../gemini-thought-signature.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
@@ -45,13 +46,6 @@ import {
 const GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS =
   /token.?count.*exceeds|exceeds.*maximum.*tokens|prompt.?is.?too.?long|too.?many.?(?:input.?)?tokens|input.?too.?long|context.?length.?exceeded/i;
 
-const GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE =
-  "context_engineering_is_the_way_to_go";
-
-function isGemini3Model(model: string): boolean {
-  return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
-}
-
 const THINKING_LEVEL_BY_NAME: Record<ThinkingLevelName, ThinkingLevel> = {
   minimal: ThinkingLevel.MINIMAL,
   low: ThinkingLevel.LOW,
@@ -435,7 +429,8 @@ export class GeminiProvider implements Provider {
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
-      Record<string, string> | undefined;
+      | Record<string, string>
+      | undefined;
     const activeModel = modelOverride ?? this.model;
     const thinkingConfig = geminiModelSupportsThinking(activeModel)
       ? buildThinkingConfig(
@@ -902,28 +897,19 @@ export class GeminiProvider implements Provider {
     parts: genai.Part[],
     model: string,
   ): void {
-    if (!isGemini3Model(model)) {
-      return;
-    }
-
     const functionCallParts = parts.filter((part) => part.functionCall);
-    if (functionCallParts.length === 0) {
-      return;
-    }
-
-    const hasRealThoughtSignature = functionCallParts.some((part) =>
-      Boolean(part.thoughtSignature),
+    const fallback = unsignedThoughtSignatureFallback(
+      functionCallParts.map((part) => part.thoughtSignature),
+      { model },
     );
-    if (hasRealThoughtSignature) {
+    if (!fallback) {
       return;
     }
-
-    const firstFunctionCallPart = functionCallParts[0];
+    const firstFunctionCallPart = functionCallParts[fallback.index];
     if (!firstFunctionCallPart) {
       return;
     }
-    firstFunctionCallPart.thoughtSignature =
-      GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE;
+    firstFunctionCallPart.thoughtSignature = fallback.signature;
   }
 
   private supportsGeminiInlineFile(mimeType: string): boolean {

package/src/providers/gemini-thought-signature.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
+  isGemini3Model,
+  unsignedThoughtSignatureFallback,
+} from "./gemini-thought-signature.js";
+
+describe("isGemini3Model", () => {
+  test("matches native Gemini 3 ids", () => {
+    expect(isGemini3Model("gemini-3.7-flash")).toBe(true);
+    expect(isGemini3Model("models/gemini-3.1-pro-preview")).toBe(true);
+  });
+
+  test("matches OpenAI-compatible catalog prefixes", () => {
+    expect(isGemini3Model("google/gemini-3.7-flash")).toBe(true);
+  });
+
+  test("does not match Gemini 2.5 or unrelated ids", () => {
+    expect(isGemini3Model("gemini-2.5-flash")).toBe(false);
+    expect(isGemini3Model("gpt-5.2")).toBe(false);
+  });
+});
+
+describe("unsignedThoughtSignatureFallback", () => {
+  test("stamps the dummy on the first unsigned Gemini 3 call", () => {
+    expect(
+      unsignedThoughtSignatureFallback([undefined, undefined], {
+        model: "gemini-3.7-flash",
+      }),
+    ).toEqual({
+      index: 0,
+      signature: GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
+    });
+  });
+
+  test("does not stamp when any call already has a signature", () => {
+    expect(
+      unsignedThoughtSignatureFallback(["signed-thought-1", undefined], {
+        model: "gemini-3.7-flash",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("does not stamp for non-Gemini-3 models when a model id is provided", () => {
+    expect(
+      unsignedThoughtSignatureFallback([undefined], { model: "gpt-5.2" }),
+    ).toBeUndefined();
+  });
+
+  test("stamps unsigned calls when no model gate is supplied", () => {
+    expect(unsignedThoughtSignatureFallback([undefined])).toEqual({
+      index: 0,
+      signature: GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
+    });
+  });
+
+  test("does not stamp an empty function-call list", () => {
+    expect(
+      unsignedThoughtSignatureFallback([], { model: "gemini-3.7-flash" }),
+    ).toBeUndefined();
+  });
+});

package/src/providers/gemini-thought-signature.ts

@@ -0,0 +1,44 @@
+/**
+ * Gemini 3.x requires a thought signature on the first function-call part of
+ * each step. When history has no captured signature (unsigned tool_use from an
+ * earlier provider, or a client-injected call), Google documents these dummy
+ * values to skip validation.
+ */
+export const GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE =
+  "context_engineering_is_the_way_to_go";
+
+/**
+ * True for Gemini 3.x model ids, including the native `models/` prefix and
+ * OpenAI-compatible catalog prefixes such as `google/gemini-3.7-flash`.
+ */
+export function isGemini3Model(model: string): boolean {
+  if (model.startsWith("gemini-3") || model.startsWith("models/gemini-3")) {
+    return true;
+  }
+  return /\/gemini-3/.test(model);
+}
+
+/**
+ * Decide whether unsigned function-call history should receive Google's
+ * documented dummy thought signature. Returns the first call's index when
+ * every call is unsigned. Pass `model` to restrict this to Gemini 3.x;
+ * omit it for retry backfills that already observed a thought-signature 4xx.
+ */
+export function unsignedThoughtSignatureFallback(
+  signatures: ReadonlyArray<string | undefined | null>,
+  options?: { model?: string },
+): { index: 0; signature: string } | undefined {
+  if (options?.model !== undefined && !isGemini3Model(options.model)) {
+    return undefined;
+  }
+  if (signatures.length === 0) {
+    return undefined;
+  }
+  if (signatures.some((signature) => Boolean(signature))) {
+    return undefined;
+  }
+  return {
+    index: 0,
+    signature: GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
+  };
+}

package/src/providers/model-catalog.ts

@@ -76,6 +76,13 @@ export interface CatalogModel {
   supportsAudioInput?: boolean;
   supportsToolUse?: boolean;
   supportsEffort?: boolean;
+  /**
+   * Whether this provider/model serving surface accepts a forced OpenAI
+   * chat-completions tool choice while thinking is enabled. Omit unless the
+   * combination is known incompatible. Daemon-only: not projected into the
+   * client catalog (see scripts/sync-llm-catalog.ts).
+   */
+  supportsForcedToolChoiceWithThinking?: boolean;
   pricing?: CatalogModelPricing;
   /**
    * Upper bound for `reasoning_effort` accepted by this model's upstream API.
@@ -856,6 +863,9 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.03,
         },
       },
+      // Limited to grandfathered accounts: other API keys get HTTP 404 "no
+      // longer available to new users", so this model is user-selectable
+      // only and no intent column may resolve to it.
       {
         id: "gemini-2.5-flash-lite",
         displayName: "Gemini 2.5 Flash Lite",
@@ -1816,6 +1826,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
+        supportsForcedToolChoiceWithThinking: false,
         pricing: {
           inputPer1mTokens: 0.95,
           outputPer1mTokens: 4.0,
@@ -2628,6 +2639,29 @@ export function modelSupportedEfforts(
   );
 }
 
+/**
+ * Whether a provider/model serving surface accepts a forced OpenAI
+ * chat-completions tool choice while thinking is enabled. Unknown providers
+ * and models fail open so custom routes retain their existing request shape
+ * and can rely on the bounded provider-error retry if needed.
+ */
+export function supportsForcedToolChoiceWithThinking(
+  providerId: string,
+  modelId: string,
+): boolean {
+  const provider = PROVIDER_CATALOG.find((entry) => entry.id === providerId);
+  if (!provider) {
+    return true;
+  }
+  const stripDateSuffix = (id: string): string => id.replace(/-\d{8}$/, "");
+  const normalizedModelId = stripDateSuffix(modelId);
+  return !provider.models.some(
+    (model) =>
+      model.supportsForcedToolChoiceWithThinking === false &&
+      (model.id === modelId || stripDateSuffix(model.id) === normalizedModelId),
+  );
+}
+
 /**
  * Return the catalog provider that owns a model ID, if known. When multiple
  * providers list the same ID (e.g. OpenRouter and the Vercel AI Gateway share

package/src/providers/model-intents.ts

@@ -11,10 +11,15 @@ const PROVIDER_DEFAULT_MODELS: Record<string, string> = Object.fromEntries(
 );
 
 // `cost-optimized` is the cheapest model a provider serves, `latency-optimized`
-// the fastest to first token. On anthropic, ollama, fireworks and openai the
-// same model is both, so those columns repeat by construction rather than by
-// oversight (openai's balanced repeats it too: the default-profile templates
-// split those tiers by reasoning effort, not model).
+// the fastest to first token. On anthropic, ollama, fireworks, openai and
+// gemini the same model is both, so those columns repeat by construction
+// rather than by oversight (openai's balanced repeats it too: the
+// default-profile templates split those tiers by reasoning effort, not model).
+//
+// "Serves" means serves to every API key: Google's `gemini-2.5-flash-lite`
+// undercuts every 3.x Flash-Lite but is limited to grandfathered accounts
+// (other keys get HTTP 404 "no longer available to new users"), so the
+// gemini column skips it.
 const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
     balanced: "claude-sonnet-4-6",
@@ -32,7 +37,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
-    "cost-optimized": "gemini-2.5-flash-lite",
+    "cost-optimized": "gemini-3.1-flash-lite",
     "latency-optimized": "gemini-3.1-flash-lite",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",