@shivaedev/agent-opencode 0.1.0 → 0.3.0

package/src/adapters/partEvents.ts

@@ -0,0 +1,85 @@
+import type { Raw } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type RawPayload = typeof Raw.Type;
+
+import { Option, Schema } from "effect";
+import { rawEvent } from "#adapters/mapping.ts";
+import type { MessageAuthor, MessageAuthors } from "#adapters/messageAuthors.ts";
+import { KnownPart, PartUpdatedProperties } from "#adapters/protocolParts.ts";
+import { toolEvents } from "#adapters/toolEvents.ts";
+
+const decodeProperties = Schema.decodeUnknownOption(PartUpdatedProperties);
+const decodePart = Schema.decodeUnknownOption(KnownPart);
+type Settled = Extract<
+	KnownPart,
+	{
+		type: "reasoning" | "text";
+	}
+>;
+function isSettled(part: Settled, author: MessageAuthor): boolean {
+	return author.role === "user" || part.time?.end !== undefined;
+}
+function spokenEvents(raw: RawPayload, part: Settled, author: MessageAuthor): AgentEvent[] {
+	return part.type === "reasoning"
+		? [{ raw, text: part.text, type: "thinking" }]
+		: [{ parts: [{ text: part.text, type: "text" }], raw, role: author.role, type: "message" }];
+}
+function usageEvents(
+	raw: RawPayload,
+	part: Extract<
+		KnownPart,
+		{
+			type: "step-finish";
+		}
+	>,
+	author: MessageAuthor,
+): AgentEvent[] {
+	const model = author.model === undefined ? {} : { model: author.model };
+	const counted = {
+		...(part.tokens.cache?.read === undefined ? {} : { cacheReadTokens: part.tokens.cache.read }),
+		...(part.tokens.cache?.write === undefined ? {} : { cacheWriteTokens: part.tokens.cache.write }),
+		inputTokens: part.tokens.input,
+		outputTokens: part.tokens.output,
+	};
+	return [
+		{ ...counted, ...model, raw, scope: "delta", type: "usage", unit: "turn" },
+		...(part.cost === undefined
+			? []
+			: [
+					{
+						amount: part.cost,
+						currency: "USD",
+						...model,
+						raw,
+						scope: "delta" as const,
+						source: "provider" as const,
+						type: "cost" as const,
+						unit: "turn" as const,
+					},
+				]),
+	];
+}
+function authoredEvents(raw: RawPayload, part: KnownPart, author: MessageAuthor, firstReport: (key: string) => boolean): AgentEvent[] {
+	if (part.type === "tool") {
+		return toolEvents(raw, part, (callId) => firstReport(`${part.state.status}:${callId}`));
+	}
+	if (part.type === "step-finish") {
+		return firstReport(`part:${part.id}`) ? usageEvents(raw, part, author) : [];
+	}
+	return isSettled(part, author) && firstReport(`part:${part.id}`) ? spokenEvents(raw, part, author) : [];
+}
+export function partEvents(raw: RawPayload, properties: unknown, authors: MessageAuthors, firstReport: (key: string) => boolean): AgentEvent[] {
+	return Option.match(decodeProperties(properties), {
+		onNone: () => rawEvent(raw),
+		onSome: ({ part }) =>
+			Option.match(decodePart(part), {
+				onNone: () => rawEvent(raw),
+				onSome: (known) =>
+					Option.match(authors.of(known.messageID), {
+						onNone: () => rawEvent(raw),
+						onSome: (author) => authoredEvents(raw, known, author, firstReport),
+					}),
+			}),
+	});
+}

package/src/adapters/projection.ts

