@shivaedev/agent-opencode 0.1.0 → 0.2.0

package/src/operations.ts

@@ -0,0 +1,111 @@
+import { type Cause, Effect, Option, Queue, Stream } from "effect";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { ProtocolFailure, UnknownAcceptance } from "@shivaedev/agent/failures.ts";
+import type { Observation, Receipt, StartRequest } from "@shivaedev/agent/run.ts";
+import { opencodeFailure } from "#failure.ts";
+import { openOpencodeSession } from "#openOpencodeSession.ts";
+import type { OpencodeOptions, SessionHandle } from "#options.ts";
+import { Provider } from "#Provider.ts";
+export interface OpenRun {
+	readonly events: Stream.Stream<RunEvent>;
+	readonly receipt: Receipt;
+	readonly session: SessionHandle;
+}
+export const makeOperations = Effect.fnUntraced(function* (options: OpencodeOptions) {
+	const server = yield* Provider;
+	const runs = new Map<string, OpenRun>();
+	const receipts = new Map<string, Receipt>();
+	const observation = new Map<string, Observation>();
+	function lookup(receipt: Receipt) {
+		return Effect.suspend(() => {
+			const run = runs.get(receipt.operationId);
+			return receipt.backend === "opencode" && receipt.reference.version === 1 && run?.receipt.reference.value === receipt.reference.value
+				? Effect.succeed(run)
+				: Effect.fail(opencodeFailure("run is not open in this backend scope"));
+		});
+	}
+	const open = Effect.fnUntraced(function* (request: StartRequest, resume: Option.Option<string>) {
+		if (receipts.has(request.operationId)) {
+			return yield* Effect.fail(opencodeFailure("operation already acknowledged; reconcile instead"));
+		}
+		const session = yield* openOpencodeSession({
+			constrainedPrompt: options.constrainedPrompt,
+			cwd: request.cwd,
+			effort: Option.fromUndefinedOr(request.effort),
+			model: request.model,
+			resume,
+			tools: options.sessionTools?.(request) ?? options.tools ?? [],
+		}).pipe(Effect.provideService(Provider, server));
+		const reference = yield* session.nativeRef;
+		if (Option.isNone(reference)) {
+			return yield* Effect.fail(opencodeFailure("session returned no reference"));
+		}
+		const receipt: Receipt = {
+			backend: "opencode",
+			operationId: request.operationId,
+			reference: { value: reference.value, version: 1 },
+			session: { value: reference.value, version: 1 },
+		};
+		yield* session
+			.steer(request.input)
+			.pipe(
+				Effect.mapError((error) =>
+					error._tag === "Rejected"
+						? error
+						: new UnknownAcceptance({ backend: "opencode", message: error.message, operationId: request.operationId }),
+				),
+			);
+		const output = yield* Queue.unbounded<RunEvent, Cause.Done>();
+		observation.set(request.operationId, { state: "accepted", type: "known" });
+		function observe(event: RunEvent) {
+			return Effect.sync(() => {
+				if (event.type === "execution") {
+					observation.set(request.operationId, { state: event.state, type: "known" });
+				}
+			}).pipe(Effect.andThen(Queue.offer(output, event)));
+		}
+		const ended = Effect.sync(() => {
+			const latest = observation.get(request.operationId);
+			if (runs.has(request.operationId) && latest?.type === "known" && !["completed", "failed", "interrupted"].includes(latest.state)) {
+				observation.set(request.operationId, { reason: "provider event stream ended without terminal evidence", type: "missing" });
+			}
+		}).pipe(Effect.andThen(Queue.end(output)));
+		yield* Effect.forkScoped(session.events.pipe(Stream.runForEach(observe), Effect.ensuring(ended)));
+		const events = Stream.fromQueue(output);
+		runs.set(request.operationId, { events, receipt, session });
+		receipts.set(request.operationId, receipt);
+		yield* Effect.addFinalizer(() =>
+			Effect.sync(() => {
+				runs.delete(request.operationId);
+				observation.delete(request.operationId);
+			}),
+		);
+		return receipt;
+	});
+	return {
+		events: (receipt: Receipt) => Stream.unwrap(lookup(receipt).pipe(Effect.map((run) => run.events))),
+		inspect: (receipt: Receipt) =>
+			Effect.sync(
+				(): Observation => observation.get(receipt.operationId) ?? { reason: "no live execution evidence in this backend scope", type: "missing" },
+			),
+		lookup,
+		open,
+		reconcile: (operationId: string) =>
+			Effect.sync(() => {
+				const receipt = receipts.get(operationId);
+				return receipt === undefined
+					? { operationId, reason: "OpenCode has no operation-id lookup; absence is not proof of refusal", type: "uncertain" as const }
+					: { receipt, type: "accepted" as const };
+			}),
+		resume: (
+			reference: {
+				readonly value: string;
+				readonly version: number;
+			},
+			request: StartRequest,
+		) =>
+			reference.version === 1
+				? open(request, Option.some(reference.value))
+				: Effect.fail(new ProtocolFailure({ backend: "opencode", message: "unsupported session reference version" })),
+	};
+});

