@stablekernel/opencode-bifrost 0.8.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -7,6 +7,7 @@ OpenCode plugin that routes model traffic through a [Bifrost](https://docs.getbi
7
7
  - Registers a `bifrost` provider on OpenCode's OpenAI-compatible surface.
8
8
  - Fetches the model list at startup through `gateway-cli models --wire=openai`, with per-model context/output limits and pricing already applied — no catalog is checked in, so a model added to the gateway appears without a local edit.
9
9
  - Seeds reasoning capability per model: catalog-flagged models are registered `reasoning: true` with one variant per effort value they accept. The config cascade's default `reasoning_effort` is seeded as the model's default when the model accepts it — on OpenCode 1.x as `options.reasoningEffort`, on OpenCode 2 as model-level `settings.reasoningEffort` — and a variant picked in the model picker overrides it. The static `gateway-cli emit opencode` block mirrors this (`--v2` for the 2.x form).
10
+ - Routes first-party OpenAI GPT models (`…openai.gpt-*`, not `gpt-oss`) over the Responses API, since the gateway answers their chat-completions requests with 400: a per-model `provider.npm: "@ai-sdk/openai"` (+ `options.forceReasoning`) on 1.x, `package: "@opencode/ai/providers/openai/responses"` on 2.x.
10
11
  - Resolves the virtual key per project directory (`gateway-cli resolve` / `gateway-cli key print`), so two projects on different keys never collide in OpenCode's global auth store. On OpenCode 1.x it falls back to a credential stored via `opencode auth login` on machines without `gateway-cli`; OpenCode 2 removed that hook, so there discovery requires the CLI.
11
12
 
12
13
  No secret is held by the plugin; the key is read at runtime.
@@ -40,35 +41,6 @@ the moment you run it:
40
41
  Either way the result arrives as a message part, never as an error: a failure
41
42
  prints one line. The virtual key is never printed or logged.
42
43
 
43
- ## Datasheet supplement (off by default)
44
-
45
- Wildcard-provider models — e.g. a fresh Fireworks launch that the CLI's
46
- models.dev source has not cataloged yet — never reach `gateway-cli models`,
47
- so they cannot be listed here either. When configured, this plugin also reads
48
- the datasheet feed Bifrost itself syncs from and appends the wildcard-provider
49
- ids the CLI list lacks; CLI-listed ids always win. The supplement applies to
50
- the single `bifrost` provider.
51
-
52
- Activation (first wins):
53
-
54
- 1. env `GATEWAY_DATASHEET_URL`
55
- 2. `~/.config/bifrost/datasheet.json` — `{"url": "..."}`
56
- 3. `<project>/.gateway/datasheet.json` — same shape
57
-
58
- The URL must be `https://`; a source with anything else is treated as absent.
59
-
60
- Behavior: the feed is fetched once per hour and cached under
61
- `~/.cache/opencode/datasheet-cache.json` (or `$XDG_CACHE_HOME`), with a 3s
62
- hard timeout and a stale-cache fallback on failure. A failed first fetch
63
- also triggers a background cache fill, so a slow or cold feed costs one
64
- session rather than every start. Unconfigured or unreachable, the
65
- supplement is silently skipped — startup never blocks on it.
66
-
67
- Provenance: supplement-only models are tagged `limits_source: "datasheet"`
68
- and `cost_source: "datasheet"` in the `gateway-cli models` payload they ride
69
- in. The tags stop there — opencode's config schema has no provenance field,
70
- so they are not forwarded into the emitted `opencode.json`.
71
-
72
44
  ## Requirements
73
45
 
74
46
  - `gateway-cli` on `PATH` (or the `GATEWAY_CLI_BIN` env var pointing at it), connected once with `gateway-cli connect`.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@stablekernel/opencode-bifrost",
3
- "version": "0.8.0",
3
+ "version": "0.10.0",
4
4
  "description": "OpenCode plugin that routes models through the Bifrost gateway, resolving per-project virtual keys via gateway-cli. Supports OpenCode 1.x and 2.x.",
5
5
  "type": "module",
6
6
  "main": "src/index.ts",
package/src/index.test.ts CHANGED
@@ -21,11 +21,8 @@ const ORIGINAL_XDG_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
21
21
  const ORIGINAL_FETCH = globalThis.fetch;
22
22
 
23
23
  beforeEach(() => {
24
- // The config-hook tests run the real datasheetSupplement. Keep it
25
- // deterministic and machine-independent: drop the env override and point
26
- // HOME at an empty temp dir, so neither ~/.config/bifrost/datasheet.json
27
- // nor the real ~/.cache/opencode cache is read or written.
28
- delete process.env.GATEWAY_DATASHEET_URL;
24
+ // Point HOME at an empty temp dir so the real ~/.cache/opencode
25
+ // version-check cache is never read or written.
29
26
  // /bifrost-refresh reads its gateway and key from the environment; a real
30
27
  // BIFROST_GATEWAY_URL in the developer's shell must not reach these tests.
31
28
  delete process.env.BIFROST_GATEWAY_URL;
@@ -791,3 +788,46 @@ describe("stale-plugin notice", () => {
791
788
  expect(isStale("dev", "dev")).toBe(false);
792
789
  });
793
790
  });
791
+
792
+ describe("responses routing", () => {
793
+ const GPT: CliModel = {
794
+ id: "bedrock/openai.gpt-6.1-sol",
795
+ name: "GPT-6.1 Sol",
796
+ context_window: 400000,
797
+ max_output_tokens: 128000,
798
+ limits_source: "catalog",
799
+ reasoning: true,
800
+ reasoning_efforts: ["low", "medium", "high"],
801
+ };
802
+ const OSS: CliModel = {
803
+ ...GPT,
804
+ id: "bedrock/openai.gpt-oss-120b",
805
+ name: "GPT OSS 120B",
806
+ };
807
+
808
+ test("sends first-party GPT models to the OpenAI Responses package", () => {
809
+ const m = toConfigModels({ models: [GPT] })[GPT.id];
810
+ expect(m.provider).toEqual({ npm: "@ai-sdk/openai" });
811
+ });
812
+
813
+ test("leaves gpt-oss and non-GPT models on the provider's package", () => {
814
+ const models = toConfigModels({ models: [OSS, HAIKU] });
815
+ expect(models[OSS.id].provider).toBeUndefined();
816
+ expect(models[HAIKU.id].provider).toBeUndefined();
817
+ });
818
+
819
+ test("forces reasoning mode: @ai-sdk/openai only recognizes ids starting gpt-", () => {
820
+ // Without it the SDK drops reasoningEffort for the prefixed id.
821
+ expect(toConfigModels({ models: [GPT] })[GPT.id].options).toEqual({
822
+ forceReasoning: true,
823
+ });
824
+ const plain: CliModel = { ...GPT, reasoning: false };
825
+ expect(toConfigModels({ models: [plain] })[GPT.id].options).toBeUndefined();
826
+ });
827
+
828
+ test("still seeds the default effort and variants for a routed model", () => {
829
+ const m = toConfigModels({ models: [GPT] }, "high")[GPT.id];
830
+ expect(m.options).toEqual({ forceReasoning: true, reasoningEffort: "high" });
831
+ expect(Object.keys(m.variants ?? {})).toEqual(["low", "medium", "high"]);
832
+ });
833
+ });
package/src/index.ts CHANGED
@@ -11,6 +11,7 @@ import {
11
11
  REFRESH_DESCRIPTION,
12
12
  REFRESH_TEMPLATE,
13
13
  resolveInfo,
14
+ usesResponsesApi,
14
15
  type CliModels,
15
16
  } from "./shared.js";
16
17
  import { setupV2 } from "./v2.js";
@@ -53,6 +54,9 @@ type ConfigModel = {
53
54
  /** Provider options passed on every request (e.g. a seeded default
54
55
  * reasoningEffort); a variant or agent override replaces these. */
55
56
  options?: Record<string, unknown>;
57
+ /** Per-model package override; OpenCode resolves model.provider.npm ahead
58
+ * of the provider's. */
59
+ provider?: { npm: string };
56
60
  };
57
61
 
58
62
  /**
@@ -135,7 +139,7 @@ export const BifrostGateway: Plugin = async ({ client, directory, $ }) => {
135
139
  ).provider ??= {});
136
140
  const existing: ProviderEntry = providers[PROVIDER_ID] ?? {};
137
141
  const models = toConfigModels(
138
- await listCliModels(cli, directory),
142
+ await listCliModels(cli),
139
143
  info.reasoning_effort,
140
144
  );
141
145
  const merged = { ...models, ...(existing.models ?? {}) };
@@ -290,16 +294,20 @@ export function toConfigModels(
290
294
  ? { attachment: true, modalities: { input: ["text", "image"] } }
291
295
  : {}),
292
296
  };
297
+ const responses = usesResponsesApi(m.id);
298
+ if (responses) entry.provider = { npm: "@ai-sdk/openai" };
293
299
  if (m.reasoning) {
294
300
  entry.reasoning = true;
301
+ // @ai-sdk/openai only treats ids starting "gpt-" as reasoning models, so
302
+ // a prefixed id would silently lose reasoningEffort without this.
303
+ if (responses) entry.options = { forceReasoning: true };
295
304
  const variants: Record<string, { reasoningEffort: string }> = {};
296
305
  for (const e of efforts) variants[e] = { reasoningEffort: e };
297
306
  if (Object.keys(variants).length > 0) entry.variants = variants;
298
307
  if (defaultEffort && efforts.includes(defaultEffort)) {
299
308
  // Seeding at model level makes the effort the default unless a
300
309
  // variant or agent override replaces it.
301
- (entry as ConfigModel & { options?: Record<string, unknown> }).options =
302
- { reasoningEffort: defaultEffort };
310
+ entry.options = { ...entry.options, reasoningEffort: defaultEffort };
303
311
  }
304
312
  }
305
313
  out[m.id] = entry;
@@ -1,42 +1,11 @@
1
- import { afterEach, beforeEach, describe, expect, test } from "bun:test";
2
- import { mkdtempSync } from "node:fs";
3
- import { tmpdir } from "node:os";
4
- import { join } from "node:path";
1
+ import { describe, expect, test } from "bun:test";
5
2
  import {
6
3
  listCliModels,
7
4
  readCliKey,
8
5
  resolveInfo,
6
+ usesResponsesApi,
9
7
  } from "./shared.js";
10
8
 
11
- /** HOME as the suite found it, restored after each test. */
12
- const ORIGINAL_HOME = process.env.HOME;
13
-
14
- /** XDG_CACHE_HOME as the suite found it, restored after each test. */
15
- const ORIGINAL_XDG_CACHE_HOME = process.env.XDG_CACHE_HOME;
16
-
17
- /** GATEWAY_DATASHEET_URL as the suite found it, restored after each test. */
18
- const ORIGINAL_DATASHEET_URL = process.env.GATEWAY_DATASHEET_URL;
19
-
20
- beforeEach(() => {
21
- // The listCliModels tests run the real datasheet supplement. Keep it
22
- // deterministic and machine-independent: point HOME and the cache root
23
- // at an empty temp dir, so neither ~/.config/bifrost/datasheet.json nor
24
- // a warm ~/.cache/opencode cache is read, and drop any feed override
25
- // from the developer's shell.
26
- delete process.env.GATEWAY_DATASHEET_URL;
27
- delete process.env.XDG_CACHE_HOME;
28
- process.env.HOME = mkdtempSync(join(tmpdir(), "gw-oc-home-"));
29
- });
30
-
31
- afterEach(() => {
32
- if (ORIGINAL_HOME === undefined) delete process.env.HOME;
33
- else process.env.HOME = ORIGINAL_HOME;
34
- if (ORIGINAL_XDG_CACHE_HOME === undefined) delete process.env.XDG_CACHE_HOME;
35
- else process.env.XDG_CACHE_HOME = ORIGINAL_XDG_CACHE_HOME;
36
- if (ORIGINAL_DATASHEET_URL === undefined) delete process.env.GATEWAY_DATASHEET_URL;
37
- else process.env.GATEWAY_DATASHEET_URL = ORIGINAL_DATASHEET_URL;
38
- });
39
-
40
9
  /**
41
10
  * Records every exec and answers from a scripted map. These three helpers
42
11
  * are the whole CLI-discovery surface both majors share, so the tests pin
@@ -124,7 +93,6 @@ describe("listCliModels", () => {
124
93
  const calls: string[][] = [];
125
94
  const payload = await listCliModels(
126
95
  fakeExec({ "models --wire=openai": PAYLOAD }, calls),
127
- "/repo",
128
96
  );
129
97
  expect(payload?.models?.map((m) => m.id)).toEqual([
130
98
  "bedrock/amazon.nova-lite-v1:0",
@@ -133,9 +101,25 @@ describe("listCliModels", () => {
133
101
  });
134
102
 
135
103
  test("returns null when the CLI is missing or emits garbage", async () => {
136
- expect(await listCliModels(async () => null, "/repo")).toBeNull();
104
+ expect(await listCliModels(async () => null)).toBeNull();
137
105
  expect(
138
- await listCliModels(fakeExec({ "models --wire=openai": "not json" }, []), "/repo"),
106
+ await listCliModels(fakeExec({ "models --wire=openai": "not json" }, [])),
139
107
  ).toBeNull();
140
108
  });
141
109
  });
110
+
111
+ describe("usesResponsesApi", () => {
112
+ // The gateway answers every first-party GPT chat-completions request with
113
+ // 400 ("use /v1/responses"); gpt-oss and other vendors stay on completions.
114
+ test.each([
115
+ ["bedrock/openai.gpt-6.1-sol", true],
116
+ ["bedrock/openai.gpt-5.5", true],
117
+ ["openai/gpt-6.0", true],
118
+ ["bedrock/openai.gpt-oss-120b", false],
119
+ ["fireworks/gpt-oss-120b", false],
120
+ ["bedrock/amazon.nova-lite-v1:0", false],
121
+ ["claude-sonnet-4-6", false],
122
+ ])("%s -> %p", (id, want) => {
123
+ expect(usesResponsesApi(id)).toBe(want);
124
+ });
125
+ });
package/src/shared.ts CHANGED
@@ -1,6 +1,5 @@
1
1
  import { readFileSync } from "node:fs";
2
2
  import { homedir } from "node:os";
3
- import { datasheetSupplement, mergeModels } from "./datasheet.js";
4
3
  import { keyFileValue, type Exec } from "./refresh.js";
5
4
 
6
5
  /** Provider id registered with OpenCode. */
@@ -9,6 +8,15 @@ export const PROVIDER_ID = "bifrost";
9
8
  /** Overridable so a non-PATH install still works. */
10
9
  export const CLI = process.env.GATEWAY_CLI_BIN ?? "gateway-cli";
11
10
 
11
+ /**
12
+ * First-party OpenAI GPT ids ("openai/gpt-6.0", "bedrock/openai.gpt-6.1-sol")
13
+ * are served only on /v1/responses: the gateway answers every chat-completions
14
+ * request with 400. gpt-oss is open-weight and fine on completions. Mirrors
15
+ * OPENAI_GPT in packages/pi-bifrost/src/index.ts.
16
+ */
17
+ export const usesResponsesApi = (id: string): boolean =>
18
+ /(?:^|\/)openai[./]gpt-(?!oss)/.test(id);
19
+
12
20
  /**
13
21
  * Suffix for models nothing could price.
14
22
  *
@@ -96,13 +104,6 @@ function versionCheckPath(): string | null {
96
104
  return `${base}/opencode/bifrost-version-check.json`;
97
105
  }
98
106
 
99
- /** Where the datasheet feed cache lives; same base as the version check. */
100
- function datasheetCacheDir(): string | null {
101
- const home = process.env.HOME || homedir() || null;
102
- const base = process.env.XDG_CACHE_HOME ?? (home ? `${home}/.cache` : null);
103
- return base ? `${base}/opencode` : null;
104
- }
105
-
106
107
  /**
107
108
  * Run `gateway-cli resolve --json` through `exec` and allowlist the origin it
108
109
  * reports. Null when the CLI is missing, the payload is malformed, or the
@@ -133,27 +134,14 @@ export async function readCliKey(exec: Exec): Promise<string | null> {
133
134
  }
134
135
 
135
136
  /**
136
- * Fetch the model list via `gateway-cli models --wire=openai` and merge in
137
- * the datasheet supplement: wildcard-provider ids the CLI cannot list yet
138
- * (a feed Bifrost itself syncs from); CLI-listed ids always win. `root` is
139
- * the project directory, where a per-project `.gateway/datasheet.json` may
140
- * live — under OpenCode 2 the process cwd is the background service's, not
141
- * the project's. Null when the CLI is missing or its payload is malformed.
137
+ * Fetch the model list via `gateway-cli models --wire=openai`. Null when the
138
+ * CLI is missing or its payload is malformed.
142
139
  */
143
- export async function listCliModels(
144
- exec: Exec,
145
- root: string,
146
- ): Promise<CliModels | null> {
140
+ export async function listCliModels(exec: Exec): Promise<CliModels | null> {
147
141
  const raw = await exec(["models", "--wire=openai"]);
148
142
  if (!raw) return null;
149
143
  try {
150
- const payload = JSON.parse(raw) as CliModels;
151
- const cacheDir = datasheetCacheDir();
152
- if (cacheDir) {
153
- const extra = await datasheetSupplement(root, cacheDir);
154
- payload.models = mergeModels(payload.models ?? [], extra);
155
- }
156
- return payload;
144
+ return JSON.parse(raw) as CliModels;
157
145
  } catch {
158
146
  return null;
159
147
  }
package/src/v2.test.ts CHANGED
@@ -12,9 +12,6 @@ const ORIGINAL_HOME = process.env.HOME;
12
12
  /** XDG_CACHE_HOME as the suite found it, restored after each test. */
13
13
  const ORIGINAL_XDG_CACHE_HOME = process.env.XDG_CACHE_HOME;
14
14
 
15
- /** GATEWAY_DATASHEET_URL as the suite found it, restored after each test. */
16
- const ORIGINAL_DATASHEET_URL = process.env.GATEWAY_DATASHEET_URL;
17
-
18
15
  /** BIFROST_GATEWAY_URL as the suite found it, restored after each test. */
19
16
  const ORIGINAL_GATEWAY_URL = process.env.BIFROST_GATEWAY_URL;
20
17
 
@@ -28,12 +25,9 @@ const ORIGINAL_VK = process.env.BIFROST_VK;
28
25
  const ORIGINAL_XDG_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
29
26
 
30
27
  beforeEach(() => {
31
- // The setupV2 tests run the real listCliModels, which consults the real
32
- // datasheet supplement. Keep it deterministic and machine-independent:
33
- // point HOME and the cache root at an empty temp dir, so neither
34
- // ~/.config/bifrost/datasheet.json nor a warm ~/.cache/opencode cache
35
- // is read, and drop any feed override from the developer's shell.
36
- delete process.env.GATEWAY_DATASHEET_URL;
28
+ // Keep the version-check cache machine-independent: point HOME and the
29
+ // cache root at an empty temp dir so the real ~/.cache/opencode is never
30
+ // read or written.
37
31
  delete process.env.XDG_CACHE_HOME;
38
32
  // /bifrost-refresh reads its gateway and key from the environment; a real
39
33
  // BIFROST_GATEWAY_URL in the developer's shell must not reach these tests.
@@ -52,8 +46,6 @@ afterEach(() => {
52
46
  else process.env.HOME = ORIGINAL_HOME;
53
47
  if (ORIGINAL_XDG_CACHE_HOME === undefined) delete process.env.XDG_CACHE_HOME;
54
48
  else process.env.XDG_CACHE_HOME = ORIGINAL_XDG_CACHE_HOME;
55
- if (ORIGINAL_DATASHEET_URL === undefined) delete process.env.GATEWAY_DATASHEET_URL;
56
- else process.env.GATEWAY_DATASHEET_URL = ORIGINAL_DATASHEET_URL;
57
49
  if (ORIGINAL_GATEWAY_URL === undefined) delete process.env.BIFROST_GATEWAY_URL;
58
50
  else process.env.BIFROST_GATEWAY_URL = ORIGINAL_GATEWAY_URL;
59
51
  if (ORIGINAL_DISCOVERY_URL === undefined) delete process.env.BIFROST_DISCOVERY_URL;
@@ -392,3 +384,25 @@ describe("setupV2", () => {
392
384
  expect(commands.map((c) => c.name)).toEqual(["bifrost-refresh"]);
393
385
  });
394
386
  });
387
+
388
+ describe("responses routing", () => {
389
+ const GPT: CliModel = {
390
+ ...REASONING,
391
+ id: "bedrock/openai.gpt-6.1-sol",
392
+ name: "GPT-6.1 Sol",
393
+ };
394
+ const OSS: CliModel = { ...GPT, id: "bedrock/openai.gpt-oss-120b" };
395
+
396
+ test("overrides the package for first-party GPT models only", () => {
397
+ const models = toV2Models({ models: [GPT, OSS, NOVA] });
398
+ expect(byId(models, GPT.id)!.package).toBe(
399
+ "@opencode/ai/providers/openai/responses",
400
+ );
401
+ expect(byId(models, OSS.id)!.package).toBe(
402
+ "@opencode/ai/providers/openai-compatible",
403
+ );
404
+ expect(byId(models, NOVA.id)!.package).toBe(
405
+ "@opencode/ai/providers/openai-compatible",
406
+ );
407
+ });
408
+ });
package/src/v2.ts CHANGED
@@ -10,6 +10,7 @@ import {
10
10
  readKeyFile,
11
11
  REFRESH_DESCRIPTION,
12
12
  resolveInfo,
13
+ usesResponsesApi,
13
14
  type CliModels,
14
15
  } from "./shared.js";
15
16
 
@@ -21,6 +22,7 @@ const exec = promisify(execFile);
21
22
  * gateway route is built by the host rather than bundled here.
22
23
  */
23
24
  const PROVIDER_PACKAGE = "@opencode/ai/providers/openai-compatible";
25
+ const RESPONSES_PACKAGE = "@opencode/ai/providers/openai/responses";
24
26
 
25
27
  /**
26
28
  * Directories searched for the CLI when it is not on the inherited PATH.
@@ -86,7 +88,7 @@ export function toV2Models(
86
88
  modelID: m.id,
87
89
  providerID: PROVIDER_ID,
88
90
  name: m.cost ? m.name : `${m.name}${UNPRICED_SUFFIX}`,
89
- package: PROVIDER_PACKAGE,
91
+ package: usesResponsesApi(m.id) ? RESPONSES_PACKAGE : PROVIDER_PACKAGE,
90
92
  capabilities: {
91
93
  tools: true,
92
94
  input: m.image_input ? ["text", "image"] : ["text"],
@@ -285,7 +287,7 @@ export async function setupV2(ctx: V2Context, exec?: Exec): Promise<void> {
285
287
  const key = await readCliKey(run);
286
288
  if (!key) return;
287
289
 
288
- const models = toV2Models(await listCliModels(run, directory), info.reasoning_effort);
290
+ const models = toV2Models(await listCliModels(run), info.reasoning_effort);
289
291
  if (models.length === 0) return;
290
292
 
291
293
  await ctx.provider.transform((editor) => {
@@ -1,133 +0,0 @@
1
- import { expect, test } from "bun:test";
2
- import { mkdtempSync } from "node:fs";
3
- import { tmpdir } from "node:os";
4
- import { join } from "node:path";
5
- import { BifrostGateway } from "./index.js";
6
-
7
- // Exercises the REAL ./datasheet.js (no mock.module): the supplement is
8
- // env + fetch driven, so the test points GATEWAY_DATASHEET_URL at a stubbed
9
- // fetch and HOME at a temp dir. This keeps the whole supplement path —
10
- // datasheet.js through shared.ts's listCliModels — honest without
11
- // rewriting module bindings, which leak across test files in one process.
12
-
13
- const ORIGINAL_FETCH = globalThis.fetch;
14
- const ORIGINAL_HOME = process.env.HOME;
15
- const ORIGINAL_XDG_CACHE_HOME = process.env.XDG_CACHE_HOME;
16
- const ORIGINAL_DATASHEET_URL = process.env.GATEWAY_DATASHEET_URL;
17
-
18
- const EXTRA_FLASH = "glm-5p3-flash";
19
-
20
- const RESOLUTION = {
21
- env: "prod",
22
- root: "/repo",
23
- anthropic_base_url: "https://gw.example.com/anthropic",
24
- openai_base_url: "https://gw.example.com/openai/v1",
25
- has_key: true,
26
- };
27
-
28
- const SHELL: Record<string, string> = {
29
- "resolve --json": JSON.stringify(RESOLUTION),
30
- "key print": "sk-bf-projectkey\n",
31
- "models --wire=openai": JSON.stringify({
32
- wire: "openai-completions",
33
- env: "prod",
34
- models: [
35
- {
36
- id: "anthropic/claude-haiku-4-5-20251001",
37
- name: "Claude Haiku 4.5",
38
- context_window: 200000,
39
- max_output_tokens: 64000,
40
- cost: { input: 1, output: 5, cache_read: 0.1, cache_write: 1.25 },
41
- limits_source: "gateway",
42
- cost_source: "catalog",
43
- },
44
- {
45
- id: "bedrock/amazon.nova-lite-v1:0",
46
- name: "Nova Lite",
47
- context_window: 300000,
48
- max_output_tokens: 8192,
49
- cost: { input: 0.06, output: 0.24, cache_read: 0.015, cache_write: 0 },
50
- limits_source: "catalog",
51
- cost_source: "catalog",
52
- },
53
- ],
54
- }),
55
- };
56
-
57
- function fakeShell(responses: Record<string, string>) {
58
- return (_strings: TemplateStringsArray, ...values: unknown[]) => {
59
- const argv = (values[1] as string[]) ?? [];
60
- const cmd = argv.join(" ");
61
- const chain = {
62
- cwd: () => chain,
63
- quiet: () => chain,
64
- text: async () => {
65
- if (!(cmd in responses)) throw new Error(`command failed: ${cmd}`);
66
- return responses[cmd];
67
- },
68
- };
69
- return chain;
70
- };
71
- }
72
-
73
- test("appends datasheet supplement ids to the bifrost provider's models map", async () => {
74
- // Home holds no ~/.config/bifrost/datasheet.json, so the env override is
75
- // the only activation; the cache dir under it is otherwise empty.
76
- const home = mkdtempSync(join(tmpdir(), "gw-oc-ds-"));
77
- process.env.HOME = home;
78
- // datasheetCacheDir() checks XDG_CACHE_HOME before HOME, so pin it under
79
- // the temp home too — otherwise CI/Linux reads and dirties the real cache.
80
- process.env.XDG_CACHE_HOME = join(home, ".cache");
81
- process.env.GATEWAY_DATASHEET_URL = "https://feed.example/datasheet";
82
- // The stubbed feed answers immediately, so the supplement is active this run.
83
- globalThis.fetch = (async () => ({
84
- ok: true,
85
- status: 200,
86
- json: async () => ({
87
- "fireworks_ai/glm-5p3-flash": {
88
- mode: "chat",
89
- base_model: "glm-5p3-flash",
90
- max_input_tokens: 1048576,
91
- max_output_tokens: 131072,
92
- },
93
- }),
94
- })) as never;
95
- try {
96
- const hooks = await BifrostGateway({
97
- directory: "/repo",
98
- $: fakeShell(SHELL),
99
- client: {
100
- app: { log: async () => undefined },
101
- instance: { dispose: async () => {} },
102
- },
103
- } as never);
104
- const cfg = {
105
- command: {},
106
- provider: {},
107
- } as unknown as {
108
- command: Record<string, unknown>;
109
- provider: Record<
110
- string,
111
- { models: Record<string, { limit: { context: number; output: number } }> }
112
- >;
113
- };
114
- await hooks.config!(cfg as never);
115
- const ids = Object.keys(cfg.provider.bifrost.models);
116
- // The CLI's list survives; the supplemented id is appended alongside.
117
- expect(ids).toContain("anthropic/claude-haiku-4-5-20251001");
118
- expect(ids).toContain("bedrock/amazon.nova-lite-v1:0");
119
- expect(ids).toContain(EXTRA_FLASH);
120
- expect(cfg.provider.bifrost.models[EXTRA_FLASH]!.limit).toEqual({
121
- context: 1048576,
122
- output: 131072,
123
- });
124
- } finally {
125
- globalThis.fetch = ORIGINAL_FETCH;
126
- if (ORIGINAL_HOME === undefined) delete process.env.HOME;
127
- else process.env.HOME = ORIGINAL_HOME;
128
- if (ORIGINAL_XDG_CACHE_HOME === undefined) delete process.env.XDG_CACHE_HOME;
129
- else process.env.XDG_CACHE_HOME = ORIGINAL_XDG_CACHE_HOME;
130
- if (ORIGINAL_DATASHEET_URL === undefined) delete process.env.GATEWAY_DATASHEET_URL;
131
- else process.env.GATEWAY_DATASHEET_URL = ORIGINAL_DATASHEET_URL;
132
- }
133
- });
@@ -1,355 +0,0 @@
1
- import { describe, expect, test } from "bun:test";
2
- import {
3
- existsSync,
4
- mkdirSync,
5
- mkdtempSync,
6
- readFileSync,
7
- writeFileSync,
8
- } from "node:fs";
9
- import { tmpdir } from "node:os";
10
- import { join } from "node:path";
11
- import {
12
- type FetchLike,
13
- type SupplementalModel,
14
- datasheetUrl,
15
- fetchDatasheet,
16
- mergeModels,
17
- parseDatasheet,
18
- } from "./datasheet.js";
19
- import { toConfigModels, type CliModels } from "./index.js";
20
-
21
- const glmFlash = {
22
- provider: "fireworks_ai",
23
- mode: "chat",
24
- base_model: "glm-5.3-flash",
25
- context_length: 1048576,
26
- max_input_tokens: 1048576,
27
- max_output_tokens: 131072,
28
- input_cost_per_token: 0.00000015,
29
- cache_read_input_token_cost: 0.000000029,
30
- output_cost_per_token: 0.0000005,
31
- supports_reasoning: true,
32
- };
33
-
34
- describe("parseDatasheet", () => {
35
- test("maps a fireworks_ai chat entry, converting per-token to per-million", () => {
36
- const out = parseDatasheet({
37
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": glmFlash,
38
- });
39
- expect(out).toHaveLength(1);
40
- expect(out[0]).toEqual({
41
- id: "accounts/fireworks/models/glm-5p3-flash",
42
- name: "glm-5.3-flash",
43
- context_window: 1048576,
44
- max_output_tokens: 131072,
45
- limits_source: "datasheet",
46
- cost_source: "datasheet",
47
- cost: {
48
- input: 0.15,
49
- output: 0.5,
50
- cache_read: 0.029,
51
- cache_write: 0,
52
- },
53
- reasoning: true,
54
- } satisfies SupplementalModel);
55
- });
56
-
57
- test("maps supports_image_input to image_input only when true", () => {
58
- const out = parseDatasheet({
59
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": {
60
- ...glmFlash,
61
- supports_image_input: true,
62
- },
63
- "fireworks_ai/accounts/fireworks/models/glm-5p2": {
64
- ...glmFlash,
65
- supports_image_input: false,
66
- },
67
- });
68
- expect(out).toHaveLength(2);
69
- const byId = new Map(out.map((m) => [m.id, m]));
70
- expect(byId.get("accounts/fireworks/models/glm-5p3-flash")?.image_input).toBe(true);
71
- expect(byId.get("accounts/fireworks/models/glm-5p2")?.image_input).toBeUndefined();
72
- });
73
-
74
- test("maps supports_vision to image_input — the upstream field name (1570 rows vs 8 for supports_image_input)", () => {
75
- const out = parseDatasheet({
76
- "fireworks_ai/accounts/fireworks/models/deepseek-v4-flash-vision-exp": {
77
- ...glmFlash,
78
- supports_vision: true,
79
- },
80
- "fireworks_ai/accounts/fireworks/models/deepseek-v4-flash": {
81
- ...glmFlash,
82
- supports_vision: false,
83
- },
84
- });
85
- expect(out).toHaveLength(2);
86
- const byId = new Map(out.map((m) => [m.id, m]));
87
- expect(byId.get("accounts/fireworks/models/deepseek-v4-flash-vision-exp")?.image_input).toBe(true);
88
- expect(byId.get("accounts/fireworks/models/deepseek-v4-flash")?.image_input).toBeUndefined();
89
- });
90
-
91
- test("falls back to max_input_tokens when context_length is absent — upstream rows never carry context_length", () => {
92
- const { context_length, ...upstreamShape } = glmFlash;
93
- const out = parseDatasheet({
94
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": upstreamShape,
95
- });
96
- expect(out).toHaveLength(1);
97
- expect(out[0].context_window).toBe(upstreamShape.max_input_tokens);
98
- });
99
-
100
- test("reads cache_write from cache_creation_input_token_cost — the upstream field name (503 rows vs 0)", () => {
101
- const out = parseDatasheet({
102
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": {
103
- ...glmFlash,
104
- cache_creation_input_token_cost: 0.00000015,
105
- },
106
- });
107
- expect(out).toHaveLength(1);
108
- expect(out[0].cost?.cache_write).toBe(0.15);
109
- });
110
-
111
- test("drops non-chat entries, unknown providers, and rows without limits", () => {
112
- const out = parseDatasheet({
113
- "fireworks_ai/accounts/fireworks/models/qwen3-embedding-8b": {
114
- ...glmFlash,
115
- mode: "embedding",
116
- },
117
- "other_provider/some/model": glmFlash,
118
- "fireworks_ai/accounts/fireworks/models/no-limits": {
119
- ...glmFlash,
120
- context_length: undefined,
121
- max_input_tokens: undefined,
122
- },
123
- "fireworks_ai/accounts/fireworks/models/no-max-out": {
124
- ...glmFlash,
125
- max_output_tokens: undefined,
126
- },
127
- });
128
- expect(out).toEqual([]);
129
- });
130
-
131
- test("unpriced entry omits cost entirely and falls back to slug name", () => {
132
- const out = parseDatasheet({
133
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": {
134
- mode: "chat",
135
- context_length: 1000,
136
- max_output_tokens: 100,
137
- },
138
- });
139
- expect(out[0]?.name).toBe("glm-5p3-flash");
140
- expect(out[0]?.cost).toBeUndefined();
141
- expect(out[0]?.cost_source).toBeUndefined();
142
- });
143
- });
144
-
145
- describe("mergeModels", () => {
146
- test("appends ids the CLI list lacks; CLI entry wins on collision", () => {
147
- // mergeModels is generic over {id: string}: dedup is by id only, so the
148
- // test uses plain {id, name} literals rather than full model shapes.
149
- const cli = [
150
- { id: "a", name: "A" },
151
- { id: "b", name: "B" },
152
- ];
153
- const extra = [
154
- { id: "b", name: "B-datasheet" },
155
- { id: "c", name: "C" },
156
- ];
157
- expect(mergeModels(cli, extra)).toEqual([
158
- { id: "a", name: "A" },
159
- { id: "b", name: "B" },
160
- { id: "c", name: "C" },
161
- ]);
162
- });
163
- });
164
-
165
- describe("datasheetUrl", () => {
166
- const tmp = mkdtempSync(join(tmpdir(), "gw-ds-"));
167
- const proj = join(tmp, "proj");
168
- const home = join(tmp, "home");
169
- mkdirSync(join(proj, ".gateway"), { recursive: true });
170
- mkdirSync(join(home, ".config", "bifrost"), { recursive: true });
171
-
172
- test("env var wins over files", () => {
173
- expect(datasheetUrl("https://env/datasheet", home, proj)).toBe(
174
- "https://env/datasheet",
175
- );
176
- });
177
-
178
- test("user file beats project file", () => {
179
- writeFileSync(
180
- join(home, ".config", "bifrost", "datasheet.json"),
181
- `{"url": "https://user/datasheet"}`,
182
- );
183
- writeFileSync(
184
- join(proj, ".gateway", "datasheet.json"),
185
- `{"url": "https://proj/datasheet"}`,
186
- );
187
- expect(datasheetUrl(undefined, home, proj)).toBe("https://user/datasheet");
188
- });
189
-
190
- test("project file used when user-level absent; null when neither", () => {
191
- // Self-seeded: does not depend on files written by earlier tests.
192
- writeFileSync(
193
- join(proj, ".gateway", "datasheet.json"),
194
- `{"url": "https://proj/datasheet"}`,
195
- );
196
- // a home with no datasheet.json falls through to the project file
197
- const homeEmpty = join(tmp, "home-empty");
198
- mkdirSync(homeEmpty, { recursive: true });
199
- expect(datasheetUrl(undefined, homeEmpty, proj)).toBe(
200
- "https://proj/datasheet",
201
- );
202
- expect(datasheetUrl(undefined, homeEmpty, join(tmp, "other"))).toBeNull();
203
- });
204
-
205
- test("non-https URLs are treated as absent and fall through", () => {
206
- // Feeds steer local model listings, so every source must be TLS: an
207
- // http:// project file is skipped, and with nothing else yielding a
208
- // URL the result is null.
209
- const projHttp = join(tmp, "proj-http");
210
- mkdirSync(join(projHttp, ".gateway"), { recursive: true });
211
- writeFileSync(
212
- join(projHttp, ".gateway", "datasheet.json"),
213
- `{"url": "http://insecure/datasheet"}`,
214
- );
215
- const homeEmpty = join(tmp, "home-empty-http");
216
- mkdirSync(homeEmpty, { recursive: true });
217
- expect(datasheetUrl(undefined, homeEmpty, projHttp)).toBeNull();
218
- // A non-TLS env override likewise falls through to an https file.
219
- writeFileSync(
220
- join(projHttp, ".gateway", "datasheet.json"),
221
- `{"url": "https://proj/datasheet"}`,
222
- );
223
- expect(
224
- datasheetUrl("http://insecure-env/datasheet", homeEmpty, projHttp),
225
- ).toBe("https://proj/datasheet");
226
- });
227
- });
228
-
229
- describe("fetchDatasheet", () => {
230
- const tmp = mkdtempSync(join(tmpdir(), "gw-ds-cache-"));
231
- // Each test gets its own cache file so results never depend on run order.
232
- const cachePath = (name: string) => join(tmp, `${name}.json`);
233
- const ok: FetchLike = async () => ({
234
- ok: true,
235
- json: async () => ({
236
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": glmFlash,
237
- }),
238
- });
239
- const fail: FetchLike = async () => ({ ok: false, json: async () => ({}) });
240
-
241
- test("fetches, returns parsed body, writes cache", async () => {
242
- const body = await fetchDatasheet(
243
- "https://feed/datasheet",
244
- cachePath("t1"),
245
- ok,
246
- 1000,
247
- );
248
- expect(
249
- body?.["fireworks_ai/accounts/fireworks/models/glm-5p3-flash"],
250
- ).toBeDefined();
251
- const cached = JSON.parse(readFileSync(cachePath("t1"), "utf8"));
252
- expect(cached.fetchedAt).toBe(1000);
253
- });
254
-
255
- test("fresh cache short-circuits the fetch", async () => {
256
- // Seed a cache first so the counting call below has something to hit.
257
- await fetchDatasheet("https://feed/datasheet", cachePath("t2"), ok, 1000);
258
- let called = 0;
259
- const counting: FetchLike = async () => {
260
- called++;
261
- return ok("u");
262
- };
263
- await fetchDatasheet(
264
- "https://feed/datasheet",
265
- cachePath("t2"),
266
- counting,
267
- 1000 + 1000,
268
- );
269
- expect(called).toBe(0);
270
- });
271
-
272
- test("expired cache refetches; fetch failure falls back to stale cache", async () => {
273
- await fetchDatasheet("https://feed/datasheet", cachePath("t3"), ok, 1000);
274
- const body = await fetchDatasheet(
275
- "https://feed/datasheet",
276
- cachePath("t3"),
277
- fail,
278
- 1000 + 3_600_000 + 1,
279
- );
280
- expect(
281
- body?.["fireworks_ai/accounts/fireworks/models/glm-5p3-flash"],
282
- ).toBeDefined();
283
- });
284
-
285
- test("fetch failure with no cache returns null", async () => {
286
- expect(
287
- await fetchDatasheet(
288
- "https://feed/datasheet",
289
- cachePath("absent"),
290
- fail,
291
- 1000,
292
- ),
293
- ).toBeNull();
294
- });
295
-
296
- test("failed fetch with no cache backfills the cache in the background", async () => {
297
- const path = cachePath("backfill");
298
- let calls = 0;
299
- const flaky: FetchLike = async () => {
300
- calls++;
301
- if (calls === 1) throw new Error("cold start");
302
- return {
303
- ok: true,
304
- json: async () => ({
305
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": glmFlash,
306
- }),
307
- };
308
- };
309
- const first = await fetchDatasheet(
310
- "https://feed/datasheet",
311
- path,
312
- flaky,
313
- 1000,
314
- );
315
- expect(first).toBeNull(); // this session skips the supplement
316
- // the detached backfill (call 2) lands the cache for the next session
317
- const deadline = Date.now() + 2000;
318
- while (Date.now() < deadline) {
319
- if (existsSync(path)) break;
320
- await new Promise((r) => setTimeout(r, 25));
321
- }
322
- expect(calls).toBe(2);
323
- const doc = JSON.parse(readFileSync(path, "utf8")) as {
324
- fetchedAt: number;
325
- };
326
- expect(doc.fetchedAt).toBeGreaterThan(1000);
327
- });
328
- });
329
-
330
- describe("end-to-end: CLI payload + datasheet extra -> opencode config models", () => {
331
- test("supplemented id reaches the provider config with datasheet limits", () => {
332
- const cliPayload: CliModels = {
333
- models: [
334
- {
335
- id: "accounts/fireworks/models/glm-5p2",
336
- name: "GLM 5.2",
337
- context_window: 200000,
338
- max_output_tokens: 32768,
339
- limits_source: "gateway",
340
- },
341
- ],
342
- };
343
- const extra = parseDatasheet({
344
- "fireworks_ai/accounts/fireworks/models/glm-5p3-flash": glmFlash,
345
- });
346
- const merged = mergeModels(cliPayload.models ?? [], extra);
347
- const cfg = toConfigModels({ models: merged }, undefined);
348
- const flash = cfg["accounts/fireworks/models/glm-5p3-flash"];
349
- expect(flash).toBeDefined();
350
- expect(flash?.limit?.context).toBe(1048576);
351
- expect(flash?.limit?.output).toBe(131072);
352
- // CLI-listed model survives the merge untouched
353
- expect(cfg["accounts/fireworks/models/glm-5p2"]).toBeDefined();
354
- });
355
- });
package/src/datasheet.ts DELETED
@@ -1,303 +0,0 @@
1
- /**
2
- * Datasheet supplement: a second, faster id source for wildcard-provider
3
- * models the CLI cannot list yet.
4
- *
5
- * The CLI sources Fireworks (wildcard-provider) ids from models.dev, which
6
- * lags provider launches by days and is cached 24h. Bifrost itself syncs
7
- * from the datasheet-proxy feed hourly, so a model merged there is routable —
8
- * this module reads the same feed and merges the ids the CLI list lacks.
9
- * The virtual key never passes through here: the feed is public.
10
- *
11
- * Off by default. Activated by (first wins; the URL must be https — any
12
- * source yielding something else is treated as absent):
13
- * 1. env GATEWAY_DATASHEET_URL
14
- * 2. ~/.config/bifrost/datasheet.json {"url": "<function-url>/datasheet"}
15
- * 3. <project-root>/.gateway/datasheet.json
16
- *
17
- * Security note: entries only produce local picker listings and metadata;
18
- * requests still go to the CLI-resolved (allowlisted) gateway origin. A
19
- * hostile feed cannot redirect traffic or exfiltrate the key.
20
- */
21
- import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
22
- import { dirname, join } from "node:path";
23
-
24
- /** One row of the datasheet feed (flat map keyed by "<provider>/<model-id>"). */
25
- export type DatasheetEntry = {
26
- provider?: string;
27
- mode?: string;
28
- base_model?: string;
29
- context_length?: number;
30
- max_input_tokens?: number;
31
- max_output_tokens?: number;
32
- max_tokens?: number;
33
- input_cost_per_token?: number;
34
- output_cost_per_token?: number;
35
- cache_read_input_token_cost?: number;
36
- // Upstream rows name the cache-write rate `cache_creation_input_token_cost`
37
- // (503 rows); the `cache_write_…` spelling appears on zero rows and is
38
- // kept for symmetry with Bifrost's own pricing-card vocabulary.
39
- cache_write_input_token_cost?: number;
40
- cache_creation_input_token_cost?: number;
41
- supports_reasoning?: boolean;
42
- // Upstream rows express image capability as `supports_vision` (1,570
43
- // rows); `supports_image_input` appears on only 8. Either true counts.
44
- supports_vision?: boolean;
45
- supports_image_input?: boolean;
46
- };
47
-
48
- /** A model in the same shape `gateway-cli models` emits (structural subset). */
49
- export type SupplementalModel = {
50
- id: string;
51
- name: string;
52
- context_window: number;
53
- max_output_tokens: number;
54
- limits_source: string;
55
- cost_source?: string;
56
- cost?: {
57
- input: number;
58
- output: number;
59
- cache_read: number;
60
- cache_write: number;
61
- };
62
- reasoning?: boolean;
63
- image_input?: boolean;
64
- };
65
-
66
- /** Datasheet provider prefixes whose entries this module understands. */
67
- const PROVIDER_PREFIXES = ["fireworks_ai/"];
68
-
69
- /** How long a fetched feed is reused before refetching. */
70
- const DATASHEET_TTL_MS = 60 * 60 * 1000;
71
-
72
- /** Fetch hard timeout: the supplement must never block plugin init long. */
73
- const FETCH_TIMEOUT_MS = 3000;
74
-
75
- /** Budget for the background cache fill after a failed fetch: init is never
76
- * blocked by it, so it can afford to outlast a cold feed start. */
77
- const BACKFILL_TIMEOUT_MS = 15_000;
78
-
79
- export type FetchLike = (
80
- url: string,
81
- init?: { signal?: AbortSignal },
82
- ) => Promise<{ ok: boolean; status?: number; json(): Promise<unknown> }>;
83
-
84
- type CacheDoc = { fetchedAt: number; body: Record<string, DatasheetEntry> };
85
-
86
- /**
87
- * Discover the feed URL: env, then user file, then project file. Only
88
- * https:// URLs are honored; a source with anything else (including a
89
- * non-TLS env override) falls through to the next candidate.
90
- */
91
- export function datasheetUrl(
92
- env: string | undefined,
93
- home: string | undefined,
94
- root: string,
95
- ): string | null {
96
- if (env && env.startsWith("https://")) return env;
97
- const candidates = [
98
- home ? join(home, ".config", "bifrost", "datasheet.json") : null,
99
- join(root, ".gateway", "datasheet.json"),
100
- ];
101
- for (const p of candidates) {
102
- if (!p) continue;
103
- try {
104
- const parsed = JSON.parse(readFileSync(p, "utf8")) as { url?: unknown };
105
- if (
106
- typeof parsed.url === "string" &&
107
- parsed.url.startsWith("https://")
108
- ) {
109
- return parsed.url;
110
- }
111
- } catch {
112
- // absent or malformed: try the next candidate
113
- }
114
- }
115
- return null;
116
- }
117
-
118
- function readCache(path: string): CacheDoc | null {
119
- try {
120
- const doc = JSON.parse(readFileSync(path, "utf8")) as CacheDoc;
121
- if (
122
- typeof doc.fetchedAt === "number" &&
123
- doc.body &&
124
- typeof doc.body === "object"
125
- ) {
126
- return doc;
127
- }
128
- } catch {
129
- // absent or malformed: treat as no cache
130
- }
131
- return null;
132
- }
133
-
134
- function writeCache(path: string, doc: CacheDoc): void {
135
- try {
136
- mkdirSync(dirname(path), { recursive: true });
137
- writeFileSync(path, JSON.stringify(doc));
138
- } catch {
139
- // cache write failure is non-fatal: refetch next init
140
- }
141
- }
142
-
143
- /**
144
- * Default fetch adapter: narrows the platform Response to FetchLike's
145
- * subset so callers can inject a mock without touching the global fetch.
146
- */
147
- const defaultFetch: FetchLike = async (u, i) => {
148
- const resp = await fetch(u, i);
149
- return { ok: resp.ok, status: resp.status, json: () => resp.json() };
150
- };
151
-
152
- /**
153
- * Fetch the feed, honoring a fresh cache. On fetch failure a stale cache is
154
- * served; with no cache at all the result is null and the caller skips the
155
- * supplement. Garbage responses (non-object JSON, HTTP error) are treated
156
- * as fetch failures so they never poison the cache. A fetch failure with no
157
- * cache also triggers an unawaited backfill fetch (15s budget) that only
158
- * writes the cache, so a cold feed costs one session, not one per start.
159
- */
160
- export async function fetchDatasheet(
161
- url: string,
162
- cachePath: string,
163
- fetchImpl: FetchLike = defaultFetch,
164
- now: number = Date.now(),
165
- ): Promise<Record<string, DatasheetEntry> | null> {
166
- const cached = readCache(cachePath);
167
- if (cached && now - cached.fetchedAt < DATASHEET_TTL_MS) return cached.body;
168
- try {
169
- const resp = await fetchImpl(url, {
170
- signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
171
- });
172
- if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
173
- const body = (await resp.json()) as Record<string, DatasheetEntry>;
174
- if (!body || typeof body !== "object" || Array.isArray(body)) {
175
- throw new Error("unexpected feed shape");
176
- }
177
- writeCache(cachePath, { fetchedAt: now, body });
178
- return body;
179
- } catch {
180
- if (!cached) {
181
- // Fire-and-forget warm fill: a slow feed (cold start) must not block
182
- // plugin init, but the next session should find a warm cache. Never
183
- // awaited; every failure path is swallowed (writeCache guards, and
184
- // the .catch below covers the rest).
185
- void fetchImpl(url, {
186
- signal: AbortSignal.timeout(BACKFILL_TIMEOUT_MS),
187
- })
188
- .then(async (resp) => {
189
- if (!resp.ok) return;
190
- const body = (await resp.json()) as Record<string, DatasheetEntry>;
191
- if (body && typeof body === "object" && !Array.isArray(body)) {
192
- writeCache(cachePath, { fetchedAt: Date.now(), body });
193
- }
194
- })
195
- .catch(() => {});
196
- }
197
- return cached?.body ?? null;
198
- }
199
- }
200
-
201
- function perMillion(rate: number | undefined): number {
202
- return typeof rate === "number" ? Math.round(rate * 1_000_000 * 1e8) / 1e8 : 0;
203
- }
204
-
205
- /**
206
- * Turn feed rows into model entries. Keeps only chat-mode rows under a known
207
- * provider prefix, requires usable limits, converts per-token rates to
208
- * per-million (mirroring the CLI's perTokenToPerMTok).
209
- */
210
- export function parseDatasheet(
211
- body: Record<string, DatasheetEntry>,
212
- ): SupplementalModel[] {
213
- const out: SupplementalModel[] = [];
214
- for (const [key, e] of Object.entries(body)) {
215
- if (!e || typeof e !== "object" || e.mode !== "chat") continue;
216
- const prefix = PROVIDER_PREFIXES.find((p) => key.startsWith(p));
217
- if (!prefix) continue;
218
- const id = key.slice(prefix.length);
219
- if (!id) continue;
220
- // Upstream rows never carry `context_length` (0 of 4,336); they state
221
- // `max_input_tokens` instead. Either sets the context window.
222
- const contextLength =
223
- typeof e.context_length === "number"
224
- ? e.context_length
225
- : typeof e.max_input_tokens === "number"
226
- ? e.max_input_tokens
227
- : undefined;
228
- if (
229
- typeof contextLength !== "number" ||
230
- typeof e.max_output_tokens !== "number"
231
- ) {
232
- continue;
233
- }
234
- const slug = id.split("/").pop() as string;
235
- const priced =
236
- typeof e.input_cost_per_token === "number" ||
237
- typeof e.output_cost_per_token === "number";
238
- out.push({
239
- id,
240
- name:
241
- typeof e.base_model === "string" && e.base_model ? e.base_model : slug,
242
- context_window: contextLength,
243
- max_output_tokens: e.max_output_tokens,
244
- limits_source: "datasheet",
245
- ...(priced
246
- ? {
247
- cost_source: "datasheet",
248
- cost: {
249
- input: perMillion(e.input_cost_per_token),
250
- output: perMillion(e.output_cost_per_token),
251
- cache_read: perMillion(e.cache_read_input_token_cost),
252
- cache_write: perMillion(
253
- e.cache_write_input_token_cost ??
254
- e.cache_creation_input_token_cost,
255
- ),
256
- },
257
- }
258
- : {}),
259
- ...(e.supports_reasoning === true ? { reasoning: true } : {}),
260
- ...(e.supports_image_input === true || e.supports_vision === true
261
- ? { image_input: true }
262
- : {}),
263
- });
264
- }
265
- return out;
266
- }
267
-
268
- /** Merge supplemented ids into the CLI list. The CLI entry wins on collision. */
269
- export function mergeModels<A extends { id: string }>(
270
- cli: A[],
271
- extra: A[],
272
- ): A[] {
273
- const seen = new Set(cli.map((m) => m.id));
274
- return [...cli, ...extra.filter((m) => !seen.has(m.id))];
275
- }
276
-
277
- /**
278
- * Entry point for the plugin: resolve the feed URL for this project, fetch
279
- * (cached), and return supplementable models. Empty when the feature is off
280
- * or the feed is unreachable and uncached — never throws, never blocks init
281
- * beyond FETCH_TIMEOUT_MS.
282
- *
283
- * cacheDir may be any writable directory; the cache file is named
284
- * datasheet-cache.json so it can never collide with a discovery config file.
285
- */
286
- export async function datasheetSupplement(
287
- root: string,
288
- cacheDir: string,
289
- fetchImpl?: FetchLike,
290
- ): Promise<SupplementalModel[]> {
291
- const url = datasheetUrl(
292
- process.env.GATEWAY_DATASHEET_URL,
293
- process.env.HOME,
294
- root,
295
- );
296
- if (!url) return [];
297
- const body = await fetchDatasheet(
298
- url,
299
- join(cacheDir, "datasheet-cache.json"),
300
- fetchImpl,
301
- );
302
- return body ? parseDatasheet(body) : [];
303
- }