import { APICallError } from "@ai-sdk/provider" import type { LanguageModelV3, LanguageModelV3StreamPart } from "@ai-sdk/provider" import { createOpenAICompatible } from "@ai-sdk/openai-compatible" import { AISDK } from "@opencode/core/aisdk" import { ModelRetry } from "@opencode/core/model-retry" import { SessionRunnerRetry } from "@opencode/core/session/runner/retry" import { toSessionError } from "@opencode/core/session/to-session-error" import { Model } from "@opencode/core/model" import { Provider } from "@opencode/core/provider" import { ai, AIError, CompactionPart, HttpContext, InvalidRequestError, isContextOverflowFailure, LLMEvent, Media, Message, ProviderID, RateLimitError, TransportError, UnknownProviderError, } from "@opencode/ai/effect" import { LLMClient, RequestExecutor } from "@opencode/ai/route" import { compileRequest } from "@opencode/ai/testing" import { expect } from "bun:test" import { Effect, Layer } from "effect" import { HttpClientRequest, HttpClientResponse } from "effect/http" import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder" import { LayerNodePlatform } from "@opencode/util/effect/app-node-platform" import { testEffect } from "./lib/effect" const it = testEffect(AISDK.locationLayer) const model = (packageName: string, settings: Provider.Settings = {}): Model.RuntimeInfo => ({ ...Model.Info.make({ ...Model.Info.default(Provider.ID.make("test-provider"), Model.ID.make("catalog-model")), modelID: Model.ID.make("api-model"), package: Provider.aisdk(packageName), limit: { context: 100, output: 20 }, }), settings, }) const streamModel = (events: ReadonlyArray): LanguageModelV3 => ({ specificationVersion: "v3", provider: "test", modelId: "test", supportedUrls: {}, doGenerate: () => Promise.reject(new Error("Unexpected non-streaming request")), doStream: () => Promise.resolve({ stream: new ReadableStream({ start(controller) { events.forEach((event) => controller.enqueue(event)) controller.close() }, }), }), }) const usage = { inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1, text: 0, reasoning: 0 }, } as const const client = LLMClient.layer.pipe( Layer.provide( Layer.succeed( RequestExecutor.Service, RequestExecutor.Service.of({ execute: () => Effect.die("Unexpected HTTP request"), }), ), ), ) it.effect("rejects native provider compaction rather than silently dropping replay state", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => streamModel([]) } }) const resolved = yield* aisdk.model(model("@ai-sdk/openai")) const error = yield* compileRequest( ai.request({ model: resolved, messages: [ Message.assistant( CompactionPart.make({ provider: ProviderID.make("test-provider"), encrypted: "opaque", }), ), ], }), ).pipe(Effect.flip) expect(error.reason._tag).toBe("UnsupportedOperation") expect(error.message).toContain("cannot replay") if (error.reason._tag === "UnsupportedOperation") expect(error.reason.operation).toBe("compaction-replay") }), ) it.effect("keys language models by package and flattened overlays", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service const loaded: string[] = [] yield* aisdk.hook.sdk((event) => { loaded.push(event.package) event.sdk = { languageModel: () => ({ package: event.package }) } }) const first = yield* aisdk.language(model("first", { region: "us-east-1" })) const second = yield* aisdk.language(model("second", { region: "us-east-1" })) const third = yield* aisdk.language(model("second", { region: "us-west-2" })) expect(first).not.toBe(second) expect(second).not.toBe(third) expect(loaded).toEqual(["first", "second", "second"]) }), ) it.effect("uses canonical names and metadata without merging connection cache partitions", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service const loaded: string[] = [] yield* aisdk.hook.sdk((event) => { loaded.push(`${event.model.providerID}:${event.options.name}`) event.sdk = createOpenAICompatible({ ...event.options, name: String(event.options.name), baseURL: String(event.options.baseURL), }) }) const input = { ...model("@ai-sdk/openai-compatible", { baseURL: "https://proxy.example/v1", reasoningEffort: "high" }), providerID: Provider.ID.make("work"), canonical: Provider.ID.openai, } const first = yield* aisdk.language(input) const second = yield* aisdk.language({ ...input, providerID: Provider.ID.make("personal") }) const plain = yield* aisdk.language({ ...input, canonical: undefined }) expect(yield* aisdk.language(input)).toBe(first) expect(first).not.toBe(second) expect(first).not.toBe(plain) expect(first).toMatchObject({ modelId: "api-model", provider: "openai.chat" }) expect(plain.provider).toBe("work.chat") expect(loaded).toEqual(["work:openai", "personal:openai", "work:work"]) const resolved = yield* aisdk.model(input) expect(resolved).toMatchObject({ id: "api-model", provider: "openai" }) expect(resolved.route).toMatchObject({ provider: "openai", providerMetadataKey: "openai" }) expect(resolved.route.model({ id: "another-model" })).toMatchObject({ provider: "openai" }) const prepared = yield* compileRequest(ai.request({ model: resolved, prompt: "Hello" })) expect(prepared.body.providerOptions).toEqual({ openai: { reasoningEffort: "high" } }) }), ) it.effect("projects request settings, headers, and body overlays", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service let body: unknown let options: Record | undefined yield* aisdk.hook.sdk((event) => { body = event.options.body options = event.options event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const input = model("@ai-sdk/google", { apiKey: "secret", thinkingConfig: { thinkingBudget: 1024 }, compaction: { type: "native" }, cache: { ttl: "1h" }, encoding: "gzip", timeout: 600_000, transport: "websocket", }) const resolved = yield* aisdk.model({ ...input, headers: { "x-test": "header" }, body: { safety_setting: "strict" }, }) const prepared = yield* compileRequest( ai.request({ model: resolved, prompt: "Hello", providerOptions: { safetySettings: [{ category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" }] }, }), ) expect(prepared.body.providerOptions).toEqual({ google: { thinkingConfig: { thinkingBudget: 1024 }, safetySettings: [{ category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" }], }, }) expect(prepared.body.headers).toEqual({ "x-test": "header" }) expect(body).toEqual({ safety_setting: "strict" }) for (const key of ["compaction", "cache", "encoding", "timeout", "transport"]) expect(options).not.toHaveProperty(key) }), ) it.effect("uses only the provider timeout signal when the request signal is null", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service let wrappedFetch: typeof fetch | undefined let requestSignal: AbortSignal | null | undefined yield* aisdk.hook.sdk((event) => { if (typeof event.options.fetch === "function") { wrappedFetch = event.options.fetch as typeof fetch } event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) yield* aisdk.language( model("test-ai-sdk", { timeout: 60_000, fetch: async (_input: Parameters[0], init?: RequestInit) => { requestSignal = init?.signal return new Response() }, }), ) const request = wrappedFetch if (!request) return yield* Effect.die("Expected wrapped fetch") yield* Effect.promise(() => request("https://example.com", { signal: null })) expect(requestSignal).toBeInstanceOf(AbortSignal) expect(requestSignal?.aborted).toBeFalse() }), ) it.effect("lowers chronological system updates to wrapped user messages", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const resolved = yield* aisdk.model(model("opaque-provider")) const prepared = yield* compileRequest( ai.request({ model: resolved, system: "Initial instructions.", messages: [ Message.user("Before."), Message.system("Updated & constraints."), Message.assistant("After."), ], }), ) expect(prepared.body.prompt).toEqual([ { role: "system", content: "Initial instructions." }, { role: "user", content: [{ type: "text", text: "Before." }] }, { role: "user", content: [ { type: "text", text: "\nUpdated <rules> & constraints.\n", }, ], }, { role: "assistant", content: [{ type: "text", text: "After." }] }, ]) }), ) it.effect("leaves max output tokens unset when the request omits them", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const resolved = yield* aisdk.model({ ...model("@openrouter/ai-sdk-provider"), limit: { context: 500_000, output: 500_000 }, }) const prepared = yield* compileRequest(ai.request({ model: resolved, prompt: "Hello" })) expect(prepared.body.maxOutputTokens).toBeUndefined() }), ) it.effect("maps pro reasoning bodies to AI SDK provider options", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service let body: unknown yield* aisdk.hook.sdk((event) => { body = event.options.body event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const resolved = yield* aisdk.model({ ...model("@ai-sdk/openai"), body: { reasoning: { mode: "pro" } }, }) const prepared = yield* compileRequest(ai.request({ model: resolved, prompt: "Hello" })) expect(body).toBeUndefined() expect(prepared.body.providerOptions).toEqual({ openai: { forceReasoning: true, reasoningMode: "pro" }, }) }), ) it.effect("maps package-specific AI SDK provider option keys", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const cases = [ ["@ai-sdk/amazon-bedrock/mantle", "openai", { reasoningEffort: "high", forceReasoning: true }], ["@ai-sdk/openai-compatible", "test-provider", { reasoningEffort: "high" }], ["@jerome-benoit/sap-ai-provider-v2", "sap-ai", { reasoningEffort: "high" }], ["ai-gateway-provider", "openaiCompatible", { reasoningEffort: "high" }], ] as const for (const [packageName, key, settings] of cases) { const resolved = yield* aisdk.model(model(packageName, { reasoningEffort: "high" })) const prepared = yield* compileRequest(ai.request({ model: resolved, prompt: "Hello" })) expect(prepared.body.providerOptions).toEqual({ [key]: settings }) } }), ) it.effect("forces reasoning and projects both Azure AI SDK namespaces", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const openai = yield* aisdk.model(model("@ai-sdk/openai", { reasoningEffort: "high" })) const openaiPrepared = yield* compileRequest(ai.request({ model: openai, prompt: "Hello" })) expect(openaiPrepared.body.providerOptions).toEqual({ openai: { reasoningEffort: "high", forceReasoning: true }, }) const azure = yield* aisdk.model(model("@ai-sdk/azure", { reasoningEffort: "high" })) const azurePrepared = yield* compileRequest(ai.request({ model: azure, prompt: "Hello" })) expect(azurePrepared.body.providerOptions).toEqual({ openai: { reasoningEffort: "high", forceReasoning: true }, azure: { reasoningEffort: "high", forceReasoning: true }, }) }), ) it.effect("routes AI Gateway model options by upstream prefix", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const anthropic = yield* aisdk.model({ ...model("@ai-sdk/gateway", { gateway: { order: ["anthropic"] }, thinking: { type: "adaptive" }, }), modelID: Model.ID.make("anthropic/claude-sonnet-5"), }) const anthropicPrepared = yield* compileRequest(ai.request({ model: anthropic, prompt: "Hello" })) expect(anthropicPrepared.body.providerOptions).toEqual({ gateway: { order: ["anthropic"] }, anthropic: { thinking: { type: "adaptive" } }, }) const bedrock = yield* aisdk.model({ ...model("@ai-sdk/gateway", { reasoningConfig: { type: "enabled" } }), modelID: Model.ID.make("amazon/nova-2-lite"), }) const bedrockPrepared = yield* compileRequest(ai.request({ model: bedrock, prompt: "Hello" })) expect(bedrockPrepared.body.providerOptions).toEqual({ bedrock: { reasoningConfig: { type: "enabled" } }, }) const openai = yield* aisdk.model({ ...model("@ai-sdk/gateway", { gateway: { order: ["openai"] } }), modelID: Model.ID.make("openai/gpt-5.5"), }) const openaiPrepared = yield* compileRequest( ai.request({ model: openai, prompt: "Hello", providerOptions: { textVerbosity: "low" } }), ) expect(openaiPrepared.body.providerOptions).toEqual({ gateway: { order: ["openai"] }, openai: { textVerbosity: "low" }, }) const fallback = yield* aisdk.model({ ...model("@ai-sdk/gateway", { reasoningEffort: "high" }), modelID: Model.ID.make("deepseek/deepseek-v4"), }) const fallbackPrepared = yield* compileRequest(ai.request({ model: fallback, prompt: "Hello" })) expect(fallbackPrepared.body.providerOptions).toEqual({ deepseek: { reasoningEffort: "high" }, }) }), ) it.effect("closes the open AI SDK reasoning part when the next one starts", () => Effect.gen(function* () { // AI SDK OpenAI Responses can start summary part 1 before part 0 ends, then end both at item completion (#50662). const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => streamModel([ { type: "reasoning-start", id: "rs_1:0", providerMetadata: { gateway: { generationId: "gen_1" } } }, { type: "reasoning-start", id: "rs_1:1" }, { type: "reasoning-delta", id: "rs_1:1", delta: "Second summary" }, { type: "reasoning-end", id: "rs_1:0", providerMetadata: { gateway: { encrypted: "late" } } }, { type: "reasoning-end", id: "rs_1:1", providerMetadata: { gateway: { encrypted: "final" } } }, { type: "finish", finishReason: { unified: "stop", raw: "stop" }, usage }, ]), } }) const resolved = yield* aisdk.model(model("@ai-sdk/gateway")) const response = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Think" })).pipe( Effect.provide(client), ) expect(response.events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([ { type: "reasoning-start", id: "rs_1:0", providerMetadata: { gateway: { generationId: "gen_1" } } }, { type: "reasoning-end", id: "rs_1:0" }, { type: "reasoning-start", id: "rs_1:1", providerMetadata: undefined }, { type: "reasoning-delta", id: "rs_1:1", text: "Second summary", providerMetadata: undefined }, { type: "reasoning-end", id: "rs_1:1", providerMetadata: { gateway: { encrypted: "final" } } }, ]) }), ) it.effect("normalizes repeated, reopened, and overlapping AI SDK fragment boundaries", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => streamModel([ // Older xAI Responses repeat the start for every summary part. { type: "reasoning-start", id: "rs_1" }, { type: "reasoning-start", id: "rs_1" }, { type: "reasoning-delta", id: "rs_1", delta: "First" }, { type: "reasoning-end", id: "rs_1" }, // xAI Chat keeps streaming an ended reasoning id after an empty tool_calls chunk. { type: "reasoning-delta", id: "rs_1", delta: "Second" }, { type: "reasoning-end", id: "rs_1" }, // xAI Responses ends every message item only when the stream flushes. { type: "text-start", id: "msg_1" }, { type: "text-delta", id: "msg_1", delta: "One" }, { type: "text-start", id: "msg_2" }, { type: "text-delta", id: "msg_2", delta: "Two" }, { type: "text-end", id: "msg_1" }, { type: "text-end", id: "msg_2" }, { type: "finish", finishReason: { unified: "stop", raw: "stop" }, usage }, ]), } }) const resolved = yield* aisdk.model(model("@ai-sdk/gateway")) const response = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Think" })).pipe( Effect.provide(client), ) expect( response.events.filter((event) => event.type.startsWith("reasoning-") || event.type.startsWith("text-")), ).toMatchObject([ { type: "reasoning-start", id: "rs_1" }, { type: "reasoning-delta", id: "rs_1", text: "First" }, { type: "reasoning-end", id: "rs_1" }, { type: "reasoning-start", id: "rs_1" }, { type: "reasoning-delta", id: "rs_1", text: "Second" }, { type: "reasoning-end", id: "rs_1" }, { type: "text-start", id: "msg_1" }, { type: "text-delta", id: "msg_1", text: "One" }, { type: "text-end", id: "msg_1" }, { type: "text-start", id: "msg_2" }, { type: "text-delta", id: "msg_2", text: "Two" }, { type: "text-end", id: "msg_2" }, ]) }), ) it.effect("projects replay metadata onto AI SDK prompt parts", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const resolved = yield* aisdk.model(model("@ai-sdk/anthropic")) expect(resolved.route.providerMetadataKey).toBe("anthropic") const prepared = yield* compileRequest( ai.request({ model: resolved, messages: [ Message.assistant([ { type: "text", text: "Answer", providerMetadata: { anthropic: { cacheControl: { type: "ephemeral" } } } }, { type: "text", text: " without metadata" }, { type: "reasoning", text: "Think", providerMetadata: { anthropic: { signature: "signed" } } }, { type: "tool-call", id: "hosted", name: "web_search", input: { query: "Effect" }, providerExecuted: true, providerMetadata: { anthropic: { blockType: "server_tool_use" } }, }, ]), ], }), ) expect(prepared.body.prompt).toEqual([ { role: "assistant", content: [ { type: "text", text: "Answer", providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } }, }, { type: "text", text: " without metadata", providerOptions: undefined, }, { type: "reasoning", text: "Think", providerOptions: { anthropic: { signature: "signed" } }, }, { type: "tool-call", toolCallId: "hosted", toolName: "web_search", input: { query: "Effect" }, providerExecuted: true, providerOptions: { anthropic: { blockType: "server_tool_use" } }, }, ], }, ]) }), ) it.effect("normalizes file data across AI SDK prompt parts", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => ({ provider: event.model.providerID }) } }) const resolved = yield* aisdk.model(model("opaque-provider")) const bytes = new Uint8Array([0, 1, 2, 3]) const prepared = yield* compileRequest( ai.request({ model: resolved, messages: [ Message.user([ { type: "media", media: Media.bytes(bytes, "image/png"), filename: "bytes.png" }, { type: "media", media: Media.base64("AAAA", "image/png"), filename: "base64.png" }, { type: "media", media: Media.fromDataUrl("data:image/png;charset=utf-8;base64,AQID"), filename: "inline.png", }, { type: "media", media: Media.url("https://example.com/image.png", { mediaType: "image/png" }) }, { type: "media", media: Media.base64("s3://bucket/image.png", "image/png") }, ]), Message.assistant({ type: "media", media: Media.url("http://example.com/document.pdf", { mediaType: "application/pdf" }), filename: "document.pdf", }), Message.tool({ id: "call_1", name: "screenshot", result: { type: "content", value: [{ type: "file", uri: "data:image/png;base64,BAUG", mime: "image/png", name: "tool.png" }], }, }), ], }), ) expect(prepared.body.prompt).toEqual([ { role: "user", content: [ { type: "file", mediaType: "image/png", data: bytes, filename: "bytes.png" }, { type: "file", mediaType: "image/png", data: "AAAA", filename: "base64.png" }, { type: "file", mediaType: "image/png", data: "AQID", filename: "inline.png" }, { type: "file", mediaType: "image/png", data: new URL("https://example.com/image.png"), filename: undefined, }, { type: "file", mediaType: "image/png", data: "s3://bucket/image.png", filename: undefined }, ], }, { role: "assistant", content: [ { type: "file", mediaType: "application/pdf", data: new URL("http://example.com/document.pdf"), filename: "document.pdf", }, ], }, { role: "tool", content: [ { type: "tool-result", toolCallId: "call_1", toolName: "screenshot", output: { type: "text", value: "Media attached in the following user message." }, providerOptions: undefined, }, ], }, { role: "user", content: [ { type: "text", text: "Attached media from tool result:" }, { type: "file", mediaType: "image/png", data: "BAUG", filename: "tool.png" }, ], }, ]) }), ) it.effect("does not treat SSE comment heartbeats as model progress", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service const encoder = new TextEncoder() let heartbeat: ReturnType | undefined const customFetch = Object.assign( async () => new Response( new ReadableStream({ start(controller) { controller.enqueue( encoder.encode( 'data: {"id":"response-1","object":"chat.completion.chunk","created":0,"model":"api-model","choices":[{"index":0,"delta":{"content":"partial"},"finish_reason":null}]}\n\n', ), ) heartbeat = setInterval(() => controller.enqueue(encoder.encode(": keepalive\n\n")), 5) }, cancel() { if (heartbeat) clearInterval(heartbeat) }, }), { headers: { "content-type": "text/event-stream" } }, ), { preconnect: fetch.preconnect }, ) yield* aisdk.hook.sdk((event) => { event.sdk = createOpenAICompatible({ ...event.options, name: String(event.options.name), baseURL: String(event.options.baseURL), }) }) const resolved = yield* aisdk.model( model("@ai-sdk/openai-compatible", { apiKey: "test", baseURL: "https://example.test/v1", chunkTimeout: 25, fetch: customFetch, }), ) const result = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" })).pipe( Effect.provide(client), Effect.result, Effect.ensuring( Effect.sync(() => { if (heartbeat) clearInterval(heartbeat) }), ), ) expect(result).toMatchObject({ _tag: "Failure", failure: { message: expect.stringContaining("SSE read timed out") }, }) }), ) const chatChunk = (text: string) => `data: ${JSON.stringify({ id: "response-1", object: "chat.completion.chunk", created: 0, model: "api-model", choices: [{ index: 0, delta: { content: text }, finish_reason: "stop" }], })}\n\ndata: [DONE]\n\n` const compatibleModel = Effect.fn(function* (customFetch: typeof fetch) { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = createOpenAICompatible({ ...event.options, name: String(event.options.name), baseURL: String(event.options.baseURL), }) }) return yield* aisdk.model( model("@ai-sdk/openai-compatible", { apiKey: "test", baseURL: "https://example.test/v1", fetch: customFetch }), ) }) // Not `it`, whose AISDK layer is already built with the harness's fetch and would be reused here. testEffect(Layer.empty).effect("sends AI SDK requests through the embedder's fetch when the provider names none", () => Effect.gen(function* () { const sent: string[] = [] const embedder = async (input: Request | string | URL) => { sent.push(input instanceof Request ? input.url : String(input)) return new Response(chatChunk("embedded"), { headers: { "content-type": "text/event-stream" } }) } const response = yield* Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = createOpenAICompatible({ ...event.options, name: String(event.options.name), baseURL: String(event.options.baseURL), }) }) const resolved = yield* aisdk.model( model("@ai-sdk/openai-compatible", { apiKey: "test", baseURL: "https://example.test/v1" }), ) return yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" })).pipe(Effect.provide(client)) }).pipe( Effect.provide( AppNodeBuilder.build(AISDK.node, [LayerNodePlatform.httpFetch.replace(LayerNodePlatform.fetchLayer(embedder))]), ), ) expect(sent).toEqual(["https://example.test/v1/chat/completions"]) expect(response.text).toBe("embedded") }), ) it.effect("routes AI SDK requests and responses through HTTP hook middleware", () => Effect.gen(function* () { const sent: Array<{ url: string; headers: Headers; body: string }> = [] const resolved = yield* compatibleModel( Object.assign( async (input: Parameters[0], init?: RequestInit) => { sent.push({ url: String(input), headers: new Headers(init?.headers), body: new TextDecoder().decode(init?.body as ArrayBuffer), }) return new Response(chatChunk("upstream"), { headers: { "content-type": "text/event-stream" } }) }, { preconnect: fetch.preconnect }, ), ) const seen: string[] = [] const response = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" }), { http: (request, handler) => Effect.gen(function* () { // Read the body twice the way session hooks do, to prove it is not a single-use stream. const first = yield* HttpClientRequest.toWeb(request) const second = yield* HttpClientRequest.toWeb(request) seen.push(`${request.method} ${request.url}`) seen.push(yield* Effect.promise(() => first.text())) seen.push(yield* Effect.promise(() => second.text())) const upstream = yield* handler(HttpClientRequest.setHeader(request, "x-hook", "applied")) seen.push(`status ${upstream.status}`) return HttpClientResponse.fromWeb( upstream.request, new Response(chatChunk("rewritten"), { headers: { "content-type": "text/event-stream" } }), ) }), }).pipe(Effect.provide(client)) expect(sent).toHaveLength(1) expect(sent[0]?.url).toBe("https://example.test/v1/chat/completions") expect(sent[0]?.headers.get("x-hook")).toBe("applied") expect(sent[0]?.headers.get("authorization")).toBe("Bearer test") expect(JSON.parse(sent[0]?.body ?? "")).toMatchObject({ model: "api-model" }) expect(seen).toEqual(["POST https://example.test/v1/chat/completions", sent[0]?.body, sent[0]?.body, "status 200"]) expect(response.events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["rewritten"]) }), ) it.effect("sends AI SDK requests directly when no HTTP hook middleware is attached", () => Effect.gen(function* () { const bodies: unknown[] = [] const resolved = yield* compatibleModel( Object.assign( async (_input: Parameters[0], init?: RequestInit) => { bodies.push(init?.body) return new Response(chatChunk("upstream"), { headers: { "content-type": "text/event-stream" } }) }, { preconnect: fetch.preconnect }, ), ) const response = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" })).pipe( Effect.provide(client), ) expect(bodies).toHaveLength(1) expect(typeof bodies[0]).toBe("string") expect(response.events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["upstream"]) }), ) it.effect("fails with a retryable transport error when response headers time out", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service const customFetch = Object.assign( (_input: Parameters[0], init?: RequestInit) => new Promise((_, reject) => { init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), { once: true }) }), { preconnect: fetch.preconnect }, ) yield* aisdk.hook.sdk((event) => { event.sdk = createOpenAICompatible({ ...event.options, name: String(event.options.name), baseURL: String(event.options.baseURL), }) }) const resolved = yield* aisdk.model( model("@ai-sdk/openai-compatible", { apiKey: "test", baseURL: "https://example.test/v1", headerTimeout: 25, fetch: customFetch, }), ) const error = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" })).pipe( Effect.provide(client), Effect.flip, ) expect(error.reason).toMatchObject({ _tag: "Transport", operation: "request", message: "Response headers timed out", }) expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() }), ) it.effect("emits malformed AI SDK tool input without executing it", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service const raw = '{"query":"partial' yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => streamModel([ { type: "tool-input-start", id: "call_1", toolName: "lookup" }, { type: "tool-input-delta", id: "call_1", delta: raw }, { type: "tool-input-end", id: "call_1" }, { type: "tool-call", toolCallId: "call_1", toolName: "lookup", input: raw }, { type: "finish", finishReason: { unified: "tool-calls", raw: "tool_calls" }, usage }, ]), } }) const resolved = yield* aisdk.model(model("test-ai-sdk")) const response = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Lookup" })).pipe( Effect.provide(client), ) expect(response.events.find(LLMEvent.is.toolInputError)).toMatchObject({ id: "call_1", name: "lookup", raw, }) expect(response.events.some(LLMEvent.is.toolInputEnd)).toBeTrue() expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse() expect(response.finishReason).toEqual({ normalized: "tool-calls", raw: "tool_calls" }) }), ) it.effect("keeps malformed provider-executed AI SDK input terminal", () => Effect.gen(function* () { const aisdk = yield* AISDK.Service const raw = '{"query":"partial' yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => streamModel([ { type: "tool-input-start", id: "call_1", toolName: "web_search", providerExecuted: true }, { type: "tool-input-delta", id: "call_1", delta: raw }, { type: "tool-input-end", id: "call_1" }, { type: "tool-call", toolCallId: "call_1", toolName: "web_search", input: raw, providerExecuted: true, }, ]), } }) const resolved = yield* aisdk.model(model("hosted-test-ai-sdk")) const error = yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Search" })).pipe( Effect.provide(client), Effect.flip, ) expect(error).toBeInstanceOf(AIError) expect(error.message).toContain("Invalid JSON input for aisdk tool call web_search") }), ) const failingModel = (failure: unknown): LanguageModelV3 => ({ specificationVersion: "v3", provider: "test", modelId: "test", supportedUrls: {}, doGenerate: () => Promise.reject(new Error("Unexpected non-streaming request")), doStream: () => Promise.reject(failure), }) const streamFailure = (failure: unknown, streamed = false) => Effect.gen(function* () { const aisdk = yield* AISDK.Service yield* aisdk.hook.sdk((event) => { event.sdk = { languageModel: () => (streamed ? streamModel([{ type: "error", error: failure }]) : failingModel(failure)), } }) const resolved = yield* aisdk.model(model("test-ai-sdk")) return yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" })).pipe( Effect.provide(client), Effect.flip, ) }) it.effect("preserves non-empty AI SDK error messages", () => Effect.gen(function* () { const cause = new Error("Bad Request") const error = yield* streamFailure(cause) expect(error).toBeInstanceOf(AIError) expect(error.message).toBe("Bad Request") expect(error.reason).toBeInstanceOf(UnknownProviderError) expect(error.reason).toBeInstanceOf(Error) expect(error.cause).toBe(error.reason) expect(error.reason.cause).toBe(cause) }), ) Object.values({ object: { error: { message: "Provider busy", metadata: { requestId: "stream-request", retryable: true } } }, string: '{"error":"Provider busy","requestId":"stream-request"}', }).forEach((payload) => { it.effect(`preserves ${typeof payload} AI SDK stream error payloads in the runtime body`, () => Effect.gen(function* () { const error = yield* streamFailure(payload, true) const body = typeof payload === "string" ? payload : JSON.stringify(payload) expect(error.reason.body).toBe(body) expect(error.reason.cause).toBe(payload) }), ) }) // Shapes the Vercel AI Gateway streams when the upstream rejects a request. Object.entries({ "type validation": { name: "AI_TypeValidationError", value: { error: { type: "invalid_request_error", message: "Bad max_tokens" } }, }, invalid_request: { code: "invalid_request", message: "Bad max_tokens" }, }).forEach(([shape, failure]) => it.effect(`reads gateway ${shape} stream errors as invalid requests`, () => Effect.gen(function* () { const error = yield* streamFailure(failure, true) expect(error.message).toBe("Bad max_tokens") expect(error.reason).toBeInstanceOf(InvalidRequestError) }), ), ) it.effect("does not copy Error request internals into the provider body", () => Effect.gen(function* () { const cause = Object.assign(new Error("Connection failed"), { requestBodyValues: { prompt: "private prompt" }, requestHeaders: { authorization: "Bearer private-token" }, }) cause.cause = cause const error = yield* streamFailure(cause, true) expect(error.reason.body).toBeUndefined() expect(error.reason.cause).toBe(cause) expect(error.message).toBe("Connection failed") }), ) it.effect("preserves existing AI errors and their retry semantics unchanged", () => Effect.gen(function* () { const failure = new AIError({ reason: new RateLimitError({ message: "Provider is busy", retryAfterMs: 7000, body: '{"error":"busy"}', http: new HttpContext({ url: "https://api.example.com/chat", status: 429, headers: { "retry-after": "7" } }), cause: new Error("original provider failure"), }), }) const error = yield* streamFailure(failure) expect(error).toBe(failure) expect(error.reason).toBe(failure.reason) expect(error.reason).toBeInstanceOf(RateLimitError) expect(error.cause).toBe(error.reason) expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() }), ) const apiCallError = (input: Partial[0]>) => new APICallError({ message: "", url: "https://api.example.com/chat", requestBodyValues: { messages: [{ role: "user", content: "private prompt" }] }, responseHeaders: { authorization: "Bearer secret-token" }, ...input, }) it.effect("derives status and code when the AI SDK error message is empty", () => Effect.gen(function* () { const error = yield* streamFailure( apiCallError({ statusCode: 404, responseBody: '{"error":{"message":"","code":"not_found"}}', data: { error: { message: "", code: "not_found" } }, }), ) expect(error.message).toBe("Provider request failed with HTTP 404: not_found") expect(error.message).not.toContain("secret-token") expect(error.message).not.toContain("private prompt") const projected = toSessionError(error) expect(projected.type).toBe("provider.invalid-request") expect(projected.status).toBe(404) expect(projected.message).not.toBe("") }), ) it.effect("preserves complete HTTP context on AI SDK call errors", () => Effect.gen(function* () { const cause = apiCallError({ statusCode: 404, responseBody: '{"error":{"message":"","code":"not_found"}}', data: { error: { code: "not_found", metadata: "parsed-only" } }, }) const error = yield* streamFailure(cause) expect(error.reason).toMatchObject({ _tag: "InvalidRequest" }) expect(error.reason.http).toEqual( new HttpContext({ url: "https://api.example.com/chat", status: 404, headers: { authorization: "Bearer secret-token" }, }), ) expect(error.reason.body).toBe('{"error":{"message":"","code":"not_found"}}') expect(error.reason.cause).toBe(cause) }), ) it.effect("classifies retryable AI SDK failures with retry-after details", () => Effect.gen(function* () { const error = yield* streamFailure( apiCallError({ statusCode: 429, responseHeaders: { "retry-after": "7" }, }), ) expect(error.reason).toMatchObject({ _tag: "RateLimit", retryAfterMs: 7000 }) }), ) it.effect("classifies data-only AI SDK provider codes", () => Effect.gen(function* () { const data = { error: { code: "rate_limit_error", metadata: { requestId: "data-request", retryable: true } }, trace: { region: "test-region" }, } const cause = apiCallError({ statusCode: 400, data }) const error = yield* streamFailure(cause) expect(error.reason).toMatchObject({ _tag: "RateLimit" }) expect(error.reason.http?.status).toBe(400) expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() expect(error.reason.body).toBe(JSON.stringify(data)) expect(error.reason.cause).toBe(cause) expect(error.reason.body).not.toContain("private prompt") }), ) it.effect("classifies data-only AI SDK authentication errors", () => Effect.gen(function* () { const error = yield* streamFailure( apiCallError({ statusCode: 400, data: { error: { code: "authentication_error" } }, }), ) expect(error.reason).toMatchObject({ _tag: "Authentication" }) expect(SessionRunnerRetry.isRetryable(error)).toBeFalse() }), ) Object.entries({ json: '{"message":"Request failed"}', malformed: "Request failed", empty: "", }).forEach(([kind, responseBody]) => { it.effect(`classifies SDK data alongside the original ${kind} response body`, () => Effect.gen(function* () { const cause = apiCallError({ message: "Request failed", statusCode: 400, data: { error: { code: "authentication_error" } }, responseBody, }) const error = yield* streamFailure(cause) expect(error.reason).toMatchObject({ _tag: "Authentication" }) expect(SessionRunnerRetry.isRetryable(error)).toBeFalse() expect(error.reason.body).toBe(responseBody) expect(error.reason.cause).toBe(cause) }), ) }) it.effect("detects context overflow from data-only AI SDK errors", () => Effect.gen(function* () { const error = yield* streamFailure( apiCallError({ statusCode: 400, data: { error: { code: "context_length_exceeded" } }, }), ) expect(error.reason).toMatchObject({ _tag: "InvalidRequest", classification: "context-overflow" }) expect(isContextOverflowFailure(error)).toBeTrue() }), ) it.effect("retries status-less AI SDK transport failures", () => Effect.gen(function* () { const cause = apiCallError({ message: "Cannot connect to API: connection refused", isRetryable: true, data: { code: "ECONNREFUSED" }, }) const error = yield* streamFailure(cause) expect(error.reason).toMatchObject({ _tag: "Transport", transport: "http", operation: "request", }) expect(error.reason).not.toHaveProperty("code") expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() expect(error.reason).toBeInstanceOf(TransportError) expect(error.reason).toBeInstanceOf(Error) expect(error.cause).toBe(error.reason) expect(error.reason.cause).toBe(cause) expect(error.message).toBe(cause.message) expect(error.reason.body).toBe(JSON.stringify(cause.data)) expect(error.reason).toMatchObject({ url: "https://api.example.com/chat" }) expect(error.reason.http).toBeUndefined() }), ) it.effect("classifies native fetch failures as request transport errors", () => Effect.gen(function* () { const cause = Object.assign(new TypeError("fetch failed"), { cause: Object.assign(new Error("connect ECONNREFUSED 127.0.0.1:443"), { code: "ECONNREFUSED" }), }) const error = yield* streamFailure(cause) expect(error.reason).toMatchObject({ _tag: "Transport", transport: "http", operation: "request", code: "ECONNREFUSED", }) expect(error.message).toBe("connect ECONNREFUSED 127.0.0.1:443") expect(error.reason.cause).toBe(cause) expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() }), ) it.effect("keeps the code of a host name that didn't resolve", () => Effect.gen(function* () { const dns = Object.assign(new Error("getaddrinfo ENOTFOUND api.example.com"), { code: "ENOTFOUND" }) const raw = yield* streamFailure(dns) expect(raw.reason).toMatchObject({ _tag: "Transport", operation: "request", code: "ENOTFOUND" }) expect(ModelRetry.isUnreachable(raw)).toBeTrue() const wrapped = yield* streamFailure( apiCallError({ message: "Cannot connect to API: getaddrinfo ENOTFOUND", isRetryable: true, cause: dns }), ) expect(wrapped.reason).toMatchObject({ _tag: "Transport", operation: "request", code: "ENOTFOUND" }) expect(ModelRetry.isUnreachable(wrapped)).toBeTrue() }), ) it.effect("classifies mid-stream socket drops as read transport errors", () => Effect.gen(function* () { const cause = Object.assign(new Error("terminated"), { cause: Object.assign(new Error("other side closed"), { code: "UND_ERR_SOCKET" }), }) const error = yield* streamFailure(cause, true) expect(error.reason).toMatchObject({ _tag: "Transport", transport: "http", operation: "read", code: "UND_ERR_SOCKET", }) expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() }), ) it.effect("classifies the SSE chunk timeout as a read transport error", () => Effect.gen(function* () { const error = yield* streamFailure(new Error("SSE read timed out"), true) expect(error.reason).toMatchObject({ _tag: "Transport", transport: "http", operation: "read" }) expect(SessionRunnerRetry.isRetryable(error)).toBeTrue() }), ) it.effect("keeps unrecognized error codes on the unknown provider path", () => Effect.gen(function* () { const error = yield* streamFailure(Object.assign(new Error("kaput"), { code: "E_SOMETHING_ELSE" }), true) expect(error.reason).toBeInstanceOf(UnknownProviderError) }), ) it.effect("prefers a structured provider message over the code fallback", () => Effect.gen(function* () { const error = yield* streamFailure( apiCallError({ statusCode: 404, data: { error: { code: "not_found" } }, responseBody: '{"message":"The requested model does not exist"}', }), ) expect(error.message).toBe("The requested model does not exist") }), ) it.effect("falls back to the status alone for malformed response bodies", () => Effect.gen(function* () { const error = yield* streamFailure( apiCallError({ statusCode: 502, isRetryable: false, responseBody: "Bad Gateway", }), ) expect(error.reason).toMatchObject({ _tag: "ProviderInternal" }) expect(error.reason.http?.status).toBe(502) expect(error.message).toBe("Provider request failed with HTTP 502") }), )