@vellumai/assistant 0.6.6 → 0.7.0

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

@@ -53,16 +53,15 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
+const realEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...realEnv,
   isHttpAuthDisabled: () => true,
   hasUngatedHttpAuthDisabled: () => false,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
-  getGatewayPort: () => 7830,
   getRuntimeHttpPort: () => 7821,
   getRuntimeHttpHost: () => "127.0.0.1",
   getRuntimeGatewayOriginSecret: () => undefined,
-  getIngressPublicBaseUrl: () => undefined,
-  setIngressPublicBaseUrl: () => {},
 }));
 
 import {
@@ -70,6 +69,7 @@ import {
   DefaultPathResolver,
 } from "../runtime/migrations/vbundle-import-analyzer.js";
 import { handleMigrationImportPreflight } from "../runtime/routes/migration-routes.js";
+import { callHandler } from "./helpers/call-route-handler.js";
 
 // Test fixture data
 const EXISTING_DB_DATA = new Uint8Array([
@@ -285,7 +285,7 @@ describe("handleMigrationImportPreflight", () => {
       body: toArrayBuffer(vbundle),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportDryRunResponse;
 
     expect(res.status).toBe(200);
@@ -312,7 +312,7 @@ describe("handleMigrationImportPreflight", () => {
       body: toArrayBuffer(vbundle),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportDryRunResponse;
 
     expect(body.can_import).toBe(true);
@@ -343,7 +343,7 @@ describe("handleMigrationImportPreflight", () => {
       body: toArrayBuffer(vbundle),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportDryRunResponse;
 
     expect(body.can_import).toBe(true);
@@ -368,7 +368,7 @@ describe("handleMigrationImportPreflight", () => {
       body: toArrayBuffer(vbundle),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportDryRunResponse;
 
     expect(body.can_import).toBe(true);
@@ -389,7 +389,7 @@ describe("handleMigrationImportPreflight", () => {
       body: toArrayBuffer(vbundle),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportDryRunResponse;
 
     expect(body.manifest).toBeDefined();
@@ -408,7 +408,7 @@ describe("handleMigrationImportPreflight", () => {
       body: formData,
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportDryRunResponse;
 
     expect(res.status).toBe(200);
@@ -428,7 +428,7 @@ describe("handleMigrationImportPreflight — validation failures", () => {
       body: toArrayBuffer(new Uint8Array([0xde, 0xad, 0xbe, 0xef])),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportValidationFailureResponse;
 
     expect(res.status).toBe(200);
@@ -452,7 +452,7 @@ describe("handleMigrationImportPreflight — validation failures", () => {
       body: toArrayBuffer(vbundle),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as ImportValidationFailureResponse;
 
     expect(res.status).toBe(200);
@@ -467,7 +467,7 @@ describe("handleMigrationImportPreflight — validation failures", () => {
       body: toArrayBuffer(new Uint8Array(0)),
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as {
       error: { code: string; message: string };
     };
@@ -485,7 +485,7 @@ describe("handleMigrationImportPreflight — validation failures", () => {
       body: formData,
     });
 
-    const res = await handleMigrationImportPreflight(req);
+    const res = await callHandler(handleMigrationImportPreflight, req);
     const body = (await res.json()) as { error: { code: string } };
 
     expect(res.status).toBe(400);

package/src/__tests__/migration-jobs-status.test.ts

@@ -0,0 +1,164 @@
+/**
+ * HTTP-layer tests for GET /v1/migrations/jobs/:job_id.
+ *
+ * Covered:
+ * - 404 `{ error: { code: "job_not_found" } }` for an unknown id.
+ * - `processing` response shape for a job that is still running (runner
+ *   blocked on a deferred gate).
+ * - `complete` response shape including the runner's `result`.
+ * - `failed` response shape — confirms `error_code`, `error` message, and
+ *   the optional `upstream_status` field are all populated when the runner
+ *   throws a `kFetchBodyError`-tagged error with `upstreamStatus`.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+import { migrationJobs } from "../runtime/migrations/job-registry.js";
+import { NotFoundError } from "../runtime/routes/errors.js";
+import { handleMigrationJobStatus } from "../runtime/routes/migration-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+
+const kFetchBodyError = Symbol.for("vellum.migrationImport.fetchBodyError");
+
+/** Spin the microtask queue so `queueMicrotask`-scheduled work runs. */
+async function flushMicrotasks(n = 4): Promise<void> {
+  for (let i = 0; i < n; i++) {
+    await Promise.resolve();
+  }
+}
+
+function makeArgs(jobId: string): RouteHandlerArgs {
+  return { pathParams: { job_id: jobId } };
+}
+
+describe("GET /v1/migrations/jobs/:job_id", () => {
+  test("404 job_not_found for unknown id", async () => {
+    await expect(
+      handleMigrationJobStatus(
+        makeArgs("00000000-0000-0000-0000-000000000000"),
+      ),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("processing status while the runner is still running", async () => {
+    // Keep the runner blocked so the job stays in `running` state.
+    let release: () => void = () => {};
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+
+    const job = migrationJobs.startJob("export", async () => {
+      await gate;
+      return { ok: true };
+    });
+    // Let `queueMicrotask` flip status from `pending` to `running`.
+    await flushMicrotasks();
+
+    try {
+      const body = (await handleMigrationJobStatus(makeArgs(job.id))) as {
+        job_id: string;
+        type: string;
+        status: string;
+      };
+      expect(body.job_id).toBe(job.id);
+      expect(body.type).toBe("export");
+      expect(body.status).toBe("processing");
+    } finally {
+      release();
+      await flushMicrotasks();
+    }
+  });
+
+  test("complete status includes the runner's result", async () => {
+    const resultPayload = { files_written: 3, manifest: { schema: "vbundle/1" } };
+
+    const job = migrationJobs.startJob("export", async () => resultPayload);
+    await flushMicrotasks();
+
+    const body = (await handleMigrationJobStatus(makeArgs(job.id))) as {
+      job_id: string;
+      type: string;
+      status: string;
+      result: unknown;
+    };
+    expect(body.job_id).toBe(job.id);
+    expect(body.type).toBe("export");
+    expect(body.status).toBe("complete");
+    expect(body.result).toEqual(resultPayload);
+  });
+
+  test("failed status exposes error, error_code, and upstream_status", async () => {
+    const job = migrationJobs.startJob("import", async () => {
+      const err = new Error("upstream hung up") as Error & {
+        upstreamStatus?: number;
+      };
+      (err as unknown as Record<symbol, boolean>)[kFetchBodyError] = true;
+      err.upstreamStatus = 502;
+      throw err;
+    });
+    await flushMicrotasks();
+
+    const body = (await handleMigrationJobStatus(makeArgs(job.id))) as {
+      job_id: string;
+      type: string;
+      status: string;
+      error: string;
+      error_code: string;
+      upstream_status?: number;
+    };
+    expect(body.job_id).toBe(job.id);
+    expect(body.type).toBe("import");
+    expect(body.status).toBe("failed");
+    expect(body.error).toBe("upstream hung up");
+    expect(body.error_code).toBe("fetch_failed");
+    expect(body.upstream_status).toBe(502);
+  });
+
+  test("failed status omits upstream_status when the runner error has none", async () => {
+    const job = migrationJobs.startJob("export", async () => {
+      const err = new Error("invalid manifest") as Error & { code: string };
+      err.code = "invalid_manifest";
+      throw err;
+    });
+    await flushMicrotasks();
+
+    const body = (await handleMigrationJobStatus(
+      makeArgs(job.id),
+    )) as Record<string, unknown>;
+    expect(body.status).toBe("failed");
+    expect(body.error).toBe("invalid manifest");
+    expect(body.error_code).toBe("invalid_manifest");
+    expect(body.upstream_status).toBeUndefined();
+  });
+});

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

@@ -39,20 +39,21 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
+const realEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...realEnv,
   isHttpAuthDisabled: () => true,
   hasUngatedHttpAuthDisabled: () => false,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
-  getGatewayPort: () => 7830,
   getRuntimeHttpPort: () => 7821,
   getRuntimeHttpHost: () => "127.0.0.1",
   getRuntimeGatewayOriginSecret: () => undefined,
-  getIngressPublicBaseUrl: () => undefined,
-  setIngressPublicBaseUrl: () => {},
 }));
 
 import { validateVBundle } from "../runtime/migrations/vbundle-validator.js";
+import { BadRequestError } from "../runtime/routes/errors.js";
 import { handleMigrationValidate } from "../runtime/routes/migration-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 
 // ---------------------------------------------------------------------------
 // Tar archive builder helpers
@@ -477,57 +478,49 @@ describe("validateVBundle", () => {
 // HTTP route handler tests
 // ---------------------------------------------------------------------------
 
+/** Build RouteHandlerArgs from multipart FormData by serializing through a temp Request. */
+async function multipartArgs(formData: FormData): Promise<RouteHandlerArgs> {
+  const tmpReq = new Request("http://localhost", {
+    method: "POST",
+    body: formData,
+  });
+  // Read content-type BEFORE consuming the body — Bun clears headers after arrayBuffer().
+  const contentType = tmpReq.headers.get("content-type") ?? "";
+  const rawBody = new Uint8Array(await tmpReq.arrayBuffer());
+  return { rawBody, headers: { "content-type": contentType } };
+}
+
 describe("handleMigrationValidate", () => {
-  test("POST with valid vbundle returns 200 with is_valid: true", async () => {
+  test("POST with valid vbundle returns is_valid: true", async () => {
     const vbundle = createValidVBundle();
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: toArrayBuffer(vbundle),
-    });
+    const body = (await handleMigrationValidate({
+      rawBody: vbundle,
+      headers: { "content-type": "application/octet-stream" },
+    })) as Record<string, unknown>;
 
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as Record<string, unknown>;
-
-    expect(res.status).toBe(200);
     expect(body.is_valid).toBe(true);
     expect(body.errors).toEqual([]);
     expect(body.manifest).toBeDefined();
   });
 
-  test("POST with invalid gzip returns 200 with is_valid: false", async () => {
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: toArrayBuffer(new Uint8Array([0xde, 0xad, 0xbe, 0xef])),
-    });
-
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as {
-      is_valid: boolean;
-      errors: Array<{ code: string }>;
-    };
+  test("POST with invalid gzip returns is_valid: false", async () => {
+    const body = (await handleMigrationValidate({
+      rawBody: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),
+      headers: { "content-type": "application/octet-stream" },
+    })) as { is_valid: boolean; errors: Array<{ code: string }> };
 
-    expect(res.status).toBe(200);
     expect(body.is_valid).toBe(false);
     expect(body.errors.length).toBeGreaterThan(0);
     expect(body.errors[0].code).toBe("INVALID_GZIP");
   });
 
-  test("POST with empty body returns 400", async () => {
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: toArrayBuffer(new Uint8Array(0)),
-    });
-
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as {
-      error: { code: string; message: string };
-    };
-
-    expect(res.status).toBe(400);
-    expect(body.error.code).toBe("BAD_REQUEST");
+  test("POST with empty body throws BadRequestError", async () => {
+    await expect(
+      handleMigrationValidate({
+        rawBody: new Uint8Array(0),
+        headers: { "content-type": "application/octet-stream" },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
   });
 
   test("POST with multipart form data containing valid vbundle", async () => {
@@ -535,32 +528,20 @@ describe("handleMigrationValidate", () => {
     const formData = new FormData();
     formData.append("file", new Blob([toArrayBuffer(vbundle)]), "test.vbundle");
 
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      body: formData,
-    });
+    const body = (await handleMigrationValidate(
+      await multipartArgs(formData),
+    )) as Record<string, unknown>;
 
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as Record<string, unknown>;
-
-    expect(res.status).toBe(200);
     expect(body.is_valid).toBe(true);
   });
 
-  test("POST multipart without file field returns 400", async () => {
+  test("POST multipart without file field throws BadRequestError", async () => {
     const formData = new FormData();
     formData.append("notfile", "some text");
 
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      body: formData,
-    });
-
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as { error: { code: string } };
-
-    expect(res.status).toBe(400);
-    expect(body.error.code).toBe("BAD_REQUEST");
+    await expect(
+      handleMigrationValidate(await multipartArgs(formData)),
+    ).rejects.toBeInstanceOf(BadRequestError);
   });
 
   test("POST with missing manifest returns validation errors", async () => {
@@ -570,19 +551,11 @@ describe("handleMigrationValidate", () => {
     ]);
     const vbundle = gzipSync(tar);
 
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: toArrayBuffer(vbundle),
-    });
+    const body = (await handleMigrationValidate({
+      rawBody: vbundle,
+      headers: { "content-type": "application/octet-stream" },
+    })) as { is_valid: boolean; errors: Array<{ code: string; path?: string }> };
 
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as {
-      is_valid: boolean;
-      errors: Array<{ code: string; path?: string }>;
-    };
-
-    expect(res.status).toBe(200);
     expect(body.is_valid).toBe(false);
     expect(
       body.errors.some(
@@ -613,19 +586,11 @@ describe("handleMigrationValidate", () => {
     ]);
     const vbundle = gzipSync(tar);
 
-    const req = new Request("http://localhost/v1/migrations/validate", {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: toArrayBuffer(vbundle),
-    });
+    const body = (await handleMigrationValidate({
+      rawBody: vbundle,
+      headers: { "content-type": "application/octet-stream" },
+    })) as { is_valid: boolean; errors: Array<{ code: string }> };
 
-    const res = await handleMigrationValidate(req);
-    const body = (await res.json()) as {
-      is_valid: boolean;
-      errors: Array<{ code: string }>;
-    };
-
-    expect(res.status).toBe(200);
     expect(body.is_valid).toBe(false);
     expect(
       body.errors.some((e) => e.code === "MANIFEST_CHECKSUM_MISMATCH"),

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

@@ -1,5 +1,6 @@
 /**
- * Global test utility for mocking gateway IPC calls via `node:net`.
+ * Global test utility for mocking gateway IPC calls via
+ * `@vellumai/gateway-client/ipc-client`.
  *
  * Usage:
  *   import { mockGatewayIpc, resetMockGatewayIpc } from "../__tests__/mock-gateway-ipc.js";
@@ -23,10 +24,10 @@
  * 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.
+ * Mocks `@vellumai/gateway-client/ipc-client` at the package level so the
+ * assistant's thin wrapper in `ipc/gateway-client.ts` (which delegates to
+ * the package) gets the fake implementation. Non-gateway IPC paths (e.g.
+ * CLI IPC) are unaffected since they don't import from the package.
  */
 
 import { EventEmitter } from "node:events";
@@ -39,36 +40,27 @@ import { mock } from "bun:test";
 /** 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. */
+/** Whether the fake ipcCall 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
+// FakePersistentIpcClient — mirrors PersistentIpcClient API
 // ---------------------------------------------------------------------------
 
-class FakeSocket extends EventEmitter {
-  unref() {
-    /* no-op */
+class FakePersistentIpcClient extends EventEmitter {
+  async call(
+    method: string,
+    _params?: Record<string, unknown>,
+  ): Promise<unknown> {
+    if (simulateError) {
+      throw new Error("Mock IPC socket error");
+    }
+    return method in ipcResults ? ipcResults[method] : undefined;
   }
-  destroy() {
+
+  destroy(): void {
     /* 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
-    }
-  }
 }
 
 // ---------------------------------------------------------------------------
@@ -76,39 +68,19 @@ class FakeSocket extends EventEmitter {
 // ---------------------------------------------------------------------------
 
 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;
+  mock.module("@vellumai/gateway-client/ipc-client", () => ({
+    ipcCall: async (
+      _socketPath: string,
+      method: string,
+      _params?: Record<string, unknown>,
+    ): Promise<unknown> => {
+      if (simulateError) {
+        // Real ipcCall returns undefined on failure — mirror that behavior.
+        return undefined;
       }
-      return realConnect(...(args as Parameters<typeof realConnect>));
+      return method in ipcResults ? ipcResults[method] : undefined;
     },
+    PersistentIpcClient: FakePersistentIpcClient,
   }));
 }
 
@@ -122,8 +94,8 @@ export function installGatewayIpcMock(): void {
  * @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
+ * @param opts.code — error code (kept for API compat, unused by package mock)
+ * @param opts.results — raw method->result map for arbitrary IPC methods
  */
 export function mockGatewayIpc(
   flags?: Record<string, boolean> | null,
@@ -137,7 +109,6 @@ export function mockGatewayIpc(
   }
   if (opts?.error) {
     simulateError = true;
-    simulateErrorCode = opts.code ?? "ENOENT";
   }
 }
 
@@ -147,5 +118,4 @@ export function mockGatewayIpc(
 export function resetMockGatewayIpc(): void {
   ipcResults = {};
   simulateError = false;
-  simulateErrorCode = "ENOENT";
 }

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

@@ -28,14 +28,27 @@ describe("model intents", () => {
     expect(resolveModelIntent("openai", "latency-optimized")).toBe(
       "gpt-5.4-nano",
     );
+    expect(resolveModelIntent("gemini", "latency-optimized")).toBe(
+      "gemini-3.1-flash-lite-preview",
+    );
+    expect(resolveModelIntent("gemini", "quality-optimized")).toBe(
+      "gemini-3.1-pro-preview",
+    );
+    expect(resolveModelIntent("gemini", "vision-optimized")).toBe(
+      "gemini-3-flash-preview",
+    );
+  });
+
+  test("uses GPT-5.5 as the OpenAI provider default", () => {
+    expect(getProviderDefaultModel("openai")).toBe("gpt-5.5");
   });
 
   test("falls back to provider default for unknown providers", () => {
     expect(getProviderDefaultModel("unknown-provider")).toBe(
-      "claude-sonnet-4-6",
+      "claude-opus-4-7",
     );
     expect(resolveModelIntent("unknown-provider", "quality-optimized")).toBe(
-      "claude-sonnet-4-6",
+      "claude-opus-4-7",
     );
   });
 });