Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

feat: add opencode provider support (#1758)

Shoubhit Dashce94feeea156
diff --git a/apps/server/package.json b/apps/server/package.json
index 038134bd5..b5107d1b0 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -29,6 +29,7 @@
"@effect/platform-bun": "catalog:",
"@effect/platform-node": "catalog:",
"@effect/sql-sqlite-bun": "catalog:",
+ "@opencode-ai/sdk": "^1.3.15",
"@pierre/diffs": "^1.1.0-beta.16",
"effect": "catalog:",
"node-pty": "^1.1.0",
diff --git a/apps/server/src/git/Layers/OpenCodeTextGeneration.test.ts b/apps/server/src/git/Layers/OpenCodeTextGeneration.test.ts
new file mode 100644
index 000000000..4cf25c946
--- /dev/null
+++ b/apps/server/src/git/Layers/OpenCodeTextGeneration.test.ts
@@ -0,0 +1,259 @@
+import type { ChildProcess } from "node:child_process";
+
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it } from "@effect/vitest";
+import { Duration, Effect, Layer } from "effect";
+import { TestClock } from "effect/testing";
+import { beforeEach, expect, vi } from "vitest";
+
+import { ServerConfig } from "../../config.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import { TextGeneration } from "../Services/TextGeneration.ts";
+import { OpenCodeTextGenerationLive } from "./OpenCodeTextGeneration.ts";
+
+const runtimeMock = vi.hoisted(() => {
+ const state = {
+ startCalls: [] as string[],
+ promptUrls: [] as string[],
+ authHeaders: [] as Array<string | null>,
+ closeCalls: [] as string[],
+ promptResult: undefined as { data?: { info?: { structured?: unknown } } } | undefined,
+ };
+
+ return {
+ state,
+ reset() {
+ state.startCalls.length = 0;
+ state.promptUrls.length = 0;
+ state.authHeaders.length = 0;
+ state.closeCalls.length = 0;
+ state.promptResult = undefined;
+ },
+ };
+});
+
+vi.mock("../../provider/opencodeRuntime.ts", async () => {
+ const actual = await vi.importActual<typeof import("../../provider/opencodeRuntime.ts")>(
+ "../../provider/opencodeRuntime.ts",
+ );
+
+ return {
+ ...actual,
+ startOpenCodeServerProcess: vi.fn(async ({ binaryPath }: { binaryPath: string }) => {
+ const index = runtimeMock.state.startCalls.length + 1;
+ const url = `http://127.0.0.1:${4_300 + index}`;
+ runtimeMock.state.startCalls.push(binaryPath);
+ return {
+ url,
+ process: {} as ChildProcess,
+ close: () => {
+ runtimeMock.state.closeCalls.push(url);
+ },
+ };
+ }),
+ createOpenCodeSdkClient: vi.fn(
+ ({ baseUrl, serverPassword }: { baseUrl: string; serverPassword?: string }) => ({
+ session: {
+ create: vi.fn(async () => ({ data: { id: `${baseUrl}/session` } })),
+ prompt: vi.fn(async () => {
+ runtimeMock.state.promptUrls.push(baseUrl);
+ runtimeMock.state.authHeaders.push(
+ serverPassword ? `Basic ${btoa(`opencode:${serverPassword}`)}` : null,
+ );
+ return (
+ runtimeMock.state.promptResult ?? {
+ data: {
+ info: {
+ structured: {
+ subject: "Improve OpenCode reuse",
+ body: "Reuse one server for the full action.",
+ },
+ },
+ },
+ }
+ );
+ }),
+ },
+ }),
+ ),
+ };
+});
+
+const DEFAULT_TEST_MODEL_SELECTION = {
+ provider: "opencode" as const,
+ model: "openai/gpt-5",
+};
+
+const OPENCODE_TEXT_GENERATION_IDLE_TTL_MS = 30_000;
+
+const OpenCodeTextGenerationTestLayer = OpenCodeTextGenerationLive.pipe(
+ Layer.provideMerge(
+ ServerSettingsService.layerTest({
+ providers: {
+ opencode: {
+ binaryPath: "fake-opencode",
+ },
+ },
+ }),
+ ),
+ Layer.provideMerge(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3code-opencode-text-generation-test-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+const OpenCodeTextGenerationExistingServerTestLayer = OpenCodeTextGenerationLive.pipe(
+ Layer.provideMerge(
+ ServerSettingsService.layerTest({
+ providers: {
+ opencode: {
+ binaryPath: "fake-opencode",
+ serverUrl: "http://127.0.0.1:9999",
+ serverPassword: "secret-password",
+ },
+ },
+ }),
+ ),
+ Layer.provideMerge(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3code-opencode-text-generation-existing-server-test-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+beforeEach(() => {
+ runtimeMock.reset();
+});
+
+const advanceIdleClock = Effect.gen(function* () {
+ yield* Effect.yieldNow;
+ yield* TestClock.adjust(Duration.millis(OPENCODE_TEXT_GENERATION_IDLE_TTL_MS + 1));
+ yield* Effect.yieldNow;
+});
+
+it.layer(OpenCodeTextGenerationTestLayer)("OpenCodeTextGenerationLive", (it) => {
+ it.effect("reuses a warm server across back-to-back requests and closes it after idling", () =>
+ Effect.gen(function* () {
+ const textGeneration = yield* TextGeneration;
+
+ yield* textGeneration.generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ });
+ yield* textGeneration.generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ });
+
+ expect(runtimeMock.state.startCalls).toEqual(["fake-opencode"]);
+ expect(runtimeMock.state.promptUrls).toEqual([
+ "http://127.0.0.1:4301",
+ "http://127.0.0.1:4301",
+ ]);
+ expect(runtimeMock.state.closeCalls).toEqual([]);
+
+ yield* advanceIdleClock;
+
+ expect(runtimeMock.state.closeCalls).toEqual(["http://127.0.0.1:4301"]);
+ }).pipe(Effect.provide(TestClock.layer())),
+ );
+
+ it.effect("starts a new server after the warm server idles out", () =>
+ Effect.gen(function* () {
+ const textGeneration = yield* TextGeneration;
+
+ yield* textGeneration.generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ });
+
+ yield* advanceIdleClock;
+
+ yield* textGeneration.generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ });
+
+ expect(runtimeMock.state.startCalls).toEqual(["fake-opencode", "fake-opencode"]);
+ expect(runtimeMock.state.promptUrls).toEqual([
+ "http://127.0.0.1:4301",
+ "http://127.0.0.1:4302",
+ ]);
+ expect(runtimeMock.state.closeCalls).toEqual(["http://127.0.0.1:4301"]);
+ }).pipe(Effect.provide(TestClock.layer())),
+ );
+
+ it.effect("returns a typed missing-output error when OpenCode omits info.structured", () =>
+ Effect.gen(function* () {
+ runtimeMock.state.promptResult = { data: {} };
+ const textGeneration = yield* TextGeneration;
+
+ const error = yield* textGeneration
+ .generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ })
+ .pipe(Effect.flip);
+
+ expect(error.message).toContain("OpenCode returned no structured output.");
+ }),
+ );
+});
+
+it.layer(OpenCodeTextGenerationExistingServerTestLayer)(
+ "OpenCodeTextGenerationLive with configured server URL",
+ (it) => {
+ it.effect("reuses a configured OpenCode server URL without spawning or applying idle TTL", () =>
+ Effect.gen(function* () {
+ const textGeneration = yield* TextGeneration;
+
+ yield* textGeneration.generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ });
+ yield* textGeneration.generateCommitMessage({
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+ });
+
+ expect(runtimeMock.state.startCalls).toEqual([]);
+ expect(runtimeMock.state.promptUrls).toEqual([
+ "http://127.0.0.1:9999",
+ "http://127.0.0.1:9999",
+ ]);
+ expect(runtimeMock.state.authHeaders).toEqual([
+ `Basic ${btoa("opencode:secret-password")}`,
+ `Basic ${btoa("opencode:secret-password")}`,
+ ]);
+
+ yield* advanceIdleClock;
+
+ expect(runtimeMock.state.closeCalls).toEqual([]);
+ }).pipe(Effect.provide(TestClock.layer())),
+ );
+ },
+);
diff --git a/apps/server/src/git/Layers/OpenCodeTextGeneration.ts b/apps/server/src/git/Layers/OpenCodeTextGeneration.ts
new file mode 100644
index 000000000..7721354e4
--- /dev/null
+++ b/apps/server/src/git/Layers/OpenCodeTextGeneration.ts
@@ -0,0 +1,422 @@
+import { Duration, Effect, Exit, Fiber, Layer, Schema, Scope } from "effect";
+import * as Semaphore from "effect/Semaphore";
+
+import {
+ TextGenerationError,
+ type ChatAttachment,
+ type OpenCodeModelSelection,
+} from "@t3tools/contracts";
+import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git";
+
+import { ServerConfig } from "../../config.ts";
+import { resolveAttachmentPath } from "../../attachmentStore.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import {
+ buildBranchNamePrompt,
+ buildCommitMessagePrompt,
+ buildPrContentPrompt,
+ buildThreadTitlePrompt,
+} from "../Prompts.ts";
+import { type TextGenerationShape, TextGeneration } from "../Services/TextGeneration.ts";
+import {
+ sanitizeCommitSubject,
+ sanitizePrTitle,
+ sanitizeThreadTitle,
+ toJsonSchemaObject,
+} from "../Utils.ts";
+import {
+ createOpenCodeSdkClient,
+ type OpenCodeServerConnection,
+ type OpenCodeServerProcess,
+ parseOpenCodeModelSlug,
+ startOpenCodeServerProcess,
+ toOpenCodeFileParts,
+} from "../../provider/opencodeRuntime.ts";
+
+const OPENCODE_TEXT_GENERATION_IDLE_TTL_MS = 30_000;
+
+interface SharedOpenCodeTextGenerationServerState {
+ server: OpenCodeServerProcess | null;
+ binaryPath: string | null;
+ activeRequests: number;
+ idleCloseFiber: Fiber.Fiber<void, never> | null;
+}
+
+const makeOpenCodeTextGeneration = Effect.gen(function* () {
+ const serverConfig = yield* ServerConfig;
+ const serverSettingsService = yield* ServerSettingsService;
+ const idleFiberScope = yield* Effect.acquireRelease(Scope.make(), (scope) =>
+ Scope.close(scope, Exit.void),
+ );
+ const sharedServerMutex = yield* Semaphore.make(1);
+ const sharedServerState: SharedOpenCodeTextGenerationServerState = {
+ server: null,
+ binaryPath: null,
+ activeRequests: 0,
+ idleCloseFiber: null,
+ };
+
+ const closeSharedServer = (server: OpenCodeServerProcess) => {
+ if (sharedServerState.server === server) {
+ sharedServerState.server = null;
+ sharedServerState.binaryPath = null;
+ }
+ server.close();
+ };
+
+ const cancelIdleCloseFiber = Effect.fn("cancelIdleCloseFiber")(function* () {
+ const idleCloseFiber = sharedServerState.idleCloseFiber;
+ sharedServerState.idleCloseFiber = null;
+ if (idleCloseFiber !== null) {
+ yield* Fiber.interrupt(idleCloseFiber).pipe(Effect.ignore);
+ }
+ });
+
+ const scheduleIdleClose = Effect.fn("scheduleIdleClose")(function* (
+ server: OpenCodeServerProcess,
+ ) {
+ yield* cancelIdleCloseFiber();
+ const fiber = yield* Effect.sleep(Duration.millis(OPENCODE_TEXT_GENERATION_IDLE_TTL_MS)).pipe(
+ Effect.andThen(
+ sharedServerMutex.withPermit(
+ Effect.sync(() => {
+ if (sharedServerState.server !== server || sharedServerState.activeRequests > 0) {
+ return;
+ }
+ sharedServerState.idleCloseFiber = null;
+ closeSharedServer(server);
+ }),
+ ),
+ ),
+ Effect.forkIn(idleFiberScope),
+ );
+ sharedServerState.idleCloseFiber = fiber;
+ });
+
+ const acquireSharedServer = (input: {
+ readonly binaryPath: string;
+ readonly operation:
+ | "generateCommitMessage"
+ | "generatePrContent"
+ | "generateBranchName"
+ | "generateThreadTitle";
+ }) =>
+ sharedServerMutex.withPermit(
+ Effect.gen(function* () {
+ yield* cancelIdleCloseFiber();
+
+ const existingServer = sharedServerState.server;
+ if (existingServer !== null) {
+ if (
+ sharedServerState.binaryPath !== input.binaryPath &&
+ sharedServerState.activeRequests === 0
+ ) {
+ closeSharedServer(existingServer);
+ } else {
+ if (sharedServerState.binaryPath !== input.binaryPath) {
+ yield* Effect.logWarning(
+ "OpenCode shared server binary path mismatch: requested " +
+ input.binaryPath +
+ " but active server uses " +
+ sharedServerState.binaryPath +
+ "; reusing existing server because there are active requests",
+ );
+ }
+ sharedServerState.activeRequests += 1;
+ return existingServer;
+ }
+ }
+
+ const server = yield* Effect.tryPromise({
+ try: () => startOpenCodeServerProcess({ binaryPath: input.binaryPath }),
+ catch: (cause) =>
+ new TextGenerationError({
+ operation: input.operation,
+ detail: cause instanceof Error ? cause.message : "Failed to start OpenCode server.",
+ cause,
+ }),
+ });
+
+ sharedServerState.server = server;
+ sharedServerState.binaryPath = input.binaryPath;
+ sharedServerState.activeRequests = 1;
+ return server;
+ }),
+ );
+
+ const releaseSharedServer = (server: OpenCodeServerProcess) =>
+ sharedServerMutex.withPermit(
+ Effect.gen(function* () {
+ if (sharedServerState.server !== server) {
+ return;
+ }
+ sharedServerState.activeRequests = Math.max(0, sharedServerState.activeRequests - 1);
+ if (sharedServerState.activeRequests === 0) {
+ yield* scheduleIdleClose(server);
+ }
+ }),
+ );
+
+ yield* Effect.addFinalizer(() =>
+ sharedServerMutex.withPermit(
+ Effect.gen(function* () {
+ yield* cancelIdleCloseFiber();
+ const server = sharedServerState.server;
+ sharedServerState.server = null;
+ sharedServerState.binaryPath = null;
+ sharedServerState.activeRequests = 0;
+ if (server !== null) {
+ server.close();
+ }
+ }),
+ ),
+ );
+
+ const runOpenCodeJson = Effect.fn("runOpenCodeJson")(function* <S extends Schema.Top>(input: {
+ readonly operation:
+ | "generateCommitMessage"
+ | "generatePrContent"
+ | "generateBranchName"
+ | "generateThreadTitle";
+ readonly cwd: string;
+ readonly prompt: string;
+ readonly outputSchemaJson: S;
+ readonly modelSelection: OpenCodeModelSelection;
+ readonly attachments?: ReadonlyArray<ChatAttachment> | undefined;
+ }) {
+ const parsedModel = parseOpenCodeModelSlug(input.modelSelection.model);
+ if (!parsedModel) {
+ return yield* new TextGenerationError({
+ operation: input.operation,
+ detail: "OpenCode model selection must use the 'provider/model' format.",
+ });
+ }
+
+ const settings = yield* serverSettingsService.getSettings.pipe(
+ Effect.map(
+ (value) =>
+ value.providers?.opencode ?? {
+ enabled: true,
+ binaryPath: "opencode",
+ serverUrl: "",
+ serverPassword: "",
+ customModels: [],
+ },
+ ),
+ Effect.orElseSucceed(() => ({
+ enabled: true,
+ binaryPath: "opencode",
+ serverUrl: "",
+ serverPassword: "",
+ customModels: [],
+ })),
+ );
+
+ const fileParts = toOpenCodeFileParts({
+ attachments: input.attachments,
+ resolveAttachmentPath: (attachment) =>
+ resolveAttachmentPath({ attachmentsDir: serverConfig.attachmentsDir, attachment }),
+ });
+
+ const runAgainstServer = (server: Pick<OpenCodeServerConnection, "url">) =>
+ Effect.tryPromise({
+ try: async () => {
+ const client = createOpenCodeSdkClient({
+ baseUrl: server.url,
+ directory: input.cwd,
+ ...(settings.serverUrl.length > 0 && settings.serverPassword
+ ? { serverPassword: settings.serverPassword }
+ : {}),
+ });
+ const session = await client.session.create({
+ title: `T3 Code ${input.operation}`,
+ permission: [{ permission: "*", pattern: "*", action: "deny" }],
+ });
+ if (!session.data) {
+ throw new Error("OpenCode session.create returned no session payload.");
+ }
+
+ const result = await client.session.prompt({
+ sessionID: session.data.id,
+ model: parsedModel,
+ ...(input.modelSelection.options?.agent
+ ? { agent: input.modelSelection.options.agent }
+ : {}),
+ ...(input.modelSelection.options?.variant
+ ? { variant: input.modelSelection.options.variant }
+ : {}),
+ format: {
+ type: "json_schema",
+ schema: toJsonSchemaObject(input.outputSchemaJson) as Record<string, unknown>,
+ },
+ parts: [{ type: "text", text: input.prompt }, ...fileParts],
+ });
+ const structured = result.data?.info?.structured;
+ if (structured === undefined) {
+ throw new Error("OpenCode returned no structured output.");
+ }
+ return structured;
+ },
+ catch: (cause) =>
+ new TextGenerationError({
+ operation: input.operation,
+ detail:
+ cause instanceof Error ? cause.message : "OpenCode text generation request failed.",
+ cause,
+ }),
+ });
+
+ const structuredOutput =
+ settings.serverUrl.length > 0
+ ? yield* runAgainstServer({ url: settings.serverUrl })
+ : yield* Effect.acquireUseRelease(
+ acquireSharedServer({
+ binaryPath: settings.binaryPath,
+ operation: input.operation,
+ }),
+ runAgainstServer,
+ releaseSharedServer,
+ );
+
+ return yield* Schema.decodeUnknownEffect(input.outputSchemaJson)(structuredOutput).pipe(
+ Effect.catchTag("SchemaError", (cause) =>
+ Effect.fail(
+ new TextGenerationError({
+ operation: input.operation,
+ detail: "OpenCode returned invalid structured output.",
+ cause,
+ }),
+ ),
+ ),
+ );
+ });
+
+ const generateCommitMessage: TextGenerationShape["generateCommitMessage"] = Effect.fn(
+ "OpenCodeTextGeneration.generateCommitMessage",
+ )(function* (input) {
+ if (input.modelSelection.provider !== "opencode") {
+ return yield* new TextGenerationError({
+ operation: "generateCommitMessage",
+ detail: "Invalid model selection.",
+ });
+ }
+
+ const { prompt, outputSchema } = buildCommitMessagePrompt({
+ branch: input.branch,
+ stagedSummary: input.stagedSummary,
+ stagedPatch: input.stagedPatch,
+ includeBranch: input.includeBranch === true,
+ });
+ const generated = yield* runOpenCodeJson({
+ operation: "generateCommitMessage",
+ cwd: input.cwd,
+ prompt,
+ outputSchemaJson: outputSchema,
+ modelSelection: input.modelSelection,
+ });
+
+ return {
+ subject: sanitizeCommitSubject(generated.subject),
+ body: generated.body.trim(),
+ ...("branch" in generated && typeof generated.branch === "string"
+ ? { branch: sanitizeFeatureBranchName(generated.branch) }
+ : {}),
+ };
+ });
+
+ const generatePrContent: TextGenerationShape["generatePrContent"] = Effect.fn(
+ "OpenCodeTextGeneration.generatePrContent",
+ )(function* (input) {
+ if (input.modelSelection.provider !== "opencode") {
+ return yield* new TextGenerationError({
+ operation: "generatePrContent",
+ detail: "Invalid model selection.",
+ });
+ }
+
+ const { prompt, outputSchema } = buildPrContentPrompt({
+ baseBranch: input.baseBranch,
+ headBranch: input.headBranch,
+ commitSummary: input.commitSummary,
+ diffSummary: input.diffSummary,
+ diffPatch: input.diffPatch,
+ });
+ const generated = yield* runOpenCodeJson({
+ operation: "generatePrContent",
+ cwd: input.cwd,
+ prompt,
+ outputSchemaJson: outputSchema,
+ modelSelection: input.modelSelection,
+ });
+
+ return {
+ title: sanitizePrTitle(generated.title),
+ body: generated.body.trim(),
+ };
+ });
+
+ const generateBranchName: TextGenerationShape["generateBranchName"] = Effect.fn(
+ "OpenCodeTextGeneration.generateBranchName",
+ )(function* (input) {
+ if (input.modelSelection.provider !== "opencode") {
+ return yield* new TextGenerationError({
+ operation: "generateBranchName",
+ detail: "Invalid model selection.",
+ });
+ }
+
+ const { prompt, outputSchema } = buildBranchNamePrompt({
+ message: input.message,
+ attachments: input.attachments,
+ });
+ const generated = yield* runOpenCodeJson({
+ operation: "generateBranchName",
+ cwd: input.cwd,
+ prompt,
+ outputSchemaJson: outputSchema,
+ modelSelection: input.modelSelection,
+ attachments: input.attachments,
+ });
+
+ return {
+ branch: sanitizeBranchFragment(generated.branch),
+ };
+ });
+
+ const generateThreadTitle: TextGenerationShape["generateThreadTitle"] = Effect.fn(
+ "OpenCodeTextGeneration.generateThreadTitle",
+ )(function* (input) {
+ if (input.modelSelection.provider !== "opencode") {
+ return yield* new TextGenerationError({
+ operation: "generateThreadTitle",
+ detail: "Invalid model selection.",
+ });
+ }
+
+ const { prompt, outputSchema } = buildThreadTitlePrompt({
+ message: input.message,
+ attachments: input.attachments,
+ });
+ const generated = yield* runOpenCodeJson({
+ operation: "generateThreadTitle",
+ cwd: input.cwd,
+ prompt,
+ outputSchemaJson: outputSchema,
+ modelSelection: input.modelSelection,
+ attachments: input.attachments,
+ });
+
+ return {
+ title: sanitizeThreadTitle(generated.title),
+ };
+ });
+
+ return {
+ generateCommitMessage,
+ generatePrContent,
+ generateBranchName,
+ generateThreadTitle,
+ } satisfies TextGenerationShape;
+});
+
+export const OpenCodeTextGenerationLive = Layer.effect(TextGeneration, makeOpenCodeTextGeneration);
diff --git a/apps/server/src/git/Layers/RoutingTextGeneration.ts b/apps/server/src/git/Layers/RoutingTextGeneration.ts
index 5372bc134..f0d658b69 100644
--- a/apps/server/src/git/Layers/RoutingTextGeneration.ts
+++ b/apps/server/src/git/Layers/RoutingTextGeneration.ts
@@ -18,6 +18,7 @@ import {
} from "../Services/TextGeneration.ts";
import { CodexTextGenerationLive } from "./CodexTextGeneration.ts";
import { ClaudeTextGenerationLive } from "./ClaudeTextGeneration.ts";
+import { OpenCodeTextGenerationLive } from "./OpenCodeTextGeneration.ts";
// ---------------------------------------------------------------------------
// Internal service tags so both concrete layers can coexist.
@@ -31,6 +32,10 @@ class ClaudeTextGen extends Context.Service<ClaudeTextGen, TextGenerationShape>(
"t3/git/Layers/RoutingTextGeneration/ClaudeTextGen",
) {}
+class OpenCodeTextGen extends Context.Service<OpenCodeTextGen, TextGenerationShape>()(
+ "t3/git/Layers/RoutingTextGeneration/OpenCodeTextGen",
+) {}
+
// ---------------------------------------------------------------------------
// Routing implementation
// ---------------------------------------------------------------------------
@@ -38,9 +43,10 @@ class ClaudeTextGen extends Context.Service<ClaudeTextGen, TextGenerationShape>(
const makeRoutingTextGeneration = Effect.gen(function* () {
const codex = yield* CodexTextGen;
const claude = yield* ClaudeTextGen;
+ const openCode = yield* OpenCodeTextGen;
const route = (provider?: TextGenerationProvider): TextGenerationShape =>
- provider === "claudeAgent" ? claude : codex;
+ provider === "claudeAgent" ? claude : provider === "opencode" ? openCode : codex;
return {
generateCommitMessage: (input) =>
@@ -67,7 +73,19 @@ const InternalClaudeLayer = Layer.effect(
}),
).pipe(Layer.provide(ClaudeTextGenerationLive));
+const InternalOpenCodeLayer = Layer.effect(
+ OpenCodeTextGen,
+ Effect.gen(function* () {
+ const svc = yield* TextGeneration;
+ return svc;
+ }),
+).pipe(Layer.provide(OpenCodeTextGenerationLive));
+
export const RoutingTextGenerationLive = Layer.effect(
TextGeneration,
makeRoutingTextGeneration,
-).pipe(Layer.provide(InternalCodexLayer), Layer.provide(InternalClaudeLayer));
+).pipe(
+ Layer.provide(InternalCodexLayer),
+ Layer.provide(InternalClaudeLayer),
+ Layer.provide(InternalOpenCodeLayer),
+);
diff --git a/apps/server/src/git/Services/TextGeneration.ts b/apps/server/src/git/Services/TextGeneration.ts
index 6062d552d..2833741fb 100644
--- a/apps/server/src/git/Services/TextGeneration.ts
+++ b/apps/server/src/git/Services/TextGeneration.ts
@@ -13,7 +13,7 @@ import type { ChatAttachment, ModelSelection } from "@t3tools/contracts";
import type { TextGenerationError } from "@t3tools/contracts";
/** Providers that support git text generation (commit messages, PR content, branch names). */
-export type TextGenerationProvider = "codex" | "claudeAgent";
+export type TextGenerationProvider = "codex" | "claudeAgent" | "opencode";
export interface CommitMessageGenerationInput {
cwd: string;
diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
new file mode 100644
index 000000000..98691082c
--- /dev/null
+++ b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
@@ -0,0 +1,486 @@
+import assert from "node:assert/strict";
+
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it } from "@effect/vitest";
+import { Effect, Layer, Option } from "effect";
+import { beforeEach, vi } from "vitest";
+
+import { ThreadId } from "@t3tools/contracts";
+import { ServerConfig } from "../../config.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import { ProviderSessionDirectory } from "../Services/ProviderSessionDirectory.ts";
+import { OpenCodeAdapter } from "../Services/OpenCodeAdapter.ts";
+import {
+ appendOpenCodeAssistantTextDelta,
+ makeOpenCodeAdapterLive,
+ mergeOpenCodeAssistantText,
+} from "./OpenCodeAdapter.ts";
+
+const asThreadId = (value: string): ThreadId => ThreadId.make(value);
+
+const runtimeMock = vi.hoisted(() => {
+ type MessageEntry = {
+ info: {
+ id: string;
+ role: "user" | "assistant";
+ };
+ parts: Array<unknown>;
+ };
+
+ const state = {
+ startCalls: [] as string[],
+ sessionCreateUrls: [] as string[],
+ authHeaders: [] as Array<string | null>,
+ abortCalls: [] as string[],
+ closeCalls: [] as string[],
+ revertCalls: [] as Array<{ sessionID: string; messageID?: string }>,
+ promptAsyncError: null as Error | null,
+ closeError: null as Error | null,
+ messages: [] as MessageEntry[],
+ subscribedEvents: [] as unknown[],
+ };
+
+ return {
+ state,
+ reset() {
+ state.startCalls.length = 0;
+ state.sessionCreateUrls.length = 0;
+ state.authHeaders.length = 0;
+ state.abortCalls.length = 0;
+ state.closeCalls.length = 0;
+ state.revertCalls.length = 0;
+ state.promptAsyncError = null;
+ state.closeError = null;
+ state.messages = [];
+ state.subscribedEvents = [];
+ },
+ };
+});
+
+vi.mock("../opencodeRuntime.ts", async () => {
+ const actual =
+ await vi.importActual<typeof import("../opencodeRuntime.ts")>("../opencodeRuntime.ts");
+
+ return {
+ ...actual,
+ startOpenCodeServerProcess: vi.fn(async ({ binaryPath }: { binaryPath: string }) => {
+ runtimeMock.state.startCalls.push(binaryPath);
+ return {
+ url: "http://127.0.0.1:4301",
+ process: {
+ once() {},
+ },
+ close() {},
+ };
+ }),
+ connectToOpenCodeServer: vi.fn(async ({ serverUrl }: { serverUrl?: string }) => ({
+ url: serverUrl ?? "http://127.0.0.1:4301",
+ process: null,
+ external: Boolean(serverUrl),
+ close() {
+ runtimeMock.state.closeCalls.push(serverUrl ?? "http://127.0.0.1:4301");
+ if (runtimeMock.state.closeError) {
+ throw runtimeMock.state.closeError;
+ }
+ },
+ })),
+ createOpenCodeSdkClient: vi.fn(
+ ({ baseUrl, serverPassword }: { baseUrl: string; serverPassword?: string }) => ({
+ session: {
+ create: vi.fn(async () => {
+ runtimeMock.state.sessionCreateUrls.push(baseUrl);
+ runtimeMock.state.authHeaders.push(
+ serverPassword ? `Basic ${btoa(`opencode:${serverPassword}`)}` : null,
+ );
+ return { data: { id: `${baseUrl}/session` } };
+ }),
+ abort: vi.fn(async ({ sessionID }: { sessionID: string }) => {
+ runtimeMock.state.abortCalls.push(sessionID);
+ }),
+ promptAsync: vi.fn(async () => {
+ if (runtimeMock.state.promptAsyncError) {
+ throw runtimeMock.state.promptAsyncError;
+ }
+ }),
+ messages: vi.fn(async () => ({ data: runtimeMock.state.messages })),
+ revert: vi.fn(
+ async ({ sessionID, messageID }: { sessionID: string; messageID?: string }) => {
+ runtimeMock.state.revertCalls.push({
+ sessionID,
+ ...(messageID ? { messageID } : {}),
+ });
+ if (!messageID) {
+ runtimeMock.state.messages = [];
+ return;
+ }
+
+ const targetIndex = runtimeMock.state.messages.findIndex(
+ (entry) => entry.info.id === messageID,
+ );
+ runtimeMock.state.messages =
+ targetIndex >= 0
+ ? runtimeMock.state.messages.slice(0, targetIndex + 1)
+ : runtimeMock.state.messages;
+ },
+ ),
+ },
+ event: {
+ subscribe: vi.fn(async () => ({
+ stream: (async function* () {
+ for (const event of runtimeMock.state.subscribedEvents) {
+ yield event;
+ }
+ })(),
+ })),
+ },
+ }),
+ ),
+ };
+});
+
+const providerSessionDirectoryTestLayer = Layer.succeed(ProviderSessionDirectory, {
+ upsert: () => Effect.void,
+ getProvider: () =>
+ Effect.die(new Error("ProviderSessionDirectory.getProvider is not used in test")),
+ getBinding: () => Effect.succeed(Option.none()),
+ listThreadIds: () => Effect.succeed([]),
+ listBindings: () => Effect.succeed([]),
+});
+
+const OpenCodeAdapterTestLayer = makeOpenCodeAdapterLive().pipe(
+ Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
+ Layer.provideMerge(
+ ServerSettingsService.layerTest({
+ providers: {
+ opencode: {
+ binaryPath: "fake-opencode",
+ serverUrl: "http://127.0.0.1:9999",
+ serverPassword: "secret-password",
+ },
+ },
+ }),
+ ),
+ Layer.provideMerge(providerSessionDirectoryTestLayer),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+beforeEach(() => {
+ runtimeMock.reset();
+});
+
+const sleep = (ms: number) =>
+ Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+
+it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
+ it.effect("reuses a configured OpenCode server URL instead of spawning a local server", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+
+ const session = yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-opencode"),
+ runtimeMode: "full-access",
+ });
+
+ assert.equal(session.provider, "opencode");
+ assert.equal(session.threadId, "thread-opencode");
+ assert.deepEqual(runtimeMock.state.startCalls, []);
+ assert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
+ assert.deepEqual(runtimeMock.state.authHeaders, [
+ `Basic ${btoa("opencode:secret-password")}`,
+ ]);
+ }),
+ );
+
+ it.effect("stops a configured-server session without trying to own server lifecycle", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-opencode"),
+ runtimeMode: "full-access",
+ });
+
+ yield* adapter.stopSession(asThreadId("thread-opencode"));
+
+ assert.deepEqual(runtimeMock.state.startCalls, []);
+ assert.deepEqual(
+ runtimeMock.state.abortCalls.includes("http://127.0.0.1:9999/session"),
+ true,
+ );
+ }),
+ );
+
+ it.effect("clears session state when stopAll cleanup fails", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-stop-all-a"),
+ runtimeMode: "full-access",
+ });
+ yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-stop-all-b"),
+ runtimeMode: "full-access",
+ });
+
+ runtimeMock.state.closeError = new Error("close failed");
+ const error = yield* adapter.stopAll().pipe(Effect.flip);
+ const sessions = yield* adapter.listSessions();
+
+ assert.equal(error._tag, "ProviderAdapterProcessError");
+ assert.equal(error.detail, "Failed to stop 2 OpenCode sessions.");
+ assert.deepEqual(runtimeMock.state.closeCalls, [
+ "http://127.0.0.1:9999",
+ "http://127.0.0.1:9999",
+ ]);
+ assert.deepEqual(sessions, []);
+ }),
+ );
+
+ it.effect("rolls back session state when sendTurn fails before OpenCode accepts the prompt", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-send-turn-failure"),
+ runtimeMode: "full-access",
+ });
+
+ runtimeMock.state.promptAsyncError = new Error("prompt failed");
+ const error = yield* adapter
+ .sendTurn({
+ threadId: asThreadId("thread-send-turn-failure"),
+ input: "Fix it",
+ modelSelection: {
+ provider: "opencode",
+ model: "openai/gpt-5",
+ },
+ })
+ .pipe(Effect.flip);
+ const sessions = yield* adapter.listSessions();
+
+ assert.equal(error._tag, "ProviderAdapterRequestError");
+ if (error._tag !== "ProviderAdapterRequestError") {
+ throw new Error("Unexpected error type");
+ }
+ assert.equal(error.detail, "prompt failed");
+ assert.equal(
+ error.message,
+ "Provider adapter request failed (opencode) for session.promptAsync: prompt failed",
+ );
+ assert.equal(sessions.length, 1);
+ assert.equal(sessions[0]?.status, "ready");
+ assert.equal(sessions[0]?.activeTurnId, undefined);
+ assert.equal(sessions[0]?.lastError, "prompt failed");
+ }),
+ );
+
+ it.effect("reverts the full thread when rollback removes every assistant turn", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-rollback-all");
+ yield* adapter.startSession({
+ provider: "opencode",
+ threadId,
+ runtimeMode: "full-access",
+ });
+
+ runtimeMock.state.messages = [
+ {
+ info: { id: "assistant-1", role: "assistant" },
+ parts: [],
+ },
+ {
+ info: { id: "assistant-2", role: "assistant" },
+ parts: [],
+ },
+ ];
+
+ const snapshot = yield* adapter.rollbackThread(threadId, 2);
+
+ assert.deepEqual(runtimeMock.state.revertCalls, [
+ { sessionID: "http://127.0.0.1:9999/session" },
+ ]);
+ assert.deepEqual(snapshot.turns, []);
+ }),
+ );
+
+ it.effect("deduplicates overlapping assistant text deltas after part updates", () =>
+ Effect.sync(() => {
+ const firstUpdate = mergeOpenCodeAssistantText(undefined, "Hello");
+ const overlapDelta = appendOpenCodeAssistantTextDelta(firstUpdate.latestText, "lo world");
+ const secondUpdate = mergeOpenCodeAssistantText(overlapDelta.nextText, "Hello world!");
+
+ assert.deepEqual(
+ [firstUpdate.deltaToEmit, overlapDelta.deltaToEmit, secondUpdate.deltaToEmit],
+ ["Hello", " world", "!"],
+ );
+ assert.equal(secondUpdate.latestText, "Hello world!");
+ }),
+ );
+
+ it.effect("writes provider-native observability records using the session thread id", () =>
+ Effect.gen(function* () {
+ const nativeEvents: Array<{
+ readonly event?: {
+ readonly provider?: string;
+ readonly threadId?: string;
+ readonly providerThreadId?: string;
+ readonly type?: string;
+ };
+ }> = [];
+ const nativeThreadIds: Array<string | null> = [];
+ runtimeMock.state.subscribedEvents = [
+ {
+ type: "message.updated",
+ properties: {
+ info: {
+ id: "msg-missing-session",
+ role: "assistant",
+ },
+ },
+ },
+ {
+ type: "message.updated",
+ properties: {
+ sessionID: "http://127.0.0.1:9999/other-session",
+ info: {
+ id: "msg-other-session",
+ role: "assistant",
+ },
+ },
+ },
+ {
+ type: "message.updated",
+ properties: {
+ sessionID: "http://127.0.0.1:9999/session",
+ info: {
+ id: "msg-native-log",
+ role: "assistant",
+ },
+ },
+ },
+ ];
+
+ const nativeEventLogger = {
+ filePath: "memory://opencode-native-events",
+ write: (event: unknown, threadId: ThreadId | null) => {
+ nativeEvents.push(event as (typeof nativeEvents)[number]);
+ nativeThreadIds.push(threadId ?? null);
+ return Effect.void;
+ },
+ close: () => Effect.void,
+ };
+
+ const adapterLayer = makeOpenCodeAdapterLive({ nativeEventLogger }).pipe(
+ Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
+ Layer.provideMerge(
+ ServerSettingsService.layerTest({
+ providers: {
+ opencode: {
+ binaryPath: "fake-opencode",
+ serverUrl: "http://127.0.0.1:9999",
+ serverPassword: "secret-password",
+ },
+ },
+ }),
+ ),
+ Layer.provideMerge(providerSessionDirectoryTestLayer),
+ Layer.provideMerge(NodeServices.layer),
+ );
+
+ const session = yield* Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const started = yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-native-log"),
+ runtimeMode: "full-access",
+ });
+ yield* sleep(10);
+ return started;
+ }).pipe(Effect.provide(adapterLayer));
+
+ assert.equal(session.threadId, "thread-native-log");
+ assert.equal(nativeEvents.length, 1);
+ assert.equal(
+ nativeEvents.some((record) => record.event?.provider === "opencode"),
+ true,
+ );
+ assert.equal(
+ nativeEvents.some(
+ (record) => record.event?.providerThreadId === "http://127.0.0.1:9999/session",
+ ),
+ true,
+ );
+ assert.equal(
+ nativeEvents.some((record) => record.event?.threadId === "thread-native-log"),
+ true,
+ );
+ assert.equal(
+ nativeEvents.some((record) => record.event?.type === "message.updated"),
+ true,
+ );
+ assert.equal(
+ nativeThreadIds.every((threadId) => threadId === "thread-native-log"),
+ true,
+ );
+ }),
+ );
+
+ it.effect("keeps the event pump alive when native event logging fails", () =>
+ Effect.gen(function* () {
+ runtimeMock.state.subscribedEvents = [
+ {
+ type: "message.updated",
+ properties: {
+ sessionID: "http://127.0.0.1:9999/session",
+ info: {
+ id: "msg-native-log-failure",
+ role: "assistant",
+ },
+ },
+ },
+ ];
+
+ const nativeEventLogger = {
+ filePath: "memory://opencode-native-events",
+ write: () => Effect.die(new Error("native log write failed")),
+ close: () => Effect.void,
+ };
+
+ const adapterLayer = makeOpenCodeAdapterLive({ nativeEventLogger }).pipe(
+ Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
+ Layer.provideMerge(
+ ServerSettingsService.layerTest({
+ providers: {
+ opencode: {
+ binaryPath: "fake-opencode",
+ serverUrl: "http://127.0.0.1:9999",
+ serverPassword: "secret-password",
+ },
+ },
+ }),
+ ),
+ Layer.provideMerge(providerSessionDirectoryTestLayer),
+ Layer.provideMerge(NodeServices.layer),
+ );
+
+ const sessions = yield* Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ yield* adapter.startSession({
+ provider: "opencode",
+ threadId: asThreadId("thread-native-log-failure"),
+ runtimeMode: "full-access",
+ });
+ yield* sleep(10);
+ return yield* adapter.listSessions();
+ }).pipe(Effect.provide(adapterLayer));
+
+ assert.equal(sessions.length, 1);
+ assert.equal(sessions[0]?.threadId, "thread-native-log-failure");
+ assert.deepEqual(runtimeMock.state.closeCalls, []);
+ }),
+ );
+});
diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.ts
new file mode 100644
index 000000000..4e3c12ef5
--- /dev/null
+++ b/apps/server/src/provider/Layers/OpenCodeAdapter.ts
@@ -0,0 +1,1344 @@
+import { randomUUID } from "node:crypto";
+
+import {
+ EventId,
+ type ProviderRuntimeEvent,
+ type ProviderSession,
+ RuntimeItemId,
+ RuntimeRequestId,
+ ThreadId,
+ type ToolLifecycleItemType,
+ TurnId,
+ type UserInputQuestion,
+} from "@t3tools/contracts";
+import { Cause, Effect, Layer, Queue, Stream } from "effect";
+import type { OpencodeClient, Part, PermissionRequest, QuestionRequest } from "@opencode-ai/sdk/v2";
+
+import { resolveAttachmentPath } from "../../attachmentStore.ts";
+import { ServerConfig } from "../../config.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts";
+import {
+ ProviderAdapterProcessError,
+ ProviderAdapterRequestError,
+ ProviderAdapterSessionClosedError,
+ ProviderAdapterSessionNotFoundError,
+ ProviderAdapterValidationError,
+} from "../Errors.ts";
+import { OpenCodeAdapter, type OpenCodeAdapterShape } from "../Services/OpenCodeAdapter.ts";
+import {
+ buildOpenCodePermissionRules,
+ connectToOpenCodeServer,
+ createOpenCodeSdkClient,
+ openCodeQuestionId,
+ parseOpenCodeModelSlug,
+ toOpenCodeFileParts,
+ toOpenCodePermissionReply,
+ toOpenCodeQuestionAnswers,
+ type OpenCodeServerConnection,
+} from "../opencodeRuntime.ts";
+
+const PROVIDER = "opencode" as const;
+
+interface OpenCodeTurnSnapshot {
+ readonly id: TurnId;
+ readonly items: Array<unknown>;
+}
+
+interface OpenCodeSessionContext {
+ session: ProviderSession;
+ readonly client: OpencodeClient;
+ readonly server: OpenCodeServerConnection;
+ readonly directory: string;
+ readonly openCodeSessionId: string;
+ readonly pendingPermissions: Map<string, PermissionRequest>;
+ readonly pendingQuestions: Map<string, QuestionRequest>;
+ readonly messageRoleById: Map<string, "user" | "assistant">;
+ readonly partById: Map<string, Part>;
+ readonly emittedTextByPartId: Map<string, string>;
+ readonly completedAssistantPartIds: Set<string>;
+ readonly turns: Array<OpenCodeTurnSnapshot>;
+ activeTurnId: TurnId | undefined;
+ activeAgent: string | undefined;
+ activeVariant: string | undefined;
+ stopped: boolean;
+ readonly eventsAbortController: AbortController;
+}
+
+export interface OpenCodeAdapterLiveOptions {
+ readonly nativeEventLogPath?: string;
+ readonly nativeEventLogger?: EventNdjsonLogger;
+}
+
+function nowIso(): string {
+ return new Date().toISOString();
+}
+
+function isProviderAdapterRequestError(cause: unknown): cause is ProviderAdapterRequestError {
+ return (
+ typeof cause === "object" &&
+ cause !== null &&
+ "_tag" in cause &&
+ cause._tag === "ProviderAdapterRequestError"
+ );
+}
+
+function buildEventBase(input: {
+ readonly threadId: ThreadId;
+ readonly turnId?: TurnId | undefined;
+ readonly itemId?: string | undefined;
+ readonly requestId?: string | undefined;
+ readonly createdAt?: string | undefined;
+ readonly raw?: unknown;
+}): Pick<
+ ProviderRuntimeEvent,
+ "eventId" | "provider" | "threadId" | "createdAt" | "turnId" | "itemId" | "requestId" | "raw"
+> {
+ return {
+ eventId: EventId.make(randomUUID()),
+ provider: PROVIDER,
+ threadId: input.threadId,
+ createdAt: input.createdAt ?? nowIso(),
+ ...(input.turnId ? { turnId: input.turnId } : {}),
+ ...(input.itemId ? { itemId: RuntimeItemId.make(input.itemId) } : {}),
+ ...(input.requestId ? { requestId: RuntimeRequestId.make(input.requestId) } : {}),
+ ...(input.raw !== undefined
+ ? {
+ raw: {
+ source: "opencode.sdk.event",
+ payload: input.raw,
+ },
+ }
+ : {}),
+ };
+}
+
+function toToolLifecycleItemType(toolName: string): ToolLifecycleItemType {
+ const normalized = toolName.toLowerCase();
+ if (normalized.includes("bash") || normalized.includes("command")) {
+ return "command_execution";
+ }
+ if (
+ normalized.includes("edit") ||
+ normalized.includes("write") ||
+ normalized.includes("patch") ||
+ normalized.includes("multiedit")
+ ) {
+ return "file_change";
+ }
+ if (normalized.includes("web")) {
+ return "web_search";
+ }
+ if (normalized.includes("mcp")) {
+ return "mcp_tool_call";
+ }
+ if (normalized.includes("image")) {
+ return "image_view";
+ }
+ if (
+ normalized.includes("task") ||
+ normalized.includes("agent") ||
+ normalized.includes("subtask")
+ ) {
+ return "collab_agent_tool_call";
+ }
+ return "dynamic_tool_call";
+}
+
+function mapPermissionToRequestType(
+ permission: string,
+): "command_execution_approval" | "file_read_approval" | "file_change_approval" | "unknown" {
+ switch (permission) {
+ case "bash":
+ return "command_execution_approval";
+ case "read":
+ return "file_read_approval";
+ case "edit":
+ return "file_change_approval";
+ default:
+ return "unknown";
+ }
+}
+
+function mapPermissionDecision(reply: "once" | "always" | "reject"): string {
+ switch (reply) {
+ case "once":
+ return "accept";
+ case "always":
+ return "acceptForSession";
+ case "reject":
+ default:
+ return "decline";
+ }
+}
+
+function resolveTurnSnapshot(
+ context: OpenCodeSessionContext,
+ turnId: TurnId,
+): OpenCodeTurnSnapshot {
+ const existing = context.turns.find((turn) => turn.id === turnId);
+ if (existing) {
+ return existing;
+ }
+
+ const created: OpenCodeTurnSnapshot = { id: turnId, items: [] };
+ context.turns.push(created);
+ return created;
+}
+
+function appendTurnItem(
+ context: OpenCodeSessionContext,
+ turnId: TurnId | undefined,
+ item: unknown,
+): void {
+ if (!turnId) {
+ return;
+ }
+ resolveTurnSnapshot(context, turnId).items.push(item);
+}
+
+function ensureSessionContext(
+ sessions: ReadonlyMap<ThreadId, OpenCodeSessionContext>,
+ threadId: ThreadId,
+): OpenCodeSessionContext {
+ const session = sessions.get(threadId);
+ if (!session) {
+ throw new ProviderAdapterSessionNotFoundError({ provider: PROVIDER, threadId });
+ }
+ if (session.stopped) {
+ throw new ProviderAdapterSessionClosedError({ provider: PROVIDER, threadId });
+ }
+ return session;
+}
+
+function normalizeQuestionRequest(request: QuestionRequest): ReadonlyArray<UserInputQuestion> {
+ return request.questions.map((question, index) => ({
+ id: openCodeQuestionId(index, question),
+ header: question.header,
+ question: question.question,
+ options: question.options.map((option) => ({
+ label: option.label,
+ description: option.description,
+ })),
+ ...(question.multiple ? { multiSelect: true } : {}),
+ }));
+}
+
+function resolveTextStreamKind(part: Part | undefined): "assistant_text" | "reasoning_text" {
+ return part?.type === "reasoning" ? "reasoning_text" : "assistant_text";
+}
+
+function textFromPart(part: Part): string | undefined {
+ switch (part.type) {
+ case "text":
+ case "reasoning":
+ return part.text;
+ default:
+ return undefined;
+ }
+}
+
+function commonPrefixLength(left: string, right: string): number {
+ let index = 0;
+ while (index < left.length && index < right.length && left[index] === right[index]) {
+ index += 1;
+ }
+ return index;
+}
+
+function suffixPrefixOverlap(text: string, delta: string): number {
+ const maxLength = Math.min(text.length, delta.length);
+ for (let length = maxLength; length > 0; length -= 1) {
+ if (text.endsWith(delta.slice(0, length))) {
+ return length;
+ }
+ }
+ return 0;
+}
+
+function resolveLatestAssistantText(previousText: string | undefined, nextText: string): string {
+ if (previousText && previousText.length > nextText.length && previousText.startsWith(nextText)) {
+ return previousText;
+ }
+ return nextText;
+}
+
+export function mergeOpenCodeAssistantText(
+ previousText: string | undefined,
+ nextText: string,
+): {
+ readonly latestText: string;
+ readonly deltaToEmit: string;
+} {
+ const latestText = resolveLatestAssistantText(previousText, nextText);
+ return {
+ latestText,
+ deltaToEmit: latestText.slice(commonPrefixLength(previousText ?? "", latestText)),
+ };
+}
+
+export function appendOpenCodeAssistantTextDelta(
+ previousText: string,
+ delta: string,
+): {
+ readonly nextText: string;
+ readonly deltaToEmit: string;
+} {
+ const deltaToEmit = delta.slice(suffixPrefixOverlap(previousText, delta));
+ return {
+ nextText: previousText + deltaToEmit,
+ deltaToEmit,
+ };
+}
+
+function isoFromEpochMs(value: number | undefined): string | undefined {
+ if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+ return undefined;
+ }
+ return new Date(value).toISOString();
+}
+
+function messageRoleForPart(
+ context: OpenCodeSessionContext,
+ part: Pick<Part, "messageID" | "type">,
+): "assistant" | "user" | undefined {
+ const known = context.messageRoleById.get(part.messageID);
+ if (known) {
+ return known;
+ }
+ return part.type === "tool" ? "assistant" : undefined;
+}
+
+function detailFromToolPart(part: Extract<Part, { type: "tool" }>): string | undefined {
+ switch (part.state.status) {
+ case "completed":
+ return part.state.output;
+ case "error":
+ return part.state.error;
+ case "running":
+ return part.state.title;
+ default:
+ return undefined;
+ }
+}
+
+function toolStateCreatedAt(part: Extract<Part, { type: "tool" }>): string | undefined {
+ switch (part.state.status) {
+ case "running":
+ return isoFromEpochMs(part.state.time.start);
+ case "completed":
+ case "error":
+ return isoFromEpochMs(part.state.time.end);
+ default:
+ return undefined;
+ }
+}
+
+function sessionErrorMessage(error: unknown): string {
+ if (!error || typeof error !== "object") {
+ return "OpenCode session failed.";
+ }
+ const data = "data" in error && error.data && typeof error.data === "object" ? error.data : null;
+ const message = data && "message" in data ? data.message : null;
+ return typeof message === "string" && message.trim().length > 0
+ ? message
+ : "OpenCode session failed.";
+}
+
+function updateProviderSession(
+ context: OpenCodeSessionContext,
+ patch: Partial<ProviderSession>,
+ options?: {
+ readonly clearActiveTurnId?: boolean;
+ readonly clearLastError?: boolean;
+ },
+): ProviderSession {
+ const nextSession = {
+ ...context.session,
+ ...patch,
+ updatedAt: nowIso(),
+ } as ProviderSession & Record<string, unknown>;
+ const mutableSession = nextSession as Record<string, unknown>;
+ if (options?.clearActiveTurnId) {
+ delete mutableSession.activeTurnId;
+ }
+ if (options?.clearLastError) {
+ delete mutableSession.lastError;
+ }
+ context.session = nextSession;
+ return nextSession;
+}
+
+async function stopOpenCodeContext(context: OpenCodeSessionContext): Promise<void> {
+ context.stopped = true;
+ context.eventsAbortController.abort();
+ try {
+ await context.client.session
+ .abort({ sessionID: context.openCodeSessionId })
+ .catch(() => undefined);
+ } catch {}
+ context.server.close();
+}
+
+export function makeOpenCodeAdapterLive(_options?: OpenCodeAdapterLiveOptions) {
+ return Layer.effect(
+ OpenCodeAdapter,
+ Effect.gen(function* () {
+ const serverConfig = yield* ServerConfig;
+ const serverSettings = yield* ServerSettingsService;
+ const services = yield* Effect.context<never>();
+ const nativeEventLogger =
+ _options?.nativeEventLogger ??
+ (_options?.nativeEventLogPath !== undefined
+ ? yield* makeEventNdjsonLogger(_options.nativeEventLogPath, {
+ stream: "native",
+ })
+ : undefined);
+ const runtimeEvents = yield* Queue.unbounded<ProviderRuntimeEvent>();
+ const sessions = new Map<ThreadId, OpenCodeSessionContext>();
+
+ const emit = (event: ProviderRuntimeEvent) =>
+ Queue.offer(runtimeEvents, event).pipe(Effect.asVoid);
+ const emitPromise = (event: ProviderRuntimeEvent) =>
+ emit(event).pipe(Effect.runPromiseWith(services));
+ const writeNativeEventPromise = (
+ threadId: ThreadId,
+ event: {
+ readonly observedAt: string;
+ readonly event: Record<string, unknown>;
+ },
+ ) =>
+ (nativeEventLogger ? nativeEventLogger.write(event, threadId) : Effect.void).pipe(
+ Effect.runPromiseWith(services),
+ );
+ const writeNativeEventBestEffort = (
+ threadId: ThreadId,
+ event: {
+ readonly observedAt: string;
+ readonly event: Record<string, unknown>;
+ },
+ ) => writeNativeEventPromise(threadId, event).catch(() => undefined);
+
+ const emitUnexpectedExit = (context: OpenCodeSessionContext, message: string) => {
+ if (context.stopped) {
+ return;
+ }
+ context.stopped = true;
+ sessions.delete(context.session.threadId);
+ context.server.close();
+ const turnId = context.activeTurnId;
+ void emitPromise({
+ ...buildEventBase({ threadId: context.session.threadId, turnId }),
+ type: "runtime.error",
+ payload: {
+ message,
+ class: "transport_error",
+ },
+ }).catch(() => undefined);
+ void emitPromise({
+ ...buildEventBase({ threadId: context.session.threadId, turnId }),
+ type: "session.exited",
+ payload: {
+ reason: message,
+ recoverable: false,
+ exitKind: "error",
+ },
+ }).catch(() => undefined);
+ };
+
+ /** Emit content.delta and item.completed events for an assistant text part. */
+ const emitAssistantTextDelta = async (
+ context: OpenCodeSessionContext,
+ part: Part,
+ turnId: TurnId | undefined,
+ raw: unknown,
+ ): Promise<void> => {
+ const text = textFromPart(part);
+ if (text === undefined) {
+ return;
+ }
+ const previousText = context.emittedTextByPartId.get(part.id);
+ const { latestText, deltaToEmit } = mergeOpenCodeAssistantText(previousText, text);
+ context.emittedTextByPartId.set(part.id, latestText);
+ if (latestText !== text) {
+ context.partById.set(
+ part.id,
+ (part.type === "text" || part.type === "reasoning"
+ ? { ...part, text: latestText }
+ : part) satisfies Part,
+ );
+ }
+ if (deltaToEmit.length > 0) {
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ itemId: part.id,
+ createdAt:
+ part.type === "text" || part.type === "reasoning"
+ ? isoFromEpochMs(part.time?.start)
+ : undefined,
+ raw,
+ }),
+ type: "content.delta",
+ payload: {
+ streamKind: resolveTextStreamKind(part),
+ delta: deltaToEmit,
+ },
+ });
+ }
+
+ if (
+ part.type === "text" &&
+ part.time?.end !== undefined &&
+ !context.completedAssistantPartIds.has(part.id)
+ ) {
+ context.completedAssistantPartIds.add(part.id);
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ itemId: part.id,
+ createdAt: isoFromEpochMs(part.time.end),
+ raw,
+ }),
+ type: "item.completed",
+ payload: {
+ itemType: "assistant_message",
+ status: "completed",
+ title: "Assistant message",
+ ...(latestText.length > 0 ? { detail: latestText } : {}),
+ },
+ });
+ }
+ };
+
+ const startEventPump = (context: OpenCodeSessionContext) => {
+ void (async () => {
+ try {
+ const subscription = await context.client.event.subscribe(undefined, {
+ signal: context.eventsAbortController.signal,
+ });
+
+ for await (const event of subscription.stream) {
+ const payloadSessionId =
+ "properties" in event
+ ? (event.properties as { sessionID?: unknown }).sessionID
+ : undefined;
+ if (payloadSessionId !== context.openCodeSessionId) {
+ continue;
+ }
+
+ const turnId = context.activeTurnId;
+ await writeNativeEventBestEffort(context.session.threadId, {
+ observedAt: nowIso(),
+ event: {
+ provider: PROVIDER,
+ threadId: context.session.threadId,
+ providerThreadId: context.openCodeSessionId,
+ type: event.type,
+ ...(turnId ? { turnId } : {}),
+ payload: event,
+ },
+ });
+
+ switch (event.type) {
+ case "message.updated": {
+ context.messageRoleById.set(event.properties.info.id, event.properties.info.role);
+ if (event.properties.info.role === "assistant") {
+ for (const part of context.partById.values()) {
+ if (part.messageID !== event.properties.info.id) {
+ continue;
+ }
+ await emitAssistantTextDelta(context, part, turnId, event);
+ }
+ }
+ break;
+ }
+
+ case "message.removed": {
+ context.messageRoleById.delete(event.properties.messageID);
+ break;
+ }
+
+ case "message.part.delta": {
+ const existingPart = context.partById.get(event.properties.partID);
+ if (!existingPart) {
+ break;
+ }
+ const role = messageRoleForPart(context, existingPart);
+ if (role !== "assistant") {
+ break;
+ }
+ const streamKind = resolveTextStreamKind(existingPart);
+ const delta = event.properties.delta;
+ if (delta.length === 0) {
+ break;
+ }
+ const previousText =
+ context.emittedTextByPartId.get(event.properties.partID) ??
+ textFromPart(existingPart) ??
+ "";
+ const { nextText, deltaToEmit } = appendOpenCodeAssistantTextDelta(
+ previousText,
+ delta,
+ );
+ if (deltaToEmit.length === 0) {
+ break;
+ }
+ context.emittedTextByPartId.set(event.properties.partID, nextText);
+ if (existingPart.type === "text" || existingPart.type === "reasoning") {
+ context.partById.set(event.properties.partID, {
+ ...existingPart,
+ text: nextText,
+ });
+ }
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ itemId: event.properties.partID,
+ raw: event,
+ }),
+ type: "content.delta",
+ payload: {
+ streamKind,
+ delta: deltaToEmit,
+ },
+ });
+ break;
+ }
+
+ case "message.part.updated": {
+ const part = event.properties.part;
+ context.partById.set(part.id, part);
+ const messageRole = messageRoleForPart(context, part);
+
+ if (messageRole === "assistant") {
+ await emitAssistantTextDelta(context, part, turnId, event);
+ }
+
+ if (part.type === "tool") {
+ const itemType = toToolLifecycleItemType(part.tool);
+ const title =
+ part.state.status === "running" ? (part.state.title ?? part.tool) : part.tool;
+ const detail = detailFromToolPart(part);
+ const payload = {
+ itemType,
+ ...(part.state.status === "error"
+ ? { status: "failed" as const }
+ : part.state.status === "completed"
+ ? { status: "completed" as const }
+ : { status: "inProgress" as const }),
+ ...(title ? { title } : {}),
+ ...(detail ? { detail } : {}),
+ data: {
+ tool: part.tool,
+ state: part.state,
+ },
+ };
+ const runtimeEvent: ProviderRuntimeEvent = {
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ itemId: part.callID,
+ createdAt: toolStateCreatedAt(part),
+ raw: event,
+ }),
+ type:
+ part.state.status === "pending"
+ ? "item.started"
+ : part.state.status === "completed" || part.state.status === "error"
+ ? "item.completed"
+ : "item.updated",
+ payload,
+ };
+ appendTurnItem(context, turnId, part);
+ await emitPromise(runtimeEvent);
+ }
+ break;
+ }
+
+ case "permission.asked": {
+ context.pendingPermissions.set(event.properties.id, event.properties);
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ requestId: event.properties.id,
+ raw: event,
+ }),
+ type: "request.opened",
+ payload: {
+ requestType: mapPermissionToRequestType(event.properties.permission),
+ detail:
+ event.properties.patterns.length > 0
+ ? event.properties.patterns.join("\n")
+ : event.properties.permission,
+ args: event.properties.metadata,
+ },
+ });
+ break;
+ }
+
+ case "permission.replied": {
+ context.pendingPermissions.delete(event.properties.requestID);
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ requestId: event.properties.requestID,
+ raw: event,
+ }),
+ type: "request.resolved",
+ payload: {
+ requestType: "unknown",
+ decision: mapPermissionDecision(event.properties.reply),
+ },
+ });
+ break;
+ }
+
+ case "question.asked": {
+ context.pendingQuestions.set(event.properties.id, event.properties);
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ requestId: event.properties.id,
+ raw: event,
+ }),
+ type: "user-input.requested",
+ payload: {
+ questions: normalizeQuestionRequest(event.properties),
+ },
+ });
+ break;
+ }
+
+ case "question.replied": {
+ const request = context.pendingQuestions.get(event.properties.requestID);
+ context.pendingQuestions.delete(event.properties.requestID);
+ const answers = Object.fromEntries(
+ (request?.questions ?? []).map((question, index) => [
+ openCodeQuestionId(index, question),
+ event.properties.answers[index]?.join(", ") ?? "",
+ ]),
+ );
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ requestId: event.properties.requestID,
+ raw: event,
+ }),
+ type: "user-input.resolved",
+ payload: { answers },
+ });
+ break;
+ }
+
+ case "question.rejected": {
+ context.pendingQuestions.delete(event.properties.requestID);
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ requestId: event.properties.requestID,
+ raw: event,
+ }),
+ type: "user-input.resolved",
+ payload: { answers: {} },
+ });
+ break;
+ }
+
+ case "session.status": {
+ if (event.properties.status.type === "busy") {
+ updateProviderSession(context, { status: "running", activeTurnId: turnId });
+ }
+
+ if (event.properties.status.type === "retry") {
+ await emitPromise({
+ ...buildEventBase({ threadId: context.session.threadId, turnId, raw: event }),
+ type: "runtime.warning",
+ payload: {
+ message: event.properties.status.message,
+ detail: event.properties.status,
+ },
+ });
+ break;
+ }
+
+ if (event.properties.status.type === "idle" && turnId) {
+ context.activeTurnId = undefined;
+ updateProviderSession(
+ context,
+ { status: "ready" },
+ { clearActiveTurnId: true },
+ );
+ await emitPromise({
+ ...buildEventBase({ threadId: context.session.threadId, turnId, raw: event }),
+ type: "turn.completed",
+ payload: {
+ state: "completed",
+ },
+ });
+ }
+ break;
+ }
+
+ case "session.error": {
+ const message = sessionErrorMessage(event.properties.error);
+ const activeTurnId = context.activeTurnId;
+ context.activeTurnId = undefined;
+ updateProviderSession(
+ context,
+ {
+ status: "error",
+ lastError: message,
+ },
+ { clearActiveTurnId: true },
+ );
+ if (activeTurnId) {
+ await emitPromise({
+ ...buildEventBase({
+ threadId: context.session.threadId,
+ turnId: activeTurnId,
+ raw: event,
+ }),
+ type: "turn.completed",
+ payload: {
+ state: "failed",
+ errorMessage: message,
+ },
+ });
+ }
+ await emitPromise({
+ ...buildEventBase({ threadId: context.session.threadId, raw: event }),
+ type: "runtime.error",
+ payload: {
+ message,
+ class: "provider_error",
+ detail: event.properties.error,
+ },
+ });
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+ } catch (error) {
+ if (context.eventsAbortController.signal.aborted || context.stopped) {
+ return;
+ }
+ emitUnexpectedExit(
+ context,
+ error instanceof Error ? error.message : "OpenCode event stream failed.",
+ );
+ }
+ })();
+
+ context.server.process?.once("exit", (code, signal) => {
+ if (context.stopped) {
+ return;
+ }
+ emitUnexpectedExit(
+ context,
+ `OpenCode server exited unexpectedly (${signal ?? code ?? "unknown"}).`,
+ );
+ });
+ };
+
+ const startSession: OpenCodeAdapterShape["startSession"] = Effect.fn("startSession")(
+ function* (input) {
+ const settings = yield* serverSettings.getSettings.pipe(
+ Effect.mapError(
+ (cause) =>
+ new ProviderAdapterProcessError({
+ provider: PROVIDER,
+ threadId: input.threadId,
+ detail: "Failed to read OpenCode settings.",
+ cause,
+ }),
+ ),
+ );
+ const binaryPath = settings.providers.opencode.binaryPath;
+ const serverUrl = settings.providers.opencode.serverUrl;
+ const serverPassword = settings.providers.opencode.serverPassword;
+ const directory = input.cwd ?? serverConfig.cwd;
+ const existing = sessions.get(input.threadId);
+ if (existing) {
+ yield* Effect.tryPromise({
+ try: () => stopOpenCodeContext(existing),
+ catch: (cause) =>
+ new ProviderAdapterProcessError({
+ provider: PROVIDER,
+ threadId: input.threadId,
+ detail: "Failed to stop existing OpenCode session.",
+ cause,
+ }),
+ });
+ sessions.delete(input.threadId);
+ }
+
+ const started = yield* Effect.tryPromise({
+ try: async () => {
+ const server = await connectToOpenCodeServer({ binaryPath, serverUrl });
+ const client = createOpenCodeSdkClient({
+ baseUrl: server.url,
+ directory,
+ ...(server.external && serverPassword ? { serverPassword } : {}),
+ });
+ const openCodeSession = await client.session.create({
+ title: `T3 Code ${input.threadId}`,
+ permission: buildOpenCodePermissionRules(input.runtimeMode),
+ });
+ if (!openCodeSession.data) {
+ throw new Error("OpenCode session.create returned no session payload.");
+ }
+ return { server, client, openCodeSession: openCodeSession.data };
+ },
+ catch: (cause) =>
+ new ProviderAdapterProcessError({
+ provider: PROVIDER,
+ threadId: input.threadId,
+ detail:
+ cause instanceof Error ? cause.message : "Failed to start OpenCode session.",
+ cause,
+ }),
+ });
+
+ // Guard against a concurrent startSession call that may have raced
+ // and already inserted a session while we were awaiting async work.
+ const raceWinner = sessions.get(input.threadId);
+ if (raceWinner) {
+ // Another call won the race – clean up the session we just created
+ // (including the remote SDK session) and return the existing one.
+ yield* Effect.tryPromise({
+ try: () =>
+ started.client.session
+ .abort({ sessionID: started.openCodeSession.id })
+ .catch(() => undefined),
+ catch: () => undefined,
+ }).pipe(Effect.ignore);
+ started.server.close();
+ return raceWinner.session;
+ }
+
+ const createdAt = nowIso();
+ const session: ProviderSession = {
+ provider: PROVIDER,
+ status: "ready",
+ runtimeMode: input.runtimeMode,
+ cwd: directory,
+ ...(input.modelSelection ? { model: input.modelSelection.model } : {}),
+ threadId: input.threadId,
+ createdAt,
+ updatedAt: createdAt,
+ };
+
+ const context: OpenCodeSessionContext = {
+ session,
+ client: started.client,
+ server: started.server,
+ directory,
+ openCodeSessionId: started.openCodeSession.id,
+ pendingPermissions: new Map(),
+ pendingQuestions: new Map(),
+ partById: new Map(),
+ emittedTextByPartId: new Map(),
+ messageRoleById: new Map(),
+ completedAssistantPartIds: new Set(),
+ turns: [],
+ activeTurnId: undefined,
+ activeAgent: undefined,
+ activeVariant: undefined,
+ stopped: false,
+ eventsAbortController: new AbortController(),
+ };
+ sessions.set(input.threadId, context);
+ startEventPump(context);
+
+ yield* emit({
+ ...buildEventBase({ threadId: input.threadId }),
+ type: "session.started",
+ payload: {
+ message: "OpenCode session started",
+ },
+ });
+ yield* emit({
+ ...buildEventBase({ threadId: input.threadId }),
+ type: "thread.started",
+ payload: {
+ providerThreadId: started.openCodeSession.id,
+ },
+ });
+
+ return session;
+ },
+ );
+
+ const sendTurn: OpenCodeAdapterShape["sendTurn"] = Effect.fn("sendTurn")(function* (input) {
+ const context = ensureSessionContext(sessions, input.threadId);
+ const turnId = TurnId.make(`opencode-turn-${randomUUID()}`);
+ const modelSelection =
+ input.modelSelection ??
+ (context.session.model
+ ? { provider: PROVIDER, model: context.session.model }
+ : undefined);
+ const parsedModel = parseOpenCodeModelSlug(modelSelection?.model);
+ if (!parsedModel) {
+ return yield* new ProviderAdapterValidationError({
+ provider: PROVIDER,
+ operation: "sendTurn",
+ issue: "OpenCode model selection must use the 'provider/model' format.",
+ });
+ }
+
+ const text = input.input?.trim();
+ const fileParts = toOpenCodeFileParts({
+ attachments: input.attachments,
+ resolveAttachmentPath: (attachment) =>
+ resolveAttachmentPath({ attachmentsDir: serverConfig.attachmentsDir, attachment }),
+ });
+ if ((!text || text.length === 0) && fileParts.length === 0) {
+ return yield* new ProviderAdapterValidationError({
+ provider: PROVIDER,
+ operation: "sendTurn",
+ issue: "OpenCode turns require text input or at least one attachment.",
+ });
+ }
+
+ const agent =
+ input.modelSelection?.provider === PROVIDER
+ ? input.modelSelection.options?.agent
+ : undefined;
+ const variant =
+ input.modelSelection?.provider === PROVIDER
+ ? input.modelSelection.options?.variant
+ : undefined;
+
+ context.activeTurnId = turnId;
+ context.activeAgent = agent ?? (input.interactionMode === "plan" ? "plan" : undefined);
+ context.activeVariant = variant;
+ updateProviderSession(
+ context,
+ {
+ status: "running",
+ activeTurnId: turnId,
+ model: modelSelection?.model ?? context.session.model,
+ },
+ { clearLastError: true },
+ );
+
+ yield* emit({
+ ...buildEventBase({ threadId: input.threadId, turnId }),
+ type: "turn.started",
+ payload: {
+ model: modelSelection?.model ?? context.session.model,
+ ...(variant ? { effort: variant } : {}),
+ },
+ });
+
+ const promptExit = yield* Effect.exit(
+ Effect.tryPromise({
+ try: async () => {
+ await context.client.session.promptAsync({
+ sessionID: context.openCodeSessionId,
+ model: parsedModel,
+ ...(context.activeAgent ? { agent: context.activeAgent } : {}),
+ ...(context.activeVariant ? { variant: context.activeVariant } : {}),
+ parts: [...(text ? [{ type: "text" as const, text }] : []), ...fileParts],
+ });
+ },
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "session.promptAsync",
+ detail: cause instanceof Error ? cause.message : "Failed to send OpenCode turn.",
+ cause,
+ }),
+ }),
+ );
+ if (promptExit._tag === "Failure") {
+ const failure = Cause.squash(promptExit.cause);
+ const requestError = isProviderAdapterRequestError(failure)
+ ? failure
+ : new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "session.promptAsync",
+ detail:
+ failure instanceof Error ? failure.message : "Failed to send OpenCode turn.",
+ cause: failure,
+ });
+ const failureMessage = requestError.detail;
+ context.activeTurnId = undefined;
+ context.activeAgent = undefined;
+ context.activeVariant = undefined;
+ updateProviderSession(
+ context,
+ {
+ status: "ready",
+ model: modelSelection?.model ?? context.session.model,
+ lastError: failureMessage,
+ },
+ { clearActiveTurnId: true },
+ );
+ yield* emit({
+ ...buildEventBase({ threadId: input.threadId, turnId }),
+ type: "turn.aborted",
+ payload: {
+ reason: failureMessage,
+ },
+ });
+ return yield* requestError;
+ }
+
+ return {
+ threadId: input.threadId,
+ turnId,
+ };
+ });
+
+ const interruptTurn: OpenCodeAdapterShape["interruptTurn"] = Effect.fn("interruptTurn")(
+ function* (threadId, turnId) {
+ const context = ensureSessionContext(sessions, threadId);
+ yield* Effect.tryPromise({
+ try: () => context.client.session.abort({ sessionID: context.openCodeSessionId }),
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "session.abort",
+ detail: cause instanceof Error ? cause.message : "Failed to abort OpenCode turn.",
+ cause,
+ }),
+ });
+ if (turnId ?? context.activeTurnId) {
+ yield* emit({
+ ...buildEventBase({ threadId, turnId: turnId ?? context.activeTurnId }),
+ type: "turn.aborted",
+ payload: {
+ reason: "Interrupted by user.",
+ },
+ });
+ }
+ },
+ );
+
+ const respondToRequest: OpenCodeAdapterShape["respondToRequest"] = Effect.fn(
+ "respondToRequest",
+ )(function* (threadId, requestId, decision) {
+ const context = ensureSessionContext(sessions, threadId);
+ if (!context.pendingPermissions.has(requestId)) {
+ return yield* new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "permission.reply",
+ detail: `Unknown pending permission request: ${requestId}`,
+ });
+ }
+
+ yield* Effect.tryPromise({
+ try: () =>
+ context.client.permission.reply({
+ requestID: requestId,
+ reply: toOpenCodePermissionReply(decision),
+ }),
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "permission.reply",
+ detail:
+ cause instanceof Error
+ ? cause.message
+ : "Failed to submit OpenCode permission reply.",
+ cause,
+ }),
+ });
+ });
+
+ const respondToUserInput: OpenCodeAdapterShape["respondToUserInput"] = Effect.fn(
+ "respondToUserInput",
+ )(function* (threadId, requestId, answers) {
+ const context = ensureSessionContext(sessions, threadId);
+ const request = context.pendingQuestions.get(requestId);
+ if (!request) {
+ return yield* new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "question.reply",
+ detail: `Unknown pending user-input request: ${requestId}`,
+ });
+ }
+
+ yield* Effect.tryPromise({
+ try: () =>
+ context.client.question.reply({
+ requestID: requestId,
+ answers: toOpenCodeQuestionAnswers(request, answers),
+ }),
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "question.reply",
+ detail: cause instanceof Error ? cause.message : "Failed to submit OpenCode answers.",
+ cause,
+ }),
+ });
+ });
+
+ const stopSession: OpenCodeAdapterShape["stopSession"] = Effect.fn("stopSession")(
+ function* (threadId) {
+ const context = ensureSessionContext(sessions, threadId);
+ yield* Effect.tryPromise({
+ try: () => stopOpenCodeContext(context),
+ catch: (cause) =>
+ new ProviderAdapterProcessError({
+ provider: PROVIDER,
+ threadId,
+ detail: cause instanceof Error ? cause.message : "Failed to stop OpenCode session.",
+ cause,
+ }),
+ });
+ sessions.delete(threadId);
+ yield* emit({
+ ...buildEventBase({ threadId }),
+ type: "session.exited",
+ payload: {
+ reason: "Session stopped.",
+ recoverable: false,
+ exitKind: "graceful",
+ },
+ });
+ },
+ );
+
+ const listSessions: OpenCodeAdapterShape["listSessions"] = () =>
+ Effect.sync(() => [...sessions.values()].map((context) => context.session));
+
+ const hasSession: OpenCodeAdapterShape["hasSession"] = (threadId) =>
+ Effect.sync(() => sessions.has(threadId));
+
+ const readThread: OpenCodeAdapterShape["readThread"] = Effect.fn("readThread")(
+ function* (threadId) {
+ const context = ensureSessionContext(sessions, threadId);
+ const messages = yield* Effect.tryPromise({
+ try: () => context.client.session.messages({ sessionID: context.openCodeSessionId }),
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "session.messages",
+ detail: cause instanceof Error ? cause.message : "Failed to read OpenCode thread.",
+ cause,
+ }),
+ });
+
+ const turns = (messages.data ?? [])
+ .filter((entry) => entry.info.role === "assistant")
+ .map((entry) => ({
+ id: TurnId.make(entry.info.id),
+ items: [entry.info, ...entry.parts],
+ }));
+
+ return {
+ threadId,
+ turns,
+ };
+ },
+ );
+
+ const rollbackThread: OpenCodeAdapterShape["rollbackThread"] = Effect.fn("rollbackThread")(
+ function* (threadId, numTurns) {
+ const context = ensureSessionContext(sessions, threadId);
+ const messages = yield* Effect.tryPromise({
+ try: () => context.client.session.messages({ sessionID: context.openCodeSessionId }),
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "session.messages",
+ detail:
+ cause instanceof Error ? cause.message : "Failed to inspect OpenCode thread.",
+ cause,
+ }),
+ });
+
+ const assistantMessages = (messages.data ?? []).filter(
+ (entry) => entry.info.role === "assistant",
+ );
+ const targetIndex = assistantMessages.length - numTurns - 1;
+ const target = targetIndex >= 0 ? assistantMessages[targetIndex] : null;
+ yield* Effect.tryPromise({
+ try: () =>
+ context.client.session.revert({
+ sessionID: context.openCodeSessionId,
+ ...(target ? { messageID: target.info.id } : {}),
+ }),
+ catch: (cause) =>
+ new ProviderAdapterRequestError({
+ provider: PROVIDER,
+ method: "session.revert",
+ detail: cause instanceof Error ? cause.message : "Failed to revert OpenCode turn.",
+ cause,
+ }),
+ });
+
+ return yield* readThread(threadId);
+ },
+ );
+
+ const stopAll: OpenCodeAdapterShape["stopAll"] = () =>
+ Effect.tryPromise({
+ try: async () => {
+ const contexts = [...sessions.values()];
+ sessions.clear();
+ const results = await Promise.allSettled(
+ contexts.map((context) => stopOpenCodeContext(context)),
+ );
+ const errors = results
+ .filter((result): result is PromiseRejectedResult => result.status === "rejected")
+ .map((result) => result.reason);
+ if (errors.length === 1) {
+ throw errors[0];
+ }
+ if (errors.length > 1) {
+ throw new AggregateError(
+ errors,
+ `Failed to stop ${errors.length} OpenCode sessions.`,
+ );
+ }
+ },
+ catch: (cause) =>
+ new ProviderAdapterProcessError({
+ provider: PROVIDER,
+ threadId: "*",
+ detail: cause instanceof Error ? cause.message : "Failed to stop OpenCode sessions.",
+ cause,
+ }),
+ });
+
+ return {
+ provider: PROVIDER,
+ capabilities: {
+ sessionModelSwitch: "in-session",
+ },
+ startSession,
+ sendTurn,
+ interruptTurn,
+ respondToRequest,
+ respondToUserInput,
+ stopSession,
+ listSessions,
+ hasSession,
+ readThread,
+ rollbackThread,
+ stopAll,
+ get streamEvents() {
+ return Stream.fromQueue(runtimeEvents);
+ },
+ } satisfies OpenCodeAdapterShape;
+ }),
+ );
+}
+
+export const OpenCodeAdapterLive = makeOpenCodeAdapterLive();
diff --git a/apps/server/src/provider/Layers/OpenCodeProvider.test.ts b/apps/server/src/provider/Layers/OpenCodeProvider.test.ts
new file mode 100644
index 000000000..cf3d588d9
--- /dev/null
+++ b/apps/server/src/provider/Layers/OpenCodeProvider.test.ts
@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import { beforeEach, vi } from "vitest";
+
+import { ServerConfig } from "../../config.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import { OpenCodeProvider } from "../Services/OpenCodeProvider.ts";
+import { makeOpenCodeProviderLive } from "./OpenCodeProvider.ts";
+
+const runtimeMock = vi.hoisted(() => {
+ const state = {
+ runVersionError: null as Error | null,
+ inventoryError: null as Error | null,
+ };
+
+ return {
+ state,
+ reset() {
+ state.runVersionError = null;
+ state.inventoryError = null;
+ },
+ };
+});
+
+vi.mock("../opencodeRuntime.ts", async () => {
+ const actual =
+ await vi.importActual<typeof import("../opencodeRuntime.ts")>("../opencodeRuntime.ts");
+
+ return {
+ ...actual,
+ runOpenCodeCommand: vi.fn(async () => {
+ if (runtimeMock.state.runVersionError) {
+ throw runtimeMock.state.runVersionError;
+ }
+ return { stdout: "opencode 1.0.0\n", stderr: "", code: 0 };
+ }),
+ connectToOpenCodeServer: vi.fn(async ({ serverUrl }: { serverUrl?: string }) => ({
+ url: serverUrl ?? "http://127.0.0.1:4301",
+ process: null,
+ external: Boolean(serverUrl),
+ close() {},
+ })),
+ createOpenCodeSdkClient: vi.fn(() => ({})),
+ loadOpenCodeInventory: vi.fn(async () => {
+ if (runtimeMock.state.inventoryError) {
+ throw runtimeMock.state.inventoryError;
+ }
+ return {
+ providerList: { connected: [], all: [] },
+ agents: [],
+ };
+ }),
+ flattenOpenCodeModels: vi.fn(() => []),
+ };
+});
+
+beforeEach(() => {
+ runtimeMock.reset();
+});
+
+const makeTestLayer = (settingsOverrides?: Parameters<typeof ServerSettingsService.layerTest>[0]) =>
+ makeOpenCodeProviderLive().pipe(
+ Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
+ Layer.provideMerge(ServerSettingsService.layerTest(settingsOverrides)),
+ Layer.provideMerge(NodeServices.layer),
+ );
+
+it.layer(makeTestLayer())("OpenCodeProviderLive", (it) => {
+ it.effect("shows a codex-style missing binary message", () =>
+ Effect.gen(function* () {
+ runtimeMock.state.runVersionError = new Error("spawn opencode ENOENT");
+ const provider = yield* OpenCodeProvider;
+ const snapshot = yield* provider.refresh;
+
+ assert.equal(snapshot.status, "error");
+ assert.equal(snapshot.installed, false);
+ assert.equal(snapshot.message, "OpenCode CLI (`opencode`) is not installed or not on PATH.");
+ }),
+ );
+
+ it.effect("hides generic Effect.tryPromise text for local CLI probe failures", () =>
+ Effect.gen(function* () {
+ runtimeMock.state.runVersionError = new Error("An error occurred in Effect.tryPromise");
+ const provider = yield* OpenCodeProvider;
+ const snapshot = yield* provider.refresh;
+
+ assert.equal(snapshot.status, "error");
+ assert.equal(snapshot.installed, true);
+ assert.equal(snapshot.message, "Failed to execute OpenCode CLI health check.");
+ }),
+ );
+});
+
+it.layer(
+ makeTestLayer({
+ providers: {
+ opencode: {
+ serverUrl: "http://127.0.0.1:9999",
+ serverPassword: "secret-password",
+ },
+ },
+ }),
+)("OpenCodeProviderLive with configured server URL", (it) => {
+ it.effect("surfaces a friendly auth error for configured servers", () =>
+ Effect.gen(function* () {
+ runtimeMock.state.inventoryError = new Error("401 Unauthorized");
+ const provider = yield* OpenCodeProvider;
+ const snapshot = yield* provider.refresh;
+
+ assert.equal(snapshot.status, "error");
+ assert.equal(snapshot.installed, true);
+ assert.equal(
+ snapshot.message,
+ "OpenCode server rejected authentication. Check the server URL and password.",
+ );
+ }),
+ );
+
+ it.effect("surfaces a friendly connection error for configured servers", () =>
+ Effect.gen(function* () {
+ runtimeMock.state.inventoryError = new Error(
+ "fetch failed: connect ECONNREFUSED 127.0.0.1:9999",
+ );
+ const provider = yield* OpenCodeProvider;
+ const snapshot = yield* provider.refresh;
+
+ assert.equal(snapshot.status, "error");
+ assert.equal(snapshot.installed, true);
+ assert.equal(
+ snapshot.message,
+ "Couldn't reach the configured OpenCode server at http://127.0.0.1:9999. Check that the server is running and the URL is correct.",
+ );
+ }),
+ );
+});
diff --git a/apps/server/src/provider/Layers/OpenCodeProvider.ts b/apps/server/src/provider/Layers/OpenCodeProvider.ts
new file mode 100644
index 000000000..f19694125
--- /dev/null
+++ b/apps/server/src/provider/Layers/OpenCodeProvider.ts
@@ -0,0 +1,342 @@
+import type { OpenCodeSettings, ServerProvider } from "@t3tools/contracts";
+import { Cause, Effect, Equal, Layer, Stream } from "effect";
+
+import { ServerConfig } from "../../config.ts";
+import { ServerSettingsService } from "../../serverSettings.ts";
+import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
+import {
+ buildServerProvider,
+ isCommandMissingCause,
+ parseGenericCliVersion,
+ providerModelsFromSettings,
+} from "../providerSnapshot.ts";
+import { OpenCodeProvider } from "../Services/OpenCodeProvider.ts";
+import {
+ connectToOpenCodeServer,
+ DEFAULT_OPENCODE_MODEL_CAPABILITIES,
+ createOpenCodeSdkClient,
+ flattenOpenCodeModels,
+ loadOpenCodeInventory,
+ runOpenCodeCommand,
+} from "../opencodeRuntime.ts";
+
+const PROVIDER = "opencode" as const;
+
+class OpenCodeProbePromiseError extends Error {
+ override readonly cause: unknown;
+
+ constructor(cause: unknown) {
+ super(cause instanceof Error ? cause.message : String(cause));
+ this.cause = cause;
+ this.name = "OpenCodeProbePromiseError";
+ }
+}
+
+function toOpenCodeProbeError(cause: unknown): OpenCodeProbePromiseError {
+ return new OpenCodeProbePromiseError(cause);
+}
+
+function normalizedErrorMessage(cause: unknown): string | undefined {
+ if (!(cause instanceof Error)) {
+ return undefined;
+ }
+
+ const message = cause.message.trim();
+ if (message.length === 0) {
+ return undefined;
+ }
+ if (
+ message === "An error occurred in Effect.tryPromise" ||
+ message === "An error occurred in Effect.try"
+ ) {
+ return undefined;
+ }
+ return message;
+}
+
+function formatOpenCodeProbeError(input: {
+ readonly cause: unknown;
+ readonly isExternalServer: boolean;
+ readonly serverUrl: string;
+}): { readonly installed: boolean; readonly message: string } {
+ const lower = input.cause instanceof Error ? input.cause.message.toLowerCase() : "";
+ const detail = normalizedErrorMessage(input.cause);
+
+ if (input.isExternalServer) {
+ if (
+ lower.includes("401") ||
+ lower.includes("403") ||
+ lower.includes("unauthorized") ||
+ lower.includes("forbidden")
+ ) {
+ return {
+ installed: true,
+ message: "OpenCode server rejected authentication. Check the server URL and password.",
+ };
+ }
+
+ if (
+ lower.includes("econnrefused") ||
+ lower.includes("enotfound") ||
+ lower.includes("fetch failed") ||
+ lower.includes("networkerror") ||
+ lower.includes("timed out") ||
+ lower.includes("timeout") ||
+ lower.includes("socket hang up")
+ ) {
+ return {
+ installed: true,
+ message: `Couldn't reach the configured OpenCode server at ${input.serverUrl}. Check that the server is running and the URL is correct.`,
+ };
+ }
+
+ return {
+ installed: true,
+ message: detail ?? "Failed to connect to the configured OpenCode server.",
+ };
+ }
+
+ if (input.cause instanceof Error && isCommandMissingCause(input.cause)) {
+ return {
+ installed: false,
+ message: "OpenCode CLI (`opencode`) is not installed or not on PATH.",
+ };
+ }
+
+ if (lower.includes("quarantine")) {
+ return {
+ installed: true,
+ message:
+ "macOS is blocking the OpenCode binary (quarantine). Run `xattr -d com.apple.quarantine $(which opencode)` to fix this.",
+ };
+ }
+
+ if (lower.includes("invalid code signature") || lower.includes("corrupted")) {
+ return {
+ installed: true,
+ message:
+ "macOS killed the OpenCode process due to an invalid code signature. The binary may be corrupted — try reinstalling OpenCode.",
+ };
+ }
+
+ return {
+ installed: true,
+ message: detail
+ ? `Failed to execute OpenCode CLI health check: ${detail}`
+ : "Failed to execute OpenCode CLI health check.",
+ };
+}
+
+const makePendingOpenCodeProvider = (openCodeSettings: OpenCodeSettings): ServerProvider => {
+ const checkedAt = new Date().toISOString();
+ const models = providerModelsFromSettings(
+ [],
+ PROVIDER,
+ openCodeSettings.customModels,
+ DEFAULT_OPENCODE_MODEL_CAPABILITIES,
+ );
+
+ if (!openCodeSettings.enabled) {
+ return buildServerProvider({
+ provider: PROVIDER,
+ enabled: false,
+ checkedAt,
+ models,
+ probe: {
+ installed: false,
+ version: null,
+ status: "warning",
+ auth: { status: "unknown" },
+ message:
+ openCodeSettings.serverUrl.trim().length > 0
+ ? "OpenCode is disabled in T3 Code settings. A server URL is configured."
+ : "OpenCode is disabled in T3 Code settings.",
+ },
+ });
+ }
+
+ return buildServerProvider({
+ provider: PROVIDER,
+ enabled: true,
+ checkedAt,
+ models,
+ probe: {
+ installed: false,
+ version: null,
+ status: "warning",
+ auth: { status: "unknown" },
+ message: "OpenCode provider status has not been checked in this session yet.",
+ },
+ });
+};
+
+export function checkOpenCodeProviderStatus(input: {
+ readonly settings: OpenCodeSettings;
+ readonly cwd: string;
+}): Effect.Effect<ServerProvider> {
+ const checkedAt = new Date().toISOString();
+ const customModels = input.settings.customModels;
+ const isExternalServer = input.settings.serverUrl.trim().length > 0;
+
+ const fallback = (cause: unknown, version: string | null = null) => {
+ const failure = formatOpenCodeProbeError({
+ cause,
+ isExternalServer,
+ serverUrl: input.settings.serverUrl,
+ });
+ return buildServerProvider({
+ provider: PROVIDER,
+ enabled: input.settings.enabled,
+ checkedAt,
+ models: providerModelsFromSettings(
+ [],
+ PROVIDER,
+ customModels,
+ DEFAULT_OPENCODE_MODEL_CAPABILITIES,
+ ),
+ probe: {
+ installed: failure.installed,
+ version,
+ status: "error",
+ auth: { status: "unknown" },
+ message: failure.message,
+ },
+ });
+ };
+
+ return Effect.gen(function* () {
+ if (!input.settings.enabled) {
+ return buildServerProvider({
+ provider: PROVIDER,
+ enabled: false,
+ checkedAt,
+ models: providerModelsFromSettings(
+ [],
+ PROVIDER,
+ customModels,
+ DEFAULT_OPENCODE_MODEL_CAPABILITIES,
+ ),
+ probe: {
+ installed: false,
+ version: null,
+ status: "warning",
+ auth: { status: "unknown" },
+ message: isExternalServer
+ ? "OpenCode is disabled in T3 Code settings. A server URL is configured."
+ : "OpenCode is disabled in T3 Code settings.",
+ },
+ });
+ }
+
+ let version: string | null = null;
+ if (!isExternalServer) {
+ const versionExit = yield* Effect.exit(
+ Effect.tryPromise({
+ try: () =>
+ runOpenCodeCommand({
+ binaryPath: input.settings.binaryPath,
+ args: ["--version"],
+ }),
+ catch: toOpenCodeProbeError,
+ }),
+ );
+ if (versionExit._tag === "Failure") {
+ return fallback(Cause.squash(versionExit.cause));
+ }
+ version = parseGenericCliVersion(versionExit.value.stdout) ?? null;
+ }
+
+ const inventoryExit = yield* Effect.exit(
+ Effect.acquireUseRelease(
+ Effect.tryPromise({
+ try: () =>
+ connectToOpenCodeServer({
+ binaryPath: input.settings.binaryPath,
+ serverUrl: input.settings.serverUrl,
+ }),
+ catch: toOpenCodeProbeError,
+ }),
+ (server) =>
+ Effect.tryPromise({
+ try: async () => {
+ const client = createOpenCodeSdkClient({
+ baseUrl: server.url,
+ directory: input.cwd,
+ ...(isExternalServer && input.settings.serverPassword
+ ? { serverPassword: input.settings.serverPassword }
+ : {}),
+ });
+ return await loadOpenCodeInventory(client);
+ },
+ catch: toOpenCodeProbeError,
+ }),
+ (server) => Effect.sync(() => server.close()),
+ ),
+ );
+ if (inventoryExit._tag === "Failure") {
+ return fallback(Cause.squash(inventoryExit.cause), version);
+ }
+
+ const models = providerModelsFromSettings(
+ flattenOpenCodeModels(inventoryExit.value),
+ PROVIDER,
+ customModels,
+ DEFAULT_OPENCODE_MODEL_CAPABILITIES,
+ );
+ const connectedCount = inventoryExit.value.providerList.connected.length;
+ return buildServerProvider({
+ provider: PROVIDER,
+ enabled: true,
+ checkedAt,
+ models,
+ probe: {
+ installed: true,
+ version,
+ status: connectedCount > 0 ? "ready" : "warning",
+ auth: {
+ status: connectedCount > 0 ? "authenticated" : "unknown",
+ type: "opencode",
+ },
+ message:
+ connectedCount > 0
+ ? `${connectedCount} upstream provider${connectedCount === 1 ? "" : "s"} connected through ${isExternalServer ? "the configured OpenCode server" : "OpenCode"}.`
+ : isExternalServer
+ ? "Connected to the configured OpenCode server, but it did not report any connected upstream providers."
+ : "OpenCode is available, but it did not report any connected upstream providers.",
+ },
+ });
+ });
+}
+
+export function makeOpenCodeProviderLive() {
+ return Layer.effect(
+ OpenCodeProvider,
+ Effect.gen(function* () {
+ const serverSettings = yield* ServerSettingsService;
+ const serverConfig = yield* ServerConfig;
+
+ const getProviderSettings = serverSettings.getSettings.pipe(
+ Effect.map((settings) => settings.providers.opencode),
+ );
+
+ return yield* makeManagedServerProvider<OpenCodeSettings>({
+ getSettings: getProviderSettings.pipe(Effect.orDie),
+ streamSettings: serverSettings.streamChanges.pipe(
+ Stream.map((settings) => settings.providers.opencode),
+ ),
+ haveSettingsChanged: (previous, next) => !Equal.equals(previous, next),
+ initialSnapshot: makePendingOpenCodeProvider,
+ checkProvider: getProviderSettings.pipe(
+ Effect.flatMap((settings) =>
+ checkOpenCodeProviderStatus({
+ settings,
+ cwd: serverConfig.cwd,
+ }),
+ ),
+ ),
+ });
+ }),
+ );
+}
+
+export const OpenCodeProviderLive = makeOpenCodeProviderLive();
diff --git a/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts b/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts
index 953a49fe2..1b9b5561d 100644
--- a/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts
+++ b/apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts
@@ -8,6 +8,8 @@ import { ClaudeAdapter } from "../Services/ClaudeAdapter.ts";
import type { ClaudeAdapterShape } from "../Services/ClaudeAdapter.ts";
import { CodexAdapter } from "../Services/CodexAdapter.ts";
import type { CodexAdapterShape } from "../Services/CodexAdapter.ts";
+import { OpenCodeAdapter } from "../Services/OpenCodeAdapter.ts";
+import type { OpenCodeAdapterShape } from "../Services/OpenCodeAdapter.ts";
import { ProviderAdapterRegistry } from "../Services/ProviderAdapterRegistry.ts";
import { ProviderAdapterRegistryLive } from "./ProviderAdapterRegistry.ts";
import { ProviderUnsupportedError } from "../Errors.ts";
@@ -47,6 +49,23 @@ const fakeClaudeAdapter: ClaudeAdapterShape = {
streamEvents: Stream.empty,
};
+const fakeOpenCodeAdapter: OpenCodeAdapterShape = {
+ provider: "opencode",
+ capabilities: { sessionModelSwitch: "in-session" },
+ startSession: vi.fn(),
+ sendTurn: vi.fn(),
+ interruptTurn: vi.fn(),
+ respondToRequest: vi.fn(),
+ respondToUserInput: vi.fn(),
+ stopSession: vi.fn(),
+ listSessions: vi.fn(),
+ hasSession: vi.fn(),
+ readThread: vi.fn(),
+ rollbackThread: vi.fn(),
+ stopAll: vi.fn(),
+ streamEvents: Stream.empty,
+};
+
const layer = it.layer(
Layer.mergeAll(
Layer.provide(
@@ -54,6 +73,7 @@ const layer = it.layer(
Layer.mergeAll(
Layer.succeed(CodexAdapter, fakeCodexAdapter),
Layer.succeed(ClaudeAdapter, fakeClaudeAdapter),
+ Layer.succeed(OpenCodeAdapter, fakeOpenCodeAdapter),
),
),
NodeServices.layer,
@@ -66,11 +86,13 @@ layer("ProviderAdapterRegistryLive", (it) => {
const registry = yield* ProviderAdapterRegistry;
const codex = yield* registry.getByProvider("codex");
const claude = yield* registry.getByProvider("claudeAgent");
+ const openCode = yield* registry.getByProvider("opencode");
assert.equal(codex, fakeCodexAdapter);
assert.equal(claude, fakeClaudeAdapter);
+ assert.equal(openCode, fakeOpenCodeAdapter);
const providers = yield* registry.listProviders();
- assert.deepEqual(providers, ["codex", "claudeAgent"]);
+ assert.deepEqual(providers, ["codex", "claudeAgent", "opencode"]);
}),
);
diff --git a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
index b6c987c64..2026923b5 100644
--- a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
@@ -17,6 +17,7 @@ import {
} from "../Services/ProviderAdapterRegistry.ts";
import { ClaudeAdapter } from "../Services/ClaudeAdapter.ts";
import { CodexAdapter } from "../Services/CodexAdapter.ts";
+import { OpenCodeAdapter } from "../Services/OpenCodeAdapter.ts";
export interface ProviderAdapterRegistryLiveOptions {
readonly adapters?: ReadonlyArray<ProviderAdapterShape<ProviderAdapterError>>;
@@ -28,7 +29,7 @@ const makeProviderAdapterRegistry = Effect.fn("makeProviderAdapterRegistry")(fun
const adapters =
options?.adapters !== undefined
? options.adapters
- : [yield* CodexAdapter, yield* ClaudeAdapter];
+ : [yield* CodexAdapter, yield* ClaudeAdapter, yield* OpenCodeAdapter];
const byProvider = new Map(adapters.map((adapter) => [adapter.provider, adapter]));
const getByProvider: ProviderAdapterRegistryShape["getByProvider"] = (provider) => {
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.test.ts b/apps/server/src/provider/Layers/ProviderRegistry.test.ts
index 170521d2d..6d274a14f 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.test.ts
@@ -31,6 +31,7 @@ import {
} from "./CodexProvider.ts";
import { checkClaudeProviderStatus, parseClaudeAuthStatusFromOutput } from "./ClaudeProvider.ts";
import { haveProvidersChanged, ProviderRegistryLive } from "./ProviderRegistry.ts";
+import { OpenCodeProvider } from "../Services/OpenCodeProvider.ts";
import { ServerConfig } from "../../config.ts";
import { ServerSettingsService, type ServerSettingsShape } from "../../serverSettings.ts";
import { ProviderRegistry } from "../Services/ProviderRegistry.ts";
@@ -38,6 +39,19 @@ import { ProviderRegistry } from "../Services/ProviderRegistry.ts";
// ── Test helpers ────────────────────────────────────────────────────
const encoder = new TextEncoder();
+const fakeOpenCodeSnapshot: ServerProvider = {
+ provider: "opencode",
+ status: "warning",
+ enabled: true,
+ installed: false,
+ auth: { status: "unknown" },
+ checkedAt: "2026-03-25T00:00:00.000Z",
+ version: null,
+ models: [],
+ slashCommands: [],
+ skills: [],
+ message: "OpenCode test stub",
+};
function mockHandle(result: { stdout: string; stderr: string; code: number }) {
return ChildProcessSpawner.makeHandle({
@@ -596,12 +610,9 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(
}),
),
);
- const runtimeServices = yield* Layer.build(
- Layer.mergeAll(
- Layer.succeed(ServerSettingsService, serverSettings),
- providerRegistryLayer,
- ),
- ).pipe(Scope.provide(scope));
+ const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe(
+ Scope.provide(scope),
+ );
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry;
@@ -630,6 +641,13 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(
prefix: "t3-provider-registry-",
}),
),
+ Layer.provideMerge(
+ Layer.succeed(OpenCodeProvider, {
+ getSnapshot: Effect.succeed(fakeOpenCodeSnapshot),
+ refresh: Effect.succeed(fakeOpenCodeSnapshot),
+ streamChanges: Stream.empty,
+ }),
+ ),
Layer.provideMerge(
mockCommandSpawnerLayer((command, args) => {
const joined = args.join(" ");
@@ -646,12 +664,9 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(
}),
),
);
- const runtimeServices = yield* Layer.build(
- Layer.mergeAll(
- Layer.succeed(ServerSettingsService, serverSettings),
- providerRegistryLayer,
- ),
- ).pipe(Scope.provide(scope));
+ const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe(
+ Scope.provide(scope),
+ );
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry;
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.ts b/apps/server/src/provider/Layers/ProviderRegistry.ts
index 62207ff07..c5b08ec4d 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.ts
@@ -9,10 +9,13 @@ import { Effect, Equal, FileSystem, Layer, Path, PubSub, Ref, Stream } from "eff
import { ServerConfig } from "../../config.ts";
import { ClaudeProviderLive } from "./ClaudeProvider.ts";
import { CodexProviderLive } from "./CodexProvider.ts";
+import { OpenCodeProviderLive } from "./OpenCodeProvider.ts";
import type { ClaudeProviderShape } from "../Services/ClaudeProvider.ts";
import { ClaudeProvider } from "../Services/ClaudeProvider.ts";
import type { CodexProviderShape } from "../Services/CodexProvider.ts";
import { CodexProvider } from "../Services/CodexProvider.ts";
+import type { OpenCodeProviderShape } from "../Services/OpenCodeProvider.ts";
+import { OpenCodeProvider } from "../Services/OpenCodeProvider.ts";
import { ProviderRegistry, type ProviderRegistryShape } from "../Services/ProviderRegistry.ts";
import {
hydrateCachedProvider,
@@ -26,10 +29,14 @@ import {
const loadProviders = (
codexProvider: CodexProviderShape,
claudeProvider: ClaudeProviderShape,
-): Effect.Effect<readonly [ServerProvider, ServerProvider]> =>
- Effect.all([codexProvider.getSnapshot, claudeProvider.getSnapshot], {
- concurrency: "unbounded",
- });
+ openCodeProvider: OpenCodeProviderShape,
+): Effect.Effect<readonly [ServerProvider, ServerProvider, ServerProvider]> =>
+ Effect.all(
+ [codexProvider.getSnapshot, claudeProvider.getSnapshot, openCodeProvider.getSnapshot],
+ {
+ concurrency: "unbounded",
+ },
+ );
export const haveProvidersChanged = (
previousProviders: ReadonlyArray<ServerProvider>,
@@ -41,6 +48,7 @@ export const ProviderRegistryLive = Layer.effect(
Effect.gen(function* () {
const codexProvider = yield* CodexProvider;
const claudeProvider = yield* ClaudeProvider;
+ const openCodeProvider = yield* OpenCodeProvider;
const config = yield* ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
@@ -48,7 +56,7 @@ export const ProviderRegistryLive = Layer.effect(
PubSub.unbounded<ReadonlyArray<ServerProvider>>(),
PubSub.shutdown,
);
- const fallbackProviders = yield* loadProviders(codexProvider, claudeProvider);
+ const fallbackProviders = yield* loadProviders(codexProvider, claudeProvider, openCodeProvider);
const cachePathByProvider = new Map(
PROVIDER_CACHE_IDS.map(
(provider) =>
@@ -156,6 +164,10 @@ export const ProviderRegistryLive = Layer.effect(
return yield* claudeProvider.refresh.pipe(
Effect.flatMap((nextProvider) => syncProvider(nextProvider)),
);
+ case "opencode":
+ return yield* openCodeProvider.refresh.pipe(
+ Effect.flatMap((nextProvider) => syncProvider(nextProvider)),
+ );
default:
return yield* Effect.all(
[
@@ -165,6 +177,9 @@ export const ProviderRegistryLive = Layer.effect(
claudeProvider.refresh.pipe(
Effect.flatMap((nextProvider) => syncProvider(nextProvider)),
),
+ openCodeProvider.refresh.pipe(
+ Effect.flatMap((nextProvider) => syncProvider(nextProvider)),
+ ),
],
{
concurrency: "unbounded",
@@ -180,6 +195,9 @@ export const ProviderRegistryLive = Layer.effect(
yield* Stream.runForEach(claudeProvider.streamChanges, (provider) =>
syncProvider(provider),
).pipe(Effect.forkScoped);
+ yield* Stream.runForEach(openCodeProvider.streamChanges, (provider) =>
+ syncProvider(provider),
+ ).pipe(Effect.forkScoped);
return {
getProviders: Ref.get(providersRef),
@@ -193,4 +211,8 @@ export const ProviderRegistryLive = Layer.effect(
},
} satisfies ProviderRegistryShape;
}),
-).pipe(Layer.provideMerge(CodexProviderLive), Layer.provideMerge(ClaudeProviderLive));
+).pipe(
+ Layer.provideMerge(CodexProviderLive),
+ Layer.provideMerge(ClaudeProviderLive),
+ Layer.provideMerge(OpenCodeProviderLive),
+);
diff --git a/apps/server/src/provider/Layers/ProviderService.test.ts b/apps/server/src/provider/Layers/ProviderService.test.ts
index b54976589..d02578b99 100644
--- a/apps/server/src/provider/Layers/ProviderService.test.ts
+++ b/apps/server/src/provider/Layers/ProviderService.test.ts
@@ -333,6 +333,62 @@ it.effect("ProviderServiceLive rejects new sessions for disabled providers", ()
);
const routing = makeProviderServiceLayer();
+
+it.effect("ProviderServiceLive writes canonical events to the emitting thread segment", () =>
+ Effect.gen(function* () {
+ const codex = makeFakeCodexAdapter();
+ const canonicalEvents: ProviderRuntimeEvent[] = [];
+ const canonicalThreadIds: Array<string | null> = [];
+ const registry: typeof ProviderAdapterRegistry.Service = {
+ getByProvider: (provider) =>
+ provider === "codex"
+ ? Effect.succeed(codex.adapter)
+ : Effect.fail(new ProviderUnsupportedError({ provider })),
+ listProviders: () => Effect.succeed(["codex"]),
+ };
+ const runtimeRepositoryLayer = ProviderSessionRuntimeRepositoryLive.pipe(
+ Layer.provide(SqlitePersistenceMemory),
+ );
+ const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer));
+ const providerLayer = makeProviderServiceLive({
+ canonicalEventLogger: {
+ filePath: "memory://provider-canonical-events",
+ write: (event, threadId) => {
+ canonicalEvents.push(event as ProviderRuntimeEvent);
+ canonicalThreadIds.push(threadId ?? null);
+ return Effect.void;
+ },
+ close: () => Effect.void,
+ },
+ }).pipe(
+ Layer.provide(Layer.succeed(ProviderAdapterRegistry, registry)),
+ Layer.provide(directoryLayer),
+ Layer.provide(defaultServerSettingsLayer),
+ Layer.provide(AnalyticsService.layerTest),
+ );
+
+ yield* Effect.gen(function* () {
+ yield* ProviderService;
+ yield* sleep(10);
+ codex.emit({
+ eventId: asEventId("evt-canonical-thread-segment"),
+ provider: "codex",
+ threadId: asThreadId("thread-canonical-thread-segment"),
+ createdAt: new Date().toISOString(),
+ type: "turn.completed",
+ payload: {
+ state: "completed",
+ },
+ });
+ yield* sleep(20);
+ }).pipe(Effect.provide(providerLayer));
+
+ assert.equal(canonicalEvents.length, 1);
+ assert.equal(canonicalEvents[0]?.threadId, "thread-canonical-thread-segment");
+ assert.deepEqual(canonicalThreadIds, ["thread-canonical-thread-segment"]);
+ }).pipe(Effect.provide(NodeServices.layer)),
+);
+
it.effect("ProviderServiceLive keeps persisted resumable sessions on startup", () =>
Effect.gen(function* () {
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3-provider-service-"));
diff --git a/apps/server/src/provider/Layers/ProviderService.ts b/apps/server/src/provider/Layers/ProviderService.ts
index 20479b238..a38a24655 100644
--- a/apps/server/src/provider/Layers/ProviderService.ts
+++ b/apps/server/src/provider/Layers/ProviderService.ts
@@ -161,7 +161,9 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
const publishRuntimeEvent = (event: ProviderRuntimeEvent): Effect.Effect<void> =>
Effect.succeed(event).pipe(
Effect.tap((canonicalEvent) =>
- canonicalEventLogger ? canonicalEventLogger.write(canonicalEvent, null) : Effect.void,
+ canonicalEventLogger
+ ? canonicalEventLogger.write(canonicalEvent, canonicalEvent.threadId)
+ : Effect.void,
),
Effect.flatMap((canonicalEvent) => PubSub.publish(runtimeEventPubSub, canonicalEvent)),
Effect.asVoid,
diff --git a/apps/server/src/provider/Layers/ProviderSessionDirectory.ts b/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
index b9d2439ee..660446a62 100644
--- a/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
+++ b/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
@@ -24,7 +24,7 @@ function decodeProviderKind(
providerName: string,
operation: string,
): Effect.Effect<ProviderKind, ProviderSessionDirectoryPersistenceError> {
- if (providerName === "codex" || providerName === "claudeAgent") {
+ if (providerName === "codex" || providerName === "claudeAgent" || providerName === "opencode") {
return Effect.succeed(providerName);
}
return Effect.fail(
diff --git a/apps/server/src/provider/Services/OpenCodeAdapter.ts b/apps/server/src/provider/Services/OpenCodeAdapter.ts
new file mode 100644
index 000000000..ad5660022
--- /dev/null
+++ b/apps/server/src/provider/Services/OpenCodeAdapter.ts
@@ -0,0 +1,12 @@
+import { Context } from "effect";
+
+import type { ProviderAdapterError } from "../Errors.ts";
+import type { ProviderAdapterShape } from "./ProviderAdapter.ts";
+
+export interface OpenCodeAdapterShape extends ProviderAdapterShape<ProviderAdapterError> {
+ readonly provider: "opencode";
+}
+
+export class OpenCodeAdapter extends Context.Service<OpenCodeAdapter, OpenCodeAdapterShape>()(
+ "t3/provider/Services/OpenCodeAdapter",
+) {}
diff --git a/apps/server/src/provider/Services/OpenCodeProvider.ts b/apps/server/src/provider/Services/OpenCodeProvider.ts
new file mode 100644
index 000000000..a799830ee
--- /dev/null
+++ b/apps/server/src/provider/Services/OpenCodeProvider.ts
@@ -0,0 +1,9 @@
+import { Context } from "effect";
+
+import type { ServerProviderShape } from "./ServerProvider.ts";
+
+export interface OpenCodeProviderShape extends ServerProviderShape {}
+
+export class OpenCodeProvider extends Context.Service<OpenCodeProvider, OpenCodeProviderShape>()(
+ "t3/provider/Services/OpenCodeProvider",
+) {}
diff --git a/apps/server/src/provider/opencodeRuntime.test.ts b/apps/server/src/provider/opencodeRuntime.test.ts
new file mode 100644
index 000000000..0ea63f8d5
--- /dev/null
+++ b/apps/server/src/provider/opencodeRuntime.test.ts
@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+
+import { describe, it, vi } from "vitest";
+
+const childProcessMock = vi.hoisted(() => ({
+ execFileSync: vi.fn((command: string, args: ReadonlyArray<string>) => {
+ if (command === "which" && args[0] === "opencode") {
+ return "/opt/homebrew/bin/opencode\n";
+ }
+ return "";
+ }),
+ spawn: vi.fn(),
+}));
+
+vi.mock("node:child_process", () => childProcessMock);
+
+describe("resolveOpenCodeBinaryPath", () => {
+ it("returns absolute binary paths without PATH lookup", async () => {
+ const { resolveOpenCodeBinaryPath } = await import("./opencodeRuntime.ts");
+
+ assert.equal(resolveOpenCodeBinaryPath("/usr/local/bin/opencode"), "/usr/local/bin/opencode");
+ assert.equal(childProcessMock.execFileSync.mock.calls.length, 0);
+ });
+
+ it("resolves command names through PATH", async () => {
+ const { resolveOpenCodeBinaryPath } = await import("./opencodeRuntime.ts");
+
+ assert.equal(resolveOpenCodeBinaryPath("opencode"), "/opt/homebrew/bin/opencode");
+ assert.deepEqual(childProcessMock.execFileSync.mock.calls[0], [
+ "which",
+ ["opencode"],
+ {
+ encoding: "utf8",
+ timeout: 3_000,
+ },
+ ]);
+ });
+});
diff --git a/apps/server/src/provider/opencodeRuntime.ts b/apps/server/src/provider/opencodeRuntime.ts
new file mode 100644
index 000000000..4778f6eac
--- /dev/null
+++ b/apps/server/src/provider/opencodeRuntime.ts
@@ -0,0 +1,573 @@
+import { execFileSync, spawn, type ChildProcess } from "node:child_process";
+import * as FS from "node:fs";
+import { createServer, type AddressInfo } from "node:net";
+import * as OS from "node:os";
+import * as Path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type {
+ ChatAttachment,
+ ModelCapabilities,
+ ProviderApprovalDecision,
+ RuntimeMode,
+ ServerProviderModel,
+} from "@t3tools/contracts";
+import {
+ createOpencodeClient,
+ type Agent,
+ type FilePartInput,
+ type OpencodeClient,
+ type PermissionRuleset,
+ type ProviderListResponse,
+ type QuestionAnswer,
+ type QuestionRequest,
+} from "@opencode-ai/sdk/v2";
+
+const OPENCODE_SERVER_READY_PREFIX = "opencode server listening";
+const DEFAULT_OPENCODE_SERVER_TIMEOUT_MS = 5_000;
+const DEFAULT_HOSTNAME = "127.0.0.1";
+
+const OPENAI_VARIANTS = ["none", "minimal", "low", "medium", "high", "xhigh"];
+const ANTHROPIC_VARIANTS = ["high", "max"];
+const GOOGLE_VARIANTS = ["low", "high"];
+
+export const DEFAULT_OPENCODE_MODEL_CAPABILITIES: ModelCapabilities = {
+ reasoningEffortLevels: [],
+ supportsFastMode: false,
+ supportsThinkingToggle: false,
+ contextWindowOptions: [],
+ promptInjectedEffortLevels: [],
+};
+
+export interface OpenCodeServerProcess {
+ readonly url: string;
+ readonly process: ChildProcess;
+ close(): void;
+}
+
+export interface OpenCodeServerConnection {
+ readonly url: string;
+ readonly process: ChildProcess | null;
+ readonly external: boolean;
+ close(): void;
+}
+
+function buildOpenCodeBasicAuthorizationHeader(password: string): string {
+ return `Basic ${Buffer.from(`opencode:${password}`, "utf8").toString("base64")}`;
+}
+
+export interface OpenCodeCommandResult {
+ readonly stdout: string;
+ readonly stderr: string;
+ readonly code: number;
+}
+
+export interface OpenCodeInventory {
+ readonly providerList: ProviderListResponse;
+ readonly agents: ReadonlyArray<Agent>;
+}
+
+export interface ParsedOpenCodeModelSlug {
+ readonly providerID: string;
+ readonly modelID: string;
+}
+
+function titleCaseSlug(value: string): string {
+ return value
+ .split(/[-_/]+/)
+ .filter((segment) => segment.length > 0)
+ .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+ .join(" ");
+}
+
+function parseServerUrlFromOutput(output: string): string | null {
+ for (const line of output.split("\n")) {
+ if (!line.startsWith(OPENCODE_SERVER_READY_PREFIX)) {
+ continue;
+ }
+ const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
+ return match?.[1] ?? null;
+ }
+ return null;
+}
+
+function isPrimaryAgent(agent: Agent): boolean {
+ return !agent.hidden && (agent.mode === "primary" || agent.mode === "all");
+}
+
+function inferVariantValues(providerID: string): ReadonlyArray<string> {
+ if (providerID === "anthropic") {
+ return ANTHROPIC_VARIANTS;
+ }
+ if (providerID === "openai" || providerID === "opencode") {
+ return OPENAI_VARIANTS;
+ }
+ if (providerID.startsWith("google")) {
+ return GOOGLE_VARIANTS;
+ }
+ return [];
+}
+
+function inferDefaultVariant(
+ providerID: string,
+ variants: ReadonlyArray<string>,
+): string | undefined {
+ if (variants.length === 1) {
+ return variants[0];
+ }
+ if (providerID === "anthropic" || providerID.startsWith("google")) {
+ return variants.includes("high") ? "high" : undefined;
+ }
+ if (providerID === "openai" || providerID === "opencode") {
+ return variants.includes("medium") ? "medium" : variants.includes("high") ? "high" : undefined;
+ }
+ return undefined;
+}
+
+function buildVariantOptions(
+ providerID: string,
+ model: ProviderListResponse["all"][number]["models"][string],
+) {
+ const variantValues = Object.keys(model.variants ?? {});
+ const resolvedValues =
+ variantValues.length > 0 ? variantValues : [...inferVariantValues(providerID)];
+ const defaultVariant = inferDefaultVariant(providerID, resolvedValues);
+
+ return resolvedValues.map((value) => {
+ const option: { value: string; label: string; isDefault?: boolean } = {
+ value,
+ label: titleCaseSlug(value),
+ };
+ if (defaultVariant === value) {
+ option.isDefault = true;
+ }
+ return option;
+ });
+}
+
+function buildAgentOptions(agents: ReadonlyArray<Agent>) {
+ const primaryAgents = agents.filter(isPrimaryAgent);
+ const defaultAgent =
+ primaryAgents.find((agent) => agent.name === "build")?.name ??
+ primaryAgents[0]?.name ??
+ undefined;
+ return primaryAgents.map((agent) => {
+ const option: { value: string; label: string; isDefault?: boolean } = {
+ value: agent.name,
+ label: titleCaseSlug(agent.name),
+ };
+ if (defaultAgent === agent.name) {
+ option.isDefault = true;
+ }
+ return option;
+ });
+}
+
+function openCodeCapabilitiesForModel(input: {
+ readonly providerID: string;
+ readonly model: ProviderListResponse["all"][number]["models"][string];
+ readonly agents: ReadonlyArray<Agent>;
+}): ModelCapabilities {
+ const variantOptions = buildVariantOptions(input.providerID, input.model);
+ const agentOptions = buildAgentOptions(input.agents);
+ return {
+ ...DEFAULT_OPENCODE_MODEL_CAPABILITIES,
+ ...(variantOptions.length > 0 ? { variantOptions } : {}),
+ ...(agentOptions.length > 0 ? { agentOptions } : {}),
+ };
+}
+
+export function parseOpenCodeModelSlug(
+ slug: string | null | undefined,
+): ParsedOpenCodeModelSlug | null {
+ if (typeof slug !== "string") {
+ return null;
+ }
+
+ const trimmed = slug.trim();
+ const separator = trimmed.indexOf("/");
+ if (separator <= 0 || separator === trimmed.length - 1) {
+ return null;
+ }
+
+ return {
+ providerID: trimmed.slice(0, separator),
+ modelID: trimmed.slice(separator + 1),
+ };
+}
+
+export function toOpenCodeModelSlug(providerID: string, modelID: string): string {
+ return `${providerID}/${modelID}`;
+}
+
+export function openCodeQuestionId(
+ index: number,
+ question: QuestionRequest["questions"][number],
+): string {
+ const header = question.header
+ .trim()
+ .toLowerCase()
+ .replace(/[^a-z0-9_-]+/g, "-");
+ return header.length > 0 ? `question-${index}-${header}` : `question-${index}`;
+}
+
+export function toOpenCodeFileParts(input: {
+ readonly attachments: ReadonlyArray<ChatAttachment> | undefined;
+ readonly resolveAttachmentPath: (attachment: ChatAttachment) => string | null;
+}): Array<FilePartInput> {
+ const parts: Array<FilePartInput> = [];
+
+ for (const attachment of input.attachments ?? []) {
+ const attachmentPath = input.resolveAttachmentPath(attachment);
+ if (!attachmentPath) {
+ continue;
+ }
+
+ parts.push({
+ type: "file",
+ mime: attachment.mimeType,
+ filename: attachment.name,
+ url: pathToFileURL(attachmentPath).href,
+ });
+ }
+
+ return parts;
+}
+
+export function buildOpenCodePermissionRules(runtimeMode: RuntimeMode): PermissionRuleset {
+ if (runtimeMode === "full-access") {
+ return [{ permission: "*", pattern: "*", action: "allow" }];
+ }
+
+ return [
+ { permission: "*", pattern: "*", action: "ask" },
+ { permission: "bash", pattern: "*", action: "ask" },
+ { permission: "edit", pattern: "*", action: "ask" },
+ { permission: "webfetch", pattern: "*", action: "ask" },
+ { permission: "websearch", pattern: "*", action: "ask" },
+ { permission: "codesearch", pattern: "*", action: "ask" },
+ { permission: "external_directory", pattern: "*", action: "ask" },
+ { permission: "doom_loop", pattern: "*", action: "ask" },
+ { permission: "question", pattern: "*", action: "allow" },
+ ];
+}
+
+export function toOpenCodePermissionReply(
+ decision: ProviderApprovalDecision,
+): "once" | "always" | "reject" {
+ switch (decision) {
+ case "accept":
+ return "once";
+ case "acceptForSession":
+ return "always";
+ case "decline":
+ case "cancel":
+ default:
+ return "reject";
+ }
+}
+
+export function toOpenCodeQuestionAnswers(
+ request: QuestionRequest,
+ answers: Record<string, unknown>,
+): Array<QuestionAnswer> {
+ return request.questions.map((question, index) => {
+ const raw =
+ answers[openCodeQuestionId(index, question)] ??
+ answers[question.header] ??
+ answers[question.question];
+ if (Array.isArray(raw)) {
+ return raw.filter((value): value is string => typeof value === "string");
+ }
+ if (typeof raw === "string") {
+ return raw.trim().length > 0 ? [raw] : [];
+ }
+ return [];
+ });
+}
+
+export async function findAvailablePort(): Promise<number> {
+ const server = createServer();
+ await new Promise<void>((resolve, reject) => {
+ server.once("error", reject);
+ server.listen(0, DEFAULT_HOSTNAME, () => resolve());
+ });
+ const address = server.address() as AddressInfo;
+ const port = address.port;
+ await new Promise<void>((resolve, reject) => {
+ server.close((error) => (error ? reject(error) : resolve()));
+ });
+ return port;
+}
+
+export function resolveOpenCodeBinaryPath(binaryPath: string): string {
+ if (Path.isAbsolute(binaryPath)) {
+ return binaryPath;
+ }
+ return execFileSync("which", [binaryPath], {
+ encoding: "utf8",
+ timeout: 3_000,
+ }).trim();
+}
+
+export function detectMacosSigkillHint(binaryPath: string): string | null {
+ try {
+ // Check for quarantine xattr first.
+ const resolvedPath = resolveOpenCodeBinaryPath(binaryPath);
+ const xattr = execFileSync("xattr", ["-l", resolvedPath], {
+ encoding: "utf8",
+ timeout: 3_000,
+ });
+ if (xattr.includes("com.apple.quarantine")) {
+ return (
+ `macOS quarantine is blocking the OpenCode binary. ` +
+ `Run: xattr -d com.apple.quarantine ${resolvedPath}`
+ );
+ }
+
+ // Look for a recent crash report with the termination reason.
+ const crashDir = Path.join(OS.homedir(), "Library/Logs/DiagnosticReports");
+ const binaryName = Path.basename(resolvedPath);
+ const recentReports = FS.readdirSync(crashDir)
+ .filter((f) => f.startsWith(binaryName) && f.endsWith(".ips"))
+ .toSorted()
+ .toReversed()
+ .slice(0, 1);
+
+ for (const report of recentReports) {
+ const content = FS.readFileSync(Path.join(crashDir, report), "utf8");
+ if (content.includes('"namespace":"CODESIGNING"')) {
+ return (
+ "macOS killed the process due to an invalid code signature. " +
+ "The binary may be corrupted — try reinstalling OpenCode."
+ );
+ }
+ }
+ } catch {
+ // Best-effort detection — don't fail the original error path.
+ }
+ return null;
+}
+
+export async function startOpenCodeServerProcess(input: {
+ readonly binaryPath: string;
+ readonly port?: number;
+ readonly hostname?: string;
+ readonly timeoutMs?: number;
+}): Promise<OpenCodeServerProcess> {
+ const hostname = input.hostname ?? DEFAULT_HOSTNAME;
+ const port = input.port ?? (await findAvailablePort());
+ const timeoutMs = input.timeoutMs ?? DEFAULT_OPENCODE_SERVER_TIMEOUT_MS;
+ const args = ["serve", `--hostname=${hostname}`, `--port=${port}`];
+ const child = spawn(input.binaryPath, args, {
+ stdio: ["ignore", "pipe", "pipe"],
+ env: {
+ ...process.env,
+ OPENCODE_CONFIG_CONTENT: JSON.stringify({}),
+ },
+ });
+
+ child.stdout.setEncoding("utf8");
+ child.stderr.setEncoding("utf8");
+
+ let stdout = "";
+ let stderr = "";
+ let closed = false;
+ const close = () => {
+ if (closed) {
+ return;
+ }
+ closed = true;
+ child.kill();
+ };
+
+ const url = await new Promise<string>((resolve, reject) => {
+ const timeout = setTimeout(() => {
+ close();
+ reject(new Error(`Timed out waiting for OpenCode server start after ${timeoutMs}ms.`));
+ }, timeoutMs);
+
+ const cleanup = () => {
+ clearTimeout(timeout);
+ child.stdout.off("data", onStdout);
+ child.stderr.off("data", onStderr);
+ child.off("error", onError);
+ child.off("close", onClose);
+ };
+
+ const onStdout = (chunk: string) => {
+ stdout += chunk;
+ const parsed = parseServerUrlFromOutput(stdout);
+ if (!parsed) {
+ return;
+ }
+ cleanup();
+ resolve(parsed);
+ };
+
+ const onStderr = (chunk: string) => {
+ stderr += chunk;
+ };
+
+ const onError = (error: Error) => {
+ cleanup();
+ reject(error);
+ };
+
+ const onClose = (code: number | null, signal: NodeJS.Signals | null) => {
+ cleanup();
+ const exitReason = signal ? `signal: ${signal}` : `code: ${code ?? "unknown"}`;
+ const hint =
+ signal === "SIGKILL" && process.platform === "darwin"
+ ? detectMacosSigkillHint(input.binaryPath)
+ : null;
+ reject(
+ new Error(
+ [
+ `OpenCode server exited before startup completed (${exitReason}).`,
+ hint,
+ stdout.trim() ? `stdout:\n${stdout.trim()}` : null,
+ stderr.trim() ? `stderr:\n${stderr.trim()}` : null,
+ ]
+ .filter(Boolean)
+ .join("\n\n"),
+ ),
+ );
+ };
+
+ child.stdout.on("data", onStdout);
+ child.stderr.on("data", onStderr);
+ child.once("error", onError);
+ child.once("close", onClose);
+ });
+
+ return {
+ url,
+ process: child,
+ close,
+ };
+}
+
+export async function connectToOpenCodeServer(input: {
+ readonly binaryPath: string;
+ readonly serverUrl?: string | null;
+ readonly port?: number;
+ readonly hostname?: string;
+ readonly timeoutMs?: number;
+}): Promise<OpenCodeServerConnection> {
+ const serverUrl = input.serverUrl?.trim();
+ if (serverUrl) {
+ return {
+ url: serverUrl,
+ process: null,
+ external: true,
+ close() {},
+ };
+ }
+
+ const server = await startOpenCodeServerProcess({
+ binaryPath: input.binaryPath,
+ ...(input.port !== undefined ? { port: input.port } : {}),
+ ...(input.hostname !== undefined ? { hostname: input.hostname } : {}),
+ ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}),
+ });
+
+ return {
+ url: server.url,
+ process: server.process,
+ external: false,
+ close: () => server.close(),
+ };
+}
+
+export async function runOpenCodeCommand(input: {
+ readonly binaryPath: string;
+ readonly args: ReadonlyArray<string>;
+}): Promise<OpenCodeCommandResult> {
+ const child = spawn(input.binaryPath, [...input.args], {
+ stdio: ["ignore", "pipe", "pipe"],
+ shell: process.platform === "win32",
+ env: process.env,
+ });
+
+ child.stdout?.setEncoding("utf8");
+ child.stderr?.setEncoding("utf8");
+
+ const stdoutChunks: Array<string> = [];
+ const stderrChunks: Array<string> = [];
+
+ child.stdout?.on("data", (chunk: string) => stdoutChunks.push(chunk));
+ child.stderr?.on("data", (chunk: string) => stderrChunks.push(chunk));
+
+ const code = await new Promise<number>((resolve, reject) => {
+ child.once("error", reject);
+ child.once("exit", (exitCode) => resolve(exitCode ?? 0));
+ });
+
+ return {
+ stdout: stdoutChunks.join(""),
+ stderr: stderrChunks.join(""),
+ code,
+ };
+}
+
+export function createOpenCodeSdkClient(input: {
+ readonly baseUrl: string;
+ readonly directory: string;
+ readonly serverPassword?: string;
+}): OpencodeClient {
+ return createOpencodeClient({
+ baseUrl: input.baseUrl,
+ directory: input.directory,
+ ...(input.serverPassword
+ ? {
+ headers: {
+ Authorization: buildOpenCodeBasicAuthorizationHeader(input.serverPassword),
+ },
+ }
+ : {}),
+ throwOnError: true,
+ });
+}
+
+export async function loadOpenCodeInventory(client: OpencodeClient): Promise<OpenCodeInventory> {
+ const [providerListResult, agentsResult] = await Promise.all([
+ client.provider.list(),
+ client.app.agents(),
+ ]);
+ if (!providerListResult.data) {
+ throw new Error("OpenCode provider inventory was empty.");
+ }
+ return {
+ providerList: providerListResult.data,
+ agents: agentsResult.data ?? [],
+ };
+}
+
+export function flattenOpenCodeModels(
+ input: OpenCodeInventory,
+): ReadonlyArray<ServerProviderModel> {
+ const connected = new Set(input.providerList.connected);
+ const models: Array<ServerProviderModel> = [];
+
+ for (const provider of input.providerList.all) {
+ if (!connected.has(provider.id)) {
+ continue;
+ }
+
+ for (const model of Object.values(provider.models)) {
+ models.push({
+ slug: toOpenCodeModelSlug(provider.id, model.id),
+ name: `${provider.name} · ${model.name}`,
+ isCustom: false,
+ capabilities: openCodeCapabilitiesForModel({
+ providerID: provider.id,
+ model,
+ agents: input.agents,
+ }),
+ });
+ }
+ }
+
+ return models.toSorted((left, right) => left.name.localeCompare(right.name));
+}
diff --git a/apps/server/src/provider/providerSnapshot.test.ts b/apps/server/src/provider/providerSnapshot.test.ts
new file mode 100644
index 000000000..0a0d31ccb
--- /dev/null
+++ b/apps/server/src/provider/providerSnapshot.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import type { ModelCapabilities } from "@t3tools/contracts";
+
+import { providerModelsFromSettings } from "./providerSnapshot.ts";
+
+const OPENCODE_CUSTOM_MODEL_CAPABILITIES: ModelCapabilities = {
+ reasoningEffortLevels: [],
+ supportsFastMode: false,
+ supportsThinkingToggle: false,
+ contextWindowOptions: [],
+ promptInjectedEffortLevels: [],
+ variantOptions: [{ value: "medium", label: "Medium", isDefault: true }],
+ agentOptions: [{ value: "build", label: "Build", isDefault: true }],
+};
+
+describe("providerModelsFromSettings", () => {
+ it("applies the provided capabilities to custom models", () => {
+ const models = providerModelsFromSettings(
+ [],
+ "opencode",
+ ["openai/gpt-5"],
+ OPENCODE_CUSTOM_MODEL_CAPABILITIES,
+ );
+
+ expect(models).toEqual([
+ {
+ slug: "openai/gpt-5",
+ name: "openai/gpt-5",
+ isCustom: true,
+ capabilities: OPENCODE_CUSTOM_MODEL_CAPABILITIES,
+ },
+ ]);
+ });
+});
diff --git a/apps/server/src/provider/providerStatusCache.test.ts b/apps/server/src/provider/providerStatusCache.test.ts
index a82cb4ae5..6722f1ac0 100644
--- a/apps/server/src/provider/providerStatusCache.test.ts
+++ b/apps/server/src/provider/providerStatusCache.test.ts
@@ -37,6 +37,10 @@ it.layer(NodeServices.layer)("providerStatusCache", (it) => {
status: "warning",
auth: { status: "unknown" },
});
+ const openCodeProvider = makeProvider("opencode", {
+ status: "warning",
+ auth: { status: "unknown", type: "opencode" },
+ });
const codexPath = resolveProviderStatusCachePath({
cacheDir: tempDir,
provider: "codex",
@@ -45,6 +49,10 @@ it.layer(NodeServices.layer)("providerStatusCache", (it) => {
cacheDir: tempDir,
provider: "claudeAgent",
});
+ const openCodePath = resolveProviderStatusCachePath({
+ cacheDir: tempDir,
+ provider: "opencode",
+ });
yield* writeProviderStatusCache({
filePath: codexPath,
@@ -54,9 +62,14 @@ it.layer(NodeServices.layer)("providerStatusCache", (it) => {
filePath: claudePath,
provider: claudeProvider,
});
+ yield* writeProviderStatusCache({
+ filePath: openCodePath,
+ provider: openCodeProvider,
+ });
assert.deepStrictEqual(yield* readProviderStatusCache(codexPath), codexProvider);
assert.deepStrictEqual(yield* readProviderStatusCache(claudePath), claudeProvider);
+ assert.deepStrictEqual(yield* readProviderStatusCache(openCodePath), openCodeProvider);
}),
);
diff --git a/apps/server/src/provider/providerStatusCache.ts b/apps/server/src/provider/providerStatusCache.ts
index abedf99d1..7e9ea7e9c 100644
--- a/apps/server/src/provider/providerStatusCache.ts
+++ b/apps/server/src/provider/providerStatusCache.ts
@@ -2,9 +2,11 @@ import * as nodePath from "node:path";
import { type ServerProvider, ServerProvider as ServerProviderSchema } from "@t3tools/contracts";
import { Cause, Effect, FileSystem, Path, Schema } from "effect";
-export const PROVIDER_CACHE_IDS = ["codex", "claudeAgent"] as const satisfies ReadonlyArray<
- ServerProvider["provider"]
->;
+export const PROVIDER_CACHE_IDS = [
+ "codex",
+ "claudeAgent",
+ "opencode",
+] as const satisfies ReadonlyArray<ServerProvider["provider"]>;
const decodeProviderStatusCache = Schema.decodeUnknownEffect(
Schema.fromJsonString(ServerProviderSchema),
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 50d2d62aa..4ae4a4fb7 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -21,6 +21,7 @@ import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionD
import { ProviderSessionRuntimeRepositoryLive } from "./persistence/Layers/ProviderSessionRuntime.ts";
import { makeCodexAdapterLive } from "./provider/Layers/CodexAdapter.ts";
import { makeClaudeAdapterLive } from "./provider/Layers/ClaudeAdapter.ts";
+import { makeOpenCodeAdapterLive } from "./provider/Layers/OpenCodeAdapter.ts";
import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry.ts";
import { makeProviderServiceLive } from "./provider/Layers/ProviderService.ts";
import { ProviderSessionReaperLive } from "./provider/Layers/ProviderSessionReaper.ts";
@@ -154,9 +155,13 @@ const ProviderLayerLive = Layer.unwrap(
const claudeAdapterLayer = makeClaudeAdapterLive(
nativeEventLogger ? { nativeEventLogger } : undefined,
);
+ const openCodeAdapterLayer = makeOpenCodeAdapterLive(
+ nativeEventLogger ? { nativeEventLogger } : undefined,
+ );
const adapterRegistryLayer = ProviderAdapterRegistryLive.pipe(
Layer.provide(codexAdapterLayer),
Layer.provide(claudeAdapterLayer),
+ Layer.provide(openCodeAdapterLayer),
Layer.provideMerge(ProviderSessionDirectoryLayerLive),
);
return makeProviderServiceLive(
diff --git a/apps/server/src/serverSettings.test.ts b/apps/server/src/serverSettings.test.ts
index 406e1e850..655ede944 100644
--- a/apps/server/src/serverSettings.test.ts
+++ b/apps/server/src/serverSettings.test.ts
@@ -184,6 +184,11 @@ it.layer(NodeServices.layer)("server settings", (it) => {
claudeAgent: {
binaryPath: " /opt/homebrew/bin/claude ",
},
+ opencode: {
+ binaryPath: " /opt/homebrew/bin/opencode ",
+ serverUrl: " http://127.0.0.1:4096 ",
+ serverPassword: " secret-password ",
+ },
},
});
@@ -199,6 +204,13 @@ it.layer(NodeServices.layer)("server settings", (it) => {
customModels: [],
launchArgs: "",
});
+ assert.deepEqual(next.providers.opencode, {
+ enabled: true,
+ binaryPath: "/opt/homebrew/bin/opencode",
+ serverUrl: "http://127.0.0.1:4096",
+ serverPassword: "secret-password",
+ customModels: [],
+ });
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
@@ -257,6 +269,10 @@ it.layer(NodeServices.layer)("server settings", (it) => {
codex: {
binaryPath: "/opt/homebrew/bin/codex",
},
+ opencode: {
+ serverUrl: "http://127.0.0.1:4096",
+ serverPassword: "secret-password",
+ },
},
});
@@ -273,6 +289,10 @@ it.layer(NodeServices.layer)("server settings", (it) => {
codex: {
binaryPath: "/opt/homebrew/bin/codex",
},
+ opencode: {
+ serverUrl: "http://127.0.0.1:4096",
+ serverPassword: "secret-password",
+ },
},
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.ts
index d5636d5c0..b18250e44 100644
--- a/apps/server/src/serverSettings.ts
+++ b/apps/server/src/serverSettings.ts
@@ -105,7 +105,7 @@ export class ServerSettingsService extends Context.Service<
const ServerSettingsJson = fromLenientJson(ServerSettings);
-const PROVIDER_ORDER: readonly ProviderKind[] = ["codex", "claudeAgent"];
+const PROVIDER_ORDER: readonly ProviderKind[] = ["codex", "claudeAgent", "opencode"];
/**
* Ensure the `textGenerationModelSelection` points to an enabled provider.
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 7890bc0dc..06d8e8db5 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -26,7 +26,7 @@ import {
scopeProjectRef,
scopeThreadRef,
} from "@t3tools/client-runtime";
-import { applyClaudePromptEffortPrefix } from "@t3tools/shared/model";
+import { applyClaudePromptEffortPrefix, createModelSelection } from "@t3tools/shared/model";
import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";
import { truncate } from "@t3tools/shared/String";
import { Debouncer } from "@tanstack/react-pacer";
@@ -2534,16 +2534,13 @@ export default function ChatView(props: ChatViewProps) {
}
}
const title = truncate(titleSeed);
- const threadCreateModelSelection: ModelSelection = {
- provider: ctxSelectedProvider,
- model:
- ctxSelectedModel ||
+ const threadCreateModelSelection = createModelSelection(
+ ctxSelectedProvider,
+ ctxSelectedModel ||
activeProject.defaultModelSelection?.model ||
DEFAULT_MODEL_BY_PROVIDER.codex,
- ...(ctxSelectedModelSelection.options
- ? { options: ctxSelectedModelSelection.options }
- : {}),
- };
+ ctxSelectedModelSelection.options,
+ );
// Auto-title from first message
if (isFirstMessage && isServerThread) {
diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsx
index a1299c3e2..9a7ac5fbb 100644
--- a/apps/web/src/components/Icons.tsx
+++ b/apps/web/src/components/Icons.tsx
@@ -553,8 +553,10 @@ export const IntelliJIdeaIcon: Icon = (props) => {
export const OpenCodeIcon: Icon = (props) => (
<svg {...props} viewBox="0 0 32 40" fill="none" xmlns="http://www.w3.org/2000/svg">
<g clipPath="url(#opencode__clip0_1311_94969)">
- <path d="M24 32H8V16H24V32Z" fill="#BCBBBB" />
- <path d="M24 8H8V32H24V8ZM32 40H0V0H32V40Z" fill="#211E1E" />
+ <path className="dark:hidden" d="M24 32H8V16H24V32Z" fill="#CFCECD" />
+ <path className="dark:hidden" d="M24 8H8V32H24V8ZM32 40H0V0H32V40Z" fill="#211E1E" />
+ <path className="hidden dark:block" d="M24 32H8V16H24V32Z" fill="#4B4646" />
+ <path className="hidden dark:block" d="M24 8H8V32H24V8ZM32 40H0V0H32V40Z" fill="#F1ECEC" />
</g>
<defs>
<clipPath id="opencode__clip0_1311_94969">
diff --git a/apps/web/src/components/KeybindingsToast.browser.tsx b/apps/web/src/components/KeybindingsToast.browser.tsx
index 6449a7158..c72ebecae 100644
--- a/apps/web/src/components/KeybindingsToast.browser.tsx
+++ b/apps/web/src/components/KeybindingsToast.browser.tsx
@@ -99,6 +99,13 @@ function createBaseServerConfig(): ServerConfig {
providers: {
codex: { enabled: true, binaryPath: "", homePath: "", customModels: [] },
claudeAgent: { enabled: true, binaryPath: "", customModels: [], launchArgs: "" },
+ opencode: {
+ enabled: true,
+ binaryPath: "",
+ serverUrl: "",
+ serverPassword: "",
+ customModels: [],
+ },
},
},
};
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index f1663901c..80e80e4f8 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -16,7 +16,7 @@ import {
PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
} from "@t3tools/contracts";
-import { normalizeModelSlug } from "@t3tools/shared/model";
+import { createModelSelection, normalizeModelSlug } from "@t3tools/shared/model";
import {
forwardRef,
memo,
@@ -70,6 +70,7 @@ import { ComposerPlanFollowUpBanner } from "./ComposerPlanFollowUpBanner";
import { resolveComposerMenuActiveItemId } from "./composerMenuHighlight";
import { searchSlashCommandItems } from "./composerSlashCommandSearch";
import {
+ getComposerProviderControls,
getComposerProviderState,
renderProviderTraitsMenuContent,
renderProviderTraitsPicker,
@@ -159,6 +160,7 @@ const terminalContextIdListsEqual = (
contexts.length === ids.length && contexts.every((context, index) => context.id === ids[index]);
const ComposerFooterModeControls = memo(function ComposerFooterModeControls(props: {
+ showInteractionModeToggle: boolean;
interactionMode: ProviderInteractionMode;
runtimeMode: RuntimeMode;
showPlanToggle: boolean;
@@ -175,25 +177,29 @@ const ComposerFooterModeControls = memo(function ComposerFooterModeControls(prop
<>
<Separator orientation="vertical" className="mx-0.5 hidden h-4 sm:block" />
- <Button
- variant="ghost"
- className="shrink-0 whitespace-nowrap px-2 text-muted-foreground/70 hover:text-foreground/80 sm:px-3"
- size="sm"
- type="button"
- onClick={props.onToggleInteractionMode}
- title={
- props.interactionMode === "plan"
- ? "Plan mode — click to return to normal build mode"
- : "Default mode — click to enter plan mode"
- }
- >
- <BotIcon />
- <span className="sr-only sm:not-sr-only">
- {props.interactionMode === "plan" ? "Plan" : "Build"}
- </span>
- </Button>
+ {props.showInteractionModeToggle ? (
+ <>
+ <Button
+ variant="ghost"
+ className="shrink-0 whitespace-nowrap px-2 text-muted-foreground/70 hover:text-foreground/80 sm:px-3"
+ size="sm"
+ type="button"
+ onClick={props.onToggleInteractionMode}
+ title={
+ props.interactionMode === "plan"
+ ? "Plan mode — click to return to normal build mode"
+ : "Default mode — click to enter plan mode"
+ }
+ >
+ <BotIcon />
+ <span className="sr-only sm:not-sr-only">
+ {props.interactionMode === "plan" ? "Plan" : "Build"}
+ </span>
+ </Button>
- <Separator orientation="vertical" className="mx-0.5 hidden h-4 sm:block" />
+ <Separator orientation="vertical" className="mx-0.5 hidden h-4 sm:block" />
+ </>
+ ) : null}
<Select
value={props.runtimeMode}
@@ -588,12 +594,12 @@ export const ChatComposer = memo(
const selectedPromptEffort = composerProviderState.promptEffort;
const selectedModelOptionsForDispatch = composerProviderState.modelOptionsForDispatch;
+ const composerProviderControls = useMemo(
+ () => getComposerProviderControls(selectedProvider),
+ [selectedProvider],
+ );
const selectedModelSelection = useMemo<ModelSelection>(
- () => ({
- provider: selectedProvider,
- model: selectedModel,
- ...(selectedModelOptionsForDispatch ? { options: selectedModelOptionsForDispatch } : {}),
- }),
+ () => createModelSelection(selectedProvider, selectedModel, selectedModelOptionsForDispatch),
[selectedModel, selectedModelOptionsForDispatch, selectedProvider],
);
const selectedModelForPicker = selectedModel;
@@ -604,6 +610,8 @@ export const ChatComposer = memo(
codex: providerStatuses.find((provider) => provider.provider === "codex")?.models ?? [],
claudeAgent:
providerStatuses.find((provider) => provider.provider === "claudeAgent")?.models ?? [],
+ opencode:
+ providerStatuses.find((provider) => provider.provider === "opencode")?.models ?? [],
}),
[providerStatuses],
);
@@ -1933,6 +1941,7 @@ export const ChatComposer = memo(
planSidebarLabel={planSidebarLabel}
planSidebarOpen={planSidebarOpen}
runtimeMode={runtimeMode}
+ showInteractionModeToggle={composerProviderControls.showInteractionModeToggle}
traitsMenuContent={providerTraitsMenuContent}
onToggleInteractionMode={toggleInteractionMode}
onTogglePlanSidebar={togglePlanSidebar}
@@ -1950,6 +1959,9 @@ export const ChatComposer = memo(
</>
) : null}
<ComposerFooterModeControls
+ showInteractionModeToggle={
+ composerProviderControls.showInteractionModeToggle
+ }
interactionMode={interactionMode}
runtimeMode={runtimeMode}
showPlanToggle={showPlanSidebarToggle}
diff --git a/apps/web/src/components/chat/CompactComposerControlsMenu.browser.tsx b/apps/web/src/components/chat/CompactComposerControlsMenu.browser.tsx
index 86146cc17..7619a6355 100644
--- a/apps/web/src/components/chat/CompactComposerControlsMenu.browser.tsx
+++ b/apps/web/src/components/chat/CompactComposerControlsMenu.browser.tsx
@@ -126,6 +126,7 @@ async function mountMenu(props?: { modelSelection?: ModelSelection; prompt?: str
planSidebarLabel="Plan"
planSidebarOpen={false}
runtimeMode="approval-required"
+ showInteractionModeToggle
traitsMenuContent={
<TraitsMenuContent
provider={provider}
@@ -267,4 +268,38 @@ describe("CompactComposerControlsMenu", () => {
);
});
});
+
+ it("can hide the interaction mode section", async () => {
+ const host = document.createElement("div");
+ document.body.append(host);
+ const screen = await render(
+ <CompactComposerControlsMenu
+ activePlan={false}
+ interactionMode="default"
+ planSidebarLabel="Plan"
+ planSidebarOpen={false}
+ runtimeMode="approval-required"
+ showInteractionModeToggle={false}
+ onToggleInteractionMode={vi.fn()}
+ onTogglePlanSidebar={vi.fn()}
+ onRuntimeModeChange={vi.fn()}
+ />,
+ { container: host },
+ );
+
+ await page.getByLabelText("More composer controls").click();
+
+ await vi.waitFor(() => {
+ const text = document.body.textContent ?? "";
+ expect(text).not.toContain("Mode");
+ expect(text).not.toContain("Chat");
+ expect(text).not.toContain("Plan");
+ expect(text).toContain("Access");
+ expect(text).toContain("Supervised");
+ expect(text).toContain("Full access");
+ });
+
+ await screen.unmount();
+ host.remove();
+ });
});
diff --git a/apps/web/src/components/chat/CompactComposerControlsMenu.tsx b/apps/web/src/components/chat/CompactComposerControlsMenu.tsx
index 8024c2303..f1fbd193a 100644
--- a/apps/web/src/components/chat/CompactComposerControlsMenu.tsx
+++ b/apps/web/src/components/chat/CompactComposerControlsMenu.tsx
@@ -18,6 +18,7 @@ export const CompactComposerControlsMenu = memo(function CompactComposerControls
planSidebarLabel: string;
planSidebarOpen: boolean;
runtimeMode: RuntimeMode;
+ showInteractionModeToggle: boolean;
traitsMenuContent?: ReactNode;
onToggleInteractionMode: () => void;
onTogglePlanSidebar: () => void;
@@ -44,18 +45,22 @@ export const CompactComposerControlsMenu = memo(function CompactComposerControls
<MenuDivider />
</>
) : null}
- <div className="px-2 py-1.5 font-medium text-muted-foreground text-xs">Mode</div>
- <MenuRadioGroup
- value={props.interactionMode}
- onValueChange={(value) => {
- if (!value || value === props.interactionMode) return;
- props.onToggleInteractionMode();
- }}
- >
- <MenuRadioItem value="default">Chat</MenuRadioItem>
- <MenuRadioItem value="plan">Plan</MenuRadioItem>
- </MenuRadioGroup>
- <MenuDivider />
+ {props.showInteractionModeToggle ? (
+ <>
+ <div className="px-2 py-1.5 font-medium text-muted-foreground text-xs">Mode</div>
+ <MenuRadioGroup
+ value={props.interactionMode}
+ onValueChange={(value) => {
+ if (!value || value === props.interactionMode) return;
+ props.onToggleInteractionMode();
+ }}
+ >
+ <MenuRadioItem value="default">Chat</MenuRadioItem>
+ <MenuRadioItem value="plan">Plan</MenuRadioItem>
+ </MenuRadioGroup>
+ <MenuDivider />
+ </>
+ ) : null}
<div className="px-2 py-1.5 font-medium text-muted-foreground text-xs">Access</div>
<MenuRadioGroup
value={props.runtimeMode}
diff --git a/apps/web/src/components/chat/ProviderModelPicker.tsx b/apps/web/src/components/chat/ProviderModelPicker.tsx
index 01fa37516..8b20237a8 100644
--- a/apps/web/src/components/chat/ProviderModelPicker.tsx
+++ b/apps/web/src/components/chat/ProviderModelPicker.tsx
@@ -33,15 +33,13 @@ function isAvailableProviderOption(option: (typeof PROVIDER_OPTIONS)[number]): o
const PROVIDER_ICON_BY_PROVIDER: Record<ProviderPickerKind, Icon> = {
codex: OpenAI,
claudeAgent: ClaudeAI,
+ opencode: OpenCodeIcon,
cursor: CursorIcon,
};
export const AVAILABLE_PROVIDER_OPTIONS = PROVIDER_OPTIONS.filter(isAvailableProviderOption);
const UNAVAILABLE_PROVIDER_OPTIONS = PROVIDER_OPTIONS.filter((option) => !option.available);
-const COMING_SOON_PROVIDER_OPTIONS = [
- { id: "opencode", label: "OpenCode", icon: OpenCodeIcon },
- { id: "gemini", label: "Gemini", icon: Gemini },
-] as const;
+const COMING_SOON_PROVIDER_OPTIONS = [{ id: "gemini", label: "Gemini", icon: Gemini }] as const;
function providerIconClassName(
provider: ProviderKind | ProviderPickerKind,
diff --git a/apps/web/src/components/chat/TraitsPicker.browser.tsx b/apps/web/src/components/chat/TraitsPicker.browser.tsx
index 686a36b60..567fb5fee 100644
--- a/apps/web/src/components/chat/TraitsPicker.browser.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.browser.tsx
@@ -6,6 +6,7 @@ import {
CodexModelOptions,
DEFAULT_MODEL_BY_PROVIDER,
DEFAULT_SERVER_SETTINGS,
+ OpenCodeModelOptions,
EnvironmentId,
type ServerProvider,
ThreadId,
@@ -64,6 +65,39 @@ const TEST_PROVIDERS: ReadonlyArray<ServerProvider> = [
},
],
},
+ {
+ provider: "opencode",
+ enabled: true,
+ installed: true,
+ version: "0.1.0",
+ status: "ready",
+ auth: { status: "authenticated" },
+ checkedAt: "2026-01-01T00:00:00.000Z",
+ slashCommands: [],
+ skills: [],
+ models: [
+ {
+ slug: "openai/gpt-5",
+ name: "GPT-5",
+ isCustom: false,
+ capabilities: {
+ reasoningEffortLevels: [],
+ supportsFastMode: false,
+ supportsThinkingToggle: false,
+ contextWindowOptions: [],
+ promptInjectedEffortLevels: [],
+ variantOptions: [
+ { value: "low", label: "Low" },
+ { value: "medium", label: "Medium", isDefault: true },
+ ],
+ agentOptions: [
+ { value: "build", label: "Build", isDefault: true },
+ { value: "plan", label: "Plan" },
+ ],
+ },
+ },
+ ],
+ },
{
provider: "claudeAgent",
enabled: true,
@@ -125,6 +159,13 @@ const TEST_PROVIDERS: ReadonlyArray<ServerProvider> = [
],
},
];
+const findTestProvider = (provider: ServerProvider["provider"]) => {
+ const testProvider = TEST_PROVIDERS.find((candidate) => candidate.provider === provider);
+ if (!testProvider) {
+ throw new Error(`Missing test provider fixture: ${provider}`);
+ }
+ return testProvider;
+};
function ClaudeTraitsPickerHarness(props: {
model: string;
@@ -154,7 +195,7 @@ function ClaudeTraitsPickerHarness(props: {
return (
<TraitsPicker
provider="claudeAgent"
- models={TEST_PROVIDERS[1]!.models}
+ models={TEST_PROVIDERS[2]!.models}
threadRef={CLAUDE_THREAD_REF}
model={selectedModel ?? props.model}
prompt={prompt}
@@ -501,3 +542,89 @@ describe("TraitsPicker (Codex)", () => {
});
});
});
+
+// ── OpenCode TraitsPicker tests ───────────────────────────────────────
+
+async function mountOpenCodePicker(props: { model?: string; options?: OpenCodeModelOptions }) {
+ const threadId = ThreadId.make("thread-opencode-traits");
+ const threadRef = scopeThreadRef(LOCAL_ENVIRONMENT_ID, threadId);
+ const threadKey = scopedThreadKey(threadRef);
+ const model = props.model ?? DEFAULT_MODEL_BY_PROVIDER.opencode;
+ const draftsByThreadKey: Record<string, ComposerThreadDraftState> = {
+ [threadKey]: {
+ prompt: "",
+ images: [],
+ nonPersistedImageIds: [],
+ persistedAttachments: [],
+ terminalContexts: [],
+ modelSelectionByProvider: {
+ opencode: {
+ provider: "opencode",
+ model,
+ ...(props.options ? { options: props.options } : {}),
+ },
+ },
+ activeProvider: "opencode",
+ runtimeMode: null,
+ interactionMode: null,
+ },
+ };
+
+ useComposerDraftStore.setState({
+ draftsByThreadKey,
+ draftThreadsByThreadKey: {},
+ logicalProjectDraftThreadKeyByLogicalProjectKey: {},
+ });
+ const host = document.createElement("div");
+ document.body.append(host);
+ const screen = await render(
+ <TraitsPicker
+ provider="opencode"
+ models={findTestProvider("opencode").models}
+ threadRef={threadRef}
+ model={model}
+ prompt=""
+ modelOptions={props.options}
+ onPromptChange={() => {}}
+ />,
+ { container: host },
+ );
+
+ const cleanup = async () => {
+ await screen.unmount();
+ host.remove();
+ };
+
+ return {
+ [Symbol.asyncDispose]: cleanup,
+ cleanup,
+ };
+}
+
+describe("TraitsPicker (OpenCode)", () => {
+ afterEach(() => {
+ document.body.innerHTML = "";
+ localStorage.removeItem(COMPOSER_DRAFT_STORAGE_KEY);
+ useComposerDraftStore.setState({
+ draftsByThreadKey: {},
+ draftThreadsByThreadKey: {},
+ logicalProjectDraftThreadKeyByLogicalProjectKey: {},
+ stickyModelSelectionByProvider: {},
+ });
+ });
+
+ it("shows the selected agent label with capitalization in the trigger", async () => {
+ await using _ = await mountOpenCodePicker({
+ options: {
+ variant: "medium",
+ agent: "plan",
+ },
+ });
+
+ await vi.waitFor(() => {
+ const text = document.body.textContent ?? "";
+ expect(text).toContain("Medium · Plan");
+ expect(text).not.toContain("Medium · plan");
+ });
+ });
+});
diff --git a/apps/web/src/components/chat/TraitsPicker.tsx b/apps/web/src/components/chat/TraitsPicker.tsx
index 14b5cdfb3..bf2c1ff8c 100644
--- a/apps/web/src/components/chat/TraitsPicker.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.tsx
@@ -1,6 +1,7 @@
import {
type ClaudeModelOptions,
type CodexModelOptions,
+ type OpenCodeModelOptions,
type ProviderKind,
type ProviderModelOptions,
type ScopedThreadRef,
@@ -33,6 +34,12 @@ import { getProviderModelCapabilities } from "../../providerModels";
import { cn } from "~/lib/utils";
type ProviderOptions = ProviderModelOptions[ProviderKind];
+type NamedOption = {
+ value: string;
+ label: string;
+ isDefault?: boolean | undefined;
+};
+
type TraitsPersistence =
| {
threadRef?: ScopedThreadRef;
@@ -53,9 +60,29 @@ function getRawEffort(
if (provider === "codex") {
return trimOrNull((modelOptions as CodexModelOptions | undefined)?.reasoningEffort);
}
+ if (provider === "opencode") {
+ return trimOrNull((modelOptions as OpenCodeModelOptions | undefined)?.variant);
+ }
return trimOrNull((modelOptions as ClaudeModelOptions | undefined)?.effort);
}
+function getRawAgent(modelOptions: ProviderOptions | null | undefined): string | null {
+ return trimOrNull((modelOptions as OpenCodeModelOptions | undefined)?.agent);
+}
+
+function resolveNamedOption(
+ options: ReadonlyArray<NamedOption>,
+ raw: string | null,
+): NamedOption | null {
+ if (raw) {
+ const matchingOption = options.find((option) => option.value === raw);
+ if (matchingOption) {
+ return matchingOption;
+ }
+ }
+ return options.find((option) => option.isDefault) ?? null;
+}
+
function getRawContextWindow(
provider: ProviderKind,
modelOptions: ProviderOptions | null | undefined,
@@ -74,6 +101,12 @@ function buildNextOptions(
if (provider === "codex") {
return { ...(modelOptions as CodexModelOptions | undefined), ...patch } as CodexModelOptions;
}
+ if (provider === "opencode") {
+ return {
+ ...(modelOptions as OpenCodeModelOptions | undefined),
+ ...patch,
+ } as OpenCodeModelOptions;
+ }
return { ...(modelOptions as ClaudeModelOptions | undefined), ...patch } as ClaudeModelOptions;
}
@@ -86,15 +119,21 @@ function getSelectedTraits(
allowPromptInjectedEffort: boolean,
) {
const caps = getProviderModelCapabilities(models, model, provider);
- const effortLevels = allowPromptInjectedEffort
- ? caps.reasoningEffortLevels
- : caps.reasoningEffortLevels.filter(
- (option) => !caps.promptInjectedEffortLevels.includes(option.value),
- );
+ const effortLevels =
+ provider === "opencode"
+ ? (caps.variantOptions ?? [])
+ : allowPromptInjectedEffort
+ ? caps.reasoningEffortLevels
+ : caps.reasoningEffortLevels.filter(
+ (option) => !caps.promptInjectedEffortLevels.includes(option.value),
+ );
// Resolve effort from options (provider-specific key)
const rawEffort = getRawEffort(provider, modelOptions);
- const effort = resolveEffort(caps, rawEffort) ?? null;
+ const effort =
+ provider === "opencode"
+ ? (resolveNamedOption(effortLevels, rawEffort)?.value ?? null)
+ : (resolveEffort(caps, rawEffort) ?? null);
// Thinking toggle (only for models that support it)
const thinkingEnabled = caps.supportsThinkingToggle
@@ -125,6 +164,10 @@ function getSelectedTraits(
const ultrathinkInBodyText =
ultrathinkPromptControlled && isClaudeUltrathinkPrompt(prompt.replace(/^Ultrathink:\s*/i, ""));
+ const agentOptions = caps.agentOptions ?? [];
+ const selectedAgentOption =
+ provider === "opencode" ? resolveNamedOption(agentOptions, getRawAgent(modelOptions)) : null;
+
return {
caps,
effort,
@@ -136,6 +179,9 @@ function getSelectedTraits(
defaultContextWindow,
ultrathinkPromptControlled,
ultrathinkInBodyText,
+ agentOptions,
+ selectedAgent: selectedAgentOption?.value ?? null,
+ selectedAgentLabel: selectedAgentOption?.label ?? null,
};
}
@@ -189,6 +235,8 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
defaultContextWindow,
ultrathinkPromptControlled,
ultrathinkInBodyText,
+ agentOptions,
+ selectedAgent,
} = getSelectedTraits(provider, models, model, prompt, modelOptions, allowPromptInjectedEffort);
const defaultEffort = getDefaultEffort(caps);
@@ -197,6 +245,10 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
if (!value) return;
const nextOption = effortLevels.find((option) => option.value === value);
if (!nextOption) return;
+ if (provider === "opencode") {
+ updateModelOptions(buildNextOptions(provider, modelOptions, { variant: nextOption.value }));
+ return;
+ }
if (caps.promptInjectedEffortLevels.includes(nextOption.value)) {
const nextPrompt =
prompt.trim().length === 0
@@ -228,7 +280,12 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
],
);
- if (effort === null && thinkingEnabled === null && contextWindowOptions.length <= 1) {
+ if (
+ effort === null &&
+ thinkingEnabled === null &&
+ contextWindowOptions.length <= 1 &&
+ agentOptions.length === 0
+ ) {
return null;
}
@@ -237,7 +294,9 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
{effort ? (
<>
<MenuGroup>
- <div className="px-2 pt-1.5 pb-1 font-medium text-muted-foreground text-xs">Effort</div>
+ <div className="px-2 pt-1.5 pb-1 font-medium text-muted-foreground text-xs">
+ {provider === "opencode" ? "Variant" : "Effort"}
+ </div>
{ultrathinkInBodyText ? (
<div className="px-2 pb-1.5 text-muted-foreground/80 text-xs">
Your prompt contains &quot;ultrathink&quot; in the text. Remove it to change effort.
@@ -254,7 +313,9 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
disabled={ultrathinkInBodyText}
>
{option.label}
- {option.value === defaultEffort ? " (default)" : ""}
+ {(provider === "opencode" ? option.isDefault : option.value === defaultEffort)
+ ? " (default)"
+ : ""}
</MenuRadioItem>
))}
</MenuRadioGroup>
@@ -322,6 +383,27 @@ export const TraitsMenuContent = memo(function TraitsMenuContentImpl({
</MenuGroup>
</>
) : null}
+ {agentOptions.length > 0 ? (
+ <>
+ <MenuDivider />
+ <MenuGroup>
+ <div className="px-2 py-1.5 font-medium text-muted-foreground text-xs">Agent</div>
+ <MenuRadioGroup
+ value={selectedAgent ?? ""}
+ onValueChange={(value) => {
+ updateModelOptions(buildNextOptions(provider, modelOptions, { agent: value }));
+ }}
+ >
+ {agentOptions.map((option) => (
+ <MenuRadioItem key={option.value} value={option.value}>
+ {option.label}
+ {option.isDefault ? " (default)" : ""}
+ </MenuRadioItem>
+ ))}
+ </MenuRadioGroup>
+ </MenuGroup>
+ </>
+ ) : null}
</>
);
});
@@ -349,6 +431,7 @@ export const TraitsPicker = memo(function TraitsPicker({
contextWindow,
defaultContextWindow,
ultrathinkPromptControlled,
+ selectedAgentLabel,
} = getSelectedTraits(provider, models, model, prompt, modelOptions, allowPromptInjectedEffort);
const effortLabel = effort
@@ -368,6 +451,7 @@ export const TraitsPicker = memo(function TraitsPicker({
: `Thinking ${thinkingEnabled ? "On" : "Off"}`,
...(caps.supportsFastMode && fastModeEnabled ? ["Fast"] : []),
...(contextWindowLabel ? [contextWindowLabel] : []),
+ ...(selectedAgentLabel ? [selectedAgentLabel] : []),
]
.filter(Boolean)
.join(" · ");
diff --git a/apps/web/src/components/chat/composerProviderRegistry.test.tsx b/apps/web/src/components/chat/composerProviderRegistry.test.tsx
index 173511783..c4dd2cbb6 100644
--- a/apps/web/src/components/chat/composerProviderRegistry.test.tsx
+++ b/apps/web/src/components/chat/composerProviderRegistry.test.tsx
@@ -1,6 +1,7 @@
import { describe, expect, it } from "vitest";
import type { ServerProviderModel } from "@t3tools/contracts";
import {
+ getComposerProviderControls,
getComposerProviderState,
renderProviderTraitsMenuContent,
renderProviderTraitsPicker,
@@ -110,6 +111,29 @@ const CLAUDE_MODELS_WITH_CONTEXT_WINDOW: ReadonlyArray<ServerProviderModel> = [
},
];
+const OPENCODE_MODELS: ReadonlyArray<ServerProviderModel> = [
+ {
+ slug: "openai/gpt-5",
+ name: "GPT-5",
+ isCustom: false,
+ capabilities: {
+ reasoningEffortLevels: [],
+ supportsFastMode: false,
+ supportsThinkingToggle: false,
+ contextWindowOptions: [],
+ promptInjectedEffortLevels: [],
+ variantOptions: [
+ { value: "low", label: "Low" },
+ { value: "medium", label: "Medium", isDefault: true },
+ ],
+ agentOptions: [
+ { value: "build", label: "Build", isDefault: true },
+ { value: "plan", label: "Plan" },
+ ],
+ },
+ },
+];
+
describe("getComposerProviderState", () => {
it("returns codex defaults when no codex draft options exist", () => {
const state = getComposerProviderState({
@@ -420,6 +444,47 @@ describe("getComposerProviderState", () => {
expect(state.modelOptionsForDispatch).not.toHaveProperty("fastMode");
});
+
+ it("preserves OpenCode variant and agent options for dispatch", () => {
+ const state = getComposerProviderState({
+ provider: "opencode",
+ model: "openai/gpt-5",
+ models: OPENCODE_MODELS,
+ prompt: "",
+ modelOptions: {
+ opencode: {
+ variant: "medium",
+ agent: "plan",
+ },
+ },
+ });
+
+ expect(state).toEqual({
+ provider: "opencode",
+ promptEffort: "medium",
+ modelOptionsForDispatch: {
+ variant: "medium",
+ agent: "plan",
+ },
+ });
+ });
+});
+
+describe("getComposerProviderControls", () => {
+ it("hides the interaction mode toggle for OpenCode", () => {
+ expect(getComposerProviderControls("opencode")).toEqual({
+ showInteractionModeToggle: false,
+ });
+ });
+
+ it("keeps the interaction mode toggle for Codex and Claude", () => {
+ expect(getComposerProviderControls("codex")).toEqual({
+ showInteractionModeToggle: true,
+ });
+ expect(getComposerProviderControls("claudeAgent")).toEqual({
+ showInteractionModeToggle: true,
+ });
+ });
});
describe("provider traits render guards", () => {
diff --git a/apps/web/src/components/chat/composerProviderRegistry.tsx b/apps/web/src/components/chat/composerProviderRegistry.tsx
index 74d8d85cf..4ce68f70f 100644
--- a/apps/web/src/components/chat/composerProviderRegistry.tsx
+++ b/apps/web/src/components/chat/composerProviderRegistry.tsx
@@ -4,15 +4,17 @@ import {
type ScopedThreadRef,
type ServerProviderModel,
} from "@t3tools/contracts";
-import { isClaudeUltrathinkPrompt, resolveEffort } from "@t3tools/shared/model";
+import {
+ isClaudeUltrathinkPrompt,
+ normalizeProviderModelOptionsWithCapabilities,
+ resolveEffort,
+ trimOrNull,
+} from "@t3tools/shared/model";
import type { ReactNode } from "react";
+
import type { DraftId } from "../../composerDraftStore";
import { getProviderModelCapabilities } from "../../providerModels";
import { TraitsMenuContent, TraitsPicker } from "./TraitsPicker";
-import {
- normalizeClaudeModelOptionsWithCapabilities,
- normalizeCodexModelOptionsWithCapabilities,
-} from "@t3tools/shared/model";
export type ComposerProviderStateInput = {
provider: ProviderKind;
@@ -31,7 +33,12 @@ export type ComposerProviderState = {
modelPickerIconClassName?: string;
};
+export type ComposerProviderControls = {
+ showInteractionModeToggle: boolean;
+};
+
type ProviderRegistryEntry = {
+ controls: ComposerProviderControls;
getState: (input: ComposerProviderStateInput) => ComposerProviderState;
renderTraitsMenuContent: (input: {
threadRef?: ScopedThreadRef;
@@ -66,25 +73,26 @@ function getProviderStateFromCapabilities(
const { provider, model, models, prompt, modelOptions } = input;
const caps = getProviderModelCapabilities(models, model, provider);
const providerOptions = modelOptions?.[provider];
-
- // Resolve effort
const rawEffort = providerOptions
? "effort" in providerOptions
? providerOptions.effort
: "reasoningEffort" in providerOptions
? providerOptions.reasoningEffort
- : null
+ : "variant" in providerOptions
+ ? providerOptions.variant
+ : null
: null;
-
- const promptEffort = resolveEffort(caps, rawEffort) ?? null;
-
- // Normalize options for dispatch
- const normalizedOptions =
- provider === "codex"
- ? normalizeCodexModelOptionsWithCapabilities(caps, providerOptions)
- : normalizeClaudeModelOptionsWithCapabilities(caps, providerOptions);
-
- // Ultrathink styling (driven by capabilities data, not provider identity)
+ const normalizedOptions = normalizeProviderModelOptionsWithCapabilities(
+ provider,
+ caps,
+ providerOptions,
+ );
+ const promptEffort =
+ provider === "opencode"
+ ? (trimOrNull(
+ normalizedOptions && "variant" in normalizedOptions ? normalizedOptions.variant : null,
+ ) ?? null)
+ : (resolveEffort(caps, rawEffort) ?? null);
const ultrathinkActive =
caps.promptInjectedEffortLevels.length > 0 && isClaudeUltrathinkPrompt(prompt);
@@ -100,53 +108,19 @@ function getProviderStateFromCapabilities(
};
}
-const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
- codex: {
- getState: (input) => getProviderStateFromCapabilities(input),
- renderTraitsMenuContent: ({
- threadRef,
- draftId,
- model,
- models,
- modelOptions,
- prompt,
- onPromptChange,
- }) =>
- !hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
- <TraitsMenuContent
- provider="codex"
- models={models}
- {...(threadRef ? { threadRef } : {})}
- {...(draftId ? { draftId } : {})}
- model={model}
- modelOptions={modelOptions}
- prompt={prompt}
- onPromptChange={onPromptChange}
- />
- ),
- renderTraitsPicker: ({
- threadRef,
- draftId,
- model,
- models,
- modelOptions,
- prompt,
- onPromptChange,
- }) =>
- !hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
- <TraitsPicker
- provider="codex"
- models={models}
- {...(threadRef ? { threadRef } : {})}
- {...(draftId ? { draftId } : {})}
- model={model}
- modelOptions={modelOptions}
- prompt={prompt}
- onPromptChange={onPromptChange}
- />
- ),
- },
- claudeAgent: {
+const DEFAULT_PROVIDER_CONTROLS: ComposerProviderControls = {
+ showInteractionModeToggle: true,
+};
+
+function createProviderRegistryEntry(
+ provider: ProviderKind,
+ controls?: Partial<ComposerProviderControls>,
+): ProviderRegistryEntry {
+ return {
+ controls: {
+ ...DEFAULT_PROVIDER_CONTROLS,
+ ...controls,
+ },
getState: (input) => getProviderStateFromCapabilities(input),
renderTraitsMenuContent: ({
threadRef,
@@ -159,7 +133,7 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
}) =>
!hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
<TraitsMenuContent
- provider="claudeAgent"
+ provider={provider}
models={models}
{...(threadRef ? { threadRef } : {})}
{...(draftId ? { draftId } : {})}
@@ -180,7 +154,7 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
}) =>
!hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
<TraitsPicker
- provider="claudeAgent"
+ provider={provider}
models={models}
{...(threadRef ? { threadRef } : {})}
{...(draftId ? { draftId } : {})}
@@ -190,13 +164,25 @@ const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
onPromptChange={onPromptChange}
/>
),
- },
+ };
+}
+
+const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
+ codex: createProviderRegistryEntry("codex"),
+ claudeAgent: createProviderRegistryEntry("claudeAgent"),
+ opencode: createProviderRegistryEntry("opencode", {
+ showInteractionModeToggle: false,
+ }),
};
export function getComposerProviderState(input: ComposerProviderStateInput): ComposerProviderState {
return composerProviderRegistry[input.provider].getState(input);
}
+export function getComposerProviderControls(provider: ProviderKind): ComposerProviderControls {
+ return composerProviderRegistry[provider].controls;
+}
+
export function renderProviderTraitsMenuContent(input: {
provider: ProviderKind;
threadRef?: ScopedThreadRef;
diff --git a/apps/web/src/components/settings/SettingsPanels.browser.tsx b/apps/web/src/components/settings/SettingsPanels.browser.tsx
index 438121546..b508b29b7 100644
--- a/apps/web/src/components/settings/SettingsPanels.browser.tsx
+++ b/apps/web/src/components/settings/SettingsPanels.browser.tsx
@@ -701,4 +701,21 @@ describe("GeneralSettingsPanel observability", () => {
expect(openInEditor).toHaveBeenCalledWith("/repo/project/.t3/logs", "cursor");
});
+
+ it("shows an OpenCode server URL field in provider settings", async () => {
+ setServerConfigSnapshot(createBaseServerConfig());
+
+ mounted = await render(
+ <AppAtomRegistryProvider>
+ <GeneralSettingsPanel />
+ </AppAtomRegistryProvider>,
+ );
+
+ await page.getByLabelText("Toggle OpenCode details").click();
+
+ await expect.element(page.getByText("OpenCode server URL")).toBeInTheDocument();
+ await expect.element(page.getByPlaceholder("http://127.0.0.1:4096")).toBeInTheDocument();
+ await expect.element(page.getByText("OpenCode server password")).toBeInTheDocument();
+ await expect.element(page.getByPlaceholder("Server password")).toBeInTheDocument();
+ });
});
diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsx
index f76c69581..f4ff3851c 100644
--- a/apps/web/src/components/settings/SettingsPanels.tsx
+++ b/apps/web/src/components/settings/SettingsPanels.tsx
@@ -21,6 +21,7 @@ import {
import { scopeThreadRef } from "@t3tools/client-runtime";
import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";
import { normalizeModelSlug } from "@t3tools/shared/model";
+import { createModelSelection } from "@t3tools/shared/model";
import { Equal } from "effect";
import { APP_VERSION } from "../../branding";
import {
@@ -104,6 +105,10 @@ type InstallProviderSettings = {
title: string;
binaryPlaceholder: string;
binaryDescription: ReactNode;
+ serverUrlPlaceholder?: string;
+ serverUrlDescription?: ReactNode;
+ serverPasswordPlaceholder?: string;
+ serverPasswordDescription?: ReactNode;
homePathKey?: "codexHomePath";
homePlaceholder?: string;
homeDescription?: ReactNode;
@@ -125,6 +130,17 @@ const PROVIDER_SETTINGS: readonly InstallProviderSettings[] = [
binaryPlaceholder: "Claude binary path",
binaryDescription: "Path to the Claude binary",
},
+ {
+ provider: "opencode",
+ title: "OpenCode",
+ binaryPlaceholder: "OpenCode binary path",
+ binaryDescription: "Path to the OpenCode binary",
+ serverUrlPlaceholder: "http://127.0.0.1:4096",
+ serverUrlDescription: "Leave blank to let T3 Code spawn the server when needed",
+ serverPasswordPlaceholder: "Server password (optional)",
+ serverPasswordDescription:
+ "If your OpenCode server requires authentication, enter the password here. NOTE: Stored in plain text on disk",
+ },
] as const;
const PROVIDER_STATUS_STYLES = {
@@ -514,12 +530,22 @@ export function GeneralSettingsPanel() {
settings.providers.claudeAgent.customModels.length > 0 ||
settings.providers.claudeAgent.launchArgs !== "",
),
+ opencode: Boolean(
+ settings.providers.opencode.binaryPath !==
+ DEFAULT_UNIFIED_SETTINGS.providers.opencode.binaryPath ||
+ settings.providers.opencode.serverUrl !==
+ DEFAULT_UNIFIED_SETTINGS.providers.opencode.serverUrl ||
+ settings.providers.opencode.serverPassword !==
+ DEFAULT_UNIFIED_SETTINGS.providers.opencode.serverPassword ||
+ settings.providers.opencode.customModels.length > 0,
+ ),
});
const [customModelInputByProvider, setCustomModelInputByProvider] = useState<
Record<ProviderKind, string>
>({
codex: "",
claudeAgent: "",
+ opencode: "",
});
const [customModelErrorByProvider, setCustomModelErrorByProvider] = useState<
Partial<Record<ProviderKind, string | null>>
@@ -732,10 +758,16 @@ export function GeneralSettingsPanel() {
title: providerSettings.title,
binaryPlaceholder: providerSettings.binaryPlaceholder,
binaryDescription: providerSettings.binaryDescription,
+ serverUrlPlaceholder: providerSettings.serverUrlPlaceholder,
+ serverUrlDescription: providerSettings.serverUrlDescription,
+ serverPasswordPlaceholder: providerSettings.serverPasswordPlaceholder,
+ serverPasswordDescription: providerSettings.serverPasswordDescription,
homePathKey: providerSettings.homePathKey,
homePlaceholder: providerSettings.homePlaceholder,
homeDescription: providerSettings.homeDescription,
binaryPathValue: providerConfig.binaryPath,
+ serverUrlValue: "serverUrl" in providerConfig ? providerConfig.serverUrl : "",
+ serverPasswordValue: "serverPassword" in providerConfig ? providerConfig.serverPassword : "",
isDirty: !Equal.equals(providerConfig, defaultProviderConfig),
liveProvider,
models,
@@ -1035,7 +1067,7 @@ export function GeneralSettingsPanel() {
textGenerationModelSelection: resolveAppModelSelectionState(
{
...settings,
- textGenerationModelSelection: { provider, model },
+ textGenerationModelSelection: createModelSelection(provider, model),
},
serverProviders,
),
@@ -1060,11 +1092,11 @@ export function GeneralSettingsPanel() {
textGenerationModelSelection: resolveAppModelSelectionState(
{
...settings,
- textGenerationModelSelection: {
- provider: textGenProvider,
- model: textGenModel,
- ...(nextOptions ? { options: nextOptions } : {}),
- },
+ textGenerationModelSelection: createModelSelection(
+ textGenProvider,
+ textGenModel,
+ nextOptions,
+ ),
},
serverProviders,
),
@@ -1243,6 +1275,84 @@ export function GeneralSettingsPanel() {
</label>
</div>
+ {providerCard.serverUrlPlaceholder ? (
+ <div className="border-t border-border/60 px-4 py-3 sm:px-5">
+ <label
+ htmlFor={`provider-install-${providerCard.provider}-server-url`}
+ className="block"
+ >
+ <span className="text-xs font-medium text-foreground">
+ {providerDisplayName} server URL
+ </span>
+ <Input
+ id={`provider-install-${providerCard.provider}-server-url`}
+ className="mt-1.5"
+ value={providerCard.serverUrlValue}
+ onChange={(event) =>
+ updateSettings({
+ providers: {
+ ...settings.providers,
+ [providerCard.provider]: {
+ ...settings.providers[providerCard.provider],
+ ...(providerCard.provider === "opencode"
+ ? { serverUrl: event.target.value }
+ : {}),
+ },
+ },
+ })
+ }
+ placeholder={providerCard.serverUrlPlaceholder}
+ spellCheck={false}
+ />
+ {providerCard.serverUrlDescription ? (
+ <span className="mt-1 block text-xs text-muted-foreground">
+ {providerCard.serverUrlDescription}
+ </span>
+ ) : null}
+ </label>
+ </div>
+ ) : null}
+
+ {providerCard.serverPasswordPlaceholder ? (
+ <div className="border-t border-border/60 px-4 py-3 sm:px-5">
+ <label
+ htmlFor={`provider-install-${providerCard.provider}-server-password`}
+ className="block"
+ >
+ <span className="text-xs font-medium text-foreground">
+ {providerDisplayName} server password
+ </span>
+ <Input
+ id={`provider-install-${providerCard.provider}-server-password`}
+ className="mt-1.5"
+ type="password"
+ autoComplete="off"
+ value={providerCard.serverPasswordValue}
+ onChange={(event) =>
+ updateSettings({
+ providers: {
+ ...settings.providers,
+ [providerCard.provider]: {
+ ...settings.providers[providerCard.provider],
+ ...(providerCard.provider === "opencode"
+ ? { serverPassword: event.target.value }
+ : {}),
+ },
+ },
+ })
+ }
+ placeholder={providerCard.serverPasswordPlaceholder}
+ spellCheck={false}
+ />
+ {providerCard.serverPasswordDescription ? (
+ <span className="mt-1 block text-xs text-muted-foreground">
+ {providerCard.serverPasswordDescription}
+ </span>
+ ) : null}
+ </label>
+ </div>
+ ) : null}
+
{providerCard.homePathKey ? (
<div className="border-t border-border/60 px-4 py-3 sm:px-5">
<label
@@ -1422,7 +1532,9 @@ export function GeneralSettingsPanel() {
placeholder={
providerCard.provider === "codex"
? "gpt-6.7-codex-ultra-preview"
- : "claude-sonnet-5-0"
+ : providerCard.provider === "opencode"
+ ? "openai/gpt-5"
+ : "claude-sonnet-5-0"
}
spellCheck={false}
/>
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index da24f500e..02e4f6484 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -25,7 +25,7 @@ import {
import * as Schema from "effect/Schema";
import * as Equal from "effect/Equal";
import { DeepMutable } from "effect/Types";
-import { normalizeModelSlug } from "@t3tools/shared/model";
+import { createModelSelection, normalizeModelSlug } from "@t3tools/shared/model";
import { useMemo } from "react";
import { getLocalStorageItem } from "./hooks/useLocalStorage";
import { resolveAppModelSelection } from "./modelSelection";
@@ -527,7 +527,7 @@ function shouldRemoveDraft(draft: ComposerThreadDraftState): boolean {
}
function normalizeProviderKind(value: unknown): ProviderKind | null {
- return value === "codex" || value === "claudeAgent" ? value : null;
+ return value === "codex" || value === "claudeAgent" || value === "opencode" ? value : null;
}
function normalizeProviderModelOptions(
@@ -544,6 +544,10 @@ function normalizeProviderModelOptions(
candidate?.claudeAgent && typeof candidate.claudeAgent === "object"
? (candidate.claudeAgent as Record<string, unknown>)
: null;
+ const openCodeCandidate =
+ candidate?.opencode && typeof candidate.opencode === "object"
+ ? (candidate.opencode as Record<string, unknown>)
+ : null;
const codexReasoningEffort = Schema.is(CodexReasoningEffort)(codexCandidate?.reasoningEffort)
? codexCandidate.reasoningEffort
@@ -600,13 +604,29 @@ function normalizeProviderModelOptions(
...(claudeContextWindow !== undefined ? { contextWindow: claudeContextWindow } : {}),
}
: undefined;
+ const openCodeVariant =
+ typeof openCodeCandidate?.variant === "string" && openCodeCandidate.variant.length > 0
+ ? openCodeCandidate.variant
+ : undefined;
+ const openCodeAgent =
+ typeof openCodeCandidate?.agent === "string" && openCodeCandidate.agent.length > 0
+ ? openCodeCandidate.agent
+ : undefined;
+ const opencode =
+ openCodeVariant !== undefined || openCodeAgent !== undefined
+ ? {
+ ...(openCodeVariant !== undefined ? { variant: openCodeVariant } : {}),
+ ...(openCodeAgent !== undefined ? { agent: openCodeAgent } : {}),
+ }
+ : undefined;
- if (!codex && !claude) {
+ if (!codex && !claude && !opencode) {
return null;
}
return {
...(codex ? { codex } : {}),
...(claude ? { claudeAgent: claude } : {}),
+ ...(opencode ? { opencode } : {}),
};
}
@@ -637,12 +657,8 @@ function normalizeModelSelection(
provider,
provider === "codex" ? legacy?.legacyCodex : undefined,
);
- const options = provider === "codex" ? modelOptions?.codex : modelOptions?.claudeAgent;
- return {
- provider,
- model,
- ...(options ? { options } : {}),
- };
+ const options = modelOptions?.[provider];
+ return createModelSelection(provider, model, options);
}
// ── Legacy sync helpers (used only during migration from v2 storage) ──
@@ -655,11 +671,7 @@ function legacySyncModelSelectionOptions(
return null;
}
const options = modelOptions?.[modelSelection.provider];
- return {
- provider: modelSelection.provider,
- model: modelSelection.model,
- ...(options ? { options } : {}),
- };
+ return createModelSelection(modelSelection.provider, modelSelection.model, options);
}
function legacyMergeModelSelectionIntoProviderModelOptions(
@@ -703,17 +715,16 @@ function legacyToModelSelectionByProvider(
const result: Partial<Record<ProviderKind, ModelSelection>> = {};
// Add entries from the options bag (for non-active providers)
if (modelOptions) {
- for (const provider of ["codex", "claudeAgent"] as const) {
+ for (const provider of ["codex", "claudeAgent", "opencode"] as const) {
const options = modelOptions[provider];
if (options && Object.keys(options).length > 0) {
- result[provider] = {
+ result[provider] = createModelSelection(
provider,
- model:
- modelSelection?.provider === provider
- ? modelSelection.model
- : DEFAULT_MODEL_BY_PROVIDER[provider],
+ modelSelection?.provider === provider
+ ? modelSelection.model
+ : DEFAULT_MODEL_BY_PROVIDER[provider],
options,
- };
+ );
}
}
}
@@ -2205,11 +2216,11 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
nextMap[normalized.provider] = normalized;
} else {
// No options in selection → preserve existing options, update provider+model
- nextMap[normalized.provider] = {
- provider: normalized.provider,
- model: normalized.model,
- ...(current?.options ? { options: current.options } : {}),
- };
+ nextMap[normalized.provider] = createModelSelection(
+ normalized.provider,
+ normalized.model,
+ current?.options,
+ );
}
}
const nextActiveProvider = normalized?.provider ?? base.activeProvider;
@@ -2246,17 +2257,17 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
}
const base = existing ?? createEmptyThreadDraft();
const nextMap = { ...base.modelSelectionByProvider };
- for (const provider of ["codex", "claudeAgent"] as const) {
+ for (const provider of ["codex", "claudeAgent", "opencode"] as const) {
// Only touch providers explicitly present in the input
if (!normalizedOpts || !(provider in normalizedOpts)) continue;
const opts = normalizedOpts[provider];
const current = nextMap[provider];
if (opts) {
- nextMap[provider] = {
+ nextMap[provider] = createModelSelection(
provider,
- model: current?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider],
- options: opts,
- };
+ current?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider],
+ opts,
+ );
} else if (current?.options) {
// Remove options but keep the selection
const { options: _, ...rest } = current;
@@ -2303,11 +2314,11 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
const nextMap = { ...base.modelSelectionByProvider };
const currentForProvider = nextMap[normalizedProvider];
if (providerOpts) {
- nextMap[normalizedProvider] = {
- provider: normalizedProvider,
- model: currentForProvider?.model ?? DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
- options: providerOpts,
- };
+ nextMap[normalizedProvider] = createModelSelection(
+ normalizedProvider,
+ currentForProvider?.model ?? DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
+ providerOpts,
+ );
} else if (currentForProvider?.options) {
const { options: _, ...rest } = currentForProvider;
nextMap[normalizedProvider] = rest as ModelSelection;
@@ -2321,16 +2332,16 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
const stickyBase =
nextStickyMap[normalizedProvider] ??
base.modelSelectionByProvider[normalizedProvider] ??
- ({
- provider: normalizedProvider,
- model: DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
- } as ModelSelection);
+ createModelSelection(
+ normalizedProvider,
+ DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
+ );
if (providerOpts) {
- nextStickyMap[normalizedProvider] = {
- ...stickyBase,
- provider: normalizedProvider,
- options: providerOpts,
- };
+ nextStickyMap[normalizedProvider] = createModelSelection(
+ normalizedProvider,
+ stickyBase.model,
+ providerOpts,
+ );
} else if (stickyBase.options) {
const { options: _, ...rest } = stickyBase;
nextStickyMap[normalizedProvider] = rest as ModelSelection;
diff --git a/apps/web/src/modelSelection.ts b/apps/web/src/modelSelection.ts
index 98e2884ad..5ee426e2c 100644
--- a/apps/web/src/modelSelection.ts
+++ b/apps/web/src/modelSelection.ts
@@ -4,7 +4,11 @@ import {
type ProviderKind,
type ServerProvider,
} from "@t3tools/contracts";
-import { normalizeModelSlug, resolveSelectableModel } from "@t3tools/shared/model";
+import {
+ createModelSelection,
+ normalizeModelSlug,
+ resolveSelectableModel,
+} from "@t3tools/shared/model";
import { getComposerProviderState } from "./components/chat/composerProviderRegistry";
import { UnifiedSettings } from "@t3tools/contracts/settings";
import {
@@ -45,6 +49,13 @@ const PROVIDER_CUSTOM_MODEL_CONFIG: Record<ProviderKind, ProviderCustomModelConf
placeholder: "your-claude-model-slug",
example: "claude-sonnet-5-0",
},
+ opencode: {
+ provider: "opencode",
+ title: "OpenCode",
+ description: "Save additional OpenCode model slugs in `provider/model` format.",
+ placeholder: "openai/gpt-5",
+ example: "anthropic/claude-sonnet-4-5-20250929",
+ },
};
export const MODEL_PROVIDER_SETTINGS = Object.values(PROVIDER_CUSTOM_MODEL_CONFIG);
@@ -165,6 +176,12 @@ export function getCustomModelOptionsByProvider(
"claudeAgent",
selectedProvider === "claudeAgent" ? selectedModel : undefined,
),
+ opencode: getAppModelOptions(
+ settings,
+ providers,
+ "opencode",
+ selectedProvider === "opencode" ? selectedModel : undefined,
+ ),
};
}
@@ -192,9 +209,5 @@ export function resolveAppModelSelectionState(
},
});
- return {
- provider,
- model,
- ...(modelOptionsForDispatch ? { options: modelOptionsForDispatch } : {}),
- };
+ return createModelSelection(provider, model, modelOptionsForDispatch);
}
diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts
index b656dd0f3..188f63d1d 100644
--- a/apps/web/src/session-logic.test.ts
+++ b/apps/web/src/session-logic.test.ts
@@ -1326,12 +1326,14 @@ describe("deriveActiveWorkStartedAt", () => {
});
describe("PROVIDER_OPTIONS", () => {
- it("advertises Claude as available while keeping Cursor as a placeholder", () => {
+ it("advertises available providers while keeping Cursor as a placeholder", () => {
const claude = PROVIDER_OPTIONS.find((option) => option.value === "claudeAgent");
+ const opencode = PROVIDER_OPTIONS.find((option) => option.value === "opencode");
const cursor = PROVIDER_OPTIONS.find((option) => option.value === "cursor");
expect(PROVIDER_OPTIONS).toEqual([
{ value: "codex", label: "Codex", available: true },
{ value: "claudeAgent", label: "Claude", available: true },
+ { value: "opencode", label: "OpenCode", available: true },
{ value: "cursor", label: "Cursor", available: false },
]);
expect(claude).toEqual({
@@ -1339,6 +1341,11 @@ describe("PROVIDER_OPTIONS", () => {
label: "Claude",
available: true,
});
+ expect(opencode).toEqual({
+ value: "opencode",
+ label: "OpenCode",
+ available: true,
+ });
expect(cursor).toEqual({
value: "cursor",
label: "Cursor",
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index a5f611c41..996ac0e31 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -29,6 +29,7 @@ export const PROVIDER_OPTIONS: Array<{
}> = [
{ value: "codex", label: "Codex", available: true },
{ value: "claudeAgent", label: "Claude", available: true },
+ { value: "opencode", label: "OpenCode", available: true },
{ value: "cursor", label: "Cursor", available: false },
];
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index ec3260248..1212bbbb8 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -129,7 +129,7 @@ function arraysEqual<T>(left: readonly T[], right: readonly T[]): boolean {
return left.length === right.length && left.every((value, index) => value === right[index]);
}
-function normalizeModelSelection<T extends { provider: "codex" | "claudeAgent"; model: string }>(
+function normalizeModelSelection<T extends { provider: ProviderKind; model: string }>(
selection: T,
): T {
return {
@@ -1001,7 +1001,7 @@ function toLegacySessionStatus(
}
function toLegacyProvider(providerName: string | null): ProviderKind {
- if (providerName === "codex" || providerName === "claudeAgent") {
+ if (providerName === "codex" || providerName === "claudeAgent" || providerName === "opencode") {
return providerName;
}
return "codex";
diff --git a/bun.lock b/bun.lock
index 24918d9e0..be731ad0b 100644
--- a/bun.lock
+++ b/bun.lock
@@ -51,6 +51,7 @@
"@effect/platform-bun": "catalog:",
"@effect/platform-node": "catalog:",
"@effect/sql-sqlite-bun": "catalog:",
+ "@opencode-ai/sdk": "^1.3.15",
"@pierre/diffs": "^1.1.0-beta.16",
"effect": "catalog:",
"node-pty": "^1.1.0",
@@ -536,6 +537,8 @@
"@open-draft/until": ["@open-draft/[email protected]", "", {}, "sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg=="],
+ "@opencode-ai/sdk": ["@opencode-ai/[email protected]", "", { "dependencies": { "cross-spawn": "7.0.6" } }, "sha512-Uk59C7wsK20wpdr277yx7Xz7TqG5jGqlZUpSW3wDH/7a2K2iBg0lXc2wskHuCXLRXMhXpPZtb4a3SOpPENkkbg=="],
+
"@oslojs/encoding": ["@oslojs/[email protected]", "", {}, "sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ=="],
"@oxc-project/runtime": ["@oxc-project/[email protected]", "", {}, "sha512-Rg8Wlt5dCbXhQnsXPrkOjL1DTSvXLgb2R/KYfnf1/K+R0k6UMLEmbQXPM+kwrWqSmWA2t0B1EtHy2/3zikQpvQ=="],
diff --git a/packages/contracts/src/model.ts b/packages/contracts/src/model.ts
index 8e5301598..622243221 100644
--- a/packages/contracts/src/model.ts
+++ b/packages/contracts/src/model.ts
@@ -29,9 +29,16 @@ export const ClaudeModelOptions = Schema.Struct({
});
export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
+export const OpenCodeModelOptions = Schema.Struct({
+ variant: Schema.optional(TrimmedNonEmptyString),
+ agent: Schema.optional(TrimmedNonEmptyString),
+});
+export type OpenCodeModelOptions = typeof OpenCodeModelOptions.Type;
+
export const ProviderModelOptions = Schema.Struct({
codex: Schema.optional(CodexModelOptions),
claudeAgent: Schema.optional(ClaudeModelOptions),
+ opencode: Schema.optional(OpenCodeModelOptions),
});
export type ProviderModelOptions = typeof ProviderModelOptions.Type;
@@ -55,12 +62,15 @@ export const ModelCapabilities = Schema.Struct({
supportsThinkingToggle: Schema.Boolean,
contextWindowOptions: Schema.Array(ContextWindowOption),
promptInjectedEffortLevels: Schema.Array(TrimmedNonEmptyString),
+ variantOptions: Schema.optional(Schema.Array(EffortOption)),
+ agentOptions: Schema.optional(Schema.Array(EffortOption)),
});
export type ModelCapabilities = typeof ModelCapabilities.Type;
export const DEFAULT_MODEL_BY_PROVIDER: Record<ProviderKind, string> = {
codex: "gpt-5.4",
claudeAgent: "claude-sonnet-4-6",
+ opencode: "openai/gpt-5",
};
export const DEFAULT_MODEL = DEFAULT_MODEL_BY_PROVIDER.codex;
@@ -69,6 +79,7 @@ export const DEFAULT_MODEL = DEFAULT_MODEL_BY_PROVIDER.codex;
export const DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER: Record<ProviderKind, string> = {
codex: "gpt-5.4-mini",
claudeAgent: "claude-haiku-4-5",
+ opencode: "openai/gpt-5",
};
export const MODEL_SLUG_ALIASES_BY_PROVIDER: Record<ProviderKind, Record<string, string>> = {
@@ -96,6 +107,7 @@ export const MODEL_SLUG_ALIASES_BY_PROVIDER: Record<ProviderKind, Record<string,
"claude-haiku-4.5": "claude-haiku-4-5",
"claude-haiku-4-5-20251001": "claude-haiku-4-5",
},
+ opencode: {},
};
// ── Provider display names ────────────────────────────────────────────
@@ -103,4 +115,5 @@ export const MODEL_SLUG_ALIASES_BY_PROVIDER: Record<ProviderKind, Record<string,
export const PROVIDER_DISPLAY_NAMES: Record<ProviderKind, string> = {
codex: "Codex",
claudeAgent: "Claude",
+ opencode: "OpenCode",
};
diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
index 6cd63ab17..d9f314e15 100644
--- a/packages/contracts/src/orchestration.ts
+++ b/packages/contracts/src/orchestration.ts
@@ -1,5 +1,5 @@
import { Effect, Option, Schema, SchemaIssue, Struct } from "effect";
-import { ClaudeModelOptions, CodexModelOptions } from "./model.ts";
+import { ClaudeModelOptions, CodexModelOptions, OpenCodeModelOptions } from "./model.ts";
import { RepositoryIdentity } from "./environment.ts";
import {
ApprovalRequestId,
@@ -25,7 +25,7 @@ export const ORCHESTRATION_WS_METHODS = {
subscribeThread: "orchestration.subscribeThread",
} as const;
-export const ProviderKind = Schema.Literals(["codex", "claudeAgent"]);
+export const ProviderKind = Schema.Literals(["codex", "claudeAgent", "opencode"]);
export type ProviderKind = typeof ProviderKind.Type;
export const ProviderApprovalPolicy = Schema.Literals([
"untrusted",
@@ -57,7 +57,18 @@ export const ClaudeModelSelection = Schema.Struct({
});
export type ClaudeModelSelection = typeof ClaudeModelSelection.Type;
-export const ModelSelection = Schema.Union([CodexModelSelection, ClaudeModelSelection]);
+export const OpenCodeModelSelection = Schema.Struct({
+ provider: Schema.Literal("opencode"),
+ model: TrimmedNonEmptyString,
+ options: Schema.optionalKey(OpenCodeModelOptions),
+});
+export type OpenCodeModelSelection = typeof OpenCodeModelSelection.Type;
+
+export const ModelSelection = Schema.Union([
+ CodexModelSelection,
+ ClaudeModelSelection,
+ OpenCodeModelSelection,
+]);
export type ModelSelection = typeof ModelSelection.Type;
export const RuntimeMode = Schema.Literals([
diff --git a/packages/contracts/src/providerRuntime.ts b/packages/contracts/src/providerRuntime.ts
index 5f2673e81..eabf2b5b3 100644
--- a/packages/contracts/src/providerRuntime.ts
+++ b/packages/contracts/src/providerRuntime.ts
@@ -24,6 +24,7 @@ const RuntimeEventRawSource = Schema.Literals([
"claude.sdk.message",
"claude.sdk.permission",
"codex.sdk.thread-event",
+ "opencode.sdk.event",
]);
export type RuntimeEventRawSource = typeof RuntimeEventRawSource.Type;
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index fada38eb1..f370807b6 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -6,6 +6,7 @@ import {
ClaudeModelOptions,
CodexModelOptions,
DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER,
+ OpenCodeModelOptions,
} from "./model.ts";
import { ModelSelection } from "./orchestration.ts";
@@ -89,6 +90,15 @@ export const ClaudeSettings = Schema.Struct({
});
export type ClaudeSettings = typeof ClaudeSettings.Type;
+export const OpenCodeSettings = Schema.Struct({
+ enabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),
+ binaryPath: makeBinaryPathSetting("opencode"),
+ serverUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
+ serverPassword: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
+ customModels: Schema.Array(Schema.String).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+});
+export type OpenCodeSettings = typeof OpenCodeSettings.Type;
+
export const ObservabilitySettings = Schema.Struct({
otlpTracesUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
otlpMetricsUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
@@ -114,6 +124,7 @@ export const ServerSettings = Schema.Struct({
providers: Schema.Struct({
codex: CodexSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
claudeAgent: ClaudeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
+ opencode: OpenCodeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
}).pipe(Schema.withDecodingDefault(Effect.succeed({}))),
observability: ObservabilitySettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
});
@@ -156,6 +167,11 @@ const ClaudeModelOptionsPatch = Schema.Struct({
contextWindow: Schema.optionalKey(ClaudeModelOptions.fields.contextWindow),
});
+const OpenCodeModelOptionsPatch = Schema.Struct({
+ variant: Schema.optionalKey(OpenCodeModelOptions.fields.variant),
+ agent: Schema.optionalKey(OpenCodeModelOptions.fields.agent),
+});
+
const ModelSelectionPatch = Schema.Union([
Schema.Struct({
provider: Schema.optionalKey(Schema.Literal("codex")),
@@ -167,6 +183,11 @@ const ModelSelectionPatch = Schema.Union([
model: Schema.optionalKey(TrimmedNonEmptyString),
options: Schema.optionalKey(ClaudeModelOptionsPatch),
}),
+ Schema.Struct({
+ provider: Schema.optionalKey(Schema.Literal("opencode")),
+ model: Schema.optionalKey(TrimmedNonEmptyString),
+ options: Schema.optionalKey(OpenCodeModelOptionsPatch),
+ }),
]);
const CodexSettingsPatch = Schema.Struct({
@@ -183,6 +204,14 @@ const ClaudeSettingsPatch = Schema.Struct({
launchArgs: Schema.optionalKey(Schema.String),
});
+const OpenCodeSettingsPatch = Schema.Struct({
+ enabled: Schema.optionalKey(Schema.Boolean),
+ binaryPath: Schema.optionalKey(Schema.String),
+ serverUrl: Schema.optionalKey(Schema.String),
+ serverPassword: Schema.optionalKey(Schema.String),
+ customModels: Schema.optionalKey(Schema.Array(Schema.String)),
+});
+
export const ServerSettingsPatch = Schema.Struct({
enableAssistantStreaming: Schema.optionalKey(Schema.Boolean),
defaultThreadEnvMode: Schema.optionalKey(ThreadEnvMode),
@@ -198,6 +227,7 @@ export const ServerSettingsPatch = Schema.Struct({
Schema.Struct({
codex: Schema.optionalKey(CodexSettingsPatch),
claudeAgent: Schema.optionalKey(ClaudeSettingsPatch),
+ opencode: Schema.optionalKey(OpenCodeSettingsPatch),
}),
),
});
diff --git a/packages/shared/src/model.ts b/packages/shared/src/model.ts
index 0e11f5964..30f61d469 100644
--- a/packages/shared/src/model.ts
+++ b/packages/shared/src/model.ts
@@ -6,7 +6,9 @@ import {
type CodexModelOptions,
type ModelCapabilities,
type ModelSelection,
+ type OpenCodeModelOptions,
type ProviderKind,
+ type ProviderModelOptions,
} from "@t3tools/contracts";
export interface SelectableModelOption {
@@ -117,6 +119,50 @@ export function normalizeClaudeModelOptionsWithCapabilities(
return Object.keys(nextOptions).length > 0 ? nextOptions : undefined;
}
+function resolveLabeledOption(
+ options: ReadonlyArray<{ value: string; isDefault?: boolean | undefined }> | undefined,
+ raw: string | null | undefined,
+): string | undefined {
+ if (!options || options.length === 0) {
+ return raw ?? undefined;
+ }
+ if (raw && options.some((option) => option.value === raw)) {
+ return raw;
+ }
+ return options.find((option) => option.isDefault)?.value;
+}
+
+export function normalizeOpenCodeModelOptionsWithCapabilities(
+ caps: ModelCapabilities,
+ modelOptions: OpenCodeModelOptions | null | undefined,
+): OpenCodeModelOptions | undefined {
+ const variant = resolveLabeledOption(caps.variantOptions, trimOrNull(modelOptions?.variant));
+ const agent = resolveLabeledOption(caps.agentOptions, trimOrNull(modelOptions?.agent));
+ const nextOptions: OpenCodeModelOptions = {
+ ...(variant ? { variant } : {}),
+ ...(agent ? { agent } : {}),
+ };
+ return Object.keys(nextOptions).length > 0 ? nextOptions : undefined;
+}
+
+export function normalizeProviderModelOptionsWithCapabilities(
+ provider: ProviderKind,
+ caps: ModelCapabilities,
+ modelOptions: ProviderModelOptions[ProviderKind] | null | undefined,
+): ProviderModelOptions[ProviderKind] | undefined {
+ switch (provider) {
+ case "codex":
+ return normalizeCodexModelOptionsWithCapabilities(caps, modelOptions as CodexModelOptions);
+ case "claudeAgent":
+ return normalizeClaudeModelOptionsWithCapabilities(caps, modelOptions as ClaudeModelOptions);
+ case "opencode":
+ return normalizeOpenCodeModelOptionsWithCapabilities(
+ caps,
+ modelOptions as OpenCodeModelOptions,
+ );
+ }
+}
+
export function isClaudeUltrathinkPrompt(text: string | null | undefined): boolean {
return typeof text === "string" && /\bultrathink\b/i.test(text);
}
@@ -196,6 +242,33 @@ export function trimOrNull<T extends string>(value: T | null | undefined): T | n
return trimmed || null;
}
+export function createModelSelection(
+ provider: ProviderKind,
+ model: string,
+ options?: ProviderModelOptions[ProviderKind] | undefined,
+): ModelSelection {
+ switch (provider) {
+ case "codex":
+ return {
+ provider,
+ model,
+ ...(options ? { options: options as CodexModelOptions } : {}),
+ };
+ case "claudeAgent":
+ return {
+ provider,
+ model,
+ ...(options ? { options: options as ClaudeModelOptions } : {}),
+ };
+ case "opencode":
+ return {
+ provider,
+ model,
+ ...(options ? { options: options as OpenCodeModelOptions } : {}),
+ };
+ }
+}
+
/**
* Resolve the actual API model identifier from a model selection.
*
diff --git a/packages/shared/src/serverSettings.test.ts b/packages/shared/src/serverSettings.test.ts
index 89aa161c6..bbe5d8dc2 100644
--- a/packages/shared/src/serverSettings.test.ts
+++ b/packages/shared/src/serverSettings.test.ts
@@ -109,4 +109,30 @@ describe("serverSettings helpers", () => {
},
});
});
+
+ it("replaces text generation selection across providers without leaking stale options", () => {
+ const current = {
+ ...DEFAULT_SERVER_SETTINGS,
+ textGenerationModelSelection: {
+ provider: "codex" as const,
+ model: "gpt-5.4-mini",
+ options: {
+ reasoningEffort: "high" as const,
+ fastMode: true,
+ },
+ },
+ };
+
+ expect(
+ applyServerSettingsPatch(current, {
+ textGenerationModelSelection: {
+ provider: "opencode",
+ model: "openai/gpt-5",
+ },
+ }).textGenerationModelSelection,
+ ).toEqual({
+ provider: "opencode",
+ model: "openai/gpt-5",
+ });
+ });
});
diff --git a/packages/shared/src/serverSettings.ts b/packages/shared/src/serverSettings.ts
index 769485ceb..8821997a8 100644
--- a/packages/shared/src/serverSettings.ts
+++ b/packages/shared/src/serverSettings.ts
@@ -1,4 +1,10 @@
-import { ServerSettings, type ServerSettingsPatch } from "@t3tools/contracts";
+import {
+ ServerSettings,
+ type ClaudeModelOptions,
+ type CodexModelOptions,
+ type OpenCodeModelOptions,
+ type ServerSettingsPatch,
+} from "@t3tools/contracts";
import { Schema } from "effect";
import { deepMerge } from "./Struct.ts";
import { fromLenientJson } from "./schemaJson.ts";
@@ -46,6 +52,9 @@ function shouldReplaceTextGenerationModelSelection(
return Boolean(patch && (patch.provider !== undefined || patch.model !== undefined));
}
+const withModelSelectionOptions = <Options>(options: Options | undefined) =>
+ options ? { options } : {};
+
/**
* Applies a server settings patch while treating textGenerationModelSelection as
* replace-on-provider/model updates. This prevents stale nested options from
@@ -61,12 +70,32 @@ export function applyServerSettingsPatch(
return next;
}
+ const provider = selectionPatch.provider ?? current.textGenerationModelSelection.provider;
+ const model = selectionPatch.model ?? current.textGenerationModelSelection.model;
+
return {
...next,
- textGenerationModelSelection: {
- provider: selectionPatch.provider ?? current.textGenerationModelSelection.provider,
- model: selectionPatch.model ?? current.textGenerationModelSelection.model,
- ...(selectionPatch.options ? { options: selectionPatch.options } : {}),
- },
+ textGenerationModelSelection:
+ provider === "codex"
+ ? {
+ provider,
+ model,
+ ...withModelSelectionOptions(selectionPatch.options as CodexModelOptions | undefined),
+ }
+ : provider === "claudeAgent"
+ ? {
+ provider,
+ model,
+ ...withModelSelectionOptions(
+ selectionPatch.options as ClaudeModelOptions | undefined,
+ ),
+ }
+ : {
+ provider,
+ model,
+ ...withModelSelectionOptions(
+ selectionPatch.options as OpenCodeModelOptions | undefined,
+ ),
+ },
};
}