@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

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/inference/auth.ts

@@ -15,9 +15,8 @@ import { VELLUM_MANAGED_PROVIDER } from "../vellum-model-routing.js";
  *   - platform: route via Vellum managed proxy; no client-side credential.
  *   - none: no auth (e.g. Ollama running locally).
  *   - oauth_subscription: OAuth-based subscription auth (e.g. ChatGPT Codex).
- *
- * Schema-accepted variants (runtime rejects with a clear "not yet shipped" error):
- *   - service_account: service-account credentials (Vertex AI, Bedrock).
+ *   - service_account: Google service-account JSON key (Vertex AI); signs a
+ *     JWT and exchanges it for a bearer token at the embedded token_uri.
  */
 export const AuthSchema = z
   .discriminatedUnion("type", [

package/src/providers/inference/connection-availability.ts

@@ -178,14 +178,33 @@ export async function computeConnectionAvailability(
   }
 
   switch (connection.auth.type) {
-    // Schema-accepted but not dispatchable: `resolveAuth` returns
-    // not_implemented for service_account, so a stored credential still
-    // cannot serve inference.
-    case "service_account":
-      return {
-        status: "unsupported_auth",
-        message: `Connection "${resolvedConnectionName}" uses service-account auth, which inference does not support yet. Pick a connection with a different auth type.`,
-      };
+    case "service_account": {
+      const result = await getSecureKeyResultAsync(connection.auth.credential);
+      if (result.unreachable) {
+        return {
+          status: "unknown",
+          message: `The credential store is unreachable, so the credential for connection "${resolvedConnectionName}" could not be verified. Try again shortly.`,
+        };
+      }
+      if (result.value == null) {
+        return {
+          status: "missing_credential",
+          message: `Connection "${resolvedConnectionName}" has no service-account credential stored. Add one ${SETTINGS_HINT}.`,
+        };
+      }
+      // Validate the JSON payload before reporting ok: a stored value that is
+      // not a well-formed service-account object will be rejected by dispatch,
+      // so surface the problem here rather than letting a turn fail silently.
+      const { parseServiceAccountKey } =
+        await import("./service-account-token.js");
+      if (!parseServiceAccountKey(result.value)) {
+        return {
+          status: "missing_credential",
+          message: `Connection "${resolvedConnectionName}" has an invalid service-account credential (expected JSON with client_email, private_key, and token_uri). Update it ${SETTINGS_HINT}.`,
+        };
+      }
+      return { status: "ok" };
+    }
     case "api_key":
     case "oauth_subscription": {
       const result = await getSecureKeyResultAsync(connection.auth.credential);

package/src/providers/inference/resolve-auth.ts

@@ -6,7 +6,7 @@
  *   - platform             → build managed proxy URL and fetch the platform API key
  *   - none                 → pass through with no auth headers
  *   - oauth_subscription   → fetch OAuth token from vault (with auto-refresh) → inject as bearer header
- *   - service_account      → reject (v2 not yet shipped)
+ *   - service_account      → sign JWT and exchange for bearer token at token_uri (Google Vertex AI)
  */
 
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
@@ -119,10 +119,28 @@ export async function resolveAuth(
       };
     }
 
-    case "service_account":
+    case "service_account": {
+      const { getValidServiceAccountToken } =
+        await import("./service-account-token.js");
+      const result = await getValidServiceAccountToken(auth.credential);
+      if (!result.ok) {
+        if (result.reason === "exchange_failed") {
+          return { ok: false, error: { code: "platform_unavailable" } };
+        }
+        // not_found or invalid_config: the credential needs to be supplied or fixed.
+        return {
+          ok: false,
+          error: { code: "credential_not_found", credential: auth.credential },
+        };
+      }
       return {
-        ok: false,
-        error: { code: "not_implemented", authType: auth.type },
+        ok: true,
+        resolved: {
+          kind: "header",
+          headers: { Authorization: `Bearer ${result.token}` },
+          ...(safeBaseUrl ? { baseUrl: safeBaseUrl } : {}),
+        },
       };
+    }
   }
 }