openAgent

1import { describe, expect, test } from "bun:test"
2import { Effect, Schema } from "effect"
3import { HttpClientRequest } from "effect/unstable/http"
4import { LLM, mergeProviderOptions } from "../src"
5import { AnthropicMessages, OpenAIChat } from "../src/protocols"
6import { Auth, LLMClient } from "../src/route"
7import { it } from "./lib/effect"
8import { dynamicResponse } from "./lib/http"
9import { deltaChunk } from "./lib/openai-chunks"
10import { sseEvents } from "./lib/sse"
11 
12const TargetJson = Schema.fromJsonString(Schema.Unknown)
13const decodeJson = Schema.decodeUnknownSync(TargetJson)
14 
15describe("request option precedence", () => {
16  test("deep-merges provider option records and replaces arrays, primitives, and null", () => {
17    const merged = mergeProviderOptions(
18      {
19        openai: {
20          include: ["route"],
21          metadata: { route: true, shared: "route" },
22          nullable: "route",
23          primitive: "route",
24        },
25      },
26      {
27        openai: {
28          include: ["model"],
29          metadata: { model: true, shared: "model" },
30          nullable: null,
31          primitive: "model",
32        },
33      },
34      { openai: { metadata: { request: true }, primitive: false } },
35    )
36 
37    expect(merged).toEqual({
38      openai: {
39        include: ["model"],
40        metadata: { route: true, model: true, request: true, shared: "model" },
41        nullable: null,
42        primitive: false,
43      },
44    })
45  })
46 
47  it.effect("prepares bodies with route defaults, model defaults, and call options in order", () =>
48    Effect.gen(function* () {
49      const route = OpenAIChat.route.with({
50        endpoint: { baseURL: "https://api.openai.test/v1/" },
51        auth: Auth.bearer("test"),
52        generation: { maxTokens: 10, temperature: 1, stop: ["route"] },
53        providerOptions: { openai: { store: false, reasoningEffort: "low" } },
54      })
55      const model = route.model({
56        id: "gpt-4o-mini",
57        defaults: {
58          generation: { maxTokens: 20, temperature: 0.5, frequencyPenalty: 0.25, stop: ["model"] },
59          providerOptions: { openai: { reasoningEffort: "medium" } },
60        },
61      })
62      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
63        LLM.request({
64          model,
65          prompt: "Say hello.",
66          generation: { maxTokens: 30, topP: 0.9, stop: ["request"] },
67          providerOptions: { openai: { store: true } },
68        }),
69      )
70 
71      expect(prepared.body).toMatchObject({
72        model: "gpt-4o-mini",
73        stream: true,
74        max_tokens: 30,
75        temperature: 0.5,
76        top_p: 0.9,
77        frequency_penalty: 0.25,
78        store: true,
79        reasoning_effort: "medium",
80      })
81      expect(prepared.body.stop).toEqual(["request"])
82    }),
83  )
84 
85  it.effect("applies model HTTP defaults before request HTTP overlays", () =>
86    LLMClient.generate(
87      LLM.request({
88        model: OpenAIChat.route
89          .with({
90            endpoint: { baseURL: "https://api.openai.test/v1/" },
91            auth: Auth.bearer("fresh-key"),
92            http: {
93              body: { metadata: { route: true, shared: "route" }, value: "route" },
94              headers: { "x-route": "route", "x-shared": "route" },
95              query: { route: "1", shared: "route" },
96            },
97          })
98          .model({
99            id: "gpt-4o-mini",
100            defaults: {
101              http: {
102                body: { metadata: { model: true, shared: "model" }, value: "model" },
103                headers: { "x-model": "model", "x-shared": "model" },
104                query: { model: "1", shared: "model" },
105              },
106            },
107          }),
108        prompt: "Say hello.",
109        http: {
110          body: { metadata: { request: true }, value: null },
111          headers: { "x-request": "request" },
112          query: { request: "1" },
113        },
114      }),
115    ).pipe(
116      Effect.provide(
117        dynamicResponse((input) =>
118          Effect.gen(function* () {
119            const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
120            expect(web.url).toBe("https://api.openai.test/v1/chat/completions?route=1&shared=model&model=1&request=1")
121            expect(web.headers.get("authorization")).toBe("Bearer fresh-key")
122            expect(web.headers.get("x-route")).toBe("route")
123            expect(web.headers.get("x-model")).toBe("model")
124            expect(web.headers.get("x-request")).toBe("request")
125            expect(web.headers.get("x-shared")).toBe("model")
126            expect(decodeJson(input.text)).toMatchObject({
127              metadata: { route: true, model: true, request: true, shared: "model" },
128              value: null,
129            })
130            return input.respond(sseEvents(deltaChunk({}, "stop")), {
131              headers: { "content-type": "text/event-stream" },
132            })
133          }),
134        ),
135      ),
136    ),
137  )
138 
139  it.effect("rejects raw body overlays for protocol-owned roots", () =>
140    Effect.gen(function* () {
141      const model = OpenAIChat.route
142        .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
143        .model({ id: "gpt-4o-mini" })
144      const error = yield* LLMClient.prepare(
145        LLM.request({
146          model,
147          prompt: "Say hello.",
148          http: { body: { model: "gpt-5", messages: [], tools: [] } },
149        }),
150      ).pipe(Effect.flip)
151 
152      expect(error.reason).toMatchObject({
153        _tag: "InvalidRequest",
154        message: "http.body cannot overlay protocol-owned field(s): model, messages, tools",
155      })
156    }),
157  )
158 
159  it.effect("uses model output limits after route limits and before call maxTokens", () =>
160    Effect.gen(function* () {
161      const route = AnthropicMessages.route.with({
162        endpoint: { baseURL: "https://api.anthropic.test/v1/" },
163        auth: Auth.header("x-api-key", "test"),
164        limits: { output: 128 },
165      })
166      const model = route.model({ id: "claude-sonnet-4-5", defaults: { limits: { output: 64 } } })
167      const withoutMaxTokens = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
168        LLM.request({ model, prompt: "Say hello.", cache: "none" }),
169      )
170      const withMaxTokens = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
171        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 32 } }),
172      )
173 
174      expect(withoutMaxTokens.body.max_tokens).toBe(64)
175      expect(withMaxTokens.body.max_tokens).toBe(32)
176    }),
177  )
178})
179