openAgent

1import { describe, expect } from "bun:test"
2import { LLM } from "@opencode-ai/llm"
3import { LLMClient } from "@opencode-ai/llm/route"
4import { DateTime, Effect } from "effect"
5import { Headers } from "effect/unstable/http"
6import { Credential } from "@opencode-ai/core/credential"
7import { Integration } from "@opencode-ai/core/integration"
8import { ModelV2 } from "@opencode-ai/core/model"
9import { ProviderV2 } from "@opencode-ai/core/provider"
10import { ProjectV2 } from "@opencode-ai/core/project"
11import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
12import { SessionV2 } from "@opencode-ai/core/session"
13import { AbsolutePath } from "@opencode-ai/core/schema"
14import { it } from "./lib/effect"
15 
16type Api =
17  | {
18      readonly type: "aisdk"
19      readonly package: string
20      readonly url?: string
21      readonly settings?: Record<string, unknown>
22    }
23  | { readonly type: "native"; readonly url?: string; readonly settings: Record<string, unknown> }
24 
25const model = (api: Api, variants: ModelV2.Info["variants"] = []) =>
26  ModelV2.Info.make({
27    id: ModelV2.ID.make("test-model"),
28    providerID: ProviderV2.ID.make("test-provider"),
29    name: "Test model",
30    api: { id: ModelV2.ID.make("api-test-model"), ...api },
31    capabilities: { tools: true, input: ["text"], output: ["text"] },
32    request: {
33      headers: { "x-test": "header" },
34      body: { apiKey: "secret", custom_extension: { enabled: true } },
35    },
36    variants,
37    time: { released: 0 },
38    cost: [],
39    status: "active",
40    enabled: true,
41    limit: { context: 100, output: 20 },
42  })
43 
44describe("SessionRunnerModel", () => {
45  it.effect("maps catalog OpenAI AI SDK models into native Responses routes", () =>
46    Effect.gen(function* () {
47      const resolved = yield* SessionRunnerModel.fromCatalogModel(
48        model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
49      )
50 
51      expect(resolved).toMatchObject({ id: "api-test-model", provider: "test-provider" })
52      expect(resolved.route).toMatchObject({
53        id: "openai-responses",
54        endpoint: { baseURL: "https://openai.example/v1" },
55        defaults: {
56          headers: { "x-test": "header" },
57          limits: { context: 100, output: 20 },
58          http: { body: { custom_extension: { enabled: true } } },
59        },
60      })
61    }),
62  )
63 
64  it.effect("keeps catalog apiKey credentials out of provider JSON", () =>
65    Effect.gen(function* () {
66      const resolved = yield* SessionRunnerModel.fromCatalogModel(
67        model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
68      )
69      const prepared = yield* LLMClient.prepare(LLM.request({ model: resolved, prompt: "Hello" }))
70 
71      expect(JSON.stringify(prepared.body)).not.toContain("apiKey")
72      expect(JSON.stringify(prepared.body)).not.toContain("secret")
73    }),
74  )
75 
76  it.effect("uses merged API settings for OpenAI-compatible auth and request defaults", () =>
77    Effect.gen(function* () {
78      const resolved = yield* SessionRunnerModel.fromCatalogModel(
79        ModelV2.Info.make({
80          ...model({
81            type: "aisdk",
82            package: "@ai-sdk/openai-compatible",
83            url: "https://compatible.example/v1",
84            settings: { apiKey: "settings-secret", compatibility: "strict" },
85          }),
86          request: { headers: {}, body: {} },
87        }),
88      )
89      const request = LLM.request({ model: resolved, prompt: "Hello" })
90      const headers = yield* resolved.route.auth.apply({
91        request,
92        method: "POST",
93        url: "https://compatible.example/v1/chat/completions",
94        body: "{}",
95        headers: Headers.empty,
96      })
97 
98      expect(headers.authorization).toBe("Bearer settings-secret")
99      expect(resolved.route.defaults.http?.body).toEqual({})
100    }),
101  )
102 
103  it.effect("overlays selected OpenAI Session variant bodies", () =>
104    Effect.gen(function* () {
105      const catalog = model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }, [
106        {
107          id: ModelV2.VariantID.make("high"),
108          headers: { "x-variant": "high" },
109          body: {
110            store: false,
111            service_tier: "priority",
112            temperature: 0.2,
113            reasoning: { effort: "high" },
114          },
115        },
116      ])
117      const session = SessionV2.Info.make({
118        id: SessionV2.ID.make("ses_model_variant"),
119        projectID: ProjectV2.ID.global,
120        title: "test",
121        model: {
122          id: catalog.id,
123          providerID: catalog.providerID,
124          variant: ModelV2.VariantID.make("high"),
125        },
126        cost: 0,
127        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
128        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
129        location: { directory: AbsolutePath.make("/project") },
130      })
131 
132      const resolved = yield* SessionRunnerModel.resolve(session, catalog)
133 
134      expect(resolved.route.defaults.headers).toMatchObject({ "x-test": "header", "x-variant": "high" })
135      expect(resolved.route.defaults.http?.body).toEqual({
136        custom_extension: { enabled: true },
137        store: false,
138        service_tier: "priority",
139        temperature: 0.2,
140        reasoning: { effort: "high" },
141      })
142    }),
143  )
144 
145  it.effect("overlays selected OpenAI-compatible Session variant bodies", () =>
146    Effect.gen(function* () {
147      const catalog = model(
148        { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://compatible.example/v1" },
149        [
150          {
151            id: ModelV2.VariantID.make("high"),
152            headers: {},
153            body: { store: false, reasoning_effort: "high" },
154          },
155        ],
156      )
157      const session = SessionV2.Info.make({
158        id: SessionV2.ID.make("ses_compatible_variant"),
159        projectID: ProjectV2.ID.global,
160        title: "test",
161        model: { id: catalog.id, providerID: catalog.providerID, variant: ModelV2.VariantID.make("high") },
162        cost: 0,
163        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
164        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
165        location: { directory: AbsolutePath.make("/project") },
166      })
167 
168      const resolved = yield* SessionRunnerModel.resolve(session, catalog)
169 
170      expect(resolved.route.defaults.http?.body).toEqual({
171        custom_extension: { enabled: true },
172        store: false,
173        reasoning_effort: "high",
174      })
175    }),
176  )
177 
178  it.effect("rejects an explicit unavailable Session variant during model resolution", () =>
179    Effect.gen(function* () {
180      const catalog = model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" })
181      const session = SessionV2.Info.make({
182        id: SessionV2.ID.make("ses_model_variant_unavailable"),
183        projectID: ProjectV2.ID.global,
184        title: "test",
185        model: {
186          id: catalog.id,
187          providerID: catalog.providerID,
188          variant: ModelV2.VariantID.make("unknown"),
189        },
190        cost: 0,
191        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
192        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
193        location: { directory: AbsolutePath.make("/project") },
194      })
195 
196      const failure = yield* SessionRunnerModel.resolve(session, catalog).pipe(Effect.flip)
197 
198      expect(failure).toMatchObject({
199        _tag: "SessionRunnerModel.VariantUnavailableError",
200        providerID: "test-provider",
201        modelID: "test-model",
202        variant: "unknown",
203      })
204      expect(failure.message).toBe("Variant unavailable for test-provider/test-model: unknown")
205    }),
206  )
207 
208  it.effect("overlays selected Anthropic Session variant bodies", () =>
209    Effect.gen(function* () {
210      const catalog = model({ type: "aisdk", package: "@ai-sdk/anthropic", url: "https://anthropic.example/v1" }, [
211        {
212          id: ModelV2.VariantID.make("high"),
213          headers: {},
214          body: { thinking: { type: "enabled", budget_tokens: 12000 } },
215        },
216      ])
217      const session = SessionV2.Info.make({
218        id: SessionV2.ID.make("ses_anthropic_variant"),
219        projectID: ProjectV2.ID.global,
220        title: "test",
221        model: { id: catalog.id, providerID: catalog.providerID, variant: ModelV2.VariantID.make("high") },
222        cost: 0,
223        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
224        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
225        location: { directory: AbsolutePath.make("/project") },
226      })
227 
228      const resolved = yield* SessionRunnerModel.resolve(session, catalog)
229 
230      expect(resolved.route.defaults.http?.body).toEqual({
231        custom_extension: { enabled: true },
232        thinking: { type: "enabled", budget_tokens: 12000 },
233      })
234    }),
235  )
236 
237  it.effect("maps catalog Anthropic AI SDK models into native routes", () =>
238    Effect.gen(function* () {
239      const resolved = yield* SessionRunnerModel.fromCatalogModel(
240        model({ type: "aisdk", package: "@ai-sdk/anthropic", url: "https://anthropic.example/v1" }),
241      )
242 
243      expect(resolved.route).toMatchObject({
244        id: "anthropic-messages",
245        endpoint: { baseURL: "https://anthropic.example/v1" },
246      })
247    }),
248  )
249 
250  it.effect("uses resolved credentials for bearer auth", () =>
251    Effect.gen(function* () {
252      const resolved = yield* SessionRunnerModel.fromCatalogModel(
253        ModelV2.Info.make({
254          ...model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
255          request: { headers: {}, body: {} },
256        }),
257        Credential.Key.make({ type: "key", key: "secret" }),
258      )
259      const request = LLM.request({ model: resolved, prompt: "Hello" })
260      const headers = yield* resolved.route.auth.apply({
261        request,
262        method: "POST",
263        url: "https://openai.example/v1/responses",
264        body: "{}",
265        headers: Headers.empty,
266      })
267 
268      expect(headers.authorization).toBe("Bearer secret")
269    }),
270  )
271 
272  it.effect("prefers stored credentials over configured auth", () =>
273    Effect.gen(function* () {
274      const credential = Credential.Key.make({ type: "key", key: "stored-secret", metadata: { tenant: "work" } })
275      const resolved = yield* SessionRunnerModel.fromCatalogModel(
276        ModelV2.Info.make({
277          ...model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
278          request: { headers: {}, body: { apiKey: "configured-secret" } },
279        }),
280        credential,
281      )
282      const headers = yield* resolved.route.auth.apply({
283        request: LLM.request({ model: resolved, prompt: "Hello" }),
284        method: "POST",
285        url: "https://openai.example/v1/responses",
286        body: "{}",
287        headers: Headers.empty,
288      })
289 
290      expect(headers.authorization).toBe("Bearer stored-secret")
291      expect(resolved.route.defaults.http?.body).toEqual({ tenant: "work" })
292    }),
293  )
294 
295  it.effect("does not project OAuth account metadata into the request body", () =>
296    Effect.gen(function* () {
297      const resolved = yield* SessionRunnerModel.fromCatalogModel(
298        ModelV2.Info.make({
299          ...model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
300          request: { headers: {}, body: {} },
301        }),
302        Credential.OAuth.make({
303          type: "oauth",
304          methodID: Integration.MethodID.make("device"),
305          access: "secret",
306          refresh: "refresh",
307          expires: Date.now() + 60_000,
308          metadata: { server: "https://console.example", orgID: "org_123" },
309        }),
310      )
311 
312      expect(resolved.route.defaults.http?.body).toEqual({})
313    }),
314  )
315 
316  it.effect("rejects catalog APIs without a native route", () =>
317    Effect.gen(function* () {
318      const failure = yield* SessionRunnerModel.fromCatalogModel(
319        model({ type: "aisdk", package: "@ai-sdk/google", url: "https://google.example/v1" }),
320      ).pipe(Effect.flip)
321 
322      expect(failure).toMatchObject({
323        _tag: "SessionRunnerModel.UnsupportedApiError",
324        providerID: "test-provider",
325        modelID: "test-model",
326        api: "aisdk:@ai-sdk/google",
327      })
328      expect(failure.message).toBe("Unsupported API for test-provider/test-model: aisdk:@ai-sdk/google")
329    }),
330  )
331 
332  it.effect("reports whether a catalog model has a supported native route", () =>
333    Effect.sync(() => {
334      expect(
335        SessionRunnerModel.supported(
336          model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
337        ),
338      ).toBe(true)
339      expect(
340        SessionRunnerModel.supported(
341          model({ type: "aisdk", package: "@ai-sdk/google", url: "https://google.example/v1" }),
342        ),
343      ).toBe(false)
344      expect(SessionRunnerModel.supported(model({ type: "native", settings: {} }))).toBe(false)
345    }),
346  )
347})
348