@shivaedev/agent-opencode 0.1.0 → 0.3.0

package/dist/turnRequests.js

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import { Provider } from "#Provider.ts";
+export const turnRequests = Effect.fnUntraced(function* (sessionId, cwd, settings) {
+    const server = yield* Provider;
+    const query = { directory: cwd };
+    return {
+        abort: server.post({
+            body: {},
+            path: `/session/${sessionId}/abort`,
+            query,
+        }),
+        prompt: (text) => server.post({
+            body: { ...settings, parts: [{ text, type: "text" }] },
+            path: `/session/${sessionId}/prompt_async`,
+            query,
+        }),
+    };
+});
+//# sourceMappingURL=turnRequests.js.map

package/dist/turnRequests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnRequests.js","sourceRoot":"","sources":["../src/turnRequests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAMxC,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,SAAiB,EAAE,GAAW,EAAE,QAAwB;IAChH,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC;IAC/B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IACjC,OAAO;QACN,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC;YAClB,IAAI,EAAE,EAAE;YACR,IAAI,EAAE,YAAY,SAAS,QAAQ;YACnC,KAAK;SACL,CAAC;QACF,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE,CACxB,MAAM,CAAC,IAAI,CAAC;YACX,IAAI,EAAE,EAAE,GAAG,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE;YACtD,IAAI,EAAE,YAAY,SAAS,eAAe;YAC1C,KAAK;SACL,CAAC;KACH,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/turnState.d.ts

@@ -0,0 +1,24 @@
+import type { Deferred } from "effect";
+import type { BackendFailure } from "@shivaedev/agent/failures.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 declare const closed: ClosedTurnState;
+export declare const idle: OpenTurnState;
+export declare const SESSION_CLOSED: import("@shivaedev/agent/failures.ts").ProtocolFailure;
+export declare function withPending(state: OpenTurnState, text: PendingText): OpenTurnState;
+export declare function running(state: OpenTurnState): OpenTurnState;
+export declare function rested(state: OpenTurnState): OpenTurnState;
+export declare function sent(state: TurnState): TurnState;
+export {};
+//# sourceMappingURL=turnState.d.ts.map

package/dist/turnState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnState.d.ts","sourceRoot":"","sources":["../src/turnState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AACD,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC1B;AACD,UAAU,eAAe;IACxB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC1B;AACD,MAAM,MAAM,SAAS,GAAG,eAAe,GAAG,aAAa,CAAC;AACxD,eAAO,MAAM,MAAM,EAAE,eAAsC,CAAC;AAC5D,eAAO,MAAM,IAAI,EAAE,aAIlB,CAAC;AACF,eAAO,MAAM,cAAc,wDAAyE,CAAC;AACrG,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,GAAG,aAAa,CAElF;AACD,wBAAgB,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAK3D;AACD,wBAAgB,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAK1D;AACD,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAEhD"}

package/dist/turnState.js

@@ -0,0 +1,27 @@
+import { opencodeFailure } from "#failure.ts";
+export const closed = { "_tag": "closed" };
+export const idle = {
+    "_tag": "open",
+    pending: [],
+    running: false,
+};
+export const SESSION_CLOSED = opencodeFailure("session closed before delivery reached the provider");
+export function withPending(state, text) {
+    return { ...state, pending: [...state.pending, text] };
+}
+export function running(state) {
+    return {
+        ...state,
+        running: true,
+    };
+}
+export function rested(state) {
+    return {
+        ...state,
+        running: false,
+    };
+}
+export function sent(state) {
+    return state._tag === "closed" ? state : { ...state, pending: state.pending.slice(1) };
+}
+//# sourceMappingURL=turnState.js.map