@@ -0,0 +1,46 @@
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+import { rawEvent, rawOf } from "#adapters/mapping.ts";
+import { openMessageAuthors } from "#adapters/messageAuthors.ts";
+import { openTurnBoundary } from "#adapters/openTurnBoundary.ts";
+import { partEvents } from "#adapters/partEvents.ts";
+import type { SessionFrame } from "#adapters/sessionFrames.ts";
+
+function openFirstReport(): (key: string) => boolean {
+	const reported = new Set<string>();
+	return (key) => {
+		if (reported.has(key)) {
+			return false;
+		}
+		reported.add(key);
+		return true;
+	};
+}
+export interface SessionProjection {
+	readonly events: (frame: SessionFrame) => AgentEvent[];
+}
+export function openSessionProjection(sessionModel: string | undefined): SessionProjection {
+	const authors = openMessageAuthors(sessionModel);
+	const boundary = openTurnBoundary();
+	const firstReport = openFirstReport();
+	function project(type: string, properties: unknown): AgentEvent[] {
+		const raw = rawOf(type, properties);
+		switch (type) {
+			case "message.updated":
+				authors.record(properties);
+				return [];
+			case "message.part.updated":
+				return partEvents(raw, properties, authors, firstReport);
+			case "message.part.delta":
+				return [];
+			case "session.error":
+				return boundary.errored(raw, properties);
+			case "session.idle":
+				return boundary.idled(raw);
+			case "session.status":
+				return boundary.status(raw, properties);
+			default:
+				return rawEvent(raw);
+		}
+	}
+	return { events: (frame) => project(frame.type, frame.properties) };
+}

package/src/adapters/protocol.ts

@@ -0,0 +1,31 @@
+import { Schema } from "effect";
+export const SessionResponse = Schema.Struct({
+	directory: Schema.String,
+	id: Schema.String,
+});
+const ProviderModel = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	variants: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+});
+const Provider = Schema.Struct({
+	id: Schema.String,
+	models: Schema.Record(Schema.String, ProviderModel),
+});
+export const ProvidersResponse = Schema.Struct({
+	default: Schema.Record(Schema.String, Schema.String),
+	providers: Schema.Array(Provider),
+});
+export const GlobalFrame = Schema.Struct({
+	payload: Schema.Struct({
+		properties: Schema.optional(Schema.Unknown),
+		type: Schema.String,
+	}),
+});
+export const SessionScoped = Schema.Struct({ "sessionID": Schema.String });
+export const SessionStatusProperties = Schema.Struct({
+	status: Schema.Struct({ type: Schema.String }),
+});
+export const SessionErrorProperties = Schema.Struct({
+	error: Schema.optional(Schema.Struct({ name: Schema.optional(Schema.String) })),
+});

package/src/adapters/protocolParts.ts

@@ -0,0 +1,48 @@
+import { Schema } from "effect";
+
+const part = {
+	id: Schema.String,
+	"messageID": Schema.String,
+};
+const PartTime = Schema.Struct({ end: Schema.optional(Schema.Number) });
+const TextPart = Schema.Struct({
+	...part,
+	text: Schema.String,
+	time: Schema.optional(PartTime),
+	type: Schema.Literal("text"),
+});
+const ReasoningPart = Schema.Struct({
+	...part,
+	text: Schema.String,
+	time: Schema.optional(PartTime),
+	type: Schema.Literal("reasoning"),
+});
+const ToolPart = Schema.Struct({
+	...part,
+	"callID": Schema.String,
+	state: Schema.Struct({
+		error: Schema.optional(Schema.String),
+		input: Schema.optional(Schema.Unknown),
+		output: Schema.optional(Schema.String),
+		status: Schema.Literals(["pending", "running", "completed", "error"]),
+	}),
+	tool: Schema.String,
+	type: Schema.Literal("tool"),
+});
+const CacheTokens = Schema.Struct({
+	read: Schema.optional(Schema.Number),
+	write: Schema.optional(Schema.Number),
+});
+const StepFinishPart = Schema.Struct({
+	...part,
+	cost: Schema.optional(Schema.Number),
+	tokens: Schema.Struct({
+		cache: Schema.optional(CacheTokens),
+		input: Schema.Number,
+		output: Schema.Number,
+	}),
+	type: Schema.Literal("step-finish"),
+});
+export const KnownPart = Schema.Union([TextPart, ReasoningPart, ToolPart, StepFinishPart]);
+export type KnownPart = typeof KnownPart.Type;
+export const PartUpdatedProperties = Schema.Struct({ part: Schema.Unknown });

package/src/adapters/providerAddress.ts

