@vellumai/assistant 0.4.45 → 0.4.48

package/src/oauth/platform-connection.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  CredentialRequiredError,
+  PlatformOAuthConnection,
+  ProviderUnreachableError,
+} from "./platform-connection.js";
+
+const DEFAULT_OPTIONS = {
+  id: "conn-1",
+  providerKey: "integration:gmail",
+  externalId: "ext-123",
+  accountInfo: "user@example.com",
+  grantedScopes: ["https://www.googleapis.com/auth/gmail.readonly"],
+  assistantId: "asst-abc",
+  platformBaseUrl: "https://platform.example.com",
+  apiKey: "test-api-key",
+};
+
+describe("PlatformOAuthConnection", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test("successful proxied request", async () => {
+    const upstreamBody = { messages: [{ id: "msg-1", snippet: "Hello" }] };
+
+    globalThis.fetch = mock(
+      async (url: string | URL | Request, init?: RequestInit) => {
+        expect(url).toBe(
+          "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/gmail/",
+        );
+        expect(init?.method).toBe("POST");
+        expect(init?.headers).toEqual({
+          Authorization: "Api-Key test-api-key",
+          "Content-Type": "application/json",
+        });
+
+        const parsed = JSON.parse(init?.body as string);
+        expect(parsed).toEqual({
+          request: {
+            method: "GET",
+            path: "/gmail/v1/users/me/messages",
+            query: { maxResults: "10" },
+            headers: {},
+            body: null,
+          },
+        });
+
+        return new Response(
+          JSON.stringify({
+            status: 200,
+            headers: { "content-type": "application/json" },
+            body: upstreamBody,
+          }),
+          { status: 200 },
+        );
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const result = await conn.request({
+      method: "GET",
+      path: "/gmail/v1/users/me/messages",
+      query: { maxResults: "10" },
+    });
+
+    expect(result.status).toBe(200);
+    expect(result.headers).toEqual({ "content-type": "application/json" });
+    expect(result.body).toEqual(upstreamBody);
+  });
+
+  test("forwards baseUrl when provided", async () => {
+    globalThis.fetch = mock(
+      async (_url: string | URL | Request, init?: RequestInit) => {
+        const parsed = JSON.parse(init?.body as string);
+        expect(parsed.request.baseUrl).toBe(
+          "https://www.googleapis.com/calendar/v3",
+        );
+
+        return new Response(
+          JSON.stringify({ status: 200, headers: {}, body: {} }),
+          { status: 200 },
+        );
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    await conn.request({
+      method: "GET",
+      path: "/calendars/primary/events",
+      baseUrl: "https://www.googleapis.com/calendar/v3",
+    });
+  });
+
+  test("omits baseUrl from envelope when not provided", async () => {
+    globalThis.fetch = mock(
+      async (_url: string | URL | Request, init?: RequestInit) => {
+        const parsed = JSON.parse(init?.body as string);
+        expect("baseUrl" in parsed.request).toBe(false);
+
+        return new Response(
+          JSON.stringify({ status: 200, headers: {}, body: null }),
+          { status: 200 },
+        );
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    await conn.request({ method: "GET", path: "/some/path" });
+  });
+
+  test("424 response throws CredentialRequiredError", async () => {
+    globalThis.fetch = mock(async () => {
+      return new Response("", { status: 424 });
+    }) as unknown as typeof globalThis.fetch;
+
+    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    await expect(
+      conn.request({ method: "GET", path: "/test" }),
+    ).rejects.toThrow(CredentialRequiredError);
+  });
+
+  test("502 response throws ProviderUnreachableError", async () => {
+    globalThis.fetch = mock(async () => {
+      return new Response("", { status: 502 });
+    }) as unknown as typeof globalThis.fetch;
+
+    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    await expect(
+      conn.request({ method: "GET", path: "/test" }),
+    ).rejects.toThrow(ProviderUnreachableError);
+  });
+
+  test("withToken throws clear error", async () => {
+    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    await expect(conn.withToken(async (token) => token)).rejects.toThrow(
+      "Raw token access is not supported for platform-managed connections. Use connection.request() instead.",
+    );
+  });
+
+  test("strips integration: prefix from providerKey for slug", async () => {
+    globalThis.fetch = mock(async (url: string | URL | Request) => {
+      expect(String(url)).toContain("/external-provider-proxy/slack/");
+      return new Response(
+        JSON.stringify({ status: 200, headers: {}, body: null }),
+        { status: 200 },
+      );
+    }) as unknown as typeof globalThis.fetch;
+
+    const conn = new PlatformOAuthConnection({
+      ...DEFAULT_OPTIONS,
+      providerKey: "integration:slack",
+    });
+    await conn.request({ method: "GET", path: "/test" });
+  });
+});

package/src/oauth/platform-connection.ts

@@ -0,0 +1,110 @@
+import type {
+  OAuthConnection,
+  OAuthConnectionRequest,
+  OAuthConnectionResponse,
+} from "./connection.js";
+
+export class CredentialRequiredError extends Error {
+  constructor(message = "Connection not set up on platform") {
+    super(message);
+    this.name = "CredentialRequiredError";
+  }
+}
+
+export class ProviderUnreachableError extends Error {
+  constructor(message = "Provider is unreachable") {
+    super(message);
+    this.name = "ProviderUnreachableError";
+  }
+}
+
+export interface PlatformOAuthConnectionOptions {
+  id: string;
+  providerKey: string;
+  externalId: string;
+  accountInfo: string | null;
+  grantedScopes: string[];
+  assistantId: string;
+  platformBaseUrl: string;
+  apiKey: string;
+}
+
+export class PlatformOAuthConnection implements OAuthConnection {
+  readonly id: string;
+  readonly providerKey: string;
+  readonly externalId: string;
+  readonly accountInfo: string | null;
+  readonly grantedScopes: string[];
+
+  private readonly assistantId: string;
+  private readonly platformBaseUrl: string;
+  private readonly apiKey: string;
+
+  constructor(options: PlatformOAuthConnectionOptions) {
+    this.id = options.id;
+    this.providerKey = options.providerKey;
+    this.externalId = options.externalId;
+    this.accountInfo = options.accountInfo;
+    this.grantedScopes = options.grantedScopes;
+    this.assistantId = options.assistantId;
+    this.platformBaseUrl = options.platformBaseUrl;
+    this.apiKey = options.apiKey;
+  }
+
+  async request(req: OAuthConnectionRequest): Promise<OAuthConnectionResponse> {
+    const providerSlug = this.providerKey.replace(/^integration:/, "");
+    const proxyUrl = `${this.platformBaseUrl}/v1/assistants/${this.assistantId}/external-provider-proxy/${providerSlug}/`;
+
+    const body: Record<string, unknown> = {
+      request: {
+        method: req.method,
+        path: req.path,
+        query: req.query ?? {},
+        headers: req.headers ?? {},
+        body: req.body ?? null,
+        ...(req.baseUrl ? { baseUrl: req.baseUrl } : {}),
+      },
+    };
+
+    const response = await fetch(proxyUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Api-Key ${this.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (response.status === 424) {
+      throw new CredentialRequiredError();
+    }
+
+    if (response.status === 502) {
+      throw new ProviderUnreachableError();
+    }
+
+    if (!response.ok) {
+      throw new Error(
+        `Platform proxy returned unexpected status ${response.status}`,
+      );
+    }
+
+    const json = (await response.json()) as {
+      status: number;
+      headers: Record<string, string>;
+      body: unknown;
+    };
+
+    return {
+      status: json.status,
+      headers: json.headers,
+      body: json.body,
+    };
+  }
+
+  async withToken<T>(_fn: (token: string) => Promise<T>): Promise<T> {
+    throw new Error(
+      "Raw token access is not supported for platform-managed connections. Use connection.request() instead.",
+    );
+  }
+}

package/src/oauth/provider-base-urls.ts

@@ -0,0 +1,21 @@
+/** Default base URL per credential service. Used by the connection when no per-request override is provided. */
+export const PROVIDER_BASE_URLS: Record<string, string> = {
+  "integration:gmail": "https://gmail.googleapis.com/gmail/v1/users/me",
+  "integration:slack": "https://slack.com/api",
+  "integration:twitter": "https://api.x.com",
+  "integration:notion": "https://api.notion.com",
+  "integration:linear": "https://api.linear.app",
+  "integration:github": "https://api.github.com",
+};
+
+/**
+ * Alternative base URLs for providers that span multiple API hosts
+ * sharing one OAuth token. Callers pass these via `request({ baseUrl })`.
+ */
+export const GOOGLE_CALENDAR_BASE_URL =
+  "https://www.googleapis.com/calendar/v3";
+export const GOOGLE_PEOPLE_BASE_URL = "https://people.googleapis.com/v1";
+
+export function getProviderBaseUrl(providerKey: string): string | undefined {
+  return PROVIDER_BASE_URLS[providerKey];
+}

package/src/oauth/provider-profiles.ts

@@ -67,7 +67,7 @@ export const PROVIDER_PROFILES: Record<string, OAuthProviderProfile> = {
     ],
     extraParams: { access_type: "offline", prompt: "consent" },
     callbackTransport: "loopback",
-    setupSkillId: "google-oauth-setup",
+    setupSkillId: "google-oauth-applescript",
     setup: {
       displayName: "Google (Gmail & Calendar)",
       dashboardUrl: "https://console.cloud.google.com/apis/credentials",

package/src/oauth/token-persistence.ts

@@ -6,6 +6,7 @@
  * orchestrator without duplicating storage logic.
  */
 
+import { credentialKey, migrateKeys } from "../security/credential-key.js";
 import type {
   OAuth2FlowResult,
   TokenEndpointAuthMethod,
@@ -14,10 +15,7 @@ import {
   deleteSecureKeyAsync,
   setSecureKeyAsync,
 } from "../security/secure-keys.js";
-import {
-  deleteCredentialMetadata,
-  upsertCredentialMetadata,
-} from "../tools/credentials/metadata-store.js";
+import { upsertCredentialMetadata } from "../tools/credentials/metadata-store.js";
 import type { CredentialInjectionTemplate } from "../tools/credentials/policy-types.js";
 import { runPostConnectHook } from "../tools/credentials/post-connect-hooks.js";
 
@@ -56,6 +54,8 @@ export interface StoreOAuth2TokensParams {
 export async function storeOAuth2Tokens(
   params: StoreOAuth2TokensParams,
 ): Promise<{ accountInfo?: string }> {
+  migrateKeys();
+
   const {
     service,
     tokens,
@@ -71,7 +71,7 @@ export async function storeOAuth2Tokens(
   } = params;
 
   const tokenStored = await setSecureKeyAsync(
-    `credential:${service}:access_token`,
+    credentialKey(service, "access_token"),
     tokens.accessToken,
   );
   if (!tokenStored) {
@@ -97,17 +97,11 @@ export async function storeOAuth2Tokens(
     }
   }
 
-  // Persist client credentials in keychain for defense in depth
-  const clientIdStored = await setSecureKeyAsync(
-    `credential:${service}:client_id`,
-    clientId,
-  );
-  if (!clientIdStored) {
-    throw new Error("Failed to store client_id in secure storage");
-  }
+  // client_id is stored in metadata only (oauth2ClientId field) — not the
+  // secure store. token-manager.ts reads it from meta?.oauth2ClientId.
   if (clientSecret) {
     const clientSecretStored = await setSecureKeyAsync(
-      `credential:${service}:client_secret`,
+      credentialKey(service, "client_secret"),
       clientSecret,
     );
     if (!clientSecretStored) {
@@ -121,7 +115,6 @@ export async function storeOAuth2Tokens(
     grantedScopes,
     oauth2TokenUrl: tokenUrl,
     oauth2ClientId: clientId,
-    oauth2ClientSecret: clientSecret ?? null,
     ...(tokenEndpointAuthMethod
       ? { oauth2TokenEndpointAuthMethod: tokenEndpointAuthMethod }
       : {}),
@@ -143,11 +136,14 @@ export async function storeOAuth2Tokens(
         setNestedValue,
       } = await import("../config/loader.js");
       const raw = loadRawConfig();
+
+      // Write to the namespaced path
       setNestedValue(
         raw,
-        `integrations.accountInfo.${service}`,
+        `integrations.${service}.accountInfo`,
         resolvedAccountInfo,
       );
+
       saveRawConfig(raw);
       invalidateConfigCache();
     } catch {
@@ -157,18 +153,22 @@ export async function storeOAuth2Tokens(
 
   if (tokens.refreshToken) {
     const refreshStored = await setSecureKeyAsync(
-      `credential:${service}:refresh_token`,
+      credentialKey(service, "refresh_token"),
       tokens.refreshToken,
     );
     if (refreshStored) {
-      upsertCredentialMetadata(service, "refresh_token", {});
+      upsertCredentialMetadata(service, "access_token", {
+        hasRefreshToken: true,
+      });
     }
   } else {
     // Re-auth grants that omit refresh_token must clear any stale stored
     // token — otherwise withValidToken() will attempt refresh with invalid
     // credentials.
-    await deleteSecureKeyAsync(`credential:${service}:refresh_token`);
-    deleteCredentialMetadata(service, "refresh_token");
+    await deleteSecureKeyAsync(credentialKey(service, "refresh_token"));
+    upsertCredentialMetadata(service, "access_token", {
+      hasRefreshToken: false,
+    });
   }
 
   // Run any provider-specific post-connect actions (e.g. Slack welcome DM)

package/src/permissions/checker.ts

@@ -48,7 +48,11 @@ function riskCacheKey(
   workingDir?: string,
   manifestOverride?: ManifestOverride,
 ): string {
-  const inputJson = JSON.stringify(input);
+  // Strip `reason` before computing the cache key — it is cosmetic and varies
+  // per invocation even for identical tool operations, causing unnecessary
+  // cache misses.
+  const { reason: _reason, ...cacheableInput } = input;
+  const inputJson = JSON.stringify(cacheableInput);
   const hash = createHash("sha256")
     .update(inputJson)
     .update("\0")
@@ -139,6 +143,7 @@ const LOW_RISK_PROGRAMS = new Set([
   "tree",
   "du",
   "df",
+  "assistant",
 ]);
 
 // High-risk shell programs / patterns

package/src/prompts/system-prompt.ts

@@ -109,7 +109,11 @@ export function isOnboardingComplete(): boolean {
  *   3. If BOOTSTRAP.md exists, append first-run ritual instructions
  *   4. Append skills catalog from ~/.vellum/workspace/skills
  */
-export function buildSystemPrompt(): string {
+export interface BuildSystemPromptOptions {
+  hasNoClient?: boolean;
+}
+
+export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   const soulPath = getWorkspacePromptPath("SOUL.md");
   const identityPath = getWorkspacePromptPath("IDENTITY.md");
   const userPath = getWorkspacePromptPath("USER.md");
@@ -156,13 +160,14 @@ export function buildSystemPrompt(): string {
     );
   }
   if (getIsContainerized()) parts.push(buildContainerizedSection());
-  parts.push(buildConfigSection());
+  const hasNoClient = options?.hasNoClient ?? false;
+  parts.push(buildConfigSection(hasNoClient));
   parts.push(buildCliReferenceSection());
   parts.push(buildPostToolResponseSection());
   parts.push(buildExternalCommsIdentitySection());
   parts.push(buildChannelAwarenessSection());
   const config = getConfig();
-  parts.push(buildToolPermissionSection());
+  if (!hasNoClient) parts.push(buildToolPermissionSection());
   parts.push(buildTaskScheduleReminderRoutingSection());
   if (
     isAssistantFeatureFlagEnabled(
@@ -181,9 +186,9 @@ export function buildSystemPrompt(): string {
   if (!isOnboardingComplete()) {
     parts.push(buildStarterTaskPlaybookSection());
   }
-  parts.push(buildSystemPermissionSection());
+  if (!hasNoClient) parts.push(buildSystemPermissionSection());
   parts.push(buildSwarmGuidanceSection());
-  parts.push(buildAccessPreferenceSection());
+  parts.push(buildAccessPreferenceSection(hasNoClient));
   parts.push(buildIntegrationSection());
   parts.push(buildMemoryPersistenceSection());
   parts.push(buildMemoryRecallSection());
@@ -349,7 +354,7 @@ function buildInChatConfigurationSection(): string {
     "",
     "### Avatar Customisation",
     "",
-    'You can change your avatar appearance using the `set_avatar` tool. When the user asks to change, update, or customise your avatar, use `set_avatar` with a `description` parameter describing the desired appearance (e.g. "a friendly purple cat with green eyes wearing a tiny hat"). The tool generates an avatar image and updates all connected clients automatically. If managed avatar generation is configured, no local API key is needed.',
+    'You can change your avatar appearance using the `set_avatar` tool. When the user asks to change, update, or customise your avatar, use `set_avatar` with a `description` parameter describing the desired appearance (e.g. "a friendly purple cat with green eyes wearing a tiny hat"). The tool generates an avatar image and updates all connected clients automatically.',
     "",
     "**After generating a new avatar**, always update the `## Avatar` section in `IDENTITY.md` with a brief description of the current avatar appearance. This ensures you remember what you look like across sessions. Example:",
     "```",
@@ -402,9 +407,9 @@ export function buildPhoneCallsRoutingSection(): string {
     "### Trigger phrases",
     '- "Set up phone calling" / "enable calls"',
     '- "Make a call to..." / "call [number/business]"',
-    '- "Configure Twilio" (in context of voice calls)',
+    '- "Configure Twilio" (for voice calls)',
     '- "Can you make phone calls?"',
-    '- "Set up my phone number" (for calling)',
+    '- "Set up my phone number"',
     "",
     "### What it does",
     "The skill handles the full phone calling lifecycle:",
@@ -572,7 +577,23 @@ export function buildSwarmGuidanceSection(): string {
   ].join("\n");
 }
 
-function buildAccessPreferenceSection(): string {
+function buildAccessPreferenceSection(hasNoClient: boolean): string {
+  if (hasNoClient) {
+    return [
+      "## External Service Access Preference",
+      "",
+      "When interacting with external services (GitHub, Slack, Linear, Jira, cloud providers, etc.),",
+      "follow this priority order:",
+      "",
+      "1. **Sandbox first (`bash`)** — Always try to do things in your own sandbox environment first.",
+      "   If a tool (git, curl, jq, etc.) is not installed, install it yourself using `bash`",
+      "   (e.g. `apt-get install -y git`). The sandbox is your own machine — you have full control.",
+      "2. **web_fetch** — For public endpoints or simple API calls that don't need auth.",
+      "3. **Browser automation as last resort** — Only when the task genuinely requires a browser",
+      "   (e.g., no API exists, visual interaction needed, or OAuth consent screen).",
+    ].join("\n");
+  }
+
   return [
     "## External Service Access Preference",
     "",
@@ -635,10 +656,14 @@ function buildIntegrationSection(): string {
   const raw = loadRawConfig();
   const lines = ["## Connected Services", ""];
   for (const cred of oauthCreds) {
-    const acctInfo = getNestedValue(
+    const acctInfo = (getNestedValue(
       raw,
-      `integrations.accountInfo.${cred.service}`,
-    ) as string | undefined;
+      `integrations.${cred.service}.accountInfo`,
+    ) ??
+      // Fallback: legacy config path used before the namespace migration
+      getNestedValue(raw, `integrations.accountInfo.${cred.service}`)) as
+      | string
+      | undefined;
     const state = acctInfo ? `Connected (${acctInfo})` : "Connected";
     lines.push(`- **${cred.service}**: ${state}`);
   }
@@ -751,10 +776,12 @@ function buildPostToolResponseSection(): string {
     "  → Call document_create",
     "",
     "For permission-gated tools, send one short context sentence immediately before the tool call so the user can make an informed allow/deny decision.",
+    "",
+    '**Reason field:** For every tool call, include a `reason` parameter — a brief, non-technical explanation of what you are doing and why. This is shown to the user as a live status update. Use simple language a non-technical person would understand (e.g. "Checking your project settings" not "file_read config.ts").',
   ].join("\n");
 }
 
-function buildConfigSection(): string {
+function buildConfigSection(hasNoClient: boolean): string {
   // Always use `file_edit` (not `host_file_edit`) for workspace files — file_edit
   // handles sandbox path mapping internally, and host_file_edit is permission-gated
   // which would trigger approval prompts for routine workspace updates.
@@ -763,10 +790,14 @@ function buildConfigSection(): string {
   const config = getConfig();
   const configPreamble = `Your configuration directory is \`${hostWorkspaceDir}/\`.`;
 
+  const fileToolGuidance = hasNoClient
+    ? `${configPreamble} **Always use \`file_read\` and \`file_edit\` for these files** — they are inside your sandbox working directory:`
+    : `${configPreamble} **Always use \`file_read\` and \`file_edit\` (not \`host_file_read\` / \`host_file_edit\`) for these files** — they are inside your sandbox working directory and do not require host access or user approval:`;
+
   return [
     "## Configuration",
     `- **Active model**: \`${config.model}\` (provider: ${config.provider})`,
-    `${configPreamble} **Always use \`file_read\` and \`file_edit\` (not \`host_file_read\` / \`host_file_edit\`) for these files** — they are inside your sandbox working directory and do not require host access or user approval:`,
+    fileToolGuidance,
     "",
     "- `IDENTITY.md` — Your name, nature, personality, and emoji. Updated during the first-run ritual.",
     "- `SOUL.md` — Core principles, personality, and evolution guidance. Your behavioral foundation.",
@@ -801,7 +832,13 @@ function buildConfigSection(): string {
     "- They rename you or change your role",
     "- Your avatar appearance changes (update the `## Avatar` section with a description of the new look)",
     "",
-    "When reading or updating workspace files, always use the sandbox tools (`file_read`, `file_edit`). Never use `host_file_read` or `host_file_edit` for workspace files — those are for host-only resources outside your workspace.",
+    ...(hasNoClient
+      ? [
+          "When reading or updating workspace files, always use the sandbox tools (`file_read`, `file_edit`).",
+        ]
+      : [
+          "When reading or updating workspace files, always use the sandbox tools (`file_read`, `file_edit`). Never use `host_file_read` or `host_file_edit` for workspace files — those are for host-only resources outside your workspace.",
+        ]),
     "",
     "When updating, read the file first, then make a targeted edit. Include all useful information, but don't bloat the files over time",
   ].join("\n");

package/src/prompts/templates/BOOTSTRAP.md

@@ -40,7 +40,7 @@ Then figure out together:
    ```
 
    The two actions MUST have different labels and prompts. Double-check before calling ui_show that you are not repeating the same suggestion.
-   If `ui_show` is not available (voice, SMS, or other non-dashboard channels), present the two suggestions as plain text messages instead, numbered so the user can reply with which one they'd like. If the user types a response instead of clicking, continue via the text path. If they want to defer both suggestions and do something else entirely, that's fine too.
+   If `ui_show` is not available (voice or other non-dashboard channels), present the two suggestions as plain text messages instead, numbered so the user can reply with which one they'd like. If the user types a response instead of clicking, continue via the text path. If they want to defer both suggestions and do something else entirely, that's fine too.
 
 ## Requirements
 

package/src/providers/gemini/client.ts

@@ -16,6 +16,10 @@ export interface GeminiProviderOptions {
   streamTimeoutMs?: number;
   /** When set, routes requests through the managed proxy at this base URL. */
   managedBaseUrl?: string;
+  /** Vertex AI project placeholder (used with managed proxy). */
+  vertexProject?: string;
+  /** Vertex AI location placeholder (used with managed proxy). */
+  vertexLocation?: string;
 }
 
 export class GeminiProvider implements Provider {
@@ -29,12 +33,17 @@ export class GeminiProvider implements Provider {
     model: string,
     options: GeminiProviderOptions = {},
   ) {
-    this.client = new GoogleGenAI({
-      apiKey,
-      ...(options.managedBaseUrl
-        ? { httpOptions: { baseUrl: options.managedBaseUrl } }
-        : {}),
-    });
+    this.client = options.managedBaseUrl
+      ? new GoogleGenAI({
+          vertexai: true,
+          project: options.vertexProject ?? "proxy",
+          location: options.vertexLocation ?? "us-central1",
+          httpOptions: {
+            baseUrl: options.managedBaseUrl,
+            headers: { Authorization: `Bearer ${apiKey}` },
+          },
+        })
+      : new GoogleGenAI({ apiKey });
     this.model = model;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 300_000;
   }

package/src/providers/managed-proxy/constants.ts

@@ -29,12 +29,12 @@ export const MANAGED_PROVIDER_META: Record<string, ManagedProviderMeta> = {
   anthropic: {
     name: "anthropic",
     managed: true,
-    proxyPath: "/v1/runtime-proxy/anthropic",
+    proxyPath: "/v1/runtime-proxy/vertex",
   },
   gemini: {
     name: "gemini",
     managed: true,
-    proxyPath: "/v1/runtime-proxy/gemini",
+    proxyPath: "/v1/runtime-proxy/vertex",
   },
   fireworks: {
     name: "fireworks",

package/src/providers/managed-proxy/context.ts

@@ -10,11 +10,15 @@
  */
 
 import { getPlatformBaseUrl } from "../../config/env.js";
+import { credentialKey } from "../../security/credential-key.js";
 import { getSecureKey } from "../../security/secure-keys.js";
 import { MANAGED_PROVIDER_META } from "./constants.js";
 
 /** Storage key for the assistant API key credential. */
-const ASSISTANT_API_KEY_STORAGE_KEY = "credential:vellum:assistant_api_key";
+const ASSISTANT_API_KEY_STORAGE_KEY = credentialKey(
+  "vellum",
+  "assistant_api_key",
+);
 
 export interface ManagedProxyContext {
   /** Whether managed proxy prerequisites are satisfied. */