@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/packages/ai/providers/opencode-sdk.ts

@@ -0,0 +1,546 @@
+/**
+ * OpenCode provider — bridges Plannotator's AI layer with OpenCode's agent server.
+ *
+ * Uses @opencode-ai/sdk to connect to an existing `opencode serve` first and
+ * only spawns a new server when nothing is reachable. One server is shared
+ * across all sessions. The user must have the `opencode` CLI installed and
+ * authenticated.
+ */
+
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { BaseSession } from "../base-session.ts";
+import { buildSystemPrompt } from "../context.ts";
+import type {
+	AIMessage,
+	AIProvider,
+	AIProviderCapabilities,
+	AISession,
+	CreateSessionOptions,
+	OpenCodeConfig,
+} from "../types.ts";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const PROVIDER_NAME = "opencode-sdk";
+
+// ---------------------------------------------------------------------------
+// SDK import cache — resolve once, reuse across all sessions
+// ---------------------------------------------------------------------------
+
+// biome-ignore lint/suspicious/noExplicitAny: SDK types not available at compile time
+let sdk: any = null;
+
+async function getSDK() {
+	if (!sdk) {
+		sdk = await import("@opencode-ai/sdk");
+	}
+	return sdk;
+}
+
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+
+export class OpenCodeProvider implements AIProvider {
+	readonly name = PROVIDER_NAME;
+	readonly capabilities: AIProviderCapabilities = {
+		fork: true,
+		resume: true,
+		streaming: true,
+		tools: true,
+	};
+	models?: Array<{ id: string; label: string; default?: boolean }>;
+
+	private config: OpenCodeConfig;
+	// biome-ignore lint/suspicious/noExplicitAny: SDK types not available at compile time
+	private server: { url: string; close: () => void } | null = null;
+	private client: OpencodeClient | null = null;
+	private startPromise: Promise<void> | null = null;
+	private lastAttachError: string | null = null;
+
+	constructor(config: OpenCodeConfig) {
+		this.config = config;
+	}
+
+	/** Attach to an existing OpenCode server or spawn one if needed. */
+	async ensureServer(): Promise<void> {
+		if (this.client) return;
+		this.startPromise ??= this.doStart().catch((err) => {
+			this.startPromise = null;
+			throw err;
+		});
+		return this.startPromise;
+	}
+
+	private async doStart(): Promise<void> {
+		this.lastAttachError = null;
+		const { createOpencodeServer, createOpencodeClient } = await getSDK();
+		const attachedClient = await this.tryAttachExistingServer(createOpencodeClient);
+		if (attachedClient) {
+			this.client = attachedClient;
+			return;
+		}
+
+		try {
+			this.server = await createOpencodeServer({
+				hostname: this.config.hostname ?? "127.0.0.1",
+				...(this.config.port != null && { port: this.config.port }),
+				timeout: 15_000,
+			});
+		} catch (err) {
+			const spawnMessage = err instanceof Error ? err.message : String(err);
+			if (this.lastAttachError) {
+				throw new Error(`${this.lastAttachError}\nFallback startup also failed: ${spawnMessage}`);
+			}
+			throw err;
+		}
+
+		this.client = createOpencodeClient({
+			baseUrl: this.server!.url,
+			directory: this.config.cwd ?? process.cwd(),
+		});
+	}
+
+	private async tryAttachExistingServer(
+		createOpencodeClient: (config?: { baseUrl?: string; directory?: string }) => OpencodeClient,
+	): Promise<OpencodeClient | null> {
+		const cwd = this.config.cwd ?? process.cwd();
+		const baseUrl = `http://${this.config.hostname ?? "127.0.0.1"}:${this.config.port ?? 4096}`;
+		const client = createOpencodeClient({
+			baseUrl,
+			directory: cwd,
+		});
+
+		try {
+			await client.config.get({
+				throwOnError: true,
+				signal: AbortSignal.timeout(1_000),
+			});
+			return client;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.lastAttachError = `Failed to attach to existing OpenCode server at ${baseUrl}: ${message}`;
+			return null;
+		}
+	}
+
+	private getClient(): OpencodeClient {
+		if (!this.client) {
+			throw new Error("OpenCode client is not initialized.");
+		}
+		return this.client;
+	}
+
+	async createSession(options: CreateSessionOptions): Promise<AISession> {
+		await this.ensureServer();
+		const client = this.getClient();
+
+		const result = await client.session.create({
+			query: { directory: options.cwd ?? this.config.cwd ?? process.cwd() },
+		});
+		const sessionData = result.data;
+		if (!sessionData) {
+			throw new Error("OpenCode did not return session data.");
+		}
+
+		const session = new OpenCodeSession({
+			sessionId: sessionData.id,
+			systemPrompt: buildSystemPrompt(options.context),
+			client,
+			model: options.model,
+			parentSessionId: null,
+		});
+		return session;
+	}
+
+	async forkSession(options: CreateSessionOptions): Promise<AISession> {
+		await this.ensureServer();
+		const client = this.getClient();
+
+		const parentId = options.context.parent?.sessionId;
+		if (!parentId) {
+			throw new Error("Fork requires a parent session ID.");
+		}
+
+		const result = await client.session.fork({
+			path: { id: parentId },
+		});
+		const sessionData = result.data;
+		if (!sessionData) {
+			throw new Error("OpenCode did not return forked session data.");
+		}
+
+		return new OpenCodeSession({
+			sessionId: sessionData.id,
+			systemPrompt: buildSystemPrompt(options.context),
+			client,
+			model: options.model,
+			parentSessionId: parentId,
+		});
+	}
+
+	async resumeSession(sessionId: string): Promise<AISession> {
+		await this.ensureServer();
+		const client = this.getClient();
+
+		// Verify session exists
+		await client.session.get({ path: { id: sessionId } });
+
+		return new OpenCodeSession({
+			sessionId,
+			systemPrompt: null,
+			client,
+			model: undefined,
+			parentSessionId: null,
+		});
+	}
+
+	dispose(): void {
+		if (this.server) {
+			this.server.close();
+			this.server = null;
+		}
+		this.client = null;
+		this.startPromise = null;
+	}
+
+	/** Fetch available models from OpenCode. Call before registering the provider. */
+	async fetchModels(): Promise<void> {
+		try {
+			await this.ensureServer();
+			const client = this.getClient();
+
+			const result = await client.provider.list({
+				query: { directory: this.config.cwd ?? process.cwd() },
+			});
+			const data = result.data;
+			if (!data) {
+				return;
+			}
+			const connected = new Set(data.connected ?? []);
+			const allProviders = data.all ?? [];
+
+			const models: Array<{ id: string; label: string; default?: boolean }> = [];
+			for (const provider of allProviders) {
+				if (!connected.has(provider.id)) continue;
+				for (const model of Object.values(provider.models)) {
+					models.push({
+						id: `${provider.id}/${model.id}`,
+						label: model.name ?? model.id,
+					});
+				}
+			}
+
+			if (models.length > 0) {
+				// Mark first model as default
+				models[0].default = true;
+				this.models = models;
+			}
+		} catch {
+			// OpenCode not configured or no models available
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Session
+// ---------------------------------------------------------------------------
+
+interface SessionConfig {
+	sessionId: string;
+	systemPrompt: string | null;
+	// biome-ignore lint/suspicious/noExplicitAny: SDK types not available at compile time
+	client: any;
+	/** Model in "providerID/modelID" format. */
+	model?: string;
+	parentSessionId: string | null;
+}
+
+class OpenCodeSession extends BaseSession {
+	private config: SessionConfig;
+
+	constructor(config: SessionConfig) {
+		super({
+			parentSessionId: config.parentSessionId,
+			initialId: config.sessionId,
+		});
+		this.config = config;
+		this._resolvedId = config.sessionId;
+	}
+
+	async *query(prompt: string): AsyncIterable<AIMessage> {
+		const started = this.startQuery();
+		if (!started) {
+			yield BaseSession.BUSY_ERROR;
+			return;
+		}
+		const { gen } = started;
+
+		try {
+			// Build model param if specified
+			let modelParam: { providerID: string; modelID: string } | undefined;
+			if (this.config.model) {
+				const [providerID, ...rest] = this.config.model.split("/");
+				const modelID = rest.join("/");
+				if (providerID && modelID) {
+					modelParam = { providerID, modelID };
+				}
+			}
+
+			// Subscribe to SSE events
+			const { stream } = await this.config.client.event.subscribe();
+
+			try {
+				// Send prompt asynchronously
+				try {
+					await this.config.client.session.promptAsync({
+						path: { id: this.config.sessionId },
+						body: {
+							...(!this._firstQuerySent &&
+								this.config.systemPrompt && {
+									system: this.config.systemPrompt,
+								}),
+							...(modelParam && { model: modelParam }),
+							parts: [{ type: "text", text: prompt }],
+						},
+					});
+				} catch (err) {
+					yield {
+						type: "error",
+						error: `OpenCode rejected prompt: ${err instanceof Error ? err.message : String(err)}`,
+						code: "opencode_prompt_rejected",
+					};
+					return;
+				}
+				this._firstQuerySent = true;
+
+				// Drain SSE events filtered by session ID
+				for await (const event of stream) {
+					const eventType = event.type as string;
+					const props = event.properties as Record<string, unknown> | undefined;
+					if (!props) continue;
+
+					// Filter: only events for our session
+					const eventSessionId =
+						(props.sessionID as string) ??
+						((props.info as Record<string, unknown>)?.sessionID as string) ??
+						((props.part as Record<string, unknown>)?.sessionID as string);
+					if (eventSessionId && eventSessionId !== this.config.sessionId) continue;
+
+					const mapped = mapOpenCodeEvent(eventType, props, this.id);
+					for (const msg of mapped) {
+						yield msg;
+						if (msg.type === "result" || (msg.type === "error" && isTerminalEvent(eventType))) {
+							return;
+						}
+					}
+				}
+			} finally {
+				stream.return?.();
+			}
+		} catch (err) {
+			yield {
+				type: "error",
+				error: err instanceof Error ? err.message : String(err),
+				code: "provider_error",
+			};
+		} finally {
+			this.endQuery(gen);
+		}
+	}
+
+	abort(): void {
+		this.config.client.session
+			.abort({ path: { id: this.config.sessionId } })
+			.catch(() => {});
+		super.abort();
+	}
+
+	respondToPermission(
+		requestId: string,
+		allow: boolean,
+		_message?: string,
+	): void {
+		this.config.client
+			.postSessionIdPermissionsPermissionId({
+				path: { id: this.config.sessionId, permissionID: requestId },
+				body: { response: allow ? "once" : "reject" },
+			})
+			.catch(() => {});
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Event mapping
+// ---------------------------------------------------------------------------
+
+/** Returns true for events that should terminate the query when mapped to an error. */
+function isTerminalEvent(eventType: string): boolean {
+	return eventType === "session.error" || eventType === "session.status";
+}
+
+/**
+ * Map an OpenCode SSE event to AIMessage[].
+ *
+ * Key events:
+ *   message.part.delta  → text_delta (streaming text)
+ *   message.part.updated → tool_use / tool_result (tool lifecycle)
+ *   permission.updated   → permission_request
+ *   session.status        → result (when idle)
+ *   message.updated       → error (when message has error)
+ */
+export function mapOpenCodeEvent(
+	eventType: string,
+	props: Record<string, unknown>,
+	sessionId: string,
+): AIMessage[] {
+	switch (eventType) {
+		case "message.part.delta": {
+			const field = props.field as string;
+			const delta = props.delta as string;
+			if (field === "text" && delta) {
+				return [{ type: "text_delta", delta }];
+			}
+			return [];
+		}
+
+		case "message.part.updated": {
+			const part = props.part as Record<string, unknown>;
+			if (!part) return [];
+
+			const partType = part.type as string;
+
+			if (partType === "tool") {
+				const state = part.state as Record<string, unknown>;
+				if (!state) return [];
+
+				const status = state.status as string;
+				const callID = (part.callID as string) ?? (part.id as string);
+				const toolName = part.tool as string;
+
+				switch (status) {
+					case "running":
+						return [
+							{
+								type: "tool_use",
+								toolName: toolName ?? "unknown",
+								toolInput: (state.input as Record<string, unknown>) ?? {},
+								toolUseId: callID,
+							},
+						];
+
+					case "completed": {
+						const output = (state.output as string) ?? "";
+						return [
+							{
+								type: "tool_result",
+								toolUseId: callID,
+								result: output,
+							},
+						];
+					}
+
+					case "error": {
+						const error = (state.error as string) ?? "Tool execution failed";
+						return [
+							{
+								type: "tool_result",
+								toolUseId: callID,
+								result: `[Error] ${error}`,
+							},
+						];
+					}
+
+					default:
+						return [];
+				}
+			}
+
+			return [];
+		}
+
+		case "permission.updated": {
+			const id = props.id as string;
+			const permType = props.type as string;
+			const title = props.title as string;
+			const callID = props.callID as string;
+			const metadata = (props.metadata as Record<string, unknown>) ?? {};
+
+			return [
+				{
+					type: "permission_request",
+					requestId: id,
+					toolName: permType ?? "unknown",
+					toolInput: metadata,
+					title: title ?? permType,
+					toolUseId: callID ?? id,
+				},
+			];
+		}
+
+		case "session.status": {
+			const status = props.status as Record<string, unknown>;
+			if (status?.type === "idle") {
+				return [
+					{
+						type: "result",
+						sessionId,
+						success: true,
+					},
+				];
+			}
+			return [];
+		}
+
+		case "session.error": {
+			const error = props.error as Record<string, unknown>;
+			const message =
+				(error?.message as string) ?? (props.message as string) ?? "Session error";
+			return [
+				{
+					type: "error",
+					error: message,
+					code: "opencode_session_error",
+				},
+			];
+		}
+
+		case "message.updated": {
+			const info = props.info as Record<string, unknown>;
+			if (!info) return [];
+
+			const msgError = info.error as Record<string, unknown>;
+			if (msgError) {
+				const errorData = msgError.data as Record<string, unknown>;
+				const message =
+					(errorData?.message as string) ??
+					(msgError.name as string) ??
+					"Message error";
+				return [
+					{
+						type: "error",
+						error: message,
+						code: "opencode_message_error",
+					},
+				];
+			}
+			return [];
+		}
+
+		default:
+			return [];
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Factory registration
+// ---------------------------------------------------------------------------
+
+import { registerProviderFactory } from "../provider.ts";
+
+registerProviderFactory(
+	PROVIDER_NAME,
+	async (config) => new OpenCodeProvider(config as OpenCodeConfig),
+);

package/3p/pi-plannotator/packages/ai/providers/pi-events.ts

@@ -0,0 +1,110 @@
+/**
+ * Pi event mapping — shared between Bun and Node.js Pi providers.
+ *
+ * Pure function, no runtime-specific dependencies.
+ */
+
+import type { AIMessage } from "../types.ts";
+
+/**
+ * Map a Pi AgentEvent (received as JSONL) to AIMessage[].
+ *
+ * Pi event hierarchy:
+ *   agent_start > turn_start > message_start > message_update* > message_end
+ *     > tool_execution_start > tool_execution_end > turn_end > agent_end
+ *
+ * We extract:
+ * - text_delta from message_update.assistantMessageEvent
+ * - tool_use from toolcall_end
+ * - tool_result from tool_execution_end
+ * - result from agent_end
+ */
+export function mapPiEvent(
+	event: Record<string, unknown>,
+	sessionId: string,
+): AIMessage[] {
+	const eventType = event.type as string;
+
+	switch (eventType) {
+		case "message_update": {
+			const ame = event.assistantMessageEvent as
+				| Record<string, unknown>
+				| undefined;
+			if (!ame) return [];
+
+			const subType = ame.type as string;
+
+			switch (subType) {
+				case "text_delta":
+					return [{ type: "text_delta", delta: ame.delta as string }];
+
+				case "toolcall_end": {
+					const tc = ame.toolCall as Record<string, unknown>;
+					if (!tc) return [];
+					return [
+						{
+							type: "tool_use",
+							toolName: tc.name as string,
+							toolInput: (tc.arguments as Record<string, unknown>) ?? {},
+							toolUseId: tc.id as string,
+						},
+					];
+				}
+
+				case "error": {
+					const partial = ame.error as Record<string, unknown> | undefined;
+					const errorMessage =
+						(partial?.errorMessage as string) ?? "Stream error";
+					return [
+						{ type: "error", error: errorMessage, code: "pi_stream_error" },
+					];
+				}
+
+				default:
+					return [];
+			}
+		}
+
+		case "tool_execution_end": {
+			const result = event.result;
+			const isError = event.isError as boolean;
+			const resultStr =
+				result == null
+					? ""
+					: typeof result === "string"
+						? result
+						: JSON.stringify(result);
+
+			return [
+				{
+					type: "tool_result",
+					toolUseId: event.toolCallId as string,
+					result: isError
+						? `[Error] ${resultStr || "Tool execution failed"}`
+						: resultStr,
+				},
+			];
+		}
+
+		case "agent_end":
+			return [
+				{
+					type: "result",
+					sessionId,
+					success: true,
+				},
+			];
+
+		case "process_exited":
+			return [
+				{
+					type: "error",
+					error: "Pi process exited unexpectedly.",
+					code: "pi_process_exit",
+				},
+			];
+
+		default:
+			return [];
+	}
+}