@@ -0,0 +1,22 @@
+import { fileURLToPath } from "node:url";
+import { Effect } from "effect";
+import { serveOpencode } from "#adapters/serveOpencode.ts";
+import type { ToolSessions } from "#adapters/toolSessions.ts";
+import { unavailable } from "#failure.ts";
+import type { OpencodeOptions } from "#options.ts";
+export const providerAddress = Effect.fnUntraced(function* (options: OpencodeOptions, tools: ToolSessions) {
+	let endpoint: string | undefined;
+	if (options.tools?.length) {
+		const { answerToolRequest } = yield* Effect.tryPromise({ catch: unavailable, try: () => import("#adapters/answerToolRequest.ts") });
+		const { serveToolRequests } = yield* Effect.tryPromise({ catch: unavailable, try: () => import("#adapters/serveToolRequests.ts") });
+		endpoint = yield* serveToolRequests(answerToolRequest(options.tools, tools));
+	}
+	return yield* serveOpencode({
+		command: options.command ?? "opencode",
+		constrained: options.constrainedPrompt !== undefined,
+		cwd: options.cwd,
+		plugin: fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./opencodePlugin.config.ts" : "./opencodePlugin.config.js", import.meta.url)),
+		skills: options.skills,
+		tools: endpoint,
+	});
+});

package/src/adapters/serveOpencode.ts

@@ -0,0 +1,93 @@
+import { pathToFileURL } from "node:url";
+import { Deferred, Effect, Fiber, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { listeningUrl } from "#adapters/listeningUrl.ts";
+import { CONSTRAINED_AGENT, TOOL_SERVER_NAME } from "#adapters/toolNames.ts";
+import { unavailable } from "#failure.ts";
+
+const LOOPBACK = "127.0.0.1";
+interface ServeOptions {
+	readonly command: string;
+	readonly constrained: boolean;
+	readonly cwd: string;
+	readonly plugin: string;
+	readonly skills?: string | undefined;
+	readonly tools?: string | undefined;
+}
+function serveArgs(port: string) {
+	return ["serve", "--port", port, "--hostname", LOOPBACK];
+}
+const START_PATIENCE_MILLIS = 30_000;
+// OpenCode resets this MCP deadline on progress notifications while a tool remains pending.
+const TOOL_TIMEOUT = 300_000;
+// Pure mode would disable the caller-session plugin and the tool bridge.
+const CONSTRAINED_ENV = {
+	"OPENCODE_DISABLE_CLAUDE_CODE_PROMPT": "1",
+	"OPENCODE_DISABLE_EXTERNAL_SKILLS": "1",
+	"OPENCODE_DISABLE_PROJECT_CONFIG": "1",
+};
+const CONSTRAINED_CONFIG = {
+	agent: { [CONSTRAINED_AGENT]: { prompt: "Follow the instructions in the system message." } },
+};
+function configContent(options: ServeOptions): string {
+	const mode = options.constrained ? CONSTRAINED_CONFIG : {};
+	const skills = options.skills === undefined ? {} : { skills: { paths: [options.skills] } };
+	return JSON.stringify({
+		...(options.tools === undefined
+			? {}
+			: { mcp: { [TOOL_SERVER_NAME]: { timeout: TOOL_TIMEOUT, type: "remote", url: options.tools } }, plugin: [pathToFileURL(options.plugin).href] }),
+		...mode,
+		...(options.constrained ? {} : skills),
+	});
+}
+function serveEnv(options: ServeOptions) {
+	return {
+		"OPENCODE_CONFIG_CONTENT": configContent(options),
+		...(options.constrained ? CONSTRAINED_ENV : {}),
+	};
+}
+const complaintsOf = Effect.fnUntraced(function* (child: ChildProcessSpawner.ChildProcessHandle) {
+	const said = yield* Effect.forkScoped(Stream.mkString(Stream.decodeText(child.stderr)));
+	return Effect.orElseSucceed(Fiber.join(said), () => "");
+});
+const addressPrintedBy = Effect.fnUntraced(function* (child: ChildProcessSpawner.ChildProcessHandle) {
+	const printed = yield* Deferred.make<string>();
+	yield* Effect.forkScoped(
+		Stream.runForEach(Stream.decodeText(child.stdout).pipe(Stream.splitLines), (chunk) =>
+			Effect.sync(() => {
+				const address = listeningUrl(chunk);
+				if (address !== undefined) {
+					Deferred.doneUnsafe(printed, Effect.succeed(address));
+				}
+			}),
+		),
+	);
+	return Deferred.await(printed);
+});
+function exitedFirst(child: ChildProcessSpawner.ChildProcessHandle, complaints: Effect.Effect<string>) {
+	return Effect.flatMap(Effect.match(child.exitCode, { onFailure: String, onSuccess: String }), (reason) =>
+		Effect.flatMap(complaints, (said) => Effect.fail(`opencode serve exited with ${reason}: ${said.slice(0, 500)}`)),
+	);
+}
+export const serveOpencode = Effect.fnUntraced(function* (options: ServeOptions) {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const port = "0";
+	const child = yield* spawner.spawn(
+		ChildProcess.make(options.command, serveArgs(port), {
+			cwd: options.cwd,
+			env: serveEnv(options),
+			extendEnv: true,
+			forceKillAfter: 5000,
+			stdin: "ignore",
+		}),
+	);
+	const complaints = yield* complaintsOf(child);
+	const printed = yield* addressPrintedBy(child);
+	const address = yield* Effect.raceFirst(printed, exitedFirst(child, complaints)).pipe(
+		Effect.timeoutOrElse({
+			duration: START_PATIENCE_MILLIS,
+			orElse: () => Effect.fail(`opencode serve did not print its address on port ${port} in time`),
+		}),
+	);
+	return address;
+}, Effect.mapError(unavailable));

package/src/adapters/serveToolRequests.ts

@@ -0,0 +1,24 @@
+import { createServer } from "node:http";
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+import { Effect, type Scope } from "effect";
+import { HttpServer, HttpServerRequest, HttpServerResponse } from "effect/http";
+import type { BackendUnavailable } from "@shivaedev/agent/failures.ts";
+import { unavailable } from "#failure.ts";
+
+const LOOPBACK = "127.0.0.1";
+const onlyPosted = HttpServerResponse.empty({ headers: { allow: "POST" }, status: 405 });
+export function serveToolRequests(answer: (request: Request) => Promise<Response>): Effect.Effect<string, BackendUnavailable, Scope.Scope> {
+	return Effect.gen(function* () {
+		const server = yield* NodeHttpServer.make(createServer, { host: LOOPBACK, port: 0 });
+		const respond = Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			if (request.method !== "POST") {
+				return onlyPosted;
+			}
+			const web = yield* HttpServerRequest.toWeb(request);
+			return HttpServerResponse.fromWeb(yield* Effect.promise(() => answer(web)));
+		});
+		yield* server.serve(respond);
+		return HttpServer.formatAddress(server.address);
+	}).pipe(Effect.mapError(unavailable));
+}

