@codilore/llm 1.15.13

package/test/provider/openrouter.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM } from "../../src"
+import { LLMClient } from "../../src/route"
+import * as OpenRouter from "../../src/providers/openrouter"
+import { it } from "../lib/effect"
+
+describe("OpenRouter", () => {
+  it.effect("prepares OpenRouter models through the OpenAI-compatible Chat route", () =>
+    Effect.gen(function* () {
+      const model = OpenRouter.configure({ apiKey: "test-key" }).model("openai/gpt-4o-mini")
+
+      expect(model).toMatchObject({
+        id: "openai/gpt-4o-mini",
+        provider: "openrouter",
+        route: { id: "openrouter" },
+      })
+      expect(model.route.endpoint.baseURL).toBe("https://openrouter.ai/api/v1")
+
+      const prepared = yield* LLMClient.prepare(LLM.request({ model, prompt: "Say hello." }))
+
+      expect(prepared.route).toBe("openrouter")
+      expect(prepared.body).toMatchObject({
+        model: "openai/gpt-4o-mini",
+        messages: [{ role: "user", content: "Say hello." }],
+        stream: true,
+      })
+    }),
+  )
+
+  it.effect("applies OpenRouter payload options from the model helper", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare(
+        LLM.request({
+          model: OpenRouter.configure({
+            apiKey: "test-key",
+            providerOptions: {
+              openrouter: {
+                usage: true,
+                reasoning: { effort: "high" },
+                promptCacheKey: "session_123",
+              },
+            },
+          }).model("anthropic/claude-3.7-sonnet:thinking"),
+          prompt: "Think briefly.",
+        }),
+      )
+
+      expect(prepared.body).toMatchObject({
+        usage: { include: true },
+        reasoning: { effort: "high" },
+        prompt_cache_key: "session_123",
+      })
+    }),
+  )
+})

package/test/provider.types.ts

@@ -0,0 +1,41 @@
+import { Provider } from "../src/provider"
+import { ProviderID, type Model } from "../src/schema"
+
+declare const model: (id: string) => Model
+declare const requiredModel: (id: string, options: { readonly baseURL: string }) => Model
+declare const chat: (id: string, options: { readonly apiKey: string }) => Model
+
+Provider.make({
+  id: ProviderID.make("example"),
+  model,
+})
+
+Provider.make({
+  id: ProviderID.make("bad"),
+  model,
+  // @ts-expect-error provider definitions should not grow accidental top-level fields.
+  routes: [],
+})
+
+const requiredProvider = Provider.make({
+  id: ProviderID.make("required"),
+  model: requiredModel,
+})
+
+// Provider.make is advanced structural typing coverage; built-in providers use
+// configure(...).model(id) facades instead of second-argument selectors.
+requiredProvider.model("custom", { baseURL: "https://example.com/v1" })
+
+// @ts-expect-error Provider.make preserves required model options.
+requiredProvider.model("custom")
+
+const multiApiProvider = Provider.make({
+  id: ProviderID.make("multi-api"),
+  model,
+  apis: { chat },
+})
+
+multiApiProvider.apis.chat("chat-model", { apiKey: "key" })
+
+// @ts-expect-error Provider.make preserves API-specific option types.
+multiApiProvider.apis.chat("chat-model")

package/test/recorded-golden.ts

@@ -0,0 +1,97 @@
+import type { HttpRecorder } from "@codilore/http-recorder"
+import { describe } from "bun:test"
+import { Effect } from "effect"
+import type { Model } from "../src"
+import { goldenScenarioTags, goldenScenarioTitle, runGoldenScenario, type GoldenScenarioID } from "./recorded-scenarios"
+import { recordedTests } from "./recorded-test"
+import { kebab } from "./recorded-utils"
+
+type Transport = "http" | "websocket"
+
+type ScenarioInput =
+  | GoldenScenarioID
+  | {
+      readonly id: GoldenScenarioID
+      readonly name?: string
+      readonly cassette?: string
+      readonly tags?: ReadonlyArray<string>
+      readonly maxTokens?: number
+      readonly temperature?: number | false
+      readonly timeout?: number
+    }
+
+type TargetInput = {
+  readonly name: string
+  readonly model: Model
+  readonly protocol?: string
+  readonly requires?: ReadonlyArray<string>
+  readonly transport?: Transport
+  readonly prefix?: string
+  readonly tags?: ReadonlyArray<string>
+  readonly metadata?: Record<string, unknown>
+  readonly options?: HttpRecorder.RecordReplayOptions
+  readonly scenarios: ReadonlyArray<ScenarioInput>
+}
+
+const scenarioInput = (input: ScenarioInput) => (typeof input === "string" ? { id: input } : input)
+
+const defaultPrefix = (target: TargetInput) => {
+  if (target.prefix) return target.prefix
+  const transport = target.transport === "websocket" ? "-websocket" : ""
+  return `${target.model.provider}-${target.protocol ?? target.model.route.id}${transport}`
+}
+
+const metadata = (target: TargetInput) => ({
+  provider: target.model.provider,
+  protocol: target.protocol,
+  route: target.model.route.id,
+  transport: target.transport ?? "http",
+  model: target.model.id,
+  ...target.metadata,
+})
+
+const tags = (target: TargetInput) => [
+  ...(target.transport === "websocket" ? ["transport:websocket"] : []),
+  ...(target.tags ?? []),
+]
+
+const runTarget = (target: TargetInput) => {
+  const recorded = recordedTests({
+    prefix: defaultPrefix(target),
+    provider: target.model.provider,
+    protocol: target.protocol,
+    requires: target.requires,
+    tags: tags(target),
+    metadata: metadata(target),
+    options: target.options,
+  })
+
+  describe(`${target.name} recorded`, () => {
+    target.scenarios.forEach((raw) => {
+      const input = scenarioInput(raw)
+      const name = input.name ?? goldenScenarioTitle(input.id)
+      recorded.effect.with(
+        name,
+        {
+          cassette: input.cassette,
+          id: `${kebab(target.name)}-${input.id}`,
+          tags: [...goldenScenarioTags(input.id), ...(input.tags ?? [])],
+        },
+        () =>
+          Effect.gen(function* () {
+            yield* runGoldenScenario(input.id, {
+              id: `recorded_${kebab(target.name).replaceAll("-", "_")}_${input.id.replaceAll("-", "_")}`,
+              model: target.model,
+              maxTokens: input.maxTokens,
+              temperature: input.temperature,
+            })
+          }),
+        input.timeout,
+      )
+    })
+  })
+}
+
+export const describeRecordedGoldenScenarios = (targets: ReadonlyArray<TargetInput>) => {
+  targets.forEach(runTarget)
+}