package/src/options.ts

@@ -0,0 +1,29 @@
+import type { Effect, Option, Stream } from "effect";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import type { Input, StartRequest } from "@shivaedev/agent/run.ts";
+import type { DirectTool } from "#tools.ts";
+export interface OpencodeOptions {
+	readonly command?: string | undefined;
+	readonly constrainedPrompt?: string | undefined;
+	readonly cwd: string;
+	readonly sessionTools?: (request: StartRequest) => readonly DirectTool[];
+	readonly skills?: string | undefined;
+	readonly tools?: readonly DirectTool[];
+	readonly url?: string | undefined;
+}
+export interface OpenSessionOptions {
+	readonly constrainedPrompt?: string | undefined;
+	readonly cwd: string;
+	readonly effort: Option.Option<string>;
+	readonly model?: string | undefined;
+	readonly resume: Option.Option<string>;
+	readonly tools: readonly DirectTool[];
+}
+export interface SessionHandle {
+	readonly events: Stream.Stream<RunEvent>;
+	readonly interrupt: Effect.Effect<void, BackendFailure>;
+	readonly nativeRef: Effect.Effect<Option.Option<string>>;
+	readonly queue: (input: Input) => Effect.Effect<void, BackendFailure>;
+	readonly steer: (input: Input) => Effect.Effect<void, BackendFailure>;
+}

package/src/sessionOpen.ts

@@ -0,0 +1,74 @@
+import { Effect, Option, Schema } from "effect";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import { rawOf } from "#adapters/mapping.ts";
+import { SessionResponse } from "#adapters/protocol.ts";
+import { CONSTRAINED_AGENT, wireName } from "#adapters/toolNames.ts";
+import { opencodeFailure } from "#failure.ts";
+import type { OpenSessionOptions } from "#options.ts";
+import { Provider, type ProviderPort } from "#Provider.ts";
+
+const decodeSession = Schema.decodeUnknownOption(SessionResponse);
+export interface PromptSettings {
+	readonly agent?: string;
+	readonly model?: {
+		readonly "modelID": string;
+		readonly "providerID": string;
+	};
+	readonly system?: string;
+	readonly variant?: string;
+}
+function namedModel(model: string): Effect.Effect<PromptSettings, BackendFailure> {
+	const separator = model.indexOf("/");
+	return separator === -1
+		? Effect.fail(opencodeFailure(`model ${JSON.stringify(model)} names no provider; OpenCode reads a model as provider/model`))
+		: Effect.succeed({ model: { "modelID": model.slice(separator + 1), "providerID": model.slice(0, separator) } });
+}
+export function promptSettings(options: OpenSessionOptions): Effect.Effect<PromptSettings, BackendFailure> {
+	const constrained: PromptSettings = options.constrainedPrompt === undefined ? {} : { agent: CONSTRAINED_AGENT, system: options.constrainedPrompt };
+	const variant = Option.match(options.effort, {
+		onNone: (): PromptSettings => constrained,
+		onSome: (effort) => ({ ...constrained, variant: effort }),
+	});
+	return Effect.map(options.model === undefined ? Effect.succeed({}) : namedModel(options.model), (named) => ({ ...named, ...variant }));
+}
+function onlyGivenTools(tools: OpenSessionOptions["tools"]) {
+	return [
+		{ action: "deny", pattern: "*", permission: "*" },
+		...tools.map((tool) => ({ action: "allow", pattern: "*", permission: wireName(tool.name) })),
+	];
+}
+function withoutOtherTools(server: ProviderPort, tools: OpenSessionOptions["tools"]) {
+	const given = new Set(tools.map((tool) => tool.name));
+	return server.tools.names.filter((name) => !given.has(name)).map((name) => ({ action: "deny", pattern: "*", permission: wireName(name) }));
+}
+function permissions(server: ProviderPort, options: OpenSessionOptions) {
+	return options.constrainedPrompt === undefined ? withoutOtherTools(server, options.tools) : onlyGivenTools(options.tools);
+}
+export const openSession = Effect.fnUntraced(function* (options: OpenSessionOptions) {
+	const server = yield* Provider;
+	const query = { directory: options.cwd };
+	return yield* Option.match(options.resume, {
+		onNone: () =>
+			server
+				.post({ body: { permission: permissions(server, options) }, path: "/session", query })
+				.pipe(Effect.map((response) => ["POST /session", response] as const)),
+		onSome: (sessionId) =>
+			server
+				.get({ body: undefined, path: `/session/${sessionId}`, query })
+				.pipe(Effect.map((response) => [`GET /session/${sessionId}`, response] as const)),
+	});
+});
+export function sessionIdOf(route: string, response: unknown): Effect.Effect<string, BackendFailure> {
+	return Option.match(decodeSession(response), {
+		onNone: () => Effect.fail(opencodeFailure(`${route} returned no session`)),
+		onSome: ({ id }) => Effect.succeed(id),
+	});
+}
+export function sessionOpened(route: string, response: unknown, sessionId: string): AgentEvent {
+	return {
+		raw: rawOf(route, response),
+		reference: sessionId,
+		type: "session.opened",
+	};
+}