package/src/adapters/servedTools.ts

@@ -0,0 +1,11 @@
+import { Effect, Scope } from "effect";
+import { callWhileOpen } from "#callWhileOpen.ts";
+import type { DirectTool } from "#tools.ts";
+export const servedTools = Effect.fnUntraced(function* (tools: readonly DirectTool[]) {
+	const calls = yield* Effect.flatMap(Effect.scope, Scope.fork);
+	const services = yield* Effect.context<never>();
+	const run = Effect.runPromiseWith(services);
+	return new Map(
+		tools.map((tool) => [tool.name, (callId: string, args: unknown) => run(callWhileOpen(tool, callId, args).pipe(Scope.provide(calls)))]),
+	);
+});

package/src/adapters/sessionFrames.ts

@@ -0,0 +1,25 @@
+import { Option, Schema } from "effect";
+import { GlobalFrame, SessionScoped } from "#adapters/protocol.ts";
+
+const decodeFrame = Schema.decodeUnknownOption(GlobalFrame);
+const decodeScoped = Schema.decodeUnknownOption(SessionScoped);
+const decodeMessage = Schema.decodeUnknownOption(Schema.Struct({ info: SessionScoped }));
+const decodePart = Schema.decodeUnknownOption(Schema.Struct({ part: SessionScoped }));
+function sessionOf(properties: unknown) {
+	return decodeScoped(properties).pipe(
+		Option.orElse(() => Option.map(decodeMessage(properties), ({ info }) => info)),
+		Option.orElse(() => Option.map(decodePart(properties), ({ part }) => part)),
+	);
+}
+export interface SessionFrame {
+	readonly properties?: unknown;
+	readonly type: string;
+}
+export function frameFor(sessionId: string, frame: unknown): Option.Option<SessionFrame> {
+	return Option.flatMap(decodeFrame(frame), ({ payload }) =>
+		Option.match(sessionOf(payload.properties), {
+			onNone: () => Option.none(),
+			onSome: (scoped) => (scoped.sessionID === sessionId ? Option.some(payload) : Option.none()),
+		}),
+	);
+}

