@agilesyndrome/cf-genai-llm 4.1.0 → 4.1.2

package/CONTRACT.md

@@ -3,6 +3,10 @@
 - createFeature(options) returns name and middleware.
 - createLLM(options) returns `generate`, `generateMulti`, `review`, and `reviewMulti`.
 - `generateMulti` and `reviewMulti` start all requests concurrently and preserve input order.
+- The client uses the OpenAI Responses-compatible contract; OpenAI is the default endpoint and arbitrary compatible endpoints are supported.
+- `LLM_API_URL`, `LLM_API_TOKEN`, and `LLM_MODEL` are the universal configuration variables.
+- Cloudflare AI Gateway is detected from its URL and uses `cf-aig-authorization`; direct compatible endpoints use `Authorization`.
+- `LLM_MODEL=auto` selects the first model returned by the configured `/models` endpoint.
 - A JSON Schema may be passed as the second argument or in `{ schema }`; invalid model data gets one repair request.
 - Failed responses throw `LLMResponseError` with `code=response_failed`, `responseFailed=true`, and the raw `llmResponse`.
 - Each request emits one-line JSON request/response logs with request ID, metadata, duration, status, and token counts.

package/README.md

@@ -11,6 +11,38 @@ const result = await llm.generate("Write a summary", schema, { schemaName: "summ
 const reviews = await llm.reviewMulti(result, reviewerPrompts, reviewSchema);
 ```
 
+## Providers and AI Gateway
+
+The client speaks the OpenAI Responses-compatible API. OpenAI is the default
+endpoint, while any compatible service (including OpenRelay-style endpoints)
+can be selected with the same URL, token, and model variables.
+
+```js
+// Direct OpenAI API access remains the default.
+const direct = createLLM({ env });
+
+// Gateway is a routing/control layer; OpenAI still performs inference.
+const gateway = createLLM({ env });
+```
+
+The URL may be either a provider base URL or its `/responses` endpoint. Model
+list requests use the matching `/models` route. Cloudflare AI Gateway is
+detected from its hostname and receives the token in `cf-aig-authorization`;
+direct compatible endpoints use `Authorization: Bearer ...`.
+
+Cloudflare Workers AI can be reached through an OpenAI-compatible Gateway URL;
+the package does not use the Workers AI binding directly.
+
+### Environment configuration
+
+| Variable | Purpose |
+| --- | --- |
+| `LLM_API_URL` | Universal OpenAI-compatible Responses URL or API base URL |
+| `LLM_API_TOKEN` | Universal provider or Gateway token |
+| `LLM_MODEL` | Universal model name; use `auto` to select from `/models` |
+
+Set `LLM_MODEL=auto` when the provider supports a `/models` endpoint.
+
 A feature exports an object with middleware(request, env, ctx, next, state).
 Applications layer it into @agilesyndrome/cf-genai-base:
 

package/package.json

@@ -1 +1 @@
-{"name":"@agilesyndrome/cf-genai-llm","version":"4.1.0","description":"Composable Cloudflare Worker LLM generation and review client.","type":"module","exports":{".":"./src/index.js"},"files":["src","tests","README.md","CONTRACT.md","LICENSE"],"scripts":{"check":"node --check src/index.js","test":"node --test tests/*.test.mjs","build":"npm run check && npm test && npm pack --dry-run"},"license":"MIT","publishConfig":{"access":"public","provenance":true},"repository":{"type":"git","url":"git+https://github.com/agilesyndrome/cf-genai-llm.git"},"homepage":"https://github.com/agilesyndrome/cf-genai-llm#readme","dependencies":{"@agilesyndrome/cf-genai-base":"^4.1.1"}}
+{"name":"@agilesyndrome/cf-genai-llm","version":"4.1.2","description":"Composable Cloudflare Worker LLM generation and review client.","type":"module","exports":{".":"./src/index.js"},"files":["src","tests","README.md","CONTRACT.md","LICENSE"],"scripts":{"check":"node --check src/index.js","test":"node --test tests/*.test.mjs","build":"npm run check && npm test && npm pack --dry-run"},"license":"MIT","publishConfig":{"access":"public","provenance":true},"repository":{"type":"git","url":"git+https://github.com/agilesyndrome/cf-genai-llm.git"},"homepage":"https://github.com/agilesyndrome/cf-genai-llm#readme","dependencies":{"@agilesyndrome/cf-genai-base":"^4.1.1"}}

package/src/index.js

@@ -1,9 +1,7 @@
 const DEFAULT_ENDPOINT = "https://api.openai.com/v1/responses";
 const DEFAULT_MODEL = "gpt-5.4";
-
-const DEFAULT_MODELS_ENDPOINT = "https://api.openai.com/v1/models";
 export const PACKAGE_NAME = "@agilesyndrome/cf-genai-llm";
-export const VERSION = "0.1.11";
+export const VERSION = "4.1.1";
 export class LLMCircuitBreakerError extends Error { constructor(message = "LLM generation is temporarily unavailable") { super(message); this.name = "LLMCircuitBreakerError"; this.code = "circuit_breaker_open"; this.circuitBreakerOpen = true; } }
 
 import { getCircuitBreaker, registerCircuitBreaker, registerHealthcheck, setCircuitBreaker } from "@agilesyndrome/cf-genai-base";
@@ -20,13 +18,11 @@ export class LLMResponseError extends Error {
 export function createLLM(options = {}) {
   const fetcher = options.fetch || globalThis.fetch;
   const logger = options.logger || console;
-  const endpoint = options.endpoint || ((env) => env?.OPENAI_COMPLETIONS_URL || DEFAULT_ENDPOINT);
-  const model = options.model || ((env) => env?.OPENAI_MODEL || DEFAULT_MODEL);
   const defaults = options.metadata || {};
   const debugLogging = options.debugLogging === true;
   const featureName = options.feature || options.featureName || "cf-genai-llm";
-  const breakerId = options.breakerId || featureName + ":openai-models";
-  const healthcheckId = options.healthcheckId || featureName + ":openai-models";
+  const breakerId = options.breakerId || featureName + ":llm-models";
+  const healthcheckId = options.healthcheckId || featureName + ":llm-models";
   if (typeof fetcher !== "function") throw new TypeError("createLLM requires fetch");
 
   const log = (level, event) => {
@@ -36,30 +32,30 @@ export function createLLM(options = {}) {
 
   async function assertAvailable(requestOptions = {}) { const env = requestOptions.env || options.env; if (!env || !env.DB || requestOptions.allowWhenCircuitTripped) return; const breaker = await getCircuitBreaker(env, breakerId, { who: requestOptions.who || "system:read" }).catch(() => null); if (breaker && breaker.state !== "on") throw new LLMCircuitBreakerError(); }
 
-  async function listModels(requestOptions = {}) { const env = requestOptions.env || options.env; const apiKey = requestOptions.apiKey || options.apiKey || (env && env.OPENAI_API_KEY); if (!apiKey) throw new Error("OPENAI_API_KEY is not configured"); const modelsEndpoint = requestOptions.modelsEndpoint || options.modelsEndpoint || (typeof endpoint === "string" && endpoint.endsWith("/responses") ? endpoint.slice(0, -10) + "models" : DEFAULT_MODELS_ENDPOINT); try { const response = await fetcher(typeof modelsEndpoint === "function" ? modelsEndpoint(env) : modelsEndpoint, { method: "GET", headers: { Authorization: "Bearer " + apiKey }, signal: requestOptions.signal }); const payload = await response.json(); if (!response.ok) throw new LLMResponseError("OpenAI model list failed (" + response.status + ")", payload); if (env && env.DB) { await registerHealthcheck(env, { id: healthcheckId, feature: featureName, component: "openai-models", displayName: "OpenAI model availability", state: "green", metadata: { count: Array.isArray(payload.data) ? payload.data.length : 0 } }, { who: requestOptions.who || "system:update" }); await registerCircuitBreaker(env, { id: breakerId, feature: featureName, name: "openai-models", displayName: "OpenAI model access", state: "on", allowSelfHealing: true, healthchecks: [healthcheckId] }, { who: requestOptions.who || "system:update" }); await setCircuitBreaker(env, breakerId, "on", { who: requestOptions.who || "system:update", automated: true }).catch(() => {}); } return payload.data || []; } catch (error) { if (env && env.DB) { await registerHealthcheck(env, { id: healthcheckId, feature: featureName, component: "openai-models", displayName: "OpenAI model availability", state: "red", metadata: { error: error.message } }, { who: requestOptions.who || "system:update" }).catch(() => {}); await registerCircuitBreaker(env, { id: breakerId, feature: featureName, name: "openai-models", displayName: "OpenAI model access", state: "on", allowSelfHealing: true, healthchecks: [healthcheckId] }, { who: requestOptions.who || "system:update" }).then(() => setCircuitBreaker(env, breakerId, "tripped", { who: requestOptions.who || "system:update", automated: true })).catch(() => {}); } throw error; } }
+  async function listModels(requestOptions = {}) { const env = requestOptions.env || options.env; const config = resolveConfig(options, requestOptions, env); try { const response = await fetcher(config.modelsEndpoint, { method: "GET", headers: config.headers, signal: requestOptions.signal }); const payload = await response.json(); if (!response.ok) throw new LLMResponseError("LLM model list failed (" + response.status + ")", payload); if (env && env.DB) { await registerHealthcheck(env, { id: healthcheckId, feature: featureName, component: "llm-models", displayName: "LLM model availability", state: "green", metadata: { provider: config.provider, gateway: config.gateway, count: Array.isArray(payload.data) ? payload.data.length : 0 } }, { who: requestOptions.who || "system:update" }); await registerCircuitBreaker(env, { id: breakerId, feature: featureName, name: "llm-models", displayName: "LLM model access", state: "on", allowSelfHealing: true, healthchecks: [healthcheckId] }, { who: requestOptions.who || "system:update" }); await setCircuitBreaker(env, breakerId, "on", { who: requestOptions.who || "system:update", automated: true }).catch(() => {}); } return payload.data || []; } catch (error) { if (env && env.DB) { await registerHealthcheck(env, { id: healthcheckId, feature: featureName, component: "llm-models", displayName: "LLM model availability", state: "red", metadata: { provider: config.provider, gateway: config.gateway, error: error.message } }, { who: requestOptions.who || "system:update" }).catch(() => {}); await registerCircuitBreaker(env, { id: breakerId, feature: featureName, name: "llm-models", displayName: "LLM model access", state: "on", allowSelfHealing: true, healthchecks: [healthcheckId] }, { who: requestOptions.who || "system:update" }).then(() => setCircuitBreaker(env, breakerId, "tripped", { who: requestOptions.who || "system:update", automated: true })).catch(() => {}); } throw error; } }
 
   async function request(prompt, schema, requestOptions = {}) { await assertAvailable(requestOptions);
     const started = Date.now();
     const requestId = requestOptions.requestId || crypto.randomUUID();
     const env = requestOptions.env || options.env;
-    const apiKey = requestOptions.apiKey || options.apiKey || env?.OPENAI_API_KEY;
-    if (!apiKey) throw new Error("OPENAI_API_KEY is not configured");
+    const config = resolveConfig(options, requestOptions, env);
     const metadata = { ...defaults, ...(requestOptions.metadata || {}) };
-    const body = { model: requestOptions.model || (typeof model === "function" ? model(env) : model), input: prompt, store: false };
+    const model = await resolveModel(config, fetcher, requestOptions);
+    const body = { model, input: prompt, store: false };
     if (Object.keys(metadata).length) body.metadata = metadata;
     if (schema) body.text = { format: { type: "json_schema", name: requestOptions.schemaName || "response", strict: true, schema } };
-    log("debug", { event: "llm.request", requestId, metadata, model: body.model, hasSchema: Boolean(schema) });
+    log("debug", { event: "llm.request", requestId, metadata, provider: config.provider, gateway: config.gateway, model: body.model, hasSchema: Boolean(schema) });
     let response, payload;
     try {
-      response = await fetcher(typeof endpoint === "function" ? endpoint(env) : endpoint, { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" }, body: JSON.stringify(body), signal: requestOptions.signal });
+      response = await fetcher(config.endpoint, { method: "POST", headers: config.headers, body: JSON.stringify(body), signal: requestOptions.signal });
       payload = await response.json();
     } catch (error) {
-      log("error", { event: "llm.error", requestId, durationMs: Date.now() - started, error: error.message });
+      log("error", { event: "llm.error", requestId, durationMs: Date.now() - started, error: error.message, provider: config.provider, gateway: config.gateway, model: body.model });
       throw error;
     }
     const usage = normalizeUsage(payload?.usage);
     if (requestOptions.onUsage) await requestOptions.onUsage(usage);
-    log(response.ok ? "info" : "error", { event: "llm.response", requestId, status: response.status, durationMs: Date.now() - started, usage, metadata });
+    log(response.ok ? "info" : "error", { event: "llm.response", requestId, status: response.status, durationMs: Date.now() - started, usage, metadata, provider: config.provider, gateway: config.gateway, model: body.model });
     if (!response.ok) throw new LLMResponseError(`LLM request failed (${response.status})`, payload);
     const text = extractText(payload);
     if (!text) throw new LLMResponseError("LLM returned no text", payload);
@@ -116,6 +112,33 @@ function normalizeGenerateArgs(promptOrRequest, schemaOrOptions, maybeOptions) {
 }
 function normalizeReviewArgs(originalText, reviewPrompt, schemaOrOptions, maybeOptions) { const { schema, options } = normalizeSchemaOptions(schemaOrOptions, maybeOptions); return { originalText: String(originalText || ""), prompt: String(reviewPrompt || ""), schema, options }; }
 function normalizeSchemaOptions(value, options) { if (value && value.type) return { schema: value, options: options || {} }; return { schema: value?.schema, options: { ...(value || {}), ...(options || {}) } }; }
+function resolveValue(value, env) { return typeof value === "function" ? value(env) : value; }
+function endpointFor(baseUrl, resource) {
+  const normalized = String(baseUrl).replace(/\/+$/, "");
+  return normalized.replace(/\/(responses|models)$/, "") + "/" + resource;
+}
+function resolveConfig(options, requestOptions, env) {
+  if (requestOptions.apiUrl !== undefined && options.allowDynamicApiUrl !== true) throw new Error("Per-request LLM API URLs are disabled; configure apiUrl at client creation time.");
+  const apiUrl = (options.allowDynamicApiUrl === true ? resolveValue(requestOptions.apiUrl, env) : null) || resolveValue(options.apiUrl, env) || env?.LLM_API_URL || DEFAULT_ENDPOINT;
+  if (new URL(apiUrl).protocol !== "https:") throw new Error("LLM_API_URL must use HTTPS");
+  const token = requestOptions.apiToken || resolveValue(options.apiToken, env) || env?.LLM_API_TOKEN;
+  if (!token) throw new Error("LLM_API_TOKEN is not configured");
+  const endpoint = endpointFor(apiUrl, "responses");
+  const modelsEndpoint = endpointFor(apiUrl, "models");
+  const gateway = isCloudflareGateway(apiUrl);
+  const headers = { "Content-Type": "application/json", ...resolveValue(options.headers, env), ...requestOptions.headers };
+  if (token && !gateway) headers.Authorization = `Bearer ${token}`;
+  if (gateway) headers["cf-aig-authorization"] = `Bearer ${token}`;
+  return { provider: gateway ? "cloudflare-ai-gateway" : "openai-compatible", gateway, endpoint, modelsEndpoint, model: requestOptions.model || resolveValue(options.model, env) || env?.LLM_MODEL || DEFAULT_MODEL, headers };
+}
+function isCloudflareGateway(url) { try { return new URL(url).hostname === "gateway.ai.cloudflare.com"; } catch { return false; } }
+async function resolveModel(config, fetcher, requestOptions) {
+  if (config.model !== "auto") return config.model;
+  const response = await fetcher(config.modelsEndpoint, { method: "GET", headers: config.headers, signal: requestOptions.signal });
+  const payload = await response.json();
+  if (!response.ok || !Array.isArray(payload.data) || !payload.data[0]?.id) throw new LLMResponseError("Automatic model selection failed", payload);
+  return payload.data[0].id;
+}
 function extractText(payload) { return payload?.output_text || payload?.output?.flatMap((item) => item.content || []).find((item) => item.type === "output_text")?.text || ""; }
 function parseBestEffort(text) { try { return JSON.parse(text); } catch { return text; } }
 function validateAndReturn(text, schema) { let value; try { value = JSON.parse(text); } catch (error) { throw new Error(`response is not JSON: ${error.message}`); } validate(value, schema, "$root"); return value; }
@@ -133,4 +156,4 @@ function validate(value, schema, path) {
 }
 function normalizeUsage(usage = {}) { return { inputTokens: usage.input_tokens ?? usage.prompt_tokens ?? 0, outputTokens: usage.output_tokens ?? usage.completion_tokens ?? 0, totalTokens: usage.total_tokens ?? 0 }; }
 
-export function createFeature(options = {}) { const name = options.name || "cf-genai-llm"; const client = createLLM({ ...options, feature: name }); return { name, packageName: PACKAGE_NAME, version: VERSION, healthcheck: async (env) => { if (!env || !env.OPENAI_API_KEY) return [{ feature: name, component: "configuration", displayName: "OpenAI configuration", state: "red" }]; try { await client.listModels({ env, who: "system:update" }); return [{ feature: name, component: "configuration", displayName: "OpenAI configuration", state: "green" }]; } catch { return [{ feature: name, component: "configuration", displayName: "OpenAI configuration", state: "yellow" }]; } }, healthchecks: [{ feature: name, component: "openai-models", displayName: "OpenAI model availability", state: "yellow" }], circuitBreakers: [{ id: name + ":openai-models", feature: name, name: "openai-models", displayName: "OpenAI model access", state: "on", allowSelfHealing: true, healthchecks: [name + ":openai-models"] }], middleware: async (request, env, ctx, next, state) => { if (options.boot) await options.boot(env, { request, ctx, state }); return options.handle ? options.handle(request, env, ctx, next, state) : next(); } }; }
+export function createFeature(options = {}) { const name = options.name || "cf-genai-llm"; const client = createLLM({ ...options, feature: name }); return { name, displayName: options.displayName || name, packageName: PACKAGE_NAME, version: VERSION, dataResources: options.dataResources || [], routes: options.routes || [], healthcheck: async (env) => { try { resolveConfig(options, {}, env); } catch { return [{ feature: name, component: "configuration", displayName: "LLM configuration", state: "red" }]; } try { await client.listModels({ env, who: "system:update" }); return [{ feature: name, component: "configuration", displayName: "LLM configuration", state: "green" }]; } catch { return [{ feature: name, component: "configuration", displayName: "LLM configuration", state: "yellow" }]; } }, healthchecks: options.healthchecks || [{ feature: name, component: "llm-models", displayName: "LLM model availability", state: "yellow" }], circuitBreakers: options.circuitBreakers || [{ id: name + ":llm-models", feature: name, name: "llm-models", displayName: "LLM model access", state: "on", allowSelfHealing: true, healthchecks: [name + ":llm-models"] }], middleware: async (request, env, ctx, next, state) => { if (options.boot) await options.boot(env, { request, ctx, state }); return options.handle ? options.handle(request, env, ctx, next, state) : next(); } }; }

package/tests/feature.test.mjs

@@ -4,6 +4,7 @@ import { createFeature, createLLM, LLMResponseError } from "../src/index.js";
 
 test("feature delegates to the next handler", async () => {
   const feature = createFeature({ name: "example" });
+  assert.equal(feature.version, "4.1.1");
   const response = await feature.middleware(new Request("https://example.test/"), {}, {}, () => Response.json({ ok: true }), {});
   assert.equal(response.status, 200);
   assert.deepEqual(await response.json(), { ok: true });
@@ -14,15 +15,90 @@ function response(text, usage = { input_tokens: 3, output_tokens: 2, total_token
 
 test("generate sends metadata, validates typed output, and logs token counts", async () => {
   const calls = []; const logs = [];
-  const llm = createLLM({ apiKey: "test", fetch: async (_url, init) => { calls.push(JSON.parse(init.body)); return response("{\"answer\":\"ok\"}"); }, logger: { debug: (line) => logs.push(JSON.parse(line)), info: (line) => logs.push(JSON.parse(line)) }, metadata: { app: "test" } });
+  const llm = createLLM({ env: { LLM_API_TOKEN: "test" }, fetch: async (url, init) => { calls.push({ url, headers: init.headers, body: JSON.parse(init.body) }); return response("{\"answer\":\"ok\"}"); }, logger: { debug: (line) => logs.push(JSON.parse(line)), info: (line) => logs.push(JSON.parse(line)) }, metadata: { app: "test" } });
   assert.deepEqual(await llm.generate("hello", schema, { schemaName: "answer", metadata: { type: "unit" } }), { answer: "ok" });
-  assert.equal(calls[0].metadata.type, "unit");
-  assert.equal(logs.find((entry) => entry.event === "llm.response").usage.totalTokens, 5);
+  assert.equal(calls[0].url, "https://api.openai.com/v1/responses");
+  assert.equal(calls[0].headers.Authorization, "Bearer test");
+  assert.equal(calls[0].body.metadata.type, "unit");
+  const responseLog = logs.find((entry) => entry.event === "llm.response");
+  assert.equal(responseLog.usage.totalTokens, 5);
+  assert.equal(responseLog.provider, "openai-compatible");
+  assert.equal(responseLog.gateway, false);
+});
+
+test("Cloudflare AI Gateway routes Responses and model health through the gateway", async () => {
+  const calls = [];
+  const llm = createLLM({
+    env: { LLM_API_URL: "https://gateway.ai.cloudflare.com/v1/account/gateway/openai/", LLM_API_TOKEN: "gateway-key" },
+    fetch: async (url, init) => {
+      calls.push({ url, headers: init.headers });
+      return init.method === "GET"
+        ? new Response(JSON.stringify({ data: [{ id: "gpt-5.4" }] }), { status: 200 })
+        : response("gateway response");
+    },
+  });
+
+  assert.equal(await llm.generate("hello"), "gateway response");
+  assert.deepEqual(await llm.listModels(), [{ id: "gpt-5.4" }]);
+  assert.equal(calls[0].url, "https://gateway.ai.cloudflare.com/v1/account/gateway/openai/responses");
+  assert.equal(calls[1].url, "https://gateway.ai.cloudflare.com/v1/account/gateway/openai/models");
+  assert.equal(calls[0].headers["cf-aig-authorization"], "Bearer gateway-key");
+});
+
+test("environment configuration supports Gateway routing and provider-neutral names", async () => {
+  const calls = [];
+  const llm = createLLM({
+    env: { LLM_API_URL: "https://gateway.ai.cloudflare.com/v1/account/gateway/openai/responses", LLM_API_TOKEN: "gateway-key", LLM_MODEL: "gpt-5.4-mini" },
+    fetch: async (url, init) => { calls.push({ url, body: JSON.parse(init.body) }); return response("ok"); },
+  });
+
+  assert.equal(await llm.generate("hello"), "ok");
+  assert.equal(calls[0].url, "https://gateway.ai.cloudflare.com/v1/account/gateway/openai/responses");
+  assert.equal(calls[0].body.model, "gpt-5.4-mini");
+});
+
+test("the universal URL selects direct routing or Cloudflare Gateway routing", async () => {
+  const calls = [];
+  const llm = createLLM({
+    env: { LLM_API_URL: "https://api.openai.com/v1/responses", LLM_API_TOKEN: "openai-key" },
+    fetch: async (url) => { calls.push(url); return response("ok"); },
+  });
+
+  assert.equal(await llm.generate("hello"), "ok");
+  assert.equal(calls[0], "https://api.openai.com/v1/responses");
+});
+
+test("universal URL, token, and model variables support OpenAI-compatible endpoints", async () => {
+  const calls = [];
+  const llm = createLLM({
+    env: { LLM_API_URL: "https://openrelay.example/v1/responses", LLM_API_TOKEN: "relay-key", LLM_MODEL: "relay-model" },
+    fetch: async (url, init) => { calls.push({ url, headers: init.headers, body: JSON.parse(init.body) }); return response("ok"); },
+  });
+
+  assert.equal(await llm.generate("hello"), "ok");
+  assert.equal(calls[0].url, "https://openrelay.example/v1/responses");
+  assert.equal(calls[0].headers.Authorization, "Bearer relay-key");
+  assert.equal(calls[0].body.model, "relay-model");
+});
+
+test("auto model selection uses the compatible endpoint's model list", async () => {
+  const calls = [];
+  const llm = createLLM({
+    env: { LLM_API_URL: "https://openrelay.example/v1/responses", LLM_API_TOKEN: "relay-key", LLM_MODEL: "auto" },
+    fetch: async (url, init) => {
+      calls.push({ url, method: init.method, body: init.body && JSON.parse(init.body) });
+      return init.method === "GET" ? new Response(JSON.stringify({ data: [{ id: "auto-model" }] }), { status: 200 }) : response("ok");
+    },
+  });
+
+  assert.equal(await llm.generate("hello"), "ok");
+  assert.equal(calls[0].url, "https://openrelay.example/v1/models");
+  assert.equal(calls[1].body.model, "auto-model");
 });
 
 test("generateMulti starts parallel typed requests and reviewMulti preserves order", async () => {
   let active = 0; let peak = 0;
-  const llm = createLLM({ apiKey: "test", fetch: async (_url, init) => { active++; peak = Math.max(peak, active); const body = JSON.parse(init.body); await new Promise((resolve) => setTimeout(resolve, 5)); active--; return response(JSON.stringify({ answer: body.input.includes("two") ? "two" : "one" })); } });
+  const llm = createLLM({ env: { LLM_API_TOKEN: "test" }, fetch: async (_url, init) => { active++; peak = Math.max(peak, active); const body = JSON.parse(init.body); await new Promise((resolve) => setTimeout(resolve, 5)); active--; return response(JSON.stringify({ answer: body.input.includes("two") ? "two" : "one" })); } });
   const results = await llm.generateMulti(["one", "two"], schema);
   assert.deepEqual(results, [{ answer: "one" }, { answer: "two" }]); assert.equal(peak, 2);
   assert.deepEqual(await llm.reviewMulti("source", ["first", "second"], schema), [{ answer: "one" }, { answer: "one" }]);
@@ -30,8 +106,8 @@ test("generateMulti starts parallel typed requests and reviewMulti preserves ord
 
 test("invalid typed output gets one repair, then exposes the raw model response", async () => {
   let count = 0;
-  const llm = createLLM({ apiKey: "test", fetch: async () => { count++; return response(count === 1 ? "{\"wrong\":true}" : "{\"answer\":\"fixed\"}"); } });
+  const llm = createLLM({ env: { LLM_API_TOKEN: "test" }, fetch: async () => { count++; return response(count === 1 ? "{\"wrong\":true}" : "{\"answer\":\"fixed\"}"); } });
   assert.deepEqual(await llm.generate("repair me", schema), { answer: "fixed" }); assert.equal(count, 2);
-  const failing = createLLM({ apiKey: "test", fetch: async () => response("{\"wrong\":true}") });
+  const failing = createLLM({ env: { LLM_API_TOKEN: "test" }, fetch: async () => response("{\"wrong\":true}") });
   await assert.rejects(() => failing.generate("fail", schema), (error) => error instanceof LLMResponseError && error.responseFailed && error.llmResponse.output_text === "{\"wrong\":true}");
 });