@yeshwanthyk/coding-agent 0.2.2

package/src/adapters/acp/index.ts

@@ -0,0 +1,305 @@
+/**
+ * ACP (Agent Client Protocol) server mode for Zed integration
+ * JSON-RPC 2.0 over stdio
+ */
+
+import type { Agent } from "@yeshwanthyk/agent-core"
+import { getModels, type KnownProvider, type Model, type Api } from "@yeshwanthyk/ai"
+import { createRuntime } from "@runtime/factory.js"
+import { Effect } from "effect"
+import {
+	type JsonRpcRequest,
+	type JsonRpcNotification,
+	type InitializeParams,
+	type InitializeResult,
+	type NewSessionParams,
+	type NewSessionResult,
+	type PromptParams,
+	type PromptResult,
+	type CancelParams,
+	type SetModelParams,
+	type SetModelResult,
+	type ModelOption,
+	makeResponse,
+	makeError,
+	ErrorCodes,
+} from "./protocol.js"
+import { createUpdateEmitter } from "./updates.js"
+import { createAcpSession, type AcpSession } from "./session.js"
+import pkg from "../../../package.json"
+
+// Fixed model list for Zed picker
+const MODEL_OPTIONS: ModelOption[] = [
+	{ modelId: "claude-opus-4-5", name: "Claude Opus 4.5" },
+	{ modelId: "codex/gpt-5.2-codex", name: "GPT 5.2 Codex" },
+	{ modelId: "opencode/glm-4.7-free", name: "GLM 4.7 Free" },
+]
+
+interface AcpServerState {
+	initialized: boolean
+	session: AcpSession | null
+	agent: Agent | null
+	currentModelId: string
+}
+
+function parseModelSpec(spec: string): { provider: KnownProvider; modelId: string } {
+	if (spec.includes("/")) {
+		const [provider, ...rest] = spec.split("/")
+		return { provider: provider as KnownProvider, modelId: rest.join("/") }
+	}
+	// Default to anthropic for models without provider prefix
+	return { provider: "anthropic", modelId: spec }
+}
+
+function findModel(provider: KnownProvider, modelId: string): Model<Api> | undefined {
+	const models = getModels(provider)
+	return models.find((m) => m.id === modelId) as Model<Api> | undefined
+}
+
+export async function runAcp(args: { configDir?: string; configPath?: string; model?: string }) {
+	const runtime = await createRuntime(
+		{
+			configDir: args.configDir,
+			configPath: args.configPath,
+			model: args.model,
+		},
+		"acp",
+	)
+
+	// Initialize hooks with no-op handlers for ACP mode (no interactive UI)
+	runtime.hookRunner.initialize({
+		sendHandler: () => {},
+		sendMessageHandler: () => {},
+		sendUserMessageHandler: async () => {},
+		steerHandler: async () => {},
+		followUpHandler: async () => {},
+		isIdleHandler: () => true,
+		appendEntryHandler: (customType, data) => runtime.sessionManager.appendEntry(customType, data),
+		getSessionId: () => runtime.sessionManager.sessionId,
+		getModel: () => runtime.agent.state.model,
+		hasUI: false,
+	})
+
+	// Determine initial model from args or first in MODEL_OPTIONS
+	const initialModelId = args.model?.split(",")[0] ?? MODEL_OPTIONS[0]?.modelId ?? "claude-opus-4-5"
+
+	const state: AcpServerState = {
+		initialized: false,
+		session: null,
+		agent: null,
+		currentModelId: initialModelId,
+	}
+
+	// Write JSON-RPC message to stdout
+	const writeMessage = (msg: object) => {
+		const json = JSON.stringify(msg)
+		process.stdout.write(json + "\n")
+	}
+
+	// Handle initialize request
+	const handleInitialize = (_params: InitializeParams): InitializeResult => {
+		state.initialized = true
+		return {
+			protocolVersion: 1,
+			agentInfo: {
+				name: "Marvin",
+				version: pkg.version,
+			},
+			agentCapabilities: {
+				promptCapabilities: {
+					image: true,
+					embeddedContext: false,
+				},
+			},
+			authMethods: [],
+		}
+	}
+
+	// Handle session/new request
+	const handleNewSession = async (params: NewSessionParams): Promise<NewSessionResult> => {
+		const sessionId = crypto.randomUUID()
+		const cwd = params.cwd || process.cwd()
+
+		// Parse current model
+		const { provider, modelId } = parseModelSpec(state.currentModelId)
+		const model = findModel(provider, modelId)
+		if (!model) {
+			throw new Error(`Model not found: ${state.currentModelId}`)
+		}
+
+		// Prepare runtime agent
+		const agent = runtime.agent
+		agent.abort()
+		agent.reset()
+		agent.setModel(model)
+		agent.setThinkingLevel(runtime.config.thinking)
+		state.agent = agent
+		runtime.config.provider = provider
+		runtime.config.modelId = model.id
+		runtime.config.model = model
+
+		await Effect.runPromise(runtime.sessionOrchestrator.queue.clear)
+
+		// Create update emitter
+		const emitter = createUpdateEmitter(sessionId, writeMessage)
+
+		// Model setter
+		const setModelFn = (newModelId: string): boolean => {
+			const option = MODEL_OPTIONS.find((m) => m.modelId === newModelId)
+			if (!option) return false
+
+			const { provider: p, modelId: m } = parseModelSpec(newModelId)
+			const newModel = findModel(p, m)
+			if (!newModel) return false
+			const activeAgent = state.agent ?? runtime.agent
+			activeAgent.setModel(newModel)
+			state.currentModelId = newModelId
+			runtime.config.provider = p
+			runtime.config.modelId = newModel.id
+			runtime.config.model = newModel
+			return true
+		}
+
+		// Create session
+		state.session = createAcpSession({
+			sessionId,
+			cwd,
+			agent,
+			sessionOrchestrator: runtime.sessionOrchestrator,
+			emitter,
+			models: MODEL_OPTIONS,
+			currentModelId: state.currentModelId,
+			contextWindow: model.contextWindow,
+			thinkingLevel: runtime.config.thinking,
+			setModel: setModelFn,
+		})
+
+		return {
+			sessionId,
+			models: {
+				availableModels: MODEL_OPTIONS,
+				currentModelId: state.currentModelId,
+			},
+		}
+	}
+
+	// Emit post-session notifications (called after response is sent)
+	const emitSessionNotifications = () => {
+		if (!state.session) return
+		const emitter = createUpdateEmitter(state.session.id, writeMessage)
+		emitter.emitCommands(state.session.getAvailableCommands())
+		emitter.emitModels(MODEL_OPTIONS, state.currentModelId)
+	}
+
+	// Handle session/prompt request
+	const handlePrompt = async (params: PromptParams): Promise<PromptResult> => {
+		if (!state.session) {
+			throw new Error("No active session")
+		}
+		if (params.sessionId !== state.session.id) {
+			throw new Error("Invalid session ID")
+		}
+
+		const stopReason = await state.session.prompt(params.prompt)
+		return { stopReason }
+	}
+
+	// Handle session/cancel notification
+	const handleCancel = (params: CancelParams): void => {
+		if (state.session && params.sessionId === state.session.id) {
+			state.session.cancel()
+		}
+	}
+
+	// Handle session/set_model request
+	const handleSetModel = (params: SetModelParams): SetModelResult => {
+		if (!state.session) {
+			throw new Error("No active session")
+		}
+		if (params.sessionId !== state.session.id) {
+			throw new Error("Invalid session ID")
+		}
+
+		const success = state.session.setModel(params.modelId)
+		if (!success) {
+			throw new Error(`Unknown model: ${params.modelId}`)
+		}
+
+		return { modelId: params.modelId }
+	}
+
+	// Process a JSON-RPC request
+	const processRequest = async (req: JsonRpcRequest): Promise<void> => {
+		try {
+			let result: unknown
+
+			switch (req.method) {
+				case "initialize":
+					result = handleInitialize(req.params as InitializeParams)
+					break
+				case "session/new":
+					result = await handleNewSession(req.params as NewSessionParams)
+					break
+				case "session/prompt":
+					result = await handlePrompt(req.params as PromptParams)
+					break
+				case "session/set_model":
+					result = handleSetModel(req.params as SetModelParams)
+					break
+				default:
+					writeMessage(makeError(req.id, ErrorCodes.MethodNotFound, `Unknown method: ${req.method}`))
+					return
+			}
+
+			writeMessage(makeResponse(req.id, result))
+
+			// Emit notifications after session/new response
+			if (req.method === "session/new") {
+				emitSessionNotifications()
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err)
+			writeMessage(makeError(req.id, ErrorCodes.InternalError, message))
+		}
+	}
+
+	// Process a JSON-RPC notification
+	const processNotification = (notif: JsonRpcNotification): void => {
+		switch (notif.method) {
+			case "session/cancel":
+				handleCancel(notif.params as CancelParams)
+				break
+			// Ignore unknown notifications
+		}
+	}
+
+	// Read and process stdin line by line
+	const readline = await import("node:readline")
+	const rl = readline.createInterface({
+		input: process.stdin,
+		terminal: false,
+	})
+
+	for await (const line of rl) {
+		if (!line.trim()) continue
+
+		try {
+			const msg = JSON.parse(line)
+
+			if (msg.jsonrpc !== "2.0") {
+				writeMessage(makeError(msg.id ?? null, ErrorCodes.InvalidRequest, "Invalid JSON-RPC version"))
+				continue
+			}
+
+			if (msg.id !== undefined) {
+				// Request
+				await processRequest(msg as JsonRpcRequest)
+			} else {
+				// Notification
+				processNotification(msg as JsonRpcNotification)
+			}
+		} catch {
+			writeMessage(makeError(0, ErrorCodes.ParseError, "Parse error"))
+		}
+	}
+}