package/src/adapters/toolEvents.ts

@@ -0,0 +1,42 @@
+import type { Raw } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type RawPayload = typeof Raw.Type;
+
+import type { KnownPart } from "#adapters/protocolParts.ts";
+
+type ToolPart = Extract<
+	KnownPart,
+	{
+		type: "tool";
+	}
+>;
+export function toolEvents(raw: RawPayload, part: ToolPart, announce: (callId: string) => boolean): AgentEvent[] {
+	const { state } = part;
+	if (state.status === "completed" || state.status === "error") {
+		if (!announce(part.callID)) {
+			return [];
+		}
+		return [
+			{
+				ok: state.status === "completed",
+				output: state.output ?? state.error ?? "",
+				raw,
+				toolId: part.callID,
+				type: "tool.completed",
+			},
+		];
+	}
+	if (state.status === "pending" || !announce(part.callID)) {
+		return [];
+	}
+	return [
+		{
+			input: JSON.stringify(state.input ?? {}),
+			name: part.tool,
+			raw,
+			toolId: part.callID,
+			type: "tool.started",
+		},
+	];
+}

package/src/adapters/toolNames.ts

@@ -0,0 +1,7 @@
+export const CALLER_SESSION = "callerSession";
+export const CALLER_CALL = "callerCall";
+export const CONSTRAINED_AGENT = "platform";
+export const TOOL_SERVER_NAME = "platform";
+export function wireName(name: string): string {
+	return `${TOOL_SERVER_NAME}_${name}`;
+}

package/src/adapters/toolSessions.ts

@@ -0,0 +1,22 @@
+import { Option } from "effect";
+import type { ToolOutcome as DirectToolOutcome } from "#tools.ts";
+export type ServedTool = (callId: string, args: unknown) => Promise<DirectToolOutcome>;
+export interface ToolSessions {
+	readonly forget: (session: string) => void;
+	readonly names: readonly string[];
+	readonly remember: (session: string, tools: ReadonlyMap<string, ServedTool>) => void;
+	readonly served: (session: string) => Option.Option<ReadonlyMap<string, ServedTool>>;
+}
+export function makeToolSessions(names: readonly string[]): ToolSessions {
+	const open = new Map<string, ReadonlyMap<string, ServedTool>>();
+	return {
+		forget: (session) => {
+			open.delete(session);
+		},
+		names,
+		remember: (session, tools) => {
+			open.set(session, tools);
+		},
+		served: (session) => Option.fromNullishOr(open.get(session)),
+	};
+}

package/src/callWhileOpen.ts

@@ -0,0 +1,16 @@
+import { Effect, Exit, Fiber, type Scope } from "effect";
+import type { DirectTool, ToolOutcome } from "#tools.ts";
+
+const closed: ToolOutcome = {
+	ok: false,
+	text: "the session that served this tool closed before the call finished",
+};
+export function callWhileOpen(tool: DirectTool, callId: string, args: unknown): Effect.Effect<ToolOutcome, never, Scope.Scope> {
+	return Effect.flatMap(Effect.scope, (scope) =>
+		tool.call(callId, args).pipe(
+			Effect.forkIn(scope),
+			Effect.flatMap(Fiber.await),
+			Effect.flatMap((exit) => (Exit.hasInterrupts(exit) ? Effect.succeed(closed) : exit)),
+		),
+	);
+}

package/src/failure.ts

