@vellumai/assistant 0.6.2 → 0.6.4

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

@@ -9,7 +9,6 @@ const bootstrapRef = readFileSync(
   "utf-8",
 );
 const identity = readFileSync(join(templatesDir, "IDENTITY.md"), "utf-8");
-const user = readFileSync(join(templatesDir, "USER.md"), "utf-8");
 
 describe("onboarding template contracts", () => {
   describe("BOOTSTRAP.md", () => {
@@ -19,48 +18,17 @@ describe("onboarding template contracts", () => {
 
     test("contains identity discovery prompts", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("your name");
-      expect(lower).toContain("personality");
+      expect(lower).toContain("identity");
+      expect(lower).toContain("infer");
     });
 
-    test("leads with personality-first emotional arc", () => {
-      const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("personality");
-      expect(lower).toContain("vibe");
-      // Personality arc should come before usefulness arc
-      const personalityIdx = lower.indexOf("oh, this has personality");
-      const usefulIdx = lower.indexOf("oh, this is useful");
-      expect(personalityIdx).toBeGreaterThan(-1);
-      expect(usefulIdx).toBeGreaterThan(-1);
-      expect(personalityIdx).toBeLessThan(usefulIdx);
-    });
-
-    test("contains name selection with change-later instruction", () => {
-      const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("what they want to call you");
-      expect(lower).toContain("change it later");
-    });
-
-    test("name exchange happens before personality quiz", () => {
-      const nameIdx = bootstrap.indexOf("Step 1: Name Exchange");
-      const quizIdx = bootstrap.indexOf("Step 2: Personality Quiz");
-      expect(nameIdx).toBeGreaterThan(-1);
-      expect(quizIdx).toBeGreaterThan(-1);
-      expect(nameIdx).toBeLessThan(quizIdx);
-    });
-
-    test("gathers user context: work role, hobbies, daily tools", () => {
+    test("gathers user context", () => {
       const lower = bootstrap.toLowerCase();
       expect(lower).toContain("work role");
-      expect(lower).toContain("hobbies");
+      expect(lower).toContain("goals");
       expect(lower).toContain("tools");
     });
 
-    test("references ui_show payloads from BOOTSTRAP-REFERENCE.md", () => {
-      expect(bootstrap).toContain("ui_show");
-      expect(bootstrap).toContain("BOOTSTRAP-REFERENCE.md");
-    });
-
     test("contains wrapping-up criteria with deletion instructions", () => {
       const lower = bootstrap.toLowerCase();
       expect(lower).toContain("wrapping up");
@@ -70,27 +38,25 @@ describe("onboarding template contracts", () => {
 
     test("contains refusal policy", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("hard-required");
-      expect(lower).toContain("best-effort");
       expect(lower).toContain("declined");
-      expect(lower).toContain("not interrogation");
+      expect(lower).toContain("constraints");
     });
 
-    test("defines resolved as provided, inferred, or declined", () => {
+    test("defines field states as inferred or declined", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("resolved");
       expect(lower).toContain("inferred");
       expect(lower).toContain("declined");
     });
 
-    test("instructs saving to IDENTITY.md, USER.md, and SOUL.md via file_edit", () => {
+    test("instructs saving to IDENTITY.md, SOUL.md, and user persona file via file_edit", () => {
       expect(bootstrap).toContain("IDENTITY.md");
-      expect(bootstrap).toContain("USER.md");
       expect(bootstrap).toContain("SOUL.md");
+      expect(bootstrap).toContain("{{USER_PERSONA_FILE}}");
       expect(bootstrap).toContain("file_edit");
     });
 
     test("includes budget constraint", () => {
+      expect(bootstrap).toContain("$2");
       expect(bootstrap).toContain("$5");
     });
 
@@ -98,30 +64,73 @@ describe("onboarding template contracts", () => {
       expect(bootstrap).toContain("new colleague");
     });
 
-    test("instructs checking Connected Services for email task variant", () => {
-      expect(bootstrap).toContain("Connected Services");
-      expect(bootstrap).toContain("Connect my email");
-      expect(bootstrap).toContain("Check my email");
+    test("contains numbered goals", () => {
+      const lower = bootstrap.toLowerCase();
+      expect(lower).toContain("establish mutual identity");
+      expect(lower).toContain("prove value fast");
+      expect(lower).toContain("infer, don't interrogate");
+      expect(lower).toContain("surface what you learned");
+      expect(lower).toContain("offer the next level");
+      expect(lower).toContain("write everything immediately");
+      expect(lower).toContain("clean up");
+    });
+
+    test("contains constraints section", () => {
+      expect(bootstrap).toContain("## Constraints");
+      expect(bootstrap).toContain("$2");
+      expect(bootstrap).toContain("2 questions");
+      expect(bootstrap.toLowerCase()).toContain("don't block on setup");
+      expect(bootstrap).toContain("One-shot");
     });
 
-    test("keeps momentum by chaining off the first task", () => {
+    test("contains 'what you own' section", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("keep the momentum");
-      expect(lower).toContain("don't pivot to setup");
-      expect(lower).toContain("chain off the task");
-      expect(lower).toContain("while we're at it");
+      expect(lower).toContain("sequencing");
+      expect(lower).toContain("pacing");
     });
-  });
 
-  describe("BOOTSTRAP-REFERENCE.md", () => {
-    test("contains personality form with 4 dropdowns", () => {
-      expect(bootstrapRef).toContain('surface_type: "form"');
-      expect(bootstrapRef).toContain("communication_style");
-      expect(bootstrapRef).toContain("task_style");
-      expect(bootstrapRef).toContain("humor");
-      expect(bootstrapRef).toContain("depth");
+    test("contains technical contract", () => {
+      expect(bootstrap).toContain("Technical Contract");
+      expect(bootstrap).toContain("prescribed");
     });
 
+    test("contains capability unlock pattern", () => {
+      const lower = bootstrap.toLowerCase();
+      expect(lower).toContain("email");
+      expect(lower).toContain("voice");
+      expect(lower).toContain("slack");
+    });
+
+    test("contains tone guidance", () => {
+      expect(bootstrap).toContain("Not servile");
+      expect(bootstrap.toLowerCase()).toContain("match");
+      expect(bootstrap.toLowerCase()).toContain("energy");
+    });
+
+    test("contains pre-chat onboarding context section", () => {
+      const lower = bootstrap.toLowerCase();
+      expect(lower).toContain("onboarding");
+      expect(lower).toContain("json");
+      expect(lower).toContain("context");
+    });
+
+    test("does not contain personality quiz references", () => {
+      // BOOTSTRAP.md says "No personality quiz" as part of goal 3,
+      // but should NOT contain instructions TO USE or SHOW a personality quiz
+      expect(bootstrap).not.toMatch(/show.*personality quiz/i);
+      expect(bootstrap).not.toMatch(/present.*personality quiz/i);
+      // "dropdown" only appears in "No dropdown forms" — that's a prohibition, not an instruction
+      expect(bootstrap).not.toMatch(/show.*dropdown/i);
+    });
+
+    test("does not contain rigid step sequence", () => {
+      expect(bootstrap).not.toMatch(/Step 1:/);
+      expect(bootstrap).not.toMatch(/Step 2:/);
+      expect(bootstrap).not.toMatch(/Step 3:/);
+    });
+  });
+
+  describe("BOOTSTRAP-REFERENCE.md", () => {
     test("contains email-not-connected task card variant", () => {
       expect(bootstrapRef).toContain("Email Not Connected");
       expect(bootstrapRef).toContain("Connect my email");
@@ -132,6 +141,14 @@ describe("onboarding template contracts", () => {
       expect(bootstrapRef).toContain("Email Already Connected");
       expect(bootstrapRef).toContain("Check my email");
     });
+
+    test("does not contain personality form", () => {
+      expect(bootstrapRef).not.toContain('surface_type: "form"');
+      expect(bootstrapRef).not.toContain("communication_style");
+      expect(bootstrapRef).not.toContain("task_style");
+      expect(bootstrapRef).not.toContain("humor");
+      expect(bootstrapRef).not.toContain("depth");
+    });
   });
 
   describe("IDENTITY.md", () => {
@@ -147,14 +164,8 @@ describe("onboarding template contracts", () => {
     });
   });
 
-  describe("USER.md", () => {
-    test("contains profile fields", () => {
-      expect(user).toContain("Preferred name/reference:");
-      expect(user).toContain("Goals:");
-      expect(user).toContain("Locale:");
-      expect(user).toContain("Work role:");
-      expect(user).toContain("Hobbies/fun:");
-      expect(user).toContain("Daily tools:");
-    });
-  });
+  // Legacy `templates/USER.md` was removed by workspace migration
+  // `031-drop-user-md`. Guardian persona content is now seeded via
+  // `GUARDIAN_PERSONA_TEMPLATE` in `prompts/persona-resolver.ts` and
+  // lives on disk at `users/<slug>.md`.
 });

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

@@ -10,6 +10,8 @@ import type {
   SendMessageOptions,
   ToolDefinition,
 } from "../providers/types.js";
+import { createAbortReason } from "../util/abort-reasons.js";
+import { ProviderError } from "../util/errors.js";
 
 // ---------------------------------------------------------------------------
 // Mock openai module — must be before importing the provider
@@ -87,6 +89,7 @@ mock.module("openai", () => ({
 // Import after mocking
 import { FireworksProvider } from "../providers/fireworks/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
+import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
 import { OpenRouterProvider } from "../providers/openrouter/client.js";
 
@@ -180,6 +183,32 @@ function reasoningUsageChunk(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Class extraction sanity checks
+// ---------------------------------------------------------------------------
+
+describe("OpenAIChatCompletionsProvider extraction", () => {
+  test("OpenAIProvider is an alias for OpenAIChatCompletionsProvider", () => {
+    expect(OpenAIProvider).toBe(OpenAIChatCompletionsProvider);
+  });
+
+  test("compatibility providers extend OpenAIChatCompletionsProvider", () => {
+    lastConstructorOptions = null;
+
+    const or = new OpenRouterProvider("or-key", "openai/gpt-4o");
+    expect(or).toBeInstanceOf(OpenAIChatCompletionsProvider);
+
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/llama-v3p1-70b-instruct",
+    );
+    expect(fw).toBeInstanceOf(OpenAIChatCompletionsProvider);
+
+    const ol = new OllamaProvider("llama3.2");
+    expect(ol).toBeInstanceOf(OpenAIChatCompletionsProvider);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -653,10 +682,10 @@ describe("OpenAIProvider", () => {
       [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
       undefined,
       undefined,
-      { config: { max_tokens: 32000 } },
+      { config: { max_tokens: 64000 } },
     );
 
-    expect(lastCreateParams!.max_completion_tokens).toBe(32000);
+    expect(lastCreateParams!.max_completion_tokens).toBe(64000);
   });
 
   // -----------------------------------------------------------------------
@@ -760,6 +789,68 @@ describe("OpenAIProvider", () => {
     }
   });
 
+  // -----------------------------------------------------------------------
+  // Tagged AbortReason propagation
+  // -----------------------------------------------------------------------
+  test("attaches tagged abortReason to ProviderError wrapping an APIError when signal is aborted with a reason", async () => {
+    shouldThrow = new FakeAPIError(0, "Request was aborted.");
+    const controller = new AbortController();
+    const reason = createAbortReason("user_cancel", "test:openai");
+    controller.abort(reason);
+
+    try {
+      await provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+        undefined,
+        undefined,
+        { signal: controller.signal },
+      );
+      expect(true).toBe(false); // should not reach
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).abortReason).toBe(reason);
+    }
+  });
+
+  test("attaches tagged abortReason to ProviderError wrapping a generic error on abort", async () => {
+    shouldThrow = new Error("socket hang up");
+    const controller = new AbortController();
+    const reason = createAbortReason("preempted_by_new_message", "test:openai");
+    controller.abort(reason);
+
+    try {
+      await provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+        undefined,
+        undefined,
+        { signal: controller.signal },
+      );
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).abortReason).toBe(reason);
+    }
+  });
+
+  test("does not attach abortReason when the signal was aborted with a non-tagged reason", async () => {
+    shouldThrow = new FakeAPIError(0, "Request was aborted.");
+    const controller = new AbortController();
+    controller.abort(new Error("plain abort"));
+
+    try {
+      await provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+        undefined,
+        undefined,
+        { signal: controller.signal },
+      );
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).abortReason).toBeUndefined();
+    }
+  });
+
   // -----------------------------------------------------------------------
   // Malformed tool call JSON
   // -----------------------------------------------------------------------
@@ -1118,6 +1209,91 @@ describe("effort config passthrough", () => {
     expect(config.thinking).toBeUndefined();
     expect(config.effort).toBe("high");
   });
+
+  test("thinking 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: {
+        thinking: { type: "adaptive" },
+      },
+    });
+
+    const config = capturedOptions?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "adaptive" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// OpenRouter reasoning ↔ thinking.enabled config
+// ---------------------------------------------------------------------------
+
+describe("OpenRouterProvider reasoning", () => {
+  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;
+  });
+
+  test("sends reasoning.enabled=true when thinking config is present", async () => {
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: { thinking: { type: "adaptive" } },
+    });
+
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning).toEqual({ enabled: true });
+  });
+
+  test("sends reasoning.enabled=false when thinking config is absent", async () => {
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: {},
+    });
+
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+  });
+
+  test("sends reasoning.enabled=false when no options are provided", async () => {
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+  });
+
+  test("RetryProvider + OpenRouterProvider enables thinking end-to-end", async () => {
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    const retry = new RetryProvider(provider);
+
+    // thinking enabled at loop-level → config.thinking set
+    await retry.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: { thinking: { type: "adaptive" } },
+    });
+    expect(lastCreateParams!.reasoning).toEqual({ enabled: true });
+  });
+
+  test("RetryProvider + OpenRouterProvider disables thinking end-to-end", async () => {
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    const retry = new RetryProvider(provider);
+
+    // thinking disabled at loop-level → config.thinking omitted
+    await retry.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: {},
+    });
+    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/openai-responses-cutover-guard.test.ts

@@ -0,0 +1,184 @@
+import { execSync } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * Guard test: prevent accidental reintroduction of OpenAI Chat Completions
+ * calls in the OpenAI provider path.
+ *
+ * OpenAI inference uses the Responses API (`client.responses.stream()`).
+ * The chat-completions transport (`chat.completions.create()`) is reserved
+ * for OpenAI-compatible providers (OpenRouter, Fireworks, Ollama).
+ *
+ * These guards fail CI if:
+ * 1. The Responses provider file contains `chat.completions.create(` calls.
+ * 2. The provider registry wires `openai` to anything other than
+ *    `OpenAIResponsesProvider`.
+ * 3. A new file appears in `providers/openai/` that introduces
+ *    `chat.completions.create(` calls.
+ *
+ * Focused test commands for the OpenAI Responses API migration surface:
+ *
+ *   # This guard test
+ *   bun test src/__tests__/openai-responses-cutover-guard.test.ts
+ *
+ *   # OpenAI provider tests (responses + chat-completions)
+ *   bun test src/__tests__/openai-provider.test.ts
+ *   bun test src/__tests__/openai-responses-provider.test.ts
+ *
+ *   # LLM context normalization (transport-agnostic message handling)
+ *   bun test src/__tests__/llm-context-normalization.test.ts
+ *
+ *   # Provider registry and managed proxy integration
+ *   bun test src/__tests__/registry.test.ts
+ *   bun test src/__tests__/provider-managed-proxy-integration.test.ts
+ *
+ *   # Web search guard (allowlist includes both provider files)
+ *   bun test src/__tests__/conversation-history-web-search.test.ts
+ */
+
+const PROVIDERS_DIR = join(import.meta.dir, "..", "providers");
+const OPENAI_PROVIDERS_DIR = join(PROVIDERS_DIR, "openai");
+
+describe("OpenAI Responses API cutover guard", () => {
+  test("responses-provider.ts does not contain chat.completions.create() calls", () => {
+    const source = readFileSync(
+      join(OPENAI_PROVIDERS_DIR, "responses-provider.ts"),
+      "utf-8",
+    );
+
+    const hasChatCompletions = source.includes("chat.completions.create(");
+
+    expect(
+      hasChatCompletions,
+      [
+        "responses-provider.ts must NOT call chat.completions.create().",
+        "OpenAI inference uses the Responses API (client.responses.stream()).",
+        "If you need chat completions, use chat-completions-provider.ts instead.",
+      ].join("\n"),
+    ).toBe(false);
+  });
+
+  test("registry.ts wires the 'openai' provider to OpenAIResponsesProvider", () => {
+    const source = readFileSync(join(PROVIDERS_DIR, "registry.ts"), "utf-8");
+
+    // The registry should import OpenAIResponsesProvider
+    expect(
+      source.includes("OpenAIResponsesProvider"),
+      "registry.ts must import OpenAIResponsesProvider for the openai provider.",
+    ).toBe(true);
+
+    // The registry should instantiate OpenAIResponsesProvider for the "openai" key.
+    // Look for `new OpenAIResponsesProvider(` near the openai registration block.
+    const hasResponsesInstantiation = source.includes(
+      "new OpenAIResponsesProvider(",
+    );
+    expect(
+      hasResponsesInstantiation,
+      [
+        "registry.ts must instantiate OpenAIResponsesProvider for the 'openai' provider.",
+        "OpenAI inference uses the Responses API, not chat completions.",
+      ].join("\n"),
+    ).toBe(true);
+
+    // The registry should NOT instantiate OpenAIChatCompletionsProvider or
+    // OpenAIProvider (the backward-compatible alias) for the "openai" key.
+    // Chat-completions classes may appear in imports but should not be
+    // instantiated in the openai registration block.
+    const chatCompletionsInstantiations = [
+      ...source.matchAll(/new\s+OpenAIChatCompletionsProvider\s*\(/g),
+      ...source.matchAll(/new\s+OpenAIProvider\s*\(/g),
+    ];
+    expect(
+      chatCompletionsInstantiations.length,
+      [
+        "registry.ts must NOT instantiate OpenAIChatCompletionsProvider or",
+        "OpenAIProvider (legacy alias). Use OpenAIResponsesProvider for openai.",
+      ].join("\n"),
+    ).toBe(0);
+  });
+
+  test("no files in providers/openai/ introduce chat.completions.create() calls", () => {
+    // The chat-completions-provider.ts is the only file allowed to use
+    // chat.completions.create() — it's the dedicated chat-completions transport.
+    const ALLOWED_FILES = new Set(["chat-completions-provider.ts"]);
+
+    const files = readdirSync(OPENAI_PROVIDERS_DIR).filter(
+      (f) =>
+        f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".d.ts"),
+    );
+
+    const violations: string[] = [];
+    for (const file of files) {
+      if (ALLOWED_FILES.has(file)) continue;
+      const source = readFileSync(join(OPENAI_PROVIDERS_DIR, file), "utf-8");
+      if (source.includes("chat.completions.create(")) {
+        violations.push(file);
+      }
+    }
+
+    if (violations.length > 0) {
+      const message = [
+        "Found chat.completions.create() calls in OpenAI provider files that",
+        "should not use the chat completions transport:",
+        "",
+        "Violations:",
+        ...violations.map((f) => `  - providers/openai/${f}`),
+        "",
+        "OpenAI inference uses the Responses API. Only",
+        "chat-completions-provider.ts may call chat.completions.create().",
+      ].join("\n");
+      expect(violations, message).toEqual([]);
+    }
+  });
+
+  test("no production files outside providers/openai/ call chat.completions.create() for the openai provider path", () => {
+    // Broader scan: ensure no other production file accidentally calls
+    // chat.completions.create in a context that would affect the openai
+    // provider path. This catches cases where someone might add a direct
+    // OpenAI SDK call outside the provider directory.
+    let grepOutput = "";
+    try {
+      grepOutput = execSync(
+        `git grep -l "chat\\.completions\\.create(" -- 'assistant/src/**/*.ts'`,
+        { encoding: "utf-8", cwd: process.cwd() + "/.." },
+      ).trim();
+    } catch (err) {
+      // Exit code 1 means no matches
+      if ((err as { status?: number }).status === 1) {
+        return;
+      }
+      throw err;
+    }
+
+    // Allowed: chat-completions-provider.ts (the dedicated transport) and test files
+    const ALLOWED_PATHS = new Set([
+      "assistant/src/providers/openai/chat-completions-provider.ts",
+    ]);
+
+    const files = grepOutput
+      .split("\n")
+      .filter((f) => f.length > 0)
+      .filter((f) => !f.includes("/__tests__/"))
+      .filter((f) => !f.endsWith(".test.ts"));
+
+    const violations = files.filter((f) => !ALLOWED_PATHS.has(f));
+
+    if (violations.length > 0) {
+      const message = [
+        "Found chat.completions.create() calls in production files outside the",
+        "allowed chat-completions transport:",
+        "",
+        "Violations:",
+        ...violations.map((f) => `  - ${f}`),
+        "",
+        "OpenAI inference uses the Responses API. Direct chat.completions.create()",
+        "calls should only exist in chat-completions-provider.ts.",
+        "If this is a different provider (OpenRouter, Fireworks, etc.), add it to",
+        "ALLOWED_PATHS in this guard test.",
+      ].join("\n");
+      expect(violations, message).toEqual([]);
+    }
+  });
+});