package/src/adapters/acp/protocol.ts

@@ -0,0 +1,191 @@
+/**
+ * ACP (Agent Client Protocol) JSON-RPC 2.0 types
+ * Spec: https://agentclientprotocol.com
+ */
+
+// ============================================================================
+// JSON-RPC 2.0 Base Types
+// ============================================================================
+
+export interface JsonRpcRequest {
+	jsonrpc: "2.0"
+	id: number | string
+	method: string
+	params?: unknown
+}
+
+export interface JsonRpcResponse {
+	jsonrpc: "2.0"
+	id: number | string
+	result?: unknown
+	error?: JsonRpcError
+}
+
+export interface JsonRpcNotification {
+	jsonrpc: "2.0"
+	method: string
+	params: unknown
+}
+
+export interface JsonRpcError {
+	code: number
+	message: string
+	data?: unknown
+}
+
+// Standard JSON-RPC error codes
+export const ErrorCodes = {
+	ParseError: -32700,
+	InvalidRequest: -32600,
+	MethodNotFound: -32601,
+	InvalidParams: -32602,
+	InternalError: -32603,
+} as const
+
+// ============================================================================
+// Initialize
+// ============================================================================
+
+export interface InitializeParams {
+	protocolVersion: number
+	clientInfo?: { name: string; version: string }
+	clientCapabilities?: {
+		fs?: { readTextFile?: boolean; writeTextFile?: boolean }
+		terminal?: boolean
+	}
+}
+
+export interface InitializeResult {
+	protocolVersion: number
+	agentInfo: { name: string; version: string }
+	agentCapabilities: {
+		promptCapabilities: { image: boolean; embeddedContext: boolean }
+	}
+	authMethods: Array<{ id: string; name: string; description: string }>
+}
+
+// ============================================================================
+// Session
+// ============================================================================
+
+export interface NewSessionParams {
+	cwd: string
+	mcpServers?: unknown[]
+}
+
+export interface SlashCommand {
+	name: string
+	description: string
+}
+
+export interface ModelOption {
+	modelId: string
+	name: string
+}
+
+export interface NewSessionResult {
+	sessionId: string
+	models?: {
+		availableModels: ModelOption[]
+		currentModelId: string
+	}
+}
+
+export interface PromptParams {
+	sessionId: string
+	prompt: ContentBlock[]
+}
+
+export interface ContentBlock {
+	type: "text" | "image" | "resource" | "resource_link"
+	text?: string
+	data?: string // base64 for images
+	mimeType?: string
+	uri?: string
+}
+
+export type StopReason = "end_turn" | "cancelled" | "max_turn_requests"
+
+export interface PromptResult {
+	stopReason: StopReason
+}
+
+export interface CancelParams {
+	sessionId: string
+}
+
+export interface SetModeParams {
+	sessionId: string
+	mode: "default" | "acceptEdits" | "bypassPermissions" | "dontAsk" | "plan"
+}
+
+export interface SetModelParams {
+	sessionId: string
+	modelId: string
+}
+
+export interface SetModelResult {
+	modelId: string
+}
+
+// ============================================================================
+// Session Update (Agent → Client notifications)
+// ============================================================================
+
+export type SessionUpdateType =
+	| "agent_message_chunk"
+	| "user_message_chunk"
+	| "agent_thought_chunk"
+	| "tool_call"
+	| "tool_call_update"
+	| "plan"
+	| "available_commands_update"
+	| "current_mode_update"
+	| "models_update"
+
+export type ToolCallStatus = "pending" | "in_progress" | "completed" | "failed"
+export type ToolCallKind = "read" | "write" | "edit" | "command" | "other"
+
+export interface SessionUpdateParams {
+	sessionId: string
+	update: SessionUpdate
+}
+
+export type SessionUpdate =
+	| { sessionUpdate: "agent_message_chunk"; content: { type: "text"; text: string } }
+	| { sessionUpdate: "user_message_chunk"; content: { type: "text"; text: string } }
+	| { sessionUpdate: "agent_thought_chunk"; content: { type: "text"; text: string } }
+	| {
+			sessionUpdate: "tool_call"
+			toolCallId: string
+			title: string
+			kind: ToolCallKind
+			status: ToolCallStatus
+			rawInput?: unknown
+	  }
+	| {
+			sessionUpdate: "tool_call_update"
+			toolCallId: string
+			status: ToolCallStatus
+			title?: string
+			content?: Array<{ type: "text"; text: string }>
+	  }
+	| { sessionUpdate: "available_commands_update"; availableCommands: SlashCommand[] }
+	| { sessionUpdate: "models_update"; models: { availableModels: ModelOption[]; currentModelId: string } }
+	| { sessionUpdate: "current_mode_update"; currentModeId: string }
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+export function makeResponse(id: number | string, result: unknown): JsonRpcResponse {
+	return { jsonrpc: "2.0", id, result }
+}
+
+export function makeError(id: number | string, code: number, message: string): JsonRpcResponse {
+	return { jsonrpc: "2.0", id, error: { code, message } }
+}
+
+export function makeNotification(method: string, params: unknown): JsonRpcNotification {
+	return { jsonrpc: "2.0", method, params }
+}