@@ -0,0 +1,7 @@
+import { BackendUnavailable, ProtocolFailure } from "@shivaedev/agent/failures.ts";
+export function opencodeFailure(detail: unknown): ProtocolFailure {
+	return new ProtocolFailure({ backend: "opencode", message: String(detail) });
+}
+export function unavailable(detail: unknown): BackendUnavailable {
+	return new BackendUnavailable({ backend: "opencode", message: String(detail) });
+}

package/src/listOpencodeModels.ts

@@ -0,0 +1,34 @@
+import { Effect, Option, Schema } from "effect";
+import type { ModelChoice } from "@shivaedev/agent/eventData.ts";
+import type { ReadFailure as BackendFailure } from "@shivaedev/agent/failures.ts";
+import { ProvidersResponse } from "#adapters/protocol.ts";
+import { opencodeFailure } from "#failure.ts";
+import { Provider } from "#Provider.ts";
+
+const decodeProviders = Schema.decodeUnknownOption(ProvidersResponse);
+type Providers = typeof ProvidersResponse.Type;
+function catalogued({ default: defaults, providers }: Providers): readonly ModelChoice[] {
+	const listed: ModelChoice[] = [];
+	let preferred: string | undefined;
+	for (const provider of providers) {
+		for (const model of Object.values(provider.models)) {
+			const id = `${provider.id}/${model.id}`;
+			if (preferred === undefined && defaults[provider.id] === model.id) {
+				preferred = id;
+			}
+			listed.push({ efforts: Object.keys(model.variants ?? {}), id, isDefault: false, name: model.name });
+		}
+	}
+	const standing = preferred ?? listed[0]?.id;
+	return listed.map((model) => (model.id === standing ? { ...model, isDefault: true } : model));
+}
+function catalogue(response: unknown): Effect.Effect<readonly ModelChoice[], BackendFailure> {
+	return Option.match(decodeProviders(response), {
+		onNone: () => Effect.fail(opencodeFailure("GET /config/providers returned no catalog")),
+		onSome: (listing) => Effect.succeed(catalogued(listing)),
+	});
+}
+export const listOpencodeModels = Effect.fn("OpenCode.listOpencodeModels")(function* () {
+	const server = yield* Provider;
+	return yield* server.get({ body: undefined, path: "/config/providers", query: {} }).pipe(Effect.flatMap(catalogue));
+});

package/src/openOpencodeSession.ts

@@ -0,0 +1,60 @@
+import { Effect, Option, PubSub, type Scope, Stream } from "effect";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import { openSessionProjection, type SessionProjection } from "#adapters/projection.ts";
+import { servedTools } from "#adapters/servedTools.ts";
+import { frameFor } from "#adapters/sessionFrames.ts";
+import type { OpenSessionOptions, SessionHandle } from "#options.ts";
+import { Provider } from "#Provider.ts";
+import { openSession, promptSettings, sessionIdOf, sessionOpened } from "#sessionOpen.ts";
+import { turnRequests } from "#turnRequests.ts";
+import { makeTurnDriver } from "#turns.ts";
+
+function eventsOfFrame(sessionId: string, projection: SessionProjection) {
+	return (frame: unknown): Stream.Stream<AgentEvent> =>
+		Stream.fromIterable(
+			Option.match(frameFor(sessionId, frame), {
+				onNone: (): readonly AgentEvent[] => [],
+				onSome: projection.events,
+			}),
+		);
+}
+export const openOpencodeSession = Effect.fn("OpenCode.openOpencodeSession")(function* (
+	options: OpenSessionOptions,
+): Effect.fn.Return<SessionHandle, BackendFailure, Scope.Scope | Provider> {
+	const server = yield* Provider;
+	const settings = yield* promptSettings(options);
+	const forEvents = yield* PubSub.subscribe(server.frames);
+	const forDriver = yield* PubSub.subscribe(server.frames);
+	const [route, response] = yield* openSession(options);
+	const sessionId = yield* sessionIdOf(route, response);
+	const tools = yield* servedTools(options.tools);
+	yield* Effect.acquireRelease(
+		Effect.sync(() => server.tools.remember(sessionId, tools)),
+		() => Effect.sync(() => server.tools.forget(sessionId)),
+	);
+	const driver = yield* makeTurnDriver(yield* turnRequests(sessionId, options.cwd, settings));
+	yield* Effect.forkScoped(server.exited.pipe(Effect.andThen(driver.close)));
+	yield* Effect.forkScoped(
+		Stream.fromSubscription(forDriver).pipe(
+			Stream.runForEach((frame) =>
+				Option.match(frameFor(sessionId, frame), {
+					onNone: () => Effect.void,
+					onSome: driver.track,
+				}),
+			),
+		),
+	);
+	const projection = openSessionProjection(options.model);
+	const events: Stream.Stream<AgentEvent> = Stream.make(sessionOpened(route, response, sessionId)).pipe(
+		Stream.concat(Stream.fromSubscription(forEvents).pipe(Stream.flatMap(eventsOfFrame(sessionId, projection)))),
+		Stream.interruptWhen(server.exited),
+	);
+	return {
+		events,
+		interrupt: driver.interrupt,
+		nativeRef: Effect.succeed(Option.some(sessionId)),
+		queue: (input) => driver.queue(input.parts.map((part) => part.text).join("\n")),
+		steer: (input) => driver.steer(input.parts.map((part) => part.text).join("\n")),
+	} satisfies SessionHandle;
+});

