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.jsonindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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")(funconst 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.tsindex 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.tsindex 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 "effimport { 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 50d2d62aa..4ae4a4fb7 100644--- a/apps/server/src/server.ts+++ b/apps/server/src/server.ts@@ -21,6 +21,7 @@ import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDimport { 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.tsindex 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.tsindex 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.tsxindex 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 messageif (isFirstMessage && isServerThread) {diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsxindex 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.tsxindex 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.tsxindex 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}<Selectvalue={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.tsxindex 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?: strplanSidebarLabel="Plan"planSidebarOpen={false}runtimeMode="approval-required"+ showInteractionModeToggletraitsMenuContent={<TraitsMenuContentprovider={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.tsxindex 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 CompactComposerControlsplanSidebarLabel: 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><MenuRadioGroupvalue={props.runtimeMode}diff --git a/apps/web/src/components/chat/ProviderModelPicker.tsx b/apps/web/src/components/chat/ProviderModelPicker.tsxindex 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]): oconst 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.tsxindex 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 (<TraitsPickerprovider="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.tsxindex 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 "ultrathink" 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.tsxindex 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.tsxindex 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 effortconst 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.tsxindex 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.tsxindex 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.tsindex 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 inputif (!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 selectionconst { 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.tsindex 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, ProviderCustomModelConfplaceholder: "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.tsindex 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.tsindex 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.tsindex 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.lockindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 | nreturn 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.tsindex 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.tsindex 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,+ ),+ },};}