package/test/recorded-runner.ts

@@ -0,0 +1,100 @@
+import { test, type TestOptions } from "bun:test"
+import { Effect, type Layer } from "effect"
+import { testEffect } from "./lib/effect"
+import { cassetteName, classifiedTags, matchesSelected, missingEnv, unique } from "./recorded-utils"
+
+export type RecordedBody<A, E, R> = Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)
+
+export type RecordedGroupOptions = {
+  readonly prefix: string
+  readonly provider?: string
+  readonly protocol?: string
+  readonly requires?: ReadonlyArray<string>
+  readonly tags?: ReadonlyArray<string>
+  readonly metadata?: Record<string, unknown>
+}
+
+export type RecordedCaseOptions = {
+  readonly cassette?: string
+  readonly id?: string
+  readonly provider?: string
+  readonly protocol?: string
+  readonly requires?: ReadonlyArray<string>
+  readonly tags?: ReadonlyArray<string>
+  readonly metadata?: Record<string, unknown>
+}
+
+export const recordedEffectGroup = <
+  R,
+  E,
+  Options extends RecordedGroupOptions,
+  CaseOptions extends RecordedCaseOptions,
+>(input: {
+  readonly duplicateLabel: string
+  readonly options: Options
+  readonly cassetteExists: (cassette: string) => boolean
+  readonly layer: (input: {
+    readonly cassette: string
+    readonly tags: ReadonlyArray<string>
+    readonly metadata: Record<string, unknown>
+    readonly recording: boolean
+    readonly options: Options
+    readonly caseOptions: CaseOptions
+  }) => Layer.Layer<R, E>
+}) => {
+  const cassettes = new Set<string>()
+
+  const run = <A, E2>(
+    name: string,
+    caseOptions: CaseOptions,
+    body: RecordedBody<A, E2, R>,
+    testOptions?: number | TestOptions,
+  ) => {
+    const cassette = cassetteName(input.options.prefix, name, caseOptions)
+    if (cassettes.has(cassette)) throw new Error(`Duplicate ${input.duplicateLabel} "${cassette}"`)
+    cassettes.add(cassette)
+    const tags = unique([
+      ...classifiedTags(input.options),
+      ...classifiedTags({
+        provider: caseOptions.provider,
+        protocol: caseOptions.protocol,
+        tags: caseOptions.tags,
+      }),
+    ])
+
+    if (!matchesSelected({ prefix: input.options.prefix, name, cassette, tags }))
+      return test.skip(name, () => {}, testOptions)
+
+    const recording = process.env.RECORD === "true"
+    if (recording) {
+      if (missingEnv([...(input.options.requires ?? []), ...(caseOptions.requires ?? [])]).length > 0) {
+        return test.skip(name, () => {}, testOptions)
+      }
+    } else if (!input.cassetteExists(cassette)) {
+      return test.skip(name, () => {}, testOptions)
+    }
+
+    return testEffect(
+      input.layer({
+        cassette,
+        tags,
+        metadata: { ...input.options.metadata, ...caseOptions.metadata, tags },
+        recording,
+        options: input.options,
+        caseOptions,
+      }),
+    ).live(name, body, testOptions)
+  }
+
+  const effect = <A, E2>(name: string, body: RecordedBody<A, E2, R>, testOptions?: number | TestOptions) =>
+    run(name, {} as CaseOptions, body, testOptions)
+
+  effect.with = <A, E2>(
+    name: string,
+    caseOptions: CaseOptions,
+    body: RecordedBody<A, E2, R>,
+    testOptions?: number | TestOptions,
+  ) => run(name, caseOptions, body, testOptions)
+
+  return { effect }
+}