package/dist/turnState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnState.js","sourceRoot":"","sources":["../src/turnState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAc9C,MAAM,CAAC,MAAM,MAAM,GAAoB,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC5D,MAAM,CAAC,MAAM,IAAI,GAAkB;IAClC,MAAM,EAAE,MAAM;IACd,OAAO,EAAE,EAAE;IACX,OAAO,EAAE,KAAK;CACd,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG,eAAe,CAAC,qDAAqD,CAAC,CAAC;AACrG,MAAM,UAAU,WAAW,CAAC,KAAoB,EAAE,IAAiB;IAClE,OAAO,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC;AACxD,CAAC;AACD,MAAM,UAAU,OAAO,CAAC,KAAoB;IAC3C,OAAO;QACN,GAAG,KAAK;QACR,OAAO,EAAE,IAAI;KACb,CAAC;AACH,CAAC;AACD,MAAM,UAAU,MAAM,CAAC,KAAoB;IAC1C,OAAO;QACN,GAAG,KAAK;QACR,OAAO,EAAE,KAAK;KACd,CAAC;AACH,CAAC;AACD,MAAM,UAAU,IAAI,CAAC,KAAgB;IACpC,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACxF,CAAC"}

package/dist/turns.d.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import type { BackendFailure } from "@shivaedev/agent/failures.ts";
+import type { SessionFrame } from "#adapters/sessionFrames.ts";
+import type { TurnRequests } from "#turnRequests.ts";
+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 declare const makeTurnDriver: (requests: TurnRequests) => Effect.Effect<{
+    close: Effect.Effect<void, never, never>;
+    interrupt: Effect.Effect<void, import("@shivaedev/agent/failures.ts").BackendUnavailable | import("@shivaedev/agent/failures.ts").ProtocolFailure | import("@shivaedev/agent/failures.ts").Rejected | import("@shivaedev/agent/failures.ts").UnknownAcceptance, never>;
+    queue: (text: string) => Effect.Effect<void, import("@shivaedev/agent/failures.ts").BackendUnavailable | import("@shivaedev/agent/failures.ts").ProtocolFailure | import("@shivaedev/agent/failures.ts").Rejected | import("@shivaedev/agent/failures.ts").UnknownAcceptance, never>;
+    steer: (text: string) => Effect.Effect<void, import("@shivaedev/agent/failures.ts").BackendUnavailable | import("@shivaedev/agent/failures.ts").ProtocolFailure | import("@shivaedev/agent/failures.ts").Rejected | import("@shivaedev/agent/failures.ts").UnknownAcceptance, never>;
+    track: (frame: SessionFrame) => Effect.Effect<void, never, never>;
+}, never, import("effect/Scope").Scope>;
+//# sourceMappingURL=turns.d.ts.map

package/dist/turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turns.d.ts","sourceRoot":"","sources":["../src/turns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAkB,MAAM,QAAQ,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAiBrD,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACxD,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACtE,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACtE,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC7D;AACD,eAAO,MAAM,cAAc;;;;;;uCA6DzB,CAAC"}

package/dist/turns.js

@@ -0,0 +1,57 @@
+import { Deferred, Effect, Ref, Semaphore } from "effect";
+import { closed, idle, rested, running, SESSION_CLOSED, sent, withPending, } from "#turnState.ts";
+function refuse(next, failure) {
+    return Deferred.fail(next.accepted, failure).pipe(Effect.andThen(Effect.logWarning("opencode: queued prompt failed", failure)));
+}
+export const makeTurnDriver = Effect.fnUntraced(function* (requests) {
+    const state = yield* Ref.make(idle);
+    const gate = yield* Semaphore.make(1);
+    function sendNow(text) {
+        return requests.prompt(text).pipe(Effect.andThen(Ref.update(state, (current) => (current._tag === "closed" ? current : running(current)))));
+    }
+    function flush(current) {
+        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, 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) {
+        const accepted = yield* Deferred.make();
+        yield* gate.withPermit(admit(text, accepted));
+        yield* Deferred.await(accepted);
+    });
+    function steer(text) {
+        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),
+    };
+});
+//# sourceMappingURL=turns.js.map

