@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/migration-export-streaming.test.ts

@@ -285,6 +285,72 @@ describe("streamExportVBundle round-trip", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Streaming config sanitization test
+// ---------------------------------------------------------------------------
+
+describe("streamExportVBundle config sanitization", () => {
+  test("exported config.json has environment-specific fields stripped", async () => {
+    // Write a config with environment-specific fields that should be stripped
+    const configWithEnvFields = {
+      provider: "anthropic",
+      model: "test-model",
+      ingress: {
+        publicBaseUrl: "https://my-tunnel.example.com",
+        enabled: true,
+        port: 8080,
+      },
+      daemon: {
+        autoStart: true,
+        logLevel: "debug",
+      },
+      skills: {
+        load: {
+          extraDirs: ["/home/user/custom-skills", "/opt/skills"],
+          autoReload: true,
+        },
+      },
+      memory: { enabled: true },
+    };
+    writeFileSync(testConfigPath, JSON.stringify(configWithEnvFields, null, 2));
+
+    const result = await streamExportVBundle({
+      workspaceDir: testDir,
+    });
+
+    try {
+      const archiveData = new Uint8Array(readFileSync(result.tempPath));
+      const entries = parseTarEntries(archiveData);
+
+      const configEntry = entries.find(
+        (e) => e.name === "workspace/config.json",
+      );
+      expect(configEntry).toBeDefined();
+
+      const parsedConfig = JSON.parse(
+        new TextDecoder().decode(configEntry!.data),
+      );
+
+      // Environment-specific fields should be stripped/reset
+      expect(parsedConfig.ingress.publicBaseUrl).toBe("");
+      expect(parsedConfig.ingress.enabled).toBeUndefined();
+      expect(parsedConfig.daemon).toBeUndefined();
+      expect(parsedConfig.skills.load.extraDirs).toEqual([]);
+
+      // Non-environment-specific fields should be preserved
+      expect(parsedConfig.provider).toBe("anthropic");
+      expect(parsedConfig.model).toBe("test-model");
+      expect(parsedConfig.ingress.port).toBe(8080);
+      expect(parsedConfig.skills.load.autoReload).toBe(true);
+      expect(parsedConfig.memory.enabled).toBe(true);
+    } finally {
+      // Restore original config for subsequent tests
+      writeFileSync(testConfigPath, JSON.stringify(TEST_CONFIG, null, 2));
+      await result.cleanup();
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Cleanup idempotency test
 // ---------------------------------------------------------------------------

package/src/__tests__/migration-import-commit-http.test.ts

@@ -731,7 +731,9 @@ describe("commitImport", () => {
       expect(writtenDb).toEqual(newDbData);
 
       const writtenConfig = readFileSync(testConfigPath, "utf8");
-      expect(writtenConfig).toBe('{"model":"claude"}');
+      expect(writtenConfig).toBe(
+        JSON.stringify({ model: "claude" }, null, 2) + "\n",
+      );
     }
   });
 });
@@ -872,6 +874,104 @@ describe("commitImport — workspace clearing", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Config sanitization tests
+// ---------------------------------------------------------------------------
+
+describe("commitImport — config sanitization", () => {
+  test("imported workspace/config.json has environment-specific fields stripped", () => {
+    const configWithEnvFields = {
+      provider: "anthropic",
+      model: "test-model",
+      ingress: {
+        publicBaseUrl: "https://my-tunnel.example.com",
+        enabled: true,
+        port: 8080,
+      },
+      daemon: {
+        autoStart: true,
+        logLevel: "debug",
+      },
+      skills: {
+        load: {
+          extraDirs: ["/home/user/custom-skills"],
+          autoReload: true,
+        },
+      },
+      memory: { enabled: true },
+    };
+    const configData = new TextEncoder().encode(
+      JSON.stringify(configWithEnvFields, null, 2),
+    );
+
+    const vbundle = createValidVBundle([
+      { path: "workspace/config.json", data: configData },
+    ]);
+
+    const resolver = new DefaultPathResolver(testDir);
+    const result = commitImport({
+      archiveData: vbundle,
+      pathResolver: resolver,
+      workspaceDir: testDir,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    // Read the written config from disk and verify sanitization
+    const writtenConfig = JSON.parse(readFileSync(testConfigPath, "utf8"));
+
+    // Environment-specific fields should be stripped/reset
+    expect(writtenConfig.ingress.publicBaseUrl).toBe("");
+    expect(writtenConfig.ingress.enabled).toBeUndefined();
+    expect(writtenConfig.daemon).toBeUndefined();
+    expect(writtenConfig.skills.load.extraDirs).toEqual([]);
+
+    // Non-environment-specific fields should be preserved
+    expect(writtenConfig.provider).toBe("anthropic");
+    expect(writtenConfig.model).toBe("test-model");
+    expect(writtenConfig.ingress.port).toBe(8080);
+    expect(writtenConfig.skills.load.autoReload).toBe(true);
+    expect(writtenConfig.memory.enabled).toBe(true);
+  });
+
+  test("imported config/settings.json (legacy) has environment-specific fields stripped", () => {
+    const configWithEnvFields = {
+      provider: "openai",
+      daemon: { autoStart: false },
+      ingress: {
+        publicBaseUrl: "https://old-tunnel.example.com",
+        enabled: false,
+      },
+      skills: { load: { extraDirs: ["/legacy/skills"] } },
+    };
+    const configData = new TextEncoder().encode(
+      JSON.stringify(configWithEnvFields, null, 2),
+    );
+
+    const vbundle = createValidVBundle([
+      { path: "config/settings.json", data: configData },
+    ]);
+
+    const resolver = new DefaultPathResolver(testDir);
+    const result = commitImport({
+      archiveData: vbundle,
+      pathResolver: resolver,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    const writtenConfig = JSON.parse(readFileSync(testConfigPath, "utf8"));
+
+    expect(writtenConfig.ingress.publicBaseUrl).toBe("");
+    expect(writtenConfig.ingress.enabled).toBeUndefined();
+    expect(writtenConfig.daemon).toBeUndefined();
+    expect(writtenConfig.skills.load.extraDirs).toEqual([]);
+    expect(writtenConfig.provider).toBe("openai");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Auth policy registration tests
 // ---------------------------------------------------------------------------
@@ -888,23 +988,25 @@ describe("route policy registration", () => {
     expect(policy?.allowedPrincipalTypes).toContain("local");
   });
 
-  test("import policy matches other migration endpoint policies", async () => {
+  test("import policy matches export/preflight but differs from validate on scopes", async () => {
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const importPolicy = getPolicy("migrations/import");
     const validatePolicy = getPolicy("migrations/validate");
     const exportPolicy = getPolicy("migrations/export");
     const preflightPolicy = getPolicy("migrations/import-preflight");
 
+    // import, export, and preflight all require settings.write
+    expect(importPolicy!.requiredScopes).toEqual(exportPolicy!.requiredScopes);
     expect(importPolicy!.requiredScopes).toEqual(
-      validatePolicy!.requiredScopes,
+      preflightPolicy!.requiredScopes,
     );
+    expect(importPolicy!.requiredScopes).toEqual(["settings.write"]);
+    // validate is read-only so requires settings.read
+    expect(validatePolicy!.requiredScopes).toEqual(["settings.read"]);
+    // all share the same principal types
     expect(importPolicy!.allowedPrincipalTypes).toEqual(
       validatePolicy!.allowedPrincipalTypes,
     );
-    expect(importPolicy!.requiredScopes).toEqual(exportPolicy!.requiredScopes);
-    expect(importPolicy!.requiredScopes).toEqual(
-      preflightPolicy!.requiredScopes,
-    );
   });
 });
 

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -720,21 +720,22 @@ describe("route policy registration", () => {
     expect(policy?.allowedPrincipalTypes).toContain("local");
   });
 
-  test("import-preflight policy matches validate/export policy shape", async () => {
+  test("import-preflight policy matches export but differs from validate on scopes", async () => {
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const preflightPolicy = getPolicy("migrations/import-preflight");
     const validatePolicy = getPolicy("migrations/validate");
     const exportPolicy = getPolicy("migrations/export");
 
+    // preflight and export both require settings.write
     expect(preflightPolicy!.requiredScopes).toEqual(
-      validatePolicy!.requiredScopes,
+      exportPolicy!.requiredScopes,
     );
+    // validate is read-only so requires settings.read
+    expect(validatePolicy!.requiredScopes).toEqual(["settings.read"]);
+    // all share the same principal types
     expect(preflightPolicy!.allowedPrincipalTypes).toEqual(
       validatePolicy!.allowedPrincipalTypes,
     );
-    expect(preflightPolicy!.requiredScopes).toEqual(
-      exportPolicy!.requiredScopes,
-    );
   });
 });
 

package/src/__tests__/migration-validate-http.test.ts

@@ -5,7 +5,7 @@
  * - Success: valid .vbundle archive returns is_valid: true with manifest
  * - Validation failures: invalid gzip, missing entries, bad manifest, checksum mismatches
  * - Request errors: empty body, invalid multipart
- * - Auth: route policy enforcement (settings.write scope required)
+ * - Auth: route policy enforcement (settings.read scope required)
  * - Integration: existing routes are unaffected by the new endpoint
  */
 import { createHash } from "node:crypto";
@@ -638,13 +638,13 @@ describe("handleMigrationValidate", () => {
 // ---------------------------------------------------------------------------
 
 describe("route policy registration", () => {
-  test("migrations/validate policy requires settings.write scope", async () => {
+  test("migrations/validate policy requires settings.read scope", async () => {
     // Import route-policy to verify the registration exists
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const policy = getPolicy("migrations/validate");
 
     expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.write");
+    expect(policy?.requiredScopes).toContain("settings.read");
     expect(policy?.allowedPrincipalTypes).toContain("actor");
     expect(policy?.allowedPrincipalTypes).toContain("svc_gateway");
     expect(policy?.allowedPrincipalTypes).toContain("local");

package/src/__tests__/mock-gateway-ipc.ts

@@ -0,0 +1,151 @@
+/**
+ * Global test utility for mocking gateway IPC calls via `node:net`.
+ *
+ * Usage:
+ *   import { mockGatewayIpc, resetMockGatewayIpc } from "../__tests__/mock-gateway-ipc.js";
+ *
+ *   beforeEach(() => resetMockGatewayIpc());
+ *   afterEach(() => resetMockGatewayIpc());
+ *
+ *   it("uses IPC flags", async () => {
+ *     mockGatewayIpc({ "my-flag": true });
+ *     await initFeatureFlagOverrides();
+ *     ...
+ *   });
+ *
+ *   it("simulates socket error", async () => {
+ *     mockGatewayIpc(null, { error: true, code: "ENOENT" });
+ *     ...
+ *   });
+ *
+ * The mock is registered in the test preload (test-preload.ts) so every test
+ * file gets a no-op IPC layer by default — no test accidentally connects to
+ * a real gateway socket. Call `mockGatewayIpc()` to configure specific
+ * responses when the test cares about the IPC result.
+ *
+ * Mocks `node:net` at the socket level, but ONLY intercepts connections to
+ * `gateway.sock` paths. All other `node:net` exports and non-gateway
+ * `connect()` calls pass through to the real implementation so that proxy /
+ * tunnel tests continue to work.
+ */
+
+import { EventEmitter } from "node:events";
+import { mock } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Configurable state
+// ---------------------------------------------------------------------------
+
+/** IPC result the fake gateway will return (keyed by method name). */
+let ipcResults: Record<string, unknown> = {};
+
+/** Whether the fake socket should simulate a connection error. */
+let simulateError = false;
+
+/** Error code to use when simulating an error. */
+let simulateErrorCode = "ENOENT";
+
+// ---------------------------------------------------------------------------
+// FakeSocket — simulates the gateway IPC protocol
+// ---------------------------------------------------------------------------
+
+class FakeSocket extends EventEmitter {
+  unref() {
+    /* no-op */
+  }
+  destroy() {
+    /* no-op */
+  }
+  write(data: string) {
+    try {
+      const req = JSON.parse(data.trim());
+      const result =
+        req.method in ipcResults ? ipcResults[req.method] : undefined;
+      const response = JSON.stringify({ id: req.id, result });
+      queueMicrotask(() => {
+        this.emit("data", Buffer.from(response + "\n"));
+      });
+    } catch {
+      // Malformed request — ignore
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Register the mock (called once from test-preload.ts)
+// ---------------------------------------------------------------------------
+
+export function installGatewayIpcMock(): void {
+  // Snapshot the real node:net exports BEFORE mock.module replaces them.
+  // require() returns the current (real) module synchronously; after
+  // mock.module() the namespace is replaced for all future importers
+  // (like gateway-client.ts), but our captured references stay real.
+  // eslint-disable-next-line @typescript-eslint/no-require-imports -- require() is intentional: we need a synchronous snapshot of the real module before mock.module() replaces it
+  const realNet = require("node:net") as typeof import("node:net");
+  const realConnect = realNet.connect;
+
+  mock.module("node:net", () => ({
+    ...realNet,
+    connect(...args: unknown[]) {
+      // Only intercept Unix domain socket connections to gateway.sock.
+      // Everything else (TCP ports, other Unix sockets) passes through
+      // to the real node:net so proxy / tunnel tests keep working.
+      if (
+        typeof args[0] === "string" &&
+        (args[0] as string).endsWith("gateway.sock")
+      ) {
+        const socket = new FakeSocket();
+        queueMicrotask(() => {
+          if (simulateError) {
+            const err = new Error(simulateErrorCode) as NodeJS.ErrnoException;
+            err.code = simulateErrorCode;
+            socket.emit("error", err);
+            socket.emit("close");
+          } else {
+            socket.emit("connect");
+          }
+        });
+        return socket;
+      }
+      return realConnect(...(args as Parameters<typeof realConnect>));
+    },
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// Public API for tests
+// ---------------------------------------------------------------------------
+
+/**
+ * Configure the fake gateway IPC response.
+ *
+ * @param flags — feature flag map returned by `get_feature_flags`. Pass
+ *   `null` to skip setting a result (useful when only simulating errors).
+ * @param opts.error — simulate a socket connection error
+ * @param opts.code — error code (default "ENOENT")
+ * @param opts.results — raw method→result map for arbitrary IPC methods
+ */
+export function mockGatewayIpc(
+  flags?: Record<string, boolean> | null,
+  opts?: { error?: boolean; code?: string; results?: Record<string, unknown> },
+): void {
+  if (flags != null) {
+    ipcResults["get_feature_flags"] = flags;
+  }
+  if (opts?.results) {
+    Object.assign(ipcResults, opts.results);
+  }
+  if (opts?.error) {
+    simulateError = true;
+    simulateErrorCode = opts.code ?? "ENOENT";
+  }
+}
+
+/**
+ * Reset all IPC mock state back to defaults (empty flags, no errors).
+ */
+export function resetMockGatewayIpc(): void {
+  ipcResults = {};
+  simulateError = false;
+  simulateErrorCode = "ENOENT";
+}

package/src/__tests__/model-intents.test.ts

@@ -59,7 +59,7 @@ describe("model intents", () => {
       "claude-haiku-4-5-20251001",
     );
     expect(resolveModelIntent("anthropic", "quality-optimized")).toBe(
-      "claude-opus-4-6",
+      "claude-opus-4-7",
     );
     expect(resolveModelIntent("anthropic", "vision-optimized")).toBe(
       "claude-opus-4-6",
@@ -94,7 +94,7 @@ describe("RetryProvider model intent normalization", () => {
     });
 
     const config = seen?.config as Record<string, unknown>;
-    expect(config.model).toBe("claude-opus-4-6");
+    expect(config.model).toBe("claude-opus-4-7");
     expect(config.modelIntent).toBeUndefined();
     expect(config.max_tokens).toBe(123);
   });

package/src/__tests__/native-host-marker-sync-guard.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Sync guard: the `NATIVE_HOST_MARKER_HEADER` and
+ * `NATIVE_HOST_MARKER_VALUE` constants are referenced from two coupled
+ * files that MUST stay in lockstep:
+ *
+ *   - assistant/src/runtime/routes/browser-extension-pair-routes.ts
+ *     (the runtime side that rejects unmarked pair requests with 403)
+ *   - clients/chrome-extension/native-host/src/index.ts
+ *     (the native messaging helper that stamps the marker on every
+ *     pair POST before forwarding to the assistant)
+ *
+ * If either side drifts (typo in the header name, or a different
+ * value), the pair flow silently breaks end-to-end: the native host
+ * sends an unrecognizable header, the runtime rejects the request as
+ * if it came from a drive-by webpage, and the extension never gets a
+ * token.
+ *
+ * This guard reads the raw source text of both files at test time and
+ * uses regexes to extract the literal string values of each constant.
+ * It deliberately does NOT `import` the constants — the whole point is
+ * to catch the physical file divergence that an import-based test
+ * would paper over (a typo'd export still type-checks if both files
+ * are updated independently but inconsistently).
+ *
+ * Modeled on `extension-id-sync-guard.test.ts`.
+ */
+
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+const repoRoot = resolve(__dirname, "..", "..", "..");
+
+const ASSISTANT_PAIR_ROUTE_PATH =
+  "assistant/src/runtime/routes/browser-extension-pair-routes.ts";
+const NATIVE_HOST_INDEX_PATH =
+  "clients/chrome-extension/native-host/src/index.ts";
+
+/**
+ * Extract the string literal value of an exported const from raw
+ * TypeScript source text. Accepts both single- and double-quoted
+ * forms and is permissive about whitespace so minor formatter changes
+ * don't break the guard.
+ *
+ * Returns the literal string (without quotes) or `null` if the export
+ * cannot be found.
+ */
+function extractExportedConstString(
+  source: string,
+  constName: string,
+): string | null {
+  // Matches: export const FOO = "bar";  (also ' and whitespace
+  // variations). The value group stops at the next matching quote.
+  const re = new RegExp(
+    `export\\s+const\\s+${constName}\\s*=\\s*(['"])([^'"]*)\\1`,
+  );
+  const match = source.match(re);
+  if (!match) return null;
+  return match[2] ?? null;
+}
+
+describe("native-host marker sync guard", () => {
+  test("NATIVE_HOST_MARKER_HEADER matches across runtime route and native host", () => {
+    const assistantSource = readFileSync(
+      join(repoRoot, ASSISTANT_PAIR_ROUTE_PATH),
+      "utf8",
+    );
+    const nativeHostSource = readFileSync(
+      join(repoRoot, NATIVE_HOST_INDEX_PATH),
+      "utf8",
+    );
+
+    const assistantHeader = extractExportedConstString(
+      assistantSource,
+      "NATIVE_HOST_MARKER_HEADER",
+    );
+    const nativeHostHeader = extractExportedConstString(
+      nativeHostSource,
+      "NATIVE_HOST_MARKER_HEADER",
+    );
+
+    expect(assistantHeader).not.toBeNull();
+    expect(nativeHostHeader).not.toBeNull();
+    // Also require a non-empty value so an accidental `""` in either
+    // file trips the guard.
+    expect(assistantHeader!.length).toBeGreaterThan(0);
+    expect(nativeHostHeader!.length).toBeGreaterThan(0);
+
+    if (assistantHeader !== nativeHostHeader) {
+      throw new Error(
+        `NATIVE_HOST_MARKER_HEADER drift detected:\n` +
+          `  ${ASSISTANT_PAIR_ROUTE_PATH}: ${JSON.stringify(
+            assistantHeader,
+          )}\n` +
+          `  ${NATIVE_HOST_INDEX_PATH}: ${JSON.stringify(nativeHostHeader)}\n\n` +
+          `Both files must declare the same header name or pairing ` +
+          `silently breaks (the runtime rejects the native host's ` +
+          `requests as unmarked drive-by browser fetches).`,
+      );
+    }
+  });
+
+  test("NATIVE_HOST_MARKER_VALUE matches across runtime route and native host", () => {
+    const assistantSource = readFileSync(
+      join(repoRoot, ASSISTANT_PAIR_ROUTE_PATH),
+      "utf8",
+    );
+    const nativeHostSource = readFileSync(
+      join(repoRoot, NATIVE_HOST_INDEX_PATH),
+      "utf8",
+    );
+
+    const assistantValue = extractExportedConstString(
+      assistantSource,
+      "NATIVE_HOST_MARKER_VALUE",
+    );
+    const nativeHostValue = extractExportedConstString(
+      nativeHostSource,
+      "NATIVE_HOST_MARKER_VALUE",
+    );
+
+    expect(assistantValue).not.toBeNull();
+    expect(nativeHostValue).not.toBeNull();
+    expect(assistantValue!.length).toBeGreaterThan(0);
+    expect(nativeHostValue!.length).toBeGreaterThan(0);
+
+    if (assistantValue !== nativeHostValue) {
+      throw new Error(
+        `NATIVE_HOST_MARKER_VALUE drift detected:\n` +
+          `  ${ASSISTANT_PAIR_ROUTE_PATH}: ${JSON.stringify(
+            assistantValue,
+          )}\n` +
+          `  ${NATIVE_HOST_INDEX_PATH}: ${JSON.stringify(nativeHostValue)}\n\n` +
+          `Both files must declare the same marker value or pairing ` +
+          `silently breaks (the runtime rejects the native host's ` +
+          `requests as unmarked drive-by browser fetches).`,
+      );
+    }
+  });
+
+  test("extractExportedConstString helper handles both quote styles", () => {
+    // Smoke-test the parser helper itself so a regression in the
+    // regex can't silently mask a real drift in the coupled files.
+    expect(
+      extractExportedConstString(`export const FOO = "hello";`, "FOO"),
+    ).toBe("hello");
+    expect(
+      extractExportedConstString(`export const FOO = 'hello';`, "FOO"),
+    ).toBe("hello");
+    expect(
+      extractExportedConstString(`export  const   FOO   =   "spaced";`, "FOO"),
+    ).toBe("spaced");
+    expect(
+      extractExportedConstString(`export const OTHER = "x";`, "FOO"),
+    ).toBeNull();
+  });
+});

package/src/__tests__/oauth-apps-routes.test.ts

@@ -2,14 +2,14 @@ import { describe, expect, mock, test } from "bun:test";
 
 const mockGetApp = mock((_appId: string) => ({
   id: "app-1",
-  providerKey: "google",
+  provider: "google",
   clientId: "client-1",
 }));
 
 const mockListConnections = mock(() => [
   {
     id: "conn-1",
-    providerKey: "google",
+    provider: "google",
     accountInfo: '{"email":"alice@example.com"}',
     grantedScopes: '["email","profile"]',
     status: "active",
@@ -20,7 +20,7 @@ const mockListConnections = mock(() => [
   },
   {
     id: "conn-2",
-    providerKey: "google",
+    provider: "google",
     accountInfo: null,
     grantedScopes: [],
     status: "active",
@@ -37,28 +37,34 @@ mock.module("../oauth/oauth-store.js", () => ({
   getApp: mockGetApp,
   getAppClientSecret: mock(() => Promise.resolve(undefined)),
   getConnection: mock(() => undefined),
-  getProvider: mock((providerKey: string) =>
-    providerKey === "google"
+  getProvider: mock((provider: string) =>
+    provider === "google"
       ? {
-          providerKey: "google",
-          displayName: "Google",
+          provider: "google",
+          displayLabel: "Google",
           description: "Google OAuth provider",
           dashboardUrl: "https://console.cloud.google.com/apis/credentials",
+          logoUrl: null,
           clientIdPlaceholder: null,
           requiresClientSecret: 1,
           managedServiceConfigKey: "google-oauth",
-          authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
-          tokenUrl: "https://oauth2.googleapis.com/token",
-          tokenEndpointAuthMethod: null,
+          authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+          tokenExchangeUrl: "https://oauth2.googleapis.com/token",
+          refreshUrl: null,
+          tokenEndpointAuthMethod: "client_secret_post",
+          tokenExchangeBodyFormat: "form",
           userinfoUrl: null,
           baseUrl: null,
           defaultScopes: "[]",
           scopePolicy: "[]",
-          extraParams: null,
+          scopeSeparator: null,
+          authorizeParams: null,
           pingUrl: null,
           pingMethod: null,
           pingHeaders: null,
           pingBody: null,
+          revokeUrl: null,
+          revokeBodyTemplate: null,
           loopbackPort: null,
           injectionTemplates: null,
           appType: null,
@@ -80,7 +86,7 @@ mock.module("../oauth/oauth-store.js", () => ({
   upsertApp: mock(() =>
     Promise.resolve({
       id: "app-1",
-      providerKey: "google",
+      provider: "google",
       clientId: "client-1",
       createdAt: 1735689500000,
       updatedAt: 1735689550000,