package/src/opencode.ts

@@ -1 +1,61 @@
-export {};
+import { Effect, Layer, Option } from "effect";
+import { FetchHttpClient } from "effect/http";
+import type { ChildProcessSpawner } from "effect/process";
+import { Backend } from "@shivaedev/agent/backend.ts";
+import type { ReadFailure } from "@shivaedev/agent/failures.ts";
+import { makeOpencodeServer } from "#adapters/makeOpencodeServer.ts";
+import { providerAddress } from "#adapters/providerAddress.ts";
+import { makeToolSessions } from "#adapters/toolSessions.ts";
+import { opencodeFailure } from "#failure.ts";
+import { listOpencodeModels } from "#listOpencodeModels.ts";
+import { makeOperations } from "#operations.ts";
+import type { OpencodeOptions } from "#options.ts";
+import { Provider } from "#Provider.ts";
+export function opencode(
+	options: OpencodeOptions & {
+		readonly url: string;
+	},
+): Layer.Layer<Backend, ReadFailure>;
+export function opencode(options: OpencodeOptions): Layer.Layer<Backend, ReadFailure, ChildProcessSpawner.ChildProcessSpawner>;
+export function opencode(options: OpencodeOptions) {
+	return Layer.effect(
+		Backend,
+		Effect.gen(function* () {
+			const tools = makeToolSessions((options.tools ?? []).map((tool) => tool.name));
+			let url = options.url;
+			if (url !== undefined && (options.tools?.length || options.sessionTools !== undefined)) {
+				return yield* Effect.fail(opencodeFailure("session tool bridging requires a spawned OpenCode server"));
+			}
+			if (url === undefined) {
+				url = yield* providerAddress(options, tools);
+			}
+			const server = yield* makeOpencodeServer(url, tools);
+			const operations = yield* makeOperations(options).pipe(Effect.provideService(Provider, server));
+			return {
+				backend: "opencode",
+				events: operations.events,
+				features: {
+					imageInput: { reason: "only text input is implemented", support: "unsupported" },
+					interruption: {
+						implementation: { interrupt: (receipt) => operations.lookup(receipt).pipe(Effect.flatMap((run) => run.session.interrupt)) },
+						support: "supported",
+					},
+					models: { implementation: { list: listOpencodeModels().pipe(Effect.provideService(Provider, server)) }, support: "supported" },
+					queuedInput: {
+						implementation: { queue: (receipt, input) => operations.lookup(receipt).pipe(Effect.flatMap((run) => run.session.queue(input))) },
+						support: "supported",
+					},
+					sessions: { implementation: { resume: operations.resume }, support: "supported" },
+					steering: {
+						implementation: { steer: (receipt, input) => operations.lookup(receipt).pipe(Effect.flatMap((run) => run.session.steer(input))) },
+						support: "supported",
+					},
+					transcript: { reason: "no provider history reader is implemented", support: "unsupported" },
+				},
+				inspect: operations.inspect,
+				reconcile: operations.reconcile,
+				start: (request) => operations.open(request, Option.none()),
+			};
+		}),
+	).pipe(Layer.provide(FetchHttpClient.layer));
+}