@vellumai/assistant 0.5.13 → 0.5.14

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

@@ -0,0 +1,257 @@
+import { describe, expect, mock, test } from "bun:test";
+
+const mockListProviders = mock(() => [
+  {
+    providerKey: "google",
+    displayName: "Google",
+    description: "Google OAuth provider",
+    dashboardUrl: "https://console.cloud.google.com/apis/credentials",
+    clientIdPlaceholder: null,
+    requiresClientSecret: 1,
+    managedServiceConfigKey: "google-oauth",
+    authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+    tokenUrl: "https://oauth2.googleapis.com/token",
+    tokenEndpointAuthMethod: null,
+    userinfoUrl: null,
+    baseUrl: null,
+    defaultScopes: "[]",
+    scopePolicy: "[]",
+    extraParams: null,
+    callbackTransport: null,
+    pingUrl: null,
+    pingMethod: null,
+    pingHeaders: null,
+    pingBody: null,
+    loopbackPort: null,
+    injectionTemplates: null,
+    appType: null,
+    setupNotes: null,
+    identityUrl: null,
+    identityMethod: null,
+    identityHeaders: null,
+    identityBody: null,
+    identityFormat: null,
+    identityOkField: null,
+    identityResponsePaths: null,
+    createdAt: 1735689500000,
+    updatedAt: 1735689550000,
+  },
+  {
+    providerKey: "github",
+    displayName: "GitHub",
+    description: "GitHub OAuth provider",
+    dashboardUrl: "https://github.com/settings/developers",
+    clientIdPlaceholder: null,
+    requiresClientSecret: 1,
+    managedServiceConfigKey: null,
+    authUrl: "https://github.com/login/oauth/authorize",
+    tokenUrl: "https://github.com/login/oauth/access_token",
+    tokenEndpointAuthMethod: null,
+    userinfoUrl: null,
+    baseUrl: null,
+    defaultScopes: "[]",
+    scopePolicy: "[]",
+    extraParams: null,
+    callbackTransport: null,
+    pingUrl: null,
+    pingMethod: null,
+    pingHeaders: null,
+    pingBody: null,
+    loopbackPort: null,
+    injectionTemplates: null,
+    appType: null,
+    setupNotes: null,
+    identityUrl: null,
+    identityMethod: null,
+    identityHeaders: null,
+    identityBody: null,
+    identityFormat: null,
+    identityOkField: null,
+    identityResponsePaths: null,
+    createdAt: 1735689600000,
+    updatedAt: 1735689650000,
+  },
+]);
+
+const mockGetProvider = mock((providerKey: string) => {
+  const all = mockListProviders();
+  return all.find((p) => p.providerKey === providerKey) ?? undefined;
+});
+
+mock.module("../oauth/oauth-store.js", () => ({
+  listProviders: mockListProviders,
+  getProvider: mockGetProvider,
+}));
+
+import { oauthProvidersRouteDefinitions } from "../runtime/routes/oauth-providers.js";
+
+const routes = oauthProvidersRouteDefinitions();
+
+function getRoute(method: string, endpoint: string) {
+  const route = routes.find(
+    (r) => r.method === method && r.endpoint === endpoint,
+  );
+  if (!route) throw new Error(`Route not found: ${method} ${endpoint}`);
+  return route;
+}
+
+describe("GET /v1/oauth/providers", () => {
+  test("returns all providers with correct summary shape", async () => {
+    const req = new Request("http://localhost/v1/oauth/providers");
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/providers").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: {},
+    });
+
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      providers: Array<{
+        provider_key: string;
+        display_name: string | null;
+        description: string | null;
+        dashboard_url: string | null;
+        client_id_placeholder: string | null;
+        requires_client_secret: boolean;
+        supports_managed_mode: boolean;
+      }>;
+    };
+
+    expect(body.providers).toHaveLength(2);
+    expect(body.providers[0]!.provider_key).toBe("google");
+    expect(body.providers[1]!.provider_key).toBe("github");
+  });
+
+  test("response shape matches serializeProviderSummary output (snake_case keys)", async () => {
+    const req = new Request("http://localhost/v1/oauth/providers");
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/providers").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: {},
+    });
+
+    const body = (await res.json()) as {
+      providers: Array<Record<string, unknown>>;
+    };
+
+    const expectedKeys = [
+      "provider_key",
+      "display_name",
+      "description",
+      "dashboard_url",
+      "client_id_placeholder",
+      "requires_client_secret",
+      "supports_managed_mode",
+    ];
+
+    for (const provider of body.providers) {
+      expect(Object.keys(provider).sort()).toEqual(expectedKeys.sort());
+    }
+  });
+
+  test("supports_managed_mode=true returns only managed providers", async () => {
+    const req = new Request(
+      "http://localhost/v1/oauth/providers?supports_managed_mode=true",
+    );
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/providers").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: {},
+    });
+
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      providers: Array<{
+        provider_key: string;
+        supports_managed_mode: boolean;
+      }>;
+    };
+
+    expect(body.providers).toHaveLength(1);
+    expect(body.providers[0]!.provider_key).toBe("google");
+    expect(body.providers[0]!.supports_managed_mode).toBe(true);
+  });
+
+  test("supports_managed_mode=false returns only non-managed providers", async () => {
+    const req = new Request(
+      "http://localhost/v1/oauth/providers?supports_managed_mode=false",
+    );
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/providers").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: {},
+    });
+
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      providers: Array<{
+        provider_key: string;
+        supports_managed_mode: boolean;
+      }>;
+    };
+
+    expect(body.providers).toHaveLength(1);
+    expect(body.providers[0]!.provider_key).toBe("github");
+    expect(body.providers[0]!.supports_managed_mode).toBe(false);
+  });
+});
+
+describe("GET /v1/oauth/providers/:providerKey", () => {
+  test("returns the correct provider", async () => {
+    const req = new Request("http://localhost/v1/oauth/providers/google");
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/providers/:providerKey").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { providerKey: "google" },
+    });
+
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      provider: {
+        provider_key: string;
+        display_name: string | null;
+        description: string | null;
+        dashboard_url: string | null;
+        client_id_placeholder: string | null;
+        requires_client_secret: boolean;
+        supports_managed_mode: boolean;
+      };
+    };
+
+    expect(body.provider.provider_key).toBe("google");
+    expect(body.provider.display_name).toBe("Google");
+    expect(body.provider.supports_managed_mode).toBe(true);
+    expect(body.provider.requires_client_secret).toBe(true);
+  });
+
+  test("returns 404 for unknown provider", async () => {
+    const req = new Request("http://localhost/v1/oauth/providers/nonexistent");
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/providers/:providerKey").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { providerKey: "nonexistent" },
+    });
+
+    expect(res.status).toBe(404);
+    const body = (await res.json()) as { error: { code: string } };
+    expect(body.error.code).toBe("NOT_FOUND");
+  });
+});