package/dist/turns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turns.js","sourceRoot":"","sources":["../src/turns.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/agent-opencode",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "OpenCode integration for Effect applications",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/agent-opencode#readme",
   "bugs": {
@@ -16,14 +16,15 @@
   "type": "module",
   "imports": {
     "#*.ts": {
-      "source": "./src/*.ts",
+      "@shivaedev/source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
-    }
+    },
+    "#test/*": "./src/test-support/*"
   },
   "exports": {
     "./*.ts": {
-      "source": "./src/*.ts",
+      "@shivaedev/source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     },
@@ -32,12 +33,39 @@
   "files": [
     "dist",
     "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
     "CHANGELOG.md",
     "README.md"
   ],
+  "dependencies": {
+    "@shivaedev/agent": "0.3.0",
+    "@shivaedev/http": "0.6.0"
+  },
   "devDependencies": {
+    "@effect/platform-node": "4.0.6",
+    "@effect/vitest": "4.0.6",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@shivaedev/quality": "0.60.0",
+    "@shivaedev/test-story": "0.38.0",
     "@types/node": "24.19.2",
-    "typescript": "7.0.2"
+    "effect": "4.0.6",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "@effect/platform-node": "4.0.6",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "effect": "4.0.6"
+  },
+  "peerDependenciesMeta": {
+    "@effect/platform-node": {
+      "optional": true
+    },
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=24"
@@ -48,7 +76,8 @@
   },
   "scripts": {
     "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
-    "ready": "pnpm typecheck && pnpm build",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run --configLoader native",
     "typecheck": "tsc --noEmit"
   }
 }

package/src/Provider.ts

@@ -0,0 +1,14 @@
+import { Context, type Effect, type PubSub } from "effect";
+import type { BackendFailure, ReadFailure } from "@shivaedev/agent/failures.ts";
+import type { OpencodeRequest } from "#adapters/OpencodeRequest.ts";
+import type { ToolSessions } from "#adapters/toolSessions.ts";
+
+export interface ProviderPort {
+	readonly exited: Effect.Effect<void>;
+	readonly frames: PubSub.PubSub<unknown>;
+	readonly get: (request: OpencodeRequest) => Effect.Effect<unknown, ReadFailure>;
+	readonly post: (request: OpencodeRequest) => Effect.Effect<unknown, BackendFailure>;
+	readonly tools: ToolSessions;
+}
+
+export class Provider extends Context.Service<Provider, ProviderPort>()("@shivaedev/agent-opencode/Provider") {}

package/src/adapters/MessageUpdatedProperties.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+export const MessageUpdatedProperties = Schema.Struct({
+	info: Schema.Struct({
+		id: Schema.String,
+		"modelID": Schema.optional(Schema.String),
+		"providerID": Schema.optional(Schema.String),
+		role: Schema.Literals(["assistant", "user"]),
+	}),
+});

package/src/adapters/OpencodeRequest.ts

@@ -0,0 +1,5 @@
+export interface OpencodeRequest {
+	readonly body: unknown;
+	readonly path: string;
+	readonly query: Readonly<Record<string, string>>;
+}

package/src/adapters/answerToolRequest.ts

@@ -0,0 +1,121 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { CallToolRequest, CallToolResult, ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { Effect, Option, Schema } from "effect";
+import { CALLER_CALL, CALLER_SESSION, TOOL_SERVER_NAME } from "#adapters/toolNames.ts";
+import type { ToolSessions } from "#adapters/toolSessions.ts";
+import type { ToolDefinition } from "#tools.ts";
+
+function listed(tool: ToolDefinition) {
+	return {
+		description: tool.description,
+		inputSchema: { ...tool.inputSchema, type: "object" as const },
+		name: tool.name,
+	};
+}
+function said(text: string, ok: boolean): CallToolResult {
+	return {
+		content: [{ text, type: "text" as const }],
+		isError: !ok,
+	};
+}
+const decodeArguments = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown));
+function caller(args: unknown): {
+	readonly rest: unknown;
+	readonly session: string | undefined;
+	readonly callId: string | undefined;
+} {
+	return Option.match(decodeArguments(args), {
+		onNone: () => ({ callId: undefined, rest: args, session: undefined }),
+		onSome: ({ [CALLER_SESSION]: session, [CALLER_CALL]: callId, ...rest }) => ({
+			callId: typeof callId === "string" ? callId : undefined,
+			rest,
+			session: typeof session === "string" ? session : undefined,
+		}),
+	});
+}
+async function answerCall(sessions: ToolSessions, name: string, args: unknown): Promise<CallToolResult> {
+	const { rest, session, callId } = caller(args);
+	if (session === undefined) {
+		return said(`the call named no ${CALLER_SESSION}, so platform cannot tell which session is asking`, false);
+	}
+	if (callId === undefined) {
+		return said(`the call named no ${CALLER_CALL}, so platform cannot identify the provider call`, false);
+	}
+	const served = sessions.served(session);
+	if (Option.isNone(served)) {
+		return said(`platform serves no open session ${session}`, false);
+	}
+	const tool = served.value.get(name);
+	if (tool === undefined) {
+		return said(`session ${session} was given no tool named ${name}`, false);
+	}
+	const outcome = await tool(callId, rest);
+	return said(outcome.text, outcome.ok);
+}
+const progressWhileOpen = Effect.fnUntraced(function* (send: (progress: number) => Promise<void>) {
+	let progress = 0;
+	const report = Effect.promise(() =>
+		send(progress).then(() => {
+			progress += 1;
+		}),
+	);
+	yield* report;
+	yield* Effect.forkScoped(Effect.forever(Effect.andThen(Effect.sleep(30_000), report)));
+});
+function answerWithProgress(sessions: ToolSessions, message: CallToolRequest, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) {
+	return Effect.runPromise(
+		Effect.scoped(
+			Effect.gen(function* () {
+				const token = message.params._meta?.progressToken;
+				if (token !== undefined) {
+					yield* progressWhileOpen((progress) =>
+						extra.sendNotification({ method: "notifications/progress", params: { progress, progressToken: token } }),
+					);
+				}
+				return yield* Effect.promise(() => answerCall(sessions, message.params.name, message.params.arguments));
+			}),
+		),
+		{ signal: extra.signal },
+	);
+}
+// Omitting the session-id generator makes the transport stateless, so each request gets its own protocol server and nothing is carried between them.
+export function answerToolRequest(tools: readonly ToolDefinition[], sessions: ToolSessions) {
+	const list = tools.map(listed);
+	return async (request: Request): Promise<Response> => {
+		const server = new Server({ name: TOOL_SERVER_NAME, version: "0.0.0" }, { capabilities: { tools: {} } });
+		server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: list }));
+		server.setRequestHandler(CallToolRequestSchema, (message, extra) => answerWithProgress(sessions, message, extra));
+		const transport = new WebStandardStreamableHTTPServerTransport();
+		await server.connect(transport);
+		const response = await transport.handleRequest(request);
+		if (response.body === null) {
+			await server.close();
+			return response;
+		}
+		const reader = response.body.getReader();
+		const body = new ReadableStream<Uint8Array>({
+			async cancel() {
+				await reader.cancel();
+				await server.close();
+			},
+			async pull(controller) {
+				try {
+					const next = await reader.read();
+					if (next.done) {
+						await server.close();
+						controller.close();
+					} else {
+						controller.enqueue(next.value);
+					}
+				} catch (error) {
+					await server.close();
+					controller.error(error);
+				}
+			},
+		});
+		return new Response(body, { headers: response.headers, status: response.status });
+	};
+}

