@desplega.ai/agent-swarm 1.166.0 → 1.168.0

package/src/tests/grok-adapter.test.ts

@@ -25,6 +25,7 @@ import {
   buildGrokConfigToml,
   checkGrokCredentials,
   GrokAdapter,
+  grokOpenRouterModel,
   installedClaudePluginNames,
 } from "../providers/grok-adapter";
 import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
@@ -487,6 +488,7 @@ describe("GrokAdapter", () => {
           'base_url = "https://openrouter.ai/api/v1"',
           'env_key = "OPENROUTER_API_KEY"',
           'api_backend = "chat_completions"',
+          'extra_headers = { "HTTP-Referer" = "https://agent-swarm.dev", "X-OpenRouter-Title" = "Agent Swarm", "X-OpenRouter-Categories" = "personal-agent,cloud-agent" }',
         ].join("\n"),
       );
     } finally {
@@ -495,6 +497,17 @@ describe("GrokAdapter", () => {
     }
   });
 
+  test("OpenRouter app attribution rides only on direct openrouter.ai models", () => {
+    const toml = (env: Record<string, string>) =>
+      buildGrokConfigToml([], grokOpenRouterModel("openrouter/acme/thing", env));
+    expect(toml({})).toContain('extra_headers = { "HTTP-Referer" = "https://agent-swarm.dev"');
+    expect(toml({ OPENROUTER_BASE_URL: "https://gateway.example/v1" })).not.toContain(
+      "extra_headers",
+    );
+    expect(toml({ OPENROUTER_APP_ATTRIBUTION: "false" })).not.toContain("extra_headers");
+    expect(buildGrokConfigToml([], null)).not.toContain("extra_headers");
+  });
+
   test("an xai/-qualified model runs as the bare xAI id", async () => {
     const dir = makeTempDir();
     const grok = writeFakeGrok(dir, "ok");

package/src/tests/haiku-5-5-pricing.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import { buildModelsDevSeedRows } from "../be/seed-pricing";
+
+function ratesFor(provider: string, model: string) {
+  const cache = loadModelsDevCache();
+  expect(cache).not.toBeNull();
+  return Object.fromEntries(
+    buildModelsDevSeedRows(cache!)
+      .filter((row) => row.provider === provider && row.model === model)
+      .map((row) => [row.tokenClass, row.pricePerMillionUsd]),
+  );
+}
+
+describe("Haiku 5.5 pricing seed", () => {
+  test("seeds Anthropic rates for the claude harnesses, including the 1h cache write", () => {
+    for (const provider of ["claude", "claude-managed"]) {
+      expect(ratesFor(provider, "claude-haiku-5-5")).toEqual({
+        input: 0.1,
+        output: 0.5,
+        cached_input: 0.01,
+        cache_write: 0.125,
+        cache_write_1h: 0.2,
+      });
+    }
+  });
+
+  test("seeds the same rates without a 1h class for amp and cursor", () => {
+    for (const provider of ["amp", "cursor"]) {
+      expect(ratesFor(provider, "claude-haiku-5-5")).toEqual({
+        input: 0.1,
+        output: 0.5,
+        cached_input: 0.01,
+        cache_write: 0.125,
+      });
+    }
+  });
+});

package/src/tests/heartbeat-checklist.test.ts

@@ -1,4 +1,13 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
 import { unlink } from "node:fs/promises";
 import {
   closeDb,
@@ -13,6 +22,7 @@ import {
   checkHeartbeatChecklist,
   createBootTriageTask,
   gatherSystemStatus,
+  getBootTriageFindings,
   isEffectivelyEmpty,
   runRebootSweep,
 } from "../heartbeat/heartbeat";
@@ -343,6 +353,14 @@ describe("Heartbeat Checklist", () => {
   // ==========================================================================
 
   describe("createBootTriageTask", () => {
+    // These cases cover the task body; the clean-boot skip has its own block.
+    beforeEach(() => {
+      process.env.HEARTBEAT_BOOT_TRIAGE_ALWAYS = "true";
+    });
+    afterEach(() => {
+      delete process.env.HEARTBEAT_BOOT_TRIAGE_ALWAYS;
+    });
+
     test("skips when no lead agent registered", async () => {
       await createAgent({ name: "worker", isLead: false, status: "idle" });
 
@@ -505,6 +523,145 @@ describe("Heartbeat Checklist", () => {
     });
   });
 
+  // ==========================================================================
+  // createBootTriageTask() — clean-boot skip
+  // ==========================================================================
+
+  describe("createBootTriageTask clean-boot skip", () => {
+    const bootTriageCount = async () =>
+      (
+        await getDbClient().get<{ n: number }>(
+          "SELECT COUNT(*) AS n FROM agent_tasks WHERE taskType = 'boot-triage'",
+        )
+      )?.n ?? 0;
+
+    beforeEach(async () => {
+      delete process.env.HEARTBEAT_BOOT_TRIAGE_ALWAYS;
+      // Reset the module-level reboot findings left by earlier tests.
+      await runRebootSweep();
+    });
+
+    afterEach(() => {
+      delete process.env.HEARTBEAT_BOOT_TRIAGE_ALWAYS;
+    });
+
+    test("clean boot creates no Lead task", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      await createAgent({ name: "worker", isLead: false, status: "idle" });
+
+      expect(await getBootTriageFindings()).toEqual({
+        rebootInterrupted: 0,
+        stalled: 0,
+        orphaned: 0,
+        supersededWithoutResume: 0,
+      });
+      await createBootTriageTask();
+
+      expect(await bootTriageCount()).toBe(0);
+    });
+
+    test("a seeded orphan creates exactly one Lead task", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      const offline = await createAgent({ name: "gone", isLead: false, status: "offline" });
+      await createTaskExtended("Orphaned work", { agentId: offline.id });
+
+      expect((await getBootTriageFindings()).orphaned).toBe(1);
+      await createBootTriageTask();
+      await createBootTriageTask();
+
+      expect(await bootTriageCount()).toBe(1);
+    });
+
+    test("reboot-interrupted work creates the Lead task", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      const agent = await createAgent({ name: "dead-worker", isLead: false, status: "busy" });
+      const task = await createTaskExtended("Interrupted work", { agentId: agent.id });
+      await startTask(task.id);
+      await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+        new Date(Date.now() - 1000).toISOString(),
+        task.id,
+      ]);
+      await runRebootSweep();
+
+      expect((await getBootTriageFindings()).rebootInterrupted).toBe(1);
+      await createBootTriageTask();
+
+      expect(await bootTriageCount()).toBe(1);
+    });
+
+    test("superseded task without a resume creates the Lead task", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      const worker = await createAgent({ name: "worker", isLead: false, status: "idle" });
+      const task = await createTaskExtended("Lost resume", { agentId: worker.id });
+      await getDbClient().run(
+        "UPDATE agent_tasks SET status = 'superseded', finishedAt = ? WHERE id = ?",
+        [new Date(Date.now() - 5 * 60 * 1000).toISOString(), task.id],
+      );
+
+      expect((await getBootTriageFindings()).supersededWithoutResume).toBe(1);
+      await createBootTriageTask();
+
+      expect(await bootTriageCount()).toBe(1);
+    });
+
+    test("stalled-only work creates the Lead task", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      const agent = await createAgent({ name: "stuck-worker", isLead: false, status: "busy" });
+      const task = await createTaskExtended("Stalled work", { agentId: agent.id });
+      await startTask(task.id);
+      await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+        new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+        task.id,
+      ]);
+
+      expect(await getBootTriageFindings()).toEqual({
+        rebootInterrupted: 0,
+        stalled: 1,
+        orphaned: 0,
+        supersededWithoutResume: 0,
+      });
+      await createBootTriageTask();
+
+      expect(await bootTriageCount()).toBe(1);
+    });
+
+    test("a persistent reader error still creates exactly one Lead task", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      const client = getDbClient();
+      const query = client.query.bind(client);
+      const failStalled = spyOn(client, "query").mockImplementation((sql, params) => {
+        if (sql.includes("status = 'in_progress' AND lastUpdatedAt < ?")) {
+          throw new Error("stalled read unavailable");
+        }
+        return query(sql, params);
+      });
+      const errors = spyOn(console, "error").mockImplementation(() => {});
+      try {
+        await createBootTriageTask();
+        await createBootTriageTask();
+      } finally {
+        failStalled.mockRestore();
+        errors.mockRestore();
+      }
+
+      expect(await bootTriageCount()).toBe(1);
+      const task = await getDbClient().get<{ task: string }>(
+        "SELECT task FROM agent_tasks WHERE taskType = 'boot-triage'",
+      );
+      expect(task?.task).toContain("System status unavailable");
+      expect(task?.task).toContain("stalled read unavailable");
+    });
+
+    test("HEARTBEAT_BOOT_TRIAGE_ALWAYS creates the task on a clean boot", async () => {
+      await createAgent({ name: "lead", isLead: true, status: "idle" });
+      process.env.HEARTBEAT_BOOT_TRIAGE_ALWAYS = "true";
+
+      await createBootTriageTask();
+
+      expect(await bootTriageCount()).toBe(1);
+    });
+  });
+
   // ==========================================================================
   // gatherSystemStatus() — boot triage sections
   // ==========================================================================

