@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/mcp/__tests__/mcp-oauth-provider.test.ts

@@ -12,6 +12,8 @@ mock.module("../../inbound/platform-callback-registration.js", () => ({
 mock.module("../../inbound/public-ingress-urls.js", () => ({
   getOAuthCallbackUrl: () =>
     "https://platform.example/v1/gateway/callbacks/abc/webhooks/oauth/callback/",
+  getMcpOAuthClientMetadataUrl: () =>
+    "http://localhost/oauth/client-metadata.json",
 }));
 
 mock.module("../../config/loader.js", () => ({

package/src/mcp/client.ts

@@ -22,24 +22,6 @@ const log = getLogger("mcp-client");
 
 const CONNECT_TIMEOUT_MS = 30_000;
 
-// MCP servers occasionally return tools with a missing or non-object
-// `inputSchema` (spec violation, but seen in the wild). Coerce to a valid
-// empty object schema so downstream code that assumes `input_schema: object`
-// (e.g. `injectActivityField`) doesn't crash.
-function normalizeInputSchema(
-  raw: unknown,
-  toolName: string,
-): Record<string, unknown> {
-  if (raw != null && typeof raw === "object" && !Array.isArray(raw)) {
-    return raw as Record<string, unknown>;
-  }
-  log.warn(
-    { toolName, received: typeof raw },
-    "MCP tool returned non-object inputSchema; defaulting to empty object schema",
-  );
-  return { type: "object", properties: {} };
-}
-
 /**
  * Behavioral hints a server may attach to a tool (MCP `ToolAnnotations`).
  * Self-reported by the server, so consumers treat them as hints rather than
@@ -258,7 +240,7 @@ export class McpClient {
     return result.tools.map((tool) => ({
       name: tool.name,
       description: tool.description ?? "",
-      inputSchema: normalizeInputSchema(tool.inputSchema, tool.name),
+      inputSchema: tool.inputSchema,
       annotations: tool.annotations,
     }));
   }

package/src/mcp/mcp-oauth-provider.ts

@@ -27,6 +27,7 @@ import type {
   OAuthClientMetadata,
   OAuthTokens,
 } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { buildMcpOAuthClientMetadata } from "@vellumai/service-contracts/mcp-oauth";
 
 import { getPlatformAssistantId } from "../config/env.js";
 import { getAssistantName } from "../daemon/identity-helpers.js";
@@ -49,26 +50,16 @@ import {
 const log = getLogger("mcp-oauth");
 
 /**
- * Logo shown on an authorization server's consent screen.
+ * What stored client information was made against.
  *
- * Anonymously fetchable, which is the requirement: the server loads it
- * without credentials. It identifies Vellum rather than the individual
- * assistant, so every assistant a person runs presents the same mark.
- */
-const CLIENT_LOGO_URI = "https://www.vellum.ai/favicon.svg";
-
-/**
- * What a stored client registration was made against.
- *
- * A client identifier belongs to the authorization server that issued it and
- * is registered for one set of redirect URIs, so reusing a registration after
- * either changes is invalid. Recording both is what lets a registration be
- * reused when they still hold, which is the difference between registering
- * once per assistant and registering once per attempt.
+ * A client identifier applies to one authorization server and one set of
+ * redirect URIs, so reusing it after either changes is invalid. Recording both
+ * avoids selecting the client again on every connection attempt.
  */
 interface ClientRegistrationBinding {
   issuer: string | null;
   redirectUri: string;
+  clientMetadataUrl?: string;
 }
 
 export interface McpOAuthCallbackResult {
@@ -96,6 +87,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
   private _codeVerifier: string | undefined;
   private _state: string | undefined;
   private _redirectUrl: string | undefined;
+  private _clientMetadataUrl: string | undefined;
   private _codePromise: Promise<string> | null = null;
   /** Deferred resolver/rejector for the callback code promise. */
   private _codeResolve: ((code: string) => void) | undefined;
@@ -127,6 +119,10 @@ export class McpOAuthProvider implements OAuthClientProvider {
     return this._redirectUrl;
   }
 
+  get clientMetadataUrl(): string | undefined {
+    return this._clientMetadataUrl;
+  }
+
   // --- clientMetadata ---
 
   /**
@@ -143,23 +139,17 @@ export class McpOAuthProvider implements OAuthClientProvider {
    * `logo_uri` is the Vellum mark rather than the assistant's own avatar.
    * An authorization server fetching a logo is anonymous, and the avatar is
    * served only behind authentication, so there is no per-assistant URL to
-   * give it. A stable public identity per assistant is what would supply
-   * one, and the same prerequisite would let this move to Client ID
-   * Metadata Documents and drop registration altogether.
+   * give it.
    */
   get clientMetadata(): OAuthClientMetadata {
     const assistantName = getAssistantName();
     const assistantId = getPlatformAssistantId().trim();
-    return {
-      client_name: assistantName ?? "Vellum Assistant",
-      logo_uri: CLIENT_LOGO_URI,
-      redirect_uris: this._redirectUrl ? [this._redirectUrl] : [],
-      token_endpoint_auth_method: "none",
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      ...(assistantId.length > 0 && { software_id: assistantId }),
-      software_version: APP_VERSION,
-    };
+    return buildMcpOAuthClientMetadata({
+      clientName: assistantName ?? "Vellum Assistant",
+      redirectUris: this._redirectUrl ? [this._redirectUrl] : [],
+      softwareId: assistantId.length > 0 ? assistantId : undefined,
+      softwareVersion: APP_VERSION,
+    });
   }
 
   // --- Tokens ---
@@ -254,15 +244,12 @@ export class McpOAuthProvider implements OAuthClientProvider {
   // --- Client Information ---
 
   /**
-   * The stored registration, or `undefined` to make the SDK register a new
-   * one.
+   * The stored client information, or `undefined` to make the SDK select a
+   * client through CIMD or DCR.
    *
-   * Returning the stored value is the normal case: dynamic registration
-   * writes a record on the authorization server, so re-registering per
-   * attempt accumulates records nobody cleans up. It is withheld only when
-   * the registration provably no longer applies, because the redirect URI
-   * it was made for changed or because a different authorization server now
-   * fronts the resource.
+   * Returning the stored value is the normal case. It is withheld only when
+   * the client information provably no longer applies because its redirect
+   * URI, metadata URL, or authorization server changed.
    */
   async clientInformation(): Promise<OAuthClientInformationMixed | undefined> {
     const raw = await getSecureKeyAsync(
@@ -287,7 +274,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
     if (stale) {
       log.info(
         { serverId: this.serverId, reason: stale },
-        "Stored client registration no longer applies; registering again",
+        "Stored OAuth client information no longer applies; selecting a client again",
       );
       return undefined;
     }
@@ -309,12 +296,16 @@ export class McpOAuthProvider implements OAuthClientProvider {
       return;
     }
 
-    // Record what the registration was made against, so a later run can tell
+    // Record what the client information applies to, so a later run can tell
     // whether reusing it is still valid.
     if (this._redirectUrl) {
       const binding: ClientRegistrationBinding = {
         issuer: await this.currentIssuer(),
         redirectUri: this._redirectUrl,
+        ...(this._clientMetadataUrl &&
+          info.client_id === this._clientMetadataUrl && {
+            clientMetadataUrl: this._clientMetadataUrl,
+          }),
       };
       const boundOk = await setSecureKeyAsync(
         mcpOAuthCredentialKey(this.credentialTarget, "client_binding"),
@@ -323,7 +314,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
       if (!boundOk) {
         log.warn(
           { serverId: this.serverId },
-          "Failed to persist OAuth client binding; the registration will be remade on the next flow",
+          "Failed to persist OAuth client binding; the client will be selected again on the next flow",
         );
       }
     }
@@ -342,14 +333,14 @@ export class McpOAuthProvider implements OAuthClientProvider {
   }
 
   /**
-   * Why the stored registration cannot be reused, or null when it can.
+   * Why the stored client information cannot be reused, or null when it can.
    *
    * The redirect URI is only checked while a flow is being prepared:
    * outside one there is no redirect URI to compare against, and a silent
-   * reconnect must not be turned into a registration.
+   * reconnect must not trigger client selection.
    *
    * The issuer is only checked when discovery has run. An unverifiable
-   * issuer keeps the registration rather than discarding it, since the
+   * issuer keeps the client information rather than discarding it, since the
    * redirect check already covers the case this plugin actually changes.
    */
   private async describeStaleBinding(): Promise<string | null> {
@@ -357,8 +348,8 @@ export class McpOAuthProvider implements OAuthClientProvider {
       mcpOAuthCredentialKey(this.credentialTarget, "client_binding"),
     );
     if (!raw) {
-      // Registered before the binding was recorded. Keep it: discarding
-      // every pre-existing registration would remake all of them at once.
+      // Saved before the binding was recorded. Keep it: discarding every
+      // pre-existing client would recreate all of them at once.
       return null;
     }
 
@@ -373,6 +364,25 @@ export class McpOAuthProvider implements OAuthClientProvider {
       return "redirect URI changed";
     }
 
+    if (
+      this._redirectUrl &&
+      binding.clientMetadataUrl &&
+      binding.clientMetadataUrl !== this._clientMetadataUrl
+    ) {
+      return "client metadata URL changed";
+    }
+
+    if (this._redirectUrl && binding.clientMetadataUrl) {
+      const discovery = await this.discoveryState();
+      if (
+        discovery &&
+        discovery.authorizationServerMetadata
+          ?.client_id_metadata_document_supported !== true
+      ) {
+        return "authorization server no longer supports client metadata documents";
+      }
+    }
+
     const issuer = await this.currentIssuer();
     if (issuer && binding.issuer && binding.issuer !== issuer) {
       return "authorization server changed";
@@ -536,9 +546,9 @@ export class McpOAuthProvider implements OAuthClientProvider {
           "OAuth client information key not found in secure storage (already removed)",
         );
       }
-      // The binding describes the registration being dropped, so it goes
-      // with it. Leaving it would let a later registration inherit the
-      // previous one's issuer and redirect URI.
+      // The binding describes the client information being dropped, so it
+      // goes with it. Leaving it would let a later client inherit the previous
+      // one's issuer and redirect URI.
       await deleteSecureKeyAsync(
         mcpOAuthCredentialKey(this.credentialTarget, "client_binding"),
       );
@@ -580,10 +590,13 @@ export class McpOAuthProvider implements OAuthClientProvider {
    * the first point at which the SDK-generated `state` is known.
    */
   async startCallbackServer(): Promise<McpOAuthCallbackResult> {
-    const { resolveOauthCallbackUrl } =
+    const { resolveMcpOAuthClientMetadataUrl, resolveOauthCallbackUrl } =
       await import("../inbound/oauth-callback-url.js");
 
     this._redirectUrl = await resolveOauthCallbackUrl();
+    this._clientMetadataUrl = resolveMcpOAuthClientMetadataUrl(
+      this._redirectUrl,
+    );
 
     const codePromise = new Promise<string>((resolve, reject) => {
       this._codeResolve = resolve;
@@ -598,7 +611,11 @@ export class McpOAuthProvider implements OAuthClientProvider {
     void codePromise.catch(() => {});
 
     log.info(
-      { serverId: this.serverId, redirectUrl: this._redirectUrl },
+      {
+        serverId: this.serverId,
+        redirectUrl: this._redirectUrl,
+        clientMetadataUrl: this._clientMetadataUrl,
+      },
       "MCP OAuth callback prepared (awaiting state from auth URL)",
     );
 

package/src/media/openrouter-image-service.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 import {
   DEFAULT_OPENROUTER_IMAGE_MODEL,
   qualifyImageModelForOpenRouter,
@@ -13,6 +15,31 @@ import {
 } from "./types.js";
 
 const OPENROUTER_IMAGES_URL = "https://openrouter.ai/api/v1/images";
+const OpenRouterImageResponseSchema = z.object({
+  data: z
+    .array(
+      z
+        .object({
+          b64_json: z.string().optional().catch(undefined),
+          media_type: z.string().optional().catch(undefined),
+        })
+        .optional()
+        .catch(undefined),
+    )
+    .optional()
+    .catch(undefined),
+  error: z
+    .union([
+      z.string(),
+      z.object({
+        message: z.string().optional().catch(undefined),
+      }),
+    ])
+    .optional()
+    .catch(undefined),
+});
+
+type OpenRouterImageResponse = z.infer<typeof OpenRouterImageResponseSchema>;
 
 /**
  * Qualify a bare built-in ID or alias for OpenRouter. Call sites that skip
@@ -76,21 +103,11 @@ export function mapOpenRouterError(error: unknown): string {
   return "An unexpected error occurred during image generation.";
 }
 
-function errorMessage(body: unknown): string {
-  if (typeof body !== "object" || body === null) {
-    return "Request failed";
-  }
-  const error = (body as { error?: unknown }).error;
-  if (typeof error === "string") {
-    return error;
-  }
-  if (typeof error === "object" && error !== null) {
-    const message = (error as { message?: unknown }).message;
-    if (typeof message === "string" && message) {
-      return message;
-    }
+function errorMessage(body: OpenRouterImageResponse | undefined): string {
+  if (typeof body?.error === "string") {
+    return body.error;
   }
-  return "Request failed";
+  return body?.error?.message || "Request failed";
 }
 
 export async function generateImageOpenRouter(
@@ -98,7 +115,9 @@ export async function generateImageOpenRouter(
   request: ImageGenerationRequest,
 ): Promise<ImageGenerationResult> {
   if (credentials.type !== "direct") {
-    throw new Error("OpenRouter image generation requires an OpenRouter API key.");
+    throw new Error(
+      "OpenRouter image generation requires an OpenRouter API key.",
+    );
   }
 
   const model = resolveOpenRouterModel(request.model);
@@ -127,12 +146,10 @@ export async function generateImageOpenRouter(
     ...(request.signal ? { signal: request.signal } : {}),
   });
 
-  const body = (await response.json().catch(() => undefined)) as
-    | {
-        data?: Array<{ b64_json?: string; media_type?: string }>;
-        error?: unknown;
-      }
-    | undefined;
+  const parsed = OpenRouterImageResponseSchema.safeParse(
+    await response.json().catch(() => undefined),
+  );
+  const body = parsed.success ? parsed.data : undefined;
 
   if (!response.ok) {
     throw new OpenRouterImageError(response.status, errorMessage(body));
@@ -140,7 +157,7 @@ export async function generateImageOpenRouter(
 
   const images: GeneratedImage[] = [];
   for (const entry of body?.data ?? []) {
-    if (!entry.b64_json) {
+    if (!entry?.b64_json) {
       continue;
     }
     images.push({

package/src/monitoring/__tests__/oom-inheritance-sweep.test.ts

@@ -0,0 +1,86 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { sweepInheritedOomProtection } from "../oom-inheritance-sweep.js";
+import { stat } from "./proc-fixtures.js";
+
+const DAEMON = 100;
+const MONITOR = 200;
+
+let procRoot: string;
+
+function writeProcess(
+  pid: number,
+  ppid: number,
+  comm: string,
+  oomScoreAdj: number | null,
+): void {
+  const dir = join(procRoot, String(pid));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "stat"), stat(pid, comm, "S", ppid, 100));
+  if (oomScoreAdj != null) {
+    writeFileSync(join(dir, "oom_score_adj"), `${oomScoreAdj}\n`);
+  }
+}
+
+function readAdj(pid: number): string {
+  return readFileSync(join(procRoot, String(pid), "oom_score_adj"), "utf-8");
+}
+
+beforeEach(() => {
+  procRoot = mkdtempSync(join(tmpdir(), "oom-sweep-"));
+  writeProcess(1, 0, "init", 0);
+  writeProcess(DAEMON, 1, "bun", -700);
+  writeProcess(MONITOR, DAEMON, "bun", -500);
+});
+
+afterEach(() => {
+  rmSync(procRoot, { recursive: true, force: true });
+});
+
+describe("sweepInheritedOomProtection", () => {
+  test("resets negative descendants and leaves everything else alone", () => {
+    writeProcess(300, DAEMON, "node", -700); // forgot to reset
+    writeProcess(400, 300, "python3", -700); // inherited through 300
+    writeProcess(500, 1, "sshd", -700); // not under the daemon
+    writeProcess(600, DAEMON, "bash", 1000); // already raised
+    writeProcess(700, DAEMON, "zombie", null); // no oom_score_adj file
+
+    const resets = sweepInheritedOomProtection({
+      daemonPid: DAEMON,
+      keepPids: new Set([MONITOR]),
+      procRoot,
+    });
+
+    expect(resets.sort((a, b) => a.pid - b.pid)).toEqual([
+      { pid: 300, comm: "node", previous: -700 },
+      { pid: 400, comm: "python3", previous: -700 },
+    ]);
+    expect(readAdj(300)).toBe("0");
+    expect(readAdj(400)).toBe("0");
+    expect(readAdj(DAEMON)).toBe("-700\n");
+    expect(readAdj(MONITOR)).toBe("-500\n");
+    expect(readAdj(500)).toBe("-700\n");
+    expect(readAdj(600)).toBe("1000\n");
+  });
+
+  test("tolerates a ppid cycle in a malformed table", () => {
+    writeProcess(300, 400, "a", -700);
+    writeProcess(400, 300, "b", -700);
+    expect(
+      sweepInheritedOomProtection({
+        daemonPid: DAEMON,
+        keepPids: new Set([MONITOR]),
+        procRoot,
+      }),
+    ).toEqual([]);
+  });
+});