package/src/__tests__/oauth-store.test.ts

@@ -1,21 +1,5 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "oauth-store-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => ":memory:",
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -94,11 +78,6 @@ beforeEach(() => {
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    // best-effort cleanup
-  }
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/onboarding-template-contract.test.ts

@@ -27,9 +27,9 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("vibe");
     });
 
-    test("contains emoji auto-selection with change-later instruction", () => {
+    test("contains name selection with change-later instruction", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("emoji");
+      expect(lower).toContain("what do you want to call me");
       expect(lower).toContain("change it later");
     });
 

package/src/__tests__/openai-provider.test.ts

@@ -1,9 +1,13 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { RetryProvider } from "../providers/retry.js";
 import type {
   ContentBlock,
   Message,
+  Provider,
   ProviderEvent,
+  ProviderResponse,
+  SendMessageOptions,
   ToolDefinition,
 } from "../providers/types.js";
 
@@ -28,6 +32,9 @@ interface FakeChunk {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    completion_tokens_details?: {
+      reasoning_tokens?: number;
+    };
   } | null;
   model: string;
 }
@@ -154,6 +161,25 @@ function usageChunk(prompt: number, completion: number): FakeChunk {
   };
 }
 
+function reasoningUsageChunk(
+  prompt: number,
+  completion: number,
+  reasoning: number,
+): FakeChunk {
+  return {
+    choices: [{ delta: {}, finish_reason: "stop" }],
+    usage: {
+      prompt_tokens: prompt,
+      completion_tokens: completion,
+      total_tokens: prompt + completion,
+      completion_tokens_details: {
+        reasoning_tokens: reasoning,
+      },
+    },
+    model: "gpt-5.2",
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -807,6 +833,47 @@ describe("OpenAIProvider", () => {
     expect(result.content[0].type).toBe("tool_use");
   });
 
+  // -----------------------------------------------------------------------
+  // Reasoning tokens
+  // -----------------------------------------------------------------------
+  test("includes reasoningTokens in usage when present in completion_tokens_details", async () => {
+    fakeChunks = [
+      textChunk("Reasoning result"),
+      reasoningUsageChunk(50, 120, 80),
+    ];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Think carefully" }] },
+    ]);
+
+    expect(result.usage).toEqual({
+      inputTokens: 50,
+      outputTokens: 120,
+      reasoningTokens: 80,
+    });
+
+    // Also check rawResponse diagnostics include reasoning tokens
+    const rawUsage = (result.rawResponse as any).usage;
+    expect(rawUsage.completion_tokens_details).toEqual({
+      reasoning_tokens: 80,
+    });
+  });
+
+  test("omits reasoningTokens from usage when not present", async () => {
+    fakeChunks = [textChunk("Simple reply"), usageChunk(10, 5)];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    expect(result.usage).toEqual({ inputTokens: 10, outputTokens: 5 });
+    expect(result.usage).not.toHaveProperty("reasoningTokens");
+
+    // rawResponse should not include completion_tokens_details
+    const rawUsage = (result.rawResponse as any).usage;
+    expect(rawUsage).not.toHaveProperty("completion_tokens_details");
+  });
+
   // -----------------------------------------------------------------------
   // Assistant message with text preserves content
   // -----------------------------------------------------------------------