package/src/tools.ts

@@ -0,0 +1,13 @@
+import type { Effect } from "effect";
+export interface ToolOutcome {
+	readonly ok: boolean;
+	readonly text: string;
+}
+export interface ToolDefinition {
+	readonly description: string;
+	readonly inputSchema: Readonly<Record<string, unknown>>;
+	readonly name: string;
+}
+export interface DirectTool extends ToolDefinition {
+	readonly call: (callId: string, args: unknown) => Effect.Effect<ToolOutcome>;
+}

package/src/turnRequests.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import { Provider } from "#Provider.ts";
+import type { PromptSettings } from "#sessionOpen.ts";
+export interface TurnRequests {
+	readonly abort: Effect.Effect<unknown, BackendFailure>;
+	readonly prompt: (text: string) => Effect.Effect<unknown, BackendFailure>;
+}
+export const turnRequests = Effect.fnUntraced(function* (sessionId: string, cwd: string, settings: PromptSettings) {
+	const server = yield* Provider;
+	const query = { directory: cwd };
+	return {
+		abort: server.post({
+			body: {},
+			path: `/session/${sessionId}/abort`,
+			query,
+		}),
+		prompt: (text: string) =>
+			server.post({
+				body: { ...settings, parts: [{ text, type: "text" }] },
+				path: `/session/${sessionId}/prompt_async`,
+				query,
+			}),
+	};
+});

package/src/turnState.ts

@@ -0,0 +1,41 @@
+import type { Deferred } from "effect";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import { opencodeFailure } from "#failure.ts";
+export interface PendingText {
+	readonly accepted: Deferred.Deferred<void, BackendFailure>;
+	readonly text: string;
+}
+export interface OpenTurnState {
+	readonly "_tag": "open";
+	readonly pending: readonly PendingText[];
+	readonly running: boolean;
+}
+interface ClosedTurnState {
+	readonly "_tag": "closed";
+}
+export type TurnState = ClosedTurnState | OpenTurnState;
+export const closed: ClosedTurnState = { "_tag": "closed" };
+export const idle: OpenTurnState = {
+	"_tag": "open",
+	pending: [],
+	running: false,
+};
+export const SESSION_CLOSED = opencodeFailure("session closed before delivery reached the provider");
+export function withPending(state: OpenTurnState, text: PendingText): OpenTurnState {
+	return { ...state, pending: [...state.pending, text] };
+}
+export function running(state: OpenTurnState): OpenTurnState {
+	return {
+		...state,
+		running: true,
+	};
+}
+export function rested(state: OpenTurnState): OpenTurnState {
+	return {
+		...state,
+		running: false,
+	};
+}
+export function sent(state: TurnState): TurnState {
+	return state._tag === "closed" ? state : { ...state, pending: state.pending.slice(1) };
+}

