feat(llm): add compatible responses provider (#35908)

packages/llm/test/exports.test.ts

@@ -11,7 +11,12 @@ import {
   XAI,
 } from "@opencode-ai/llm/providers"
 import * as GitHubCopilot from "@opencode-ai/llm/providers/github-copilot"
-import { OpenAIChat, OpenAICompatibleChat, OpenAIResponses } from "@opencode-ai/llm/protocols"
+import {
+  OpenAIChat,
+  OpenAICompatibleChat,
+  OpenAICompatibleResponses,
+  OpenAIResponses,
+} from "@opencode-ai/llm/protocols"
 import * as AnthropicMessages from "@opencode-ai/llm/protocols/anthropic-messages"
 
 describe("public exports", () => {
@@ -28,12 +33,17 @@ describe("public exports", () => {
     expect(Protocol.make).toBeFunction()
   })
 
-  test("provider barrels expose user-facing facades", () => {
+  test("provider barrels expose user-facing facades", async () => {
+    const { OpenAICompatibleResponses } = await import("@opencode-ai/llm/providers")
+
     expect(OpenAI.model).toBeFunction()
     expect(OpenAI.provider.responses).toBe(OpenAI.responses)
     expect(OpenAI.provider.responsesWebSocket).toBe(OpenAI.responsesWebSocket)
     expect(OpenAI.configure({ apiKey: "fixture" }).responses).toBeFunction()
     expect(OpenAICompatible.deepseek.model).toBeFunction()
+    expect(
+      OpenAICompatibleResponses.configure({ baseURL: "https://responses.test/v1" }).model("fixture").route.id,
+    ).toBe("openai-compatible-responses")
     expect(CloudflareAIGateway.configure).toBeFunction()
     expect(CloudflareAIGateway.configure({ accountId: "fixture", gatewayApiKey: "fixture" }).model).toBeFunction()
     expect(CloudflareWorkersAI.configure).toBeFunction()
@@ -68,6 +78,7 @@ describe("public exports", () => {
   test("protocol barrels expose supported low-level routes", () => {
     expect(OpenAIChat.route.id).toBe("openai-chat")
     expect(OpenAICompatibleChat.route.id).toBe("openai-compatible-chat")
+    expect(OpenAICompatibleResponses.route.id).toBe("openai-compatible-responses")
     expect(OpenAIResponses.route.id).toBe("openai-responses")
     expect(OpenAIResponses.webSocketRoute.id).toBe("openai-responses-websocket")
     expect(AnthropicMessages.route.id).toBe("anthropic-messages")

packages/llm/test/provider-package.test.ts

@@ -9,6 +9,7 @@ describe("provider package entrypoints", () => {
       import("@opencode-ai/llm/providers/openai/chat"),
       import("@opencode-ai/llm/providers/anthropic"),
       import("@opencode-ai/llm/providers/openai-compatible"),
+      import("@opencode-ai/llm/providers/openai-compatible/responses"),
       import("@opencode-ai/llm/providers/amazon-bedrock"),
       import("@opencode-ai/llm/providers/azure"),
       import("@opencode-ai/llm/providers/azure/responses"),
@@ -18,7 +19,7 @@ describe("provider package entrypoints", () => {
 
     for (const module of modules) expect(module.model).toBeFunction()
     expect(modules[0].model).toBe(modules[1].model)
-    expect(modules[6].model).toBe(modules[7].model)
+    expect(modules[7].model).toBe(modules[8].model)
   })
 
   test("maps package settings onto the executable model", () => {
@@ -42,6 +43,32 @@ describe("provider package entrypoints", () => {
     expect(model("gpt-5", { apiKey: "fixture", transport: "websocket" }).route.id).toBe("openai-responses-websocket")
   })
 
+  test("maps OpenAI-compatible Responses settings onto the executable model", async () => {
+    const OpenAICompatibleResponses = await import("@opencode-ai/llm/providers/openai-compatible/responses")
+    const selected = OpenAICompatibleResponses.model("custom-model", {
+      apiKey: "fixture",
+      baseURL: "https://responses.example.test/v1",
+      provider: "example",
+      headers: { "x-application": "opencode" },
+      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
+      providerOptions: { openai: { reasoningEffort: "low", store: true } },
+    })
+
+    expect(String(selected.provider)).toBe("example")
+    expect(selected.route.id).toBe("openai-compatible-responses")
+    expect(selected.route.endpoint).toMatchObject({
+      baseURL: "https://responses.example.test/v1",
+      path: "/responses",
+    })
+    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
+    expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
+    expect(selected.route.defaults.providerOptions).toEqual({
+      openai: { reasoningEffort: "low", store: true },
+    })
+  })
+
   test("maps legacy OpenAI organization and project settings to headers", () => {
     const selected = model("gpt-5", {
       apiKey: "fixture",

packages/llm/test/provider/openai-compatible-responses.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM } from "../../src"
+import { configure } from "../../src/providers/openai-compatible-responses"
+import { OpenAICompatibleResponses } from "../../src/protocols/openai-compatible-responses"
+import { OpenAIResponses } from "../../src/protocols/openai-responses"
+import { LLMClient } from "../../src/route"
+import { it } from "../lib/effect"
+
+describe("OpenAI-compatible Responses route", () => {
+  it.effect("reuses the OpenAI Responses protocol for a configured deployment", () =>
+    Effect.gen(function* () {
+      expect(OpenAICompatibleResponses.route.body).toBe(OpenAIResponses.protocol.body)
+      expect(OpenAICompatibleResponses.route.transport).toBe(OpenAIResponses.httpTransport)
+
+      const model = configure({
+        apiKey: "test-key",
+        baseURL: "https://responses.example.test/v1",
+        provider: "example",
+      }).model("example-model")
+      const prepared = yield* LLMClient.prepare(
+        LLM.request({
+          model,
+          system: "You are concise.",
+          prompt: "Say hello.",
+        }),
+      )
+
+      expect(prepared.route).toBe("openai-compatible-responses")
+      expect(prepared.protocol).toBe("openai-responses")
+      expect(prepared.model).toMatchObject({
+        id: "example-model",
+        provider: "example",
+        route: {
+          id: "openai-compatible-responses",
+          endpoint: {
+            baseURL: "https://responses.example.test/v1",
+            path: "/responses",
+          },
+        },
+      })
+      expect(prepared.body).toEqual({
+        model: "example-model",
+        input: [
+          { role: "system", content: "You are concise." },
+          { role: "user", content: [{ type: "input_text", text: "Say hello." }] },
+        ],
+        store: false,
+        stream: true,
+      })
+    }),
+  )
+})