package/src/tests/onboarding.test.ts

@@ -580,6 +580,50 @@ describe("onboarding memory probe", () => {
     });
   });
 
+  test("only an openrouter.ai endpoint gets OpenRouter app attribution", async () => {
+    const referers: Record<string, string | null> = {};
+    const fake = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      fetch(req) {
+        referers.local = req.headers.get("http-referer");
+        return embeddingResponse(512);
+      },
+    });
+    const origFetch = globalThis.fetch;
+    // The probe builds a fresh OpenAI client per call, which picks up this stub.
+    globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+      const req = new Request(input, init);
+      if (new URL(req.url).hostname !== "openrouter.ai") return origFetch(input, init);
+      referers[process.env.OPENROUTER_APP_ATTRIBUTION ? "optedOut" : "openrouter"] =
+        req.headers.get("http-referer");
+      return embeddingResponse(512);
+    }) as typeof fetch;
+    const probe = (body: Record<string, unknown>) =>
+      request("/api/onboarding/memory", {
+        method: "POST",
+        body: { model: "test-embedding-model", apiKey: "example-key", ...body },
+      });
+    try {
+      expect((await probe({ preset: "openrouter" })).status).toBe(200);
+      process.env.OPENROUTER_APP_ATTRIBUTION = "false";
+      expect((await probe({ preset: "openrouter" })).status).toBe(200);
+      delete process.env.OPENROUTER_APP_ATTRIBUTION;
+      expect(
+        (await probe({ preset: "custom", baseUrl: `http://127.0.0.1:${fake.port}/v1` })).status,
+      ).toBe(200);
+    } finally {
+      globalThis.fetch = origFetch;
+      delete process.env.OPENROUTER_APP_ATTRIBUTION;
+      fake.stop(true);
+    }
+    expect(referers).toEqual({
+      openrouter: "https://agent-swarm.dev",
+      optedOut: null,
+      local: null,
+    });
+  });
+
   test("classifies a local 401 embeddings response as auth", async () => {
     const fake = startEmbeddingServer(() =>
       Response.json(

package/src/tests/opencode-adapter.test.ts

@@ -1294,15 +1294,17 @@ describe("OpencodeAdapter — reasoning_effort wiring", () => {
     expect(options).toEqual({ thinking: { type: "enabled", budgetTokens: 32768 } });
   });
 
-  test("undefined reasoningEffort leaves config.provider unset", async () => {
+  test("undefined reasoningEffort leaves model options unset", async () => {
     const events: OpencodeEvent[] = [
       { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
     ];
     const cfg = testConfig({ model: "openrouter/google/gemini-3-flash-preview" });
     await driveSession(events, cfg);
 
-    const opts = lastCreateOpencodeConfig as { config?: { provider?: unknown } };
-    expect(opts.config?.provider).toBeUndefined();
+    const opts = lastCreateOpencodeConfig as {
+      config?: { provider?: Record<string, { models?: unknown }> };
+    };
+    expect(opts.config?.provider?.openrouter?.models).toBeUndefined();
   });
 });
 
@@ -1496,3 +1498,64 @@ describe("OpencodeAdapter: event stream ends without session.idle", () => {
     expect(closeServer).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("OpenRouter attribution config", () => {
+  test("overrides harness attribution while preserving custom headers and options", async () => {
+    const { applyOpenRouterBaseUrlOverride } = await import("../providers/opencode-adapter");
+    const config = {
+      provider: {
+        openrouter: {
+          options: {
+            apiKey: "test",
+            headers: {
+              "X-Custom": "keep",
+              "X-Title": "opencode",
+              "HTTP-Referer": "https://opencode.ai",
+            },
+          },
+        },
+      },
+    };
+    applyOpenRouterBaseUrlOverride(config, {});
+    expect(config.provider.openrouter.options).toEqual({
+      apiKey: "test",
+      headers: {
+        "X-Custom": "keep",
+        "HTTP-Referer": "https://agent-swarm.dev",
+        "X-Title": "Agent Swarm",
+        "X-OpenRouter-Title": "Agent Swarm",
+        "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+      },
+    });
+  });
+  test("gateway override preserves options without injecting attribution", async () => {
+    const { applyOpenRouterBaseUrlOverride } = await import("../providers/opencode-adapter");
+    const config = {
+      provider: {
+        openrouter: {
+          models: {
+            "google/gemini-3-flash-preview": { options: { reasoning: { effort: "low" } } },
+          },
+          options: { apiKey: "test", headers: { "X-Custom": "keep" } },
+        },
+        anthropic: { options: { apiKey: "test-other" } },
+      },
+    };
+    applyOpenRouterBaseUrlOverride(config, { OPENROUTER_BASE_URL: "http://localhost:1234/v1" });
+    expect(config.provider.openrouter.options).toEqual({
+      apiKey: "test",
+      headers: { "X-Custom": "keep" },
+      baseURL: "http://localhost:1234/v1",
+    });
+    expect(config.provider.openrouter.models).toEqual({
+      "google/gemini-3-flash-preview": { options: { reasoning: { effort: "low" } } },
+    });
+    expect(config.provider.anthropic).toEqual({ options: { apiKey: "test-other" } });
+  });
+  test("task opt-out leaves default provider config untouched", async () => {
+    const { applyOpenRouterBaseUrlOverride } = await import("../providers/opencode-adapter");
+    const config = {};
+    applyOpenRouterBaseUrlOverride(config, { OPENROUTER_APP_ATTRIBUTION: "false" });
+    expect(config).toEqual({});
+  });
+});

package/src/tests/opencode-plugin.test.ts

@@ -21,11 +21,13 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import type { Message, Part } from "@opencode-ai/sdk";
 import {
   flattenOpencodeTranscript,
+  OPENROUTER_APP_ATTRIBUTION_HEADERS as PLUGIN_OPENROUTER_APP_ATTRIBUTION_HEADERS,
   runSummaryLlm,
   type SummarizeSessionForOpencodeDeps,
   type SwarmConfig,
   summarizeSessionForOpencode,
 } from "../../plugin/opencode-plugins/lib/summarize";
+import { OPENROUTER_APP_ATTRIBUTION_HEADERS } from "../utils/openrouter-base-url";
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
@@ -514,6 +516,41 @@ describe("runSummaryLlm — OPENROUTER_BASE_URL gateway", () => {
 
   afterEach(() => {
     delete process.env.OPENROUTER_BASE_URL;
+    delete process.env.OPENROUTER_APP_ATTRIBUTION;
+  });
+
+  const okSummary = async () => ({
+    ok: true,
+    status: 200,
+    text: async () => "",
+    json: async () => summaryBody,
+  });
+  const sentHeaders = () => new Headers(fetchCalls[0]?.init?.headers);
+
+  test("the inlined attribution copy matches src/utils/openrouter-base-url.ts", () => {
+    expect(PLUGIN_OPENROUTER_APP_ATTRIBUTION_HEADERS).toEqual(OPENROUTER_APP_ATTRIBUTION_HEADERS);
+  });
+
+  test("attributes direct openrouter.ai calls to Agent Swarm", async () => {
+    fetchHandler = okSummary;
+    expect(await runSummaryLlm(openrouterCred, "sys", "user")).not.toBeNull();
+    expect(sentHeaders().get("http-referer")).toBe("https://agent-swarm.dev");
+    expect(sentHeaders().get("x-openrouter-title")).toBe("Agent Swarm");
+    expect(sentHeaders().get("x-openrouter-categories")).toBe("personal-agent,cloud-agent");
+  });
+
+  test("a gateway or OPENROUTER_APP_ATTRIBUTION=false sends no attribution", async () => {
+    fetchHandler = okSummary;
+    process.env.OPENROUTER_BASE_URL = "https://control-plane.example/proxy/v1/";
+    await runSummaryLlm(openrouterCred, "sys", "user");
+    expect(sentHeaders().has("http-referer")).toBe(false);
+
+    fetchCalls.length = 0;
+    delete process.env.OPENROUTER_BASE_URL;
+    process.env.OPENROUTER_APP_ATTRIBUTION = "false";
+    await runSummaryLlm(openrouterCred, "sys", "user");
+    expect(fetchCalls[0]?.url).toBe("https://openrouter.ai/api/v1/chat/completions");
+    expect(sentHeaders().has("http-referer")).toBe(false);
   });
 
   test("defaults to openrouter.ai when the env is unset", async () => {

package/src/tests/openrouter-attribution-call-sites.test.ts

@@ -0,0 +1,204 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { OpenAIEmbeddingProvider } from "../be/memory/providers/openai-embedding";
+import { runMemoryRater } from "../be/memory/raters/llm-summarizer";
+import { validateProviderCredentials } from "../commands/provider-credentials";
+import { completeStructured } from "../utils/internal-ai/complete-structured";
+import type { ExecutorDependencies, ExecutorInput } from "../workflows/executors/base";
+import { executeRawLlm } from "../workflows/executors/raw-llm";
+import { ValidateExecutor } from "../workflows/executors/validate";
+
+/**
+ * OpenRouter app attribution at each of our own HTTP call sites: present for
+ * openrouter.ai, absent for a gateway, absent with OPENROUTER_APP_ATTRIBUTION=false.
+ */
+
+const ENV_KEYS = [
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_BASE_URL",
+  "OPENROUTER_APP_ATTRIBUTION",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "EMBEDDING_API_BASE_URL",
+] as const;
+const GATEWAY = "https://gateway.example.test/v1";
+
+type Case = { name: string; env: Record<string, string>; attributed: boolean };
+const CASES: Case[] = [
+  { name: "openrouter.ai", env: {}, attributed: true },
+  { name: "a gateway", env: { OPENROUTER_BASE_URL: GATEWAY }, attributed: false },
+  { name: "the opt-out", env: { OPENROUTER_APP_ATTRIBUTION: "false" }, attributed: false },
+];
+
+let saved: Record<string, string | undefined> = {};
+let requests: { url: string; headers: Headers }[] = [];
+const origFetch = globalThis.fetch;
+
+beforeEach(() => {
+  saved = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+  for (const key of ENV_KEYS) delete process.env[key];
+  requests = [];
+  globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+    const request = new Request(input, init);
+    requests.push({ url: request.url, headers: request.headers });
+    return new Response("bad request", { status: 400 });
+  }) as typeof fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = origFetch;
+  for (const key of ENV_KEYS) {
+    if (saved[key] === undefined) delete process.env[key];
+    else process.env[key] = saved[key];
+  }
+});
+
+function setEnv(env: Record<string, string>) {
+  for (const [key, value] of Object.entries(env)) process.env[key] = value;
+}
+
+function expectAttribution(headers: Headers | undefined, attributed: boolean) {
+  expect(headers).toBeDefined();
+  if (attributed) {
+    expect(headers?.get("http-referer")).toBe("https://agent-swarm.dev");
+    expect(headers?.get("x-openrouter-title")).toBe("Agent Swarm");
+    expect(headers?.get("x-openrouter-categories")).toBe("personal-agent,cloud-agent");
+  } else {
+    expect(headers?.has("http-referer")).toBe(false);
+    expect(headers?.has("x-openrouter-title")).toBe(false);
+    expect(headers?.has("x-openrouter-categories")).toBe(false);
+  }
+}
+
+describe("memory rater (llm-summarizer)", () => {
+  for (const c of CASES) {
+    test(`${c.name}`, async () => {
+      setEnv(c.env);
+      await runMemoryRater({ prompt: "p", apiKey: "example-or-key" });
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+});
+
+describe("completeStructured (pi-ai path)", () => {
+  for (const c of CASES) {
+    test(`${c.name}`, async () => {
+      let headers: Headers | undefined;
+      await completeStructured({
+        zodSchema: { safeParse: () => ({ success: false, error: new Error("x") }) } as never,
+        toolSchema: { type: "object", properties: {} } as never,
+        toolName: "record",
+        toolDescription: "Record.",
+        systemPrompt: "sys",
+        userPrompt: "user",
+        retries: 1,
+        env: c.env,
+        _credentialOverride: {
+          kind: "openrouter",
+          apiKey: "example-or-key",
+          modelDefault: "openrouter/deepseek/deepseek-v4.1-flash",
+        },
+        _complete: async (_model, _context, options) => {
+          headers = new Headers((options?.headers ?? {}) as Record<string, string>);
+          throw new Error("stop");
+        },
+      });
+      expectAttribution(headers, c.attributed);
+    });
+  }
+
+  test("a non-OpenRouter credential gets no attribution", async () => {
+    let headers: Headers | undefined;
+    await completeStructured({
+      zodSchema: { safeParse: () => ({ success: false, error: new Error("x") }) } as never,
+      toolSchema: { type: "object", properties: {} } as never,
+      toolName: "record",
+      toolDescription: "Record.",
+      systemPrompt: "sys",
+      userPrompt: "user",
+      retries: 1,
+      env: {},
+      _credentialOverride: {
+        kind: "anthropic",
+        apiKey: "example-ant-key",
+        modelDefault: "anthropic/claude-sonnet-4-5",
+      },
+      _complete: async (_model, _context, options) => {
+        headers = new Headers((options?.headers ?? {}) as Record<string, string>);
+        throw new Error("stop");
+      },
+    });
+    expectAttribution(headers, false);
+  });
+});
+
+describe("workflow raw-llm and validate nodes", () => {
+  const deps = { interpolate: (template: string) => template } as unknown as ExecutorDependencies;
+  const meta = { runId: "run", stepId: "step", nodeId: "node" } as unknown as ExecutorInput["meta"];
+
+  for (const c of CASES) {
+    test(`raw-llm: ${c.name}`, async () => {
+      setEnv({ OPENROUTER_API_KEY: "example-or-key", ...c.env });
+      expect((await executeRawLlm({ prompt: "hi" })).status).toBe("failed");
+      expect(
+        requests[0]?.url.startsWith(c.env.OPENROUTER_BASE_URL ?? "https://openrouter.ai/"),
+      ).toBe(true);
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+
+    test(`validate: ${c.name}`, async () => {
+      setEnv({ OPENROUTER_API_KEY: "example-or-key", ...c.env });
+      await new ValidateExecutor(deps).run({
+        config: { targetNodeId: "a", prompt: "Is it valid?" },
+        context: { a: "output" },
+        meta,
+      });
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+
+  test("an OpenAI credential gets no attribution", async () => {
+    setEnv({ OPENAI_API_KEY: "example-sk-openai" });
+    await executeRawLlm({ prompt: "hi" });
+    expect(requests[0]?.url.startsWith("https://api.openai.com/")).toBe(true);
+    expectAttribution(requests[0]?.headers, false);
+  });
+});
+
+describe("OpenRouter credential check (GET /models)", () => {
+  for (const c of CASES) {
+    test(`${c.name}`, async () => {
+      setEnv(c.env);
+      await validateProviderCredentials("grok", { OPENROUTER_API_KEY: "example-or-key" });
+      expect(requests[0]?.url.endsWith("/models")).toBe(true);
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+});
+
+describe("OpenAI-compatible embedding provider", () => {
+  const embedCases: Case[] = [
+    {
+      name: "an openrouter.ai base URL",
+      env: { EMBEDDING_API_BASE_URL: "https://openrouter.ai/api/v1" },
+      attributed: true,
+    },
+    { name: "the OpenAI default", env: {}, attributed: false },
+    { name: "a gateway", env: { EMBEDDING_API_BASE_URL: GATEWAY }, attributed: false },
+    {
+      name: "the opt-out",
+      env: {
+        EMBEDDING_API_BASE_URL: "https://openrouter.ai/api/v1",
+        OPENROUTER_APP_ATTRIBUTION: "0",
+      },
+      attributed: false,
+    },
+  ];
+  for (const c of embedCases) {
+    test(`${c.name}`, async () => {
+      setEnv(c.env);
+      const provider = new OpenAIEmbeddingProvider({ apiKey: "example-embed-key" });
+      expect(await provider.embed("hello")).toBeNull();
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+});