package/src/adapters/listeningUrl.ts

@@ -0,0 +1,4 @@
+const LISTENING = /listening on (?<url>https?:\/\/\S+)/u;
+export function listeningUrl(line: string): string | undefined {
+	return LISTENING.exec(line)?.groups?.url;
+}

package/src/adapters/makeOpencodeServer.ts

@@ -0,0 +1,77 @@
+import { Deferred, Effect, PubSub, type Scope, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { type ReadFailure, Rejected } from "@shivaedev/agent/failures.ts";
+import { checkStatus } from "@shivaedev/http/checkStatus.ts";
+import { filterStatus } from "@shivaedev/http/filterStatus.ts";
+import type { OpencodeRequest } from "#adapters/OpencodeRequest.ts";
+import { openSseBuffer } from "#adapters/openSseBuffer.ts";
+import type { ToolSessions } from "#adapters/toolSessions.ts";
+import { opencodeFailure, unavailable } from "#failure.ts";
+import type { ProviderPort } from "#Provider.ts";
+
+function checkedPost(response: HttpClientResponse.HttpClientResponse, request: OpencodeRequest) {
+	return HttpClientResponse.matchStatus(response, {
+		"4xx": (refused) =>
+			Effect.fail(
+				new Rejected({
+					backend: "opencode",
+					message: `POST ${request.path} refused with HTTP ${refused.status}`,
+					providerCode: String(refused.status),
+				}),
+			),
+		orElse: (answered) => checkStatus(answered).pipe(Effect.as(answered)),
+	});
+}
+export const makeOpencodeServer = Effect.fn("OpenCode.makeOpencodeServer")(function* (
+	url: string,
+	tools: ToolSessions,
+): Effect.fn.Return<ProviderPort, ReadFailure, Scope.Scope | HttpClient.HttpClient> {
+	const native = yield* HttpClient.HttpClient;
+	const client = filterStatus(native);
+	const frames = yield* PubSub.unbounded<unknown>();
+	const exited = yield* Deferred.make<void>();
+	const ready = yield* Deferred.make<void, ReadFailure>();
+	const buffer = openSseBuffer(() => undefined);
+	const listen = client.get(new URL("/global/event", url).href).pipe(
+		Effect.mapError(unavailable),
+		Effect.flatMap((response) =>
+			Deferred.succeed(ready, undefined).pipe(
+				Effect.andThen(
+					response.stream.pipe(
+						Stream.decodeText,
+						Stream.flatMap((text) => Stream.fromIterable(buffer.take(text))),
+						Stream.runForEach((frame) => PubSub.publish(frames, frame)),
+					),
+				),
+			),
+		),
+		Effect.catch((error) => Deferred.fail(ready, unavailable(error))),
+		Effect.ensuring(Deferred.succeed(exited, undefined)),
+	);
+	yield* Effect.forkScoped(listen);
+	yield* Deferred.await(ready);
+	function call(method: "GET" | "POST") {
+		return (request: OpencodeRequest) => {
+			const address = new URL(request.path, url);
+			for (const [key, value] of Object.entries(request.query)) {
+				address.searchParams.set(key, value);
+			}
+			const req = HttpClientRequest.make(method)(address.href);
+			const send =
+				method === "POST"
+					? native.execute(HttpClientRequest.bodyJsonUnsafe(req, request.body)).pipe(Effect.flatMap((response) => checkedPost(response, request)))
+					: client.execute(req);
+			return send.pipe(
+				Effect.mapError((error) => (error._tag === "Rejected" ? error : unavailable(error))),
+				Effect.flatMap((response) => (response.status === 204 ? Effect.succeed(undefined) : response.json.pipe(Effect.mapError(opencodeFailure)))),
+			);
+		};
+	}
+	return {
+		exited: Deferred.await(exited),
+		frames,
+		get: (request) => call("GET")(request).pipe(Effect.catchTag("Rejected", (error) => Effect.fail(opencodeFailure(error.message)))),
+		post: call("POST"),
+		tools,
+	};
+});

package/src/adapters/mapping.ts

@@ -0,0 +1,14 @@
+import type { Raw } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type RawPayload = typeof Raw.Type;
+export function rawOf(kind: string, payload: unknown): RawPayload {
+	return {
+		kind,
+		payload: JSON.stringify(payload),
+		source: "opencode",
+	};
+}
+export function rawEvent(raw: RawPayload): AgentEvent[] {
+	return [{ raw, type: "raw" }];
+}

package/src/adapters/messageAuthors.ts

@@ -0,0 +1,31 @@
+import { Option, Schema } from "effect";
+import { MessageUpdatedProperties } from "#adapters/MessageUpdatedProperties.ts";
+export interface MessageAuthor {
+	readonly model: string | undefined;
+	readonly role: "agent" | "user";
+}
+export interface MessageAuthors {
+	readonly of: (messageId: string) => Option.Option<MessageAuthor>;
+	readonly record: (properties: unknown) => void;
+}
+const decodeMessage = Schema.decodeUnknownOption(MessageUpdatedProperties);
+function modelOf(info: typeof MessageUpdatedProperties.Type.info, sessionModel: string | undefined) {
+	return info.providerID === undefined || info.modelID === undefined ? sessionModel : `${info.providerID}/${info.modelID}`;
+}
+export function openMessageAuthors(sessionModel: string | undefined): MessageAuthors {
+	const authors = new Map<string, MessageAuthor>();
+	return {
+		of: (messageId) => Option.fromNullishOr(authors.get(messageId)),
+		record: (properties) => {
+			Option.match(decodeMessage(properties), {
+				onNone: () => undefined,
+				onSome: ({ info }) => {
+					authors.set(info.id, {
+						model: modelOf(info, sessionModel),
+						role: info.role === "user" ? "user" : "agent",
+					});
+				},
+			});
+		},
+	};
+}

package/src/adapters/openSseBuffer.ts

@@ -0,0 +1,36 @@
+import { Option, Schema } from "effect";
+
+const decodeFrame = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+function dataFrames(chunk: string, onMalformed: (line: string) => void): unknown[] {
+	const frames: unknown[] = [];
+	for (const line of chunk.split("\n")) {
+		if (!line.startsWith("data:")) {
+			continue;
+		}
+		const frame = decodeFrame(line.slice(5));
+		if (Option.isSome(frame)) {
+			frames.push(frame.value);
+		} else {
+			onMalformed(line);
+		}
+	}
+	return frames;
+}
+interface SseBuffer {
+	readonly take: (chunk: string) => unknown[];
+}
+export function openSseBuffer(onMalformed: (line: string) => void): SseBuffer {
+	let pending = "";
+	return {
+		take: (chunk) => {
+			pending += chunk;
+			const boundary = pending.lastIndexOf("\n");
+			if (boundary < 0) {
+				return [];
+			}
+			const complete = pending.slice(0, boundary);
+			pending = pending.slice(boundary + 1);
+			return dataFrames(complete, onMalformed);
+		},
+	};
+}

package/src/adapters/openTurnBoundary.ts

@@ -0,0 +1,58 @@
+import type { Raw } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type RawPayload = typeof Raw.Type;
+type SessionState = "running" | "awaiting-input";
+
+import { Option, Schema } from "effect";
+import { rawEvent } from "#adapters/mapping.ts";
+import { SessionErrorProperties, SessionStatusProperties } from "#adapters/protocol.ts";
+
+const decodeStatus = Schema.decodeUnknownOption(SessionStatusProperties);
+const decodeError = Schema.decodeUnknownOption(SessionErrorProperties);
+function stateOf(type: string): SessionState | undefined {
+	if (type === "idle") {
+		return "awaiting-input";
+	}
+	return type === "busy" || type === "retry" ? "running" : undefined;
+}
+const ABORTED = "MessageAbortedError";
+interface TurnBoundary {
+	readonly errored: (raw: RawPayload, properties: unknown) => AgentEvent[];
+	readonly idled: (raw: RawPayload) => AgentEvent[];
+	readonly status: (raw: RawPayload, properties: unknown) => AgentEvent[];
+}
+export function openTurnBoundary(): TurnBoundary {
+	let running = false;
+	let outcome: "failed" | "interrupted" | undefined;
+	return {
+		errored: (raw, properties) => {
+			outcome = Option.match(decodeError(properties), {
+				onNone: () => "failed" as const,
+				onSome: ({ error }) => (error?.name === ABORTED ? "interrupted" : "failed"),
+			});
+			return rawEvent(raw);
+		},
+		idled: (raw) => {
+			if (!running) {
+				return [];
+			}
+			running = false;
+			const status = outcome ?? "completed";
+			outcome = undefined;
+			return [{ raw, state: status, type: "execution" }];
+		},
+		status: (raw, properties) =>
+			Option.match(decodeStatus(properties), {
+				onNone: () => rawEvent(raw),
+				onSome: ({ status }) => {
+					const state = stateOf(status.type);
+					if (state === undefined) {
+						return rawEvent(raw);
+					}
+					running = running || state === "running";
+					return [{ raw, state, type: "execution" }];
+				},
+			}),
+	};
+}

package/src/adapters/opencodePlugin.config.ts

@@ -0,0 +1,17 @@
+export default () => ({
+	"tool.execute.before": (
+		input: {
+			tool: string;
+			"sessionID": string;
+			"callID": string;
+		},
+		output: {
+			args: Record<string, unknown>;
+		},
+	) => {
+		if (input.tool.startsWith("platform_")) {
+			output.args.callerSession = input.sessionID;
+			output.args.callerCall = input.callID;
+		}
+	},
+});