package/src/turns.ts

@@ -0,0 +1,89 @@
+import { Deferred, Effect, Ref, Semaphore } from "effect";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import type { SessionFrame } from "#adapters/sessionFrames.ts";
+import type { TurnRequests } from "#turnRequests.ts";
+import {
+	closed,
+	idle,
+	type OpenTurnState,
+	type PendingText,
+	rested,
+	running,
+	SESSION_CLOSED,
+	sent,
+	type TurnState,
+	withPending,
+} from "#turnState.ts";
+
+function refuse(next: PendingText, failure: BackendFailure) {
+	return Deferred.fail(next.accepted, failure).pipe(Effect.andThen(Effect.logWarning("opencode: queued prompt failed", failure)));
+}
+export interface TurnDriver {
+	readonly close: Effect.Effect<void>;
+	readonly interrupt: Effect.Effect<void, BackendFailure>;
+	readonly queue: (text: string) => Effect.Effect<void, BackendFailure>;
+	readonly steer: (text: string) => Effect.Effect<void, BackendFailure>;
+	readonly track: (frame: SessionFrame) => Effect.Effect<void>;
+}
+export const makeTurnDriver = Effect.fnUntraced(function* (requests: TurnRequests) {
+	const state = yield* Ref.make<TurnState>(idle);
+	const gate = yield* Semaphore.make(1);
+	function sendNow(text: string) {
+		return requests.prompt(text).pipe(Effect.andThen(Ref.update(state, (current) => (current._tag === "closed" ? current : running(current)))));
+	}
+	function flush(current: OpenTurnState) {
+		const [next] = current.pending;
+		if (next === undefined) {
+			return Effect.void;
+		}
+		return sendNow(next.text).pipe(
+			Effect.matchEffect({
+				onFailure: (failure) => Ref.update(state, sent).pipe(Effect.andThen(refuse(next, failure))),
+				onSuccess: () => Ref.update(state, sent).pipe(Effect.andThen(Deferred.succeed(next.accepted, undefined))),
+			}),
+			Effect.asVoid,
+		);
+	}
+	function admit(text: string, accepted: PendingText["accepted"]) {
+		return Effect.flatMap(Ref.get(state), (current) => {
+			if (current._tag === "closed") {
+				return Deferred.fail(accepted, SESSION_CLOSED);
+			}
+			if (current.running) {
+				return Ref.set(state, withPending(current, { accepted, text }));
+			}
+			return sendNow(text).pipe(
+				Effect.matchEffect({
+					onFailure: (failure) => Deferred.fail(accepted, failure),
+					onSuccess: () => Deferred.succeed(accepted, undefined),
+				}),
+			);
+		});
+	}
+	const queue = Effect.fnUntraced(function* (text: string) {
+		const accepted = yield* Deferred.make<void, BackendFailure>();
+		yield* gate.withPermit(admit(text, accepted));
+		yield* Deferred.await(accepted);
+	});
+	function steer(text: string) {
+		return Effect.flatMap(Ref.get(state), (current) => (current._tag === "closed" ? Effect.fail(SESSION_CLOSED) : sendNow(text)));
+	}
+	const settled = Effect.flatMap(Ref.get(state), (current) =>
+		current._tag === "closed" ? Effect.void : Ref.set(state, rested(current)).pipe(Effect.andThen(flush(rested(current)))),
+	);
+	const close = Ref.getAndSet(state, closed).pipe(
+		Effect.flatMap((current) =>
+			current._tag === "closed"
+				? Effect.void
+				: Effect.forEach(current.pending, (waiting) => Deferred.fail(waiting.accepted, SESSION_CLOSED)).pipe(Effect.asVoid),
+		),
+	);
+	yield* Effect.addFinalizer(() => close);
+	return {
+		close,
+		interrupt: Effect.asVoid(requests.abort),
+		queue,
+		steer: (text) => gate.withPermit(steer(text)),
+		track: (frame) => (frame.type === "session.idle" ? gate.withPermit(settled) : Effect.void),
+	} satisfies TurnDriver;
+});