@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

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

@@ -39,7 +39,6 @@ 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";
@@ -844,91 +843,3 @@ 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,10 +16,6 @@ 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,
@@ -112,7 +108,6 @@ async function main(): Promise<void> {
     shuttingDown = true;
     log.info({ signal }, "Memory worker process shutting down");
     worker?.stop();
-    stopWorkspaceSkillMdMtimePoll();
     if (keepAlive != null) {
       clearInterval(keepAlive);
     }
@@ -166,7 +161,6 @@ 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
- * `mcp.json`.
+ * `config.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 { ResolvedMcpServerConfig } from "../config/schemas/mcp.js";
-import {
-  projectSpecServerToTransport,
-  SpecMcpDocumentSchema,
-  SpecMcpServerSchema,
-} from "../mcp/spec-schema.js";
+import type {
+  McpTransport,
+  ResolvedMcpServerConfig,
+} from "../config/schemas/mcp.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("plugin-mcp-servers");
@@ -77,6 +77,45 @@ 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
 // ---------------------------------------------------------------------------
@@ -212,7 +251,7 @@ export function readPluginMcpServers(
         continue;
       }
 
-      const entry = SpecMcpServerSchema.safeParse(raw);
+      const entry = PluginMcpServerSchema.safeParse(raw);
       if (!entry.success) {
         issues.push({
           pluginName: plugin.name,
@@ -286,7 +325,7 @@ function parseManifest(
     };
   }
 
-  const manifest = SpecMcpDocumentSchema.safeParse(json);
+  const manifest = PluginMcpManifestSchema.safeParse(json);
   if (!manifest.success) {
     return {
       error: `${PLUGIN_MCP_MANIFEST} is missing a valid "mcpServers" object`,
@@ -295,12 +334,33 @@ 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: Parameters<typeof projectSpecServerToTransport>[0],
+  entry: z.infer<typeof PluginMcpServerSchema>,
   pluginRoot: string,
-) {
-  const pluginData = join(pluginRoot, "data");
-  return projectSpecServerToTransport(entry, (value) =>
-    interpolatePluginPaths(value, pluginRoot, pluginData),
-  );
+): 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 }),
+  };
 }

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

@@ -50,8 +50,6 @@ 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", () => {
@@ -61,6 +59,8 @@ 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.5");
+    setOpenAiProfile("gpt-5.4");
 
     const result = await getConfiguredProvider("mainAgent", {
       overrideProfile: "openai-any",

package/src/providers/gemini/client.ts

@@ -15,7 +15,6 @@ 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";
@@ -46,6 +45,13 @@ 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,
@@ -429,8 +435,7 @@ 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(
@@ -897,19 +902,28 @@ export class GeminiProvider implements Provider {
     parts: genai.Part[],
     model: string,
   ): void {
+    if (!isGemini3Model(model)) {
+      return;
+    }
+
     const functionCallParts = parts.filter((part) => part.functionCall);
-    const fallback = unsignedThoughtSignatureFallback(
-      functionCallParts.map((part) => part.thoughtSignature),
-      { model },
+    if (functionCallParts.length === 0) {
+      return;
+    }
+
+    const hasRealThoughtSignature = functionCallParts.some((part) =>
+      Boolean(part.thoughtSignature),
     );
-    if (!fallback) {
+    if (hasRealThoughtSignature) {
       return;
     }
-    const firstFunctionCallPart = functionCallParts[fallback.index];
+
+    const firstFunctionCallPart = functionCallParts[0];
     if (!firstFunctionCallPart) {
       return;
     }
-    firstFunctionCallPart.thoughtSignature = fallback.signature;
+    firstFunctionCallPart.thoughtSignature =
+      GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE;
   }
 
   private supportsGeminiInlineFile(mimeType: string): boolean {

package/src/providers/inference/auth.ts

@@ -15,8 +15,9 @@ 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).
- *   - service_account: Google service-account JSON key (Vertex AI); signs a
- *     JWT and exchanges it for a bearer token at the embedded token_uri.
+ *
+ * Schema-accepted variants (runtime rejects with a clear "not yet shipped" error):
+ *   - service_account: service-account credentials (Vertex AI, Bedrock).
  */
 export const AuthSchema = z
   .discriminatedUnion("type", [

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

@@ -178,33 +178,14 @@ export async function computeConnectionAvailability(
   }
 
   switch (connection.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" };
-    }
+    // 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 "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      → sign JWT and exchange for bearer token at token_uri (Google Vertex AI)
+ *   - service_account      → reject (v2 not yet shipped)
  */
 
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
@@ -119,28 +119,10 @@ export async function resolveAuth(
       };
     }
 
-    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 },
-        };
-      }
+    case "service_account":
       return {
-        ok: true,
-        resolved: {
-          kind: "header",
-          headers: { Authorization: `Bearer ${result.token}` },
-          ...(safeBaseUrl ? { baseUrl: safeBaseUrl } : {}),
-        },
+        ok: false,
+        error: { code: "not_implemented", authType: auth.type },
       };
-    }
   }
 }

package/src/providers/model-catalog.ts

@@ -76,13 +76,6 @@ 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.
@@ -863,9 +856,6 @@ 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",
@@ -1826,7 +1816,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
-        supportsForcedToolChoiceWithThinking: false,
         pricing: {
           inputPer1mTokens: 0.95,
           outputPer1mTokens: 4.0,
@@ -2639,29 +2628,6 @@ 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,15 +11,10 @@ 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, 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.
+// 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).
 const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
     balanced: "claude-sonnet-4-6",
@@ -37,7 +32,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
-    "cost-optimized": "gemini-3.1-flash-lite",
+    "cost-optimized": "gemini-2.5-flash-lite",
     "latency-optimized": "gemini-3.1-flash-lite",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",