@@ -926,3 +993,197 @@ describe("custom baseURL initialization", () => {
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Effort config passthrough via RetryProvider
+// ---------------------------------------------------------------------------
+
+describe("effort config passthrough", () => {
+  const DUMMY_MESSAGES: Message[] = [
+    { role: "user", content: [{ type: "text", text: "hello" }] },
+  ];
+
+  function makeResponse(): ProviderResponse {
+    return {
+      content: [{ type: "text", text: "ok" }],
+      model: "gpt-5.4-mini",
+      usage: { inputTokens: 1, outputTokens: 1 },
+      stopReason: "end_turn",
+    };
+  }
+
+  function makeProvider(
+    name: string,
+    onCall: (options: SendMessageOptions | undefined) => void,
+  ): Provider {
+    return {
+      name,
+      async sendMessage(_messages, _tools, _systemPrompt, options) {
+        onCall(options);
+        return makeResponse();
+      },
+    };
+  }
+
+  test("effort is preserved when passed to an OpenAI provider", async () => {
+    let capturedOptions: SendMessageOptions | undefined;
+    const inner = makeProvider("openai", (opts) => {
+      capturedOptions = opts;
+    });
+    const retry = new RetryProvider(inner);
+
+    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { effort: "high" },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.effort).toBe("high");
+  });
+
+  test("effort is stripped for unsupported providers (e.g. ollama)", async () => {
+    let capturedOptions: SendMessageOptions | undefined;
+    const inner = makeProvider("ollama", (opts) => {
+      capturedOptions = opts;
+    });
+    const retry = new RetryProvider(inner);
+
+    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { effort: "medium" },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.effort).toBeUndefined();
+  });
+
+  test("effort is preserved for fireworks provider", async () => {
+    let capturedOptions: SendMessageOptions | undefined;
+    const inner = makeProvider("fireworks", (opts) => {
+      capturedOptions = opts;
+    });
+    const retry = new RetryProvider(inner);
+
+    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { effort: "low" },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.effort).toBe("low");
+  });
+
+  test("effort is preserved for openrouter provider", async () => {
+    let capturedOptions: SendMessageOptions | undefined;
+    const inner = makeProvider("openrouter", (opts) => {
+      capturedOptions = opts;
+    });
+    const retry = new RetryProvider(inner);
+
+    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { effort: "high" },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.effort).toBe("high");
+  });
+
+  test("effort is preserved for anthropic provider", async () => {
+    let capturedOptions: SendMessageOptions | undefined;
+    const inner = makeProvider("anthropic", (opts) => {
+      capturedOptions = opts;
+    });
+    const retry = new RetryProvider(inner);
+
+    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { effort: "high" },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.effort).toBe("high");
+  });
+
+  test("thinking is still stripped for OpenAI provider", async () => {
+    let capturedOptions: SendMessageOptions | undefined;
+    const inner = makeProvider("openai", (opts) => {
+      capturedOptions = opts;
+    });
+    const retry = new RetryProvider(inner);
+
+    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: {
+        thinking: { enabled: true, budgetTokens: 10000 },
+        effort: "high",
+      },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.thinking).toBeUndefined();
+    expect(config.effort).toBe("high");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reasoning effort → OpenAI reasoning_effort mapping
+// ---------------------------------------------------------------------------
+
+describe("OpenAIProvider reasoning_effort", () => {
+  let provider: OpenAIProvider;
+
+  function userMsg(text: string): Message {
+    return { role: "user", content: [{ type: "text", text }] };
+  }
+
+  beforeEach(() => {
+    fakeChunks = [textChunk("OK"), usageChunk(10, 2)];
+    lastCreateParams = null;
+    lastCreateOptions = null;
+    lastConstructorOptions = null;
+    shouldThrow = null;
+    provider = new OpenAIProvider("test-key", "gpt-5");
+  });
+
+  test('effort: "low" maps to reasoning_effort: "low"', async () => {
+    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "low" },
+    });
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning_effort).toBe("low");
+  });
+
+  test('effort: "medium" maps to reasoning_effort: "medium"', async () => {
+    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "medium" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("medium");
+  });
+
+  test('effort: "high" maps to reasoning_effort: "high"', async () => {
+    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "high" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test('effort: "max" maps to reasoning_effort: "high"', async () => {
+    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test("no effort config means no reasoning_effort in params", async () => {
+    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+      config: {},
+    });
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning_effort).toBeUndefined();
+  });
+
+  test("extraCreateParams reasoning_effort is not clobbered when no effort is set", async () => {
+    const providerWithExtra = new OpenAIProvider("test-key", "gpt-5", {
+      extraCreateParams: { reasoning_effort: "medium" },
+    });
+    await providerWithExtra.sendMessage([userMsg("hi")], undefined, "system", {
+      config: {},
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("medium");
+  });
+});

package/src/__tests__/pairing-concurrent.test.ts

@@ -39,21 +39,21 @@ function buildRegisterParams() {
 describe("PairingStore.register — concurrent pairing guard", () => {
   let store: PairingStore;
   let tmpBase: string;
-  let origBaseDataDir: string | undefined;
+  let origWorkspaceDir: string | undefined;
 
   beforeAll(() => {
     // Isolate disk writes to a temp directory so this test does not
     // pollute ~/.vellum or interfere with other test files.
     tmpBase = mkdtempSync(join(tmpdir(), "pairing-test-"));
-    origBaseDataDir = process.env.BASE_DATA_DIR;
-    process.env.BASE_DATA_DIR = tmpBase;
+    origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = tmpBase;
   });
 
   afterAll(() => {
-    if (origBaseDataDir === undefined) {
-      delete process.env.BASE_DATA_DIR;
+    if (origWorkspaceDir === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
     } else {
-      process.env.BASE_DATA_DIR = origBaseDataDir;
+      process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
     }
     rmSync(tmpBase, { recursive: true, force: true });
   });

package/src/__tests__/pairing-routes.test.ts

@@ -8,6 +8,13 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
 import { PairingStore } from "../daemon/pairing-store.js";
 import type { PairingHandlerContext } from "../runtime/routes/pairing-routes.js";
 import { handlePairingRequest } from "../runtime/routes/pairing-routes.js";
@@ -22,7 +29,6 @@ function makeContext(store: PairingStore): PairingHandlerContext {
   return {
     pairingStore: store,
     bearerToken: "test-bearer-token",
-    featureFlagToken: undefined,
     pairingBroadcast: mock(() => {}),
   };
 }

package/src/__tests__/path-policy.test.ts

@@ -29,7 +29,7 @@ const MOCK_BUNDLED_DIR = join(CLASSIFIER_TEST_ROOT, "bundled-skills");
 
 mock.module("../util/platform.js", () => ({
   getWorkspaceSkillsDir: () => MOCK_MANAGED_DIR,
-  getRootDir: () => CLASSIFIER_TEST_ROOT,
+  getProtectedDir: () => join(CLASSIFIER_TEST_ROOT, "protected"),
   getWorkspaceDir: () => join(CLASSIFIER_TEST_ROOT, "workspace"),
   getDataDir: () => join(CLASSIFIER_TEST_ROOT, "data"),
   isMacOS: () => process.platform === "darwin",