@tduyng/pi-opencode-z 0.0.0-stage → 0.0.1

package/src/index.ts

@@ -0,0 +1,195 @@
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+
+import {
+    currentService,
+    fetchZenModels,
+    opencodeBin,
+    resolveService,
+    startEventStream,
+    type EventStreamHandle,
+    type ZenModel
+} from './client.js'
+import { startMcpServer, type McpServerHandle } from './mcp.js'
+import { isFreeModel, selectModels, toPiModel, type PiModelEntry } from './models.js'
+import { allSessions, disposeAll } from './session.js'
+import { attachMcpServer, createBridgeRuntime, routeEvent, streamOpenCodeBridge, toolHintsFrom } from './stream.js'
+import { bridgeModelsRaw, configPath, projectConfigPath } from './config.js'
+
+const PROVIDER_ID = 'opencode-z'
+const API_ID = 'opencode-z'
+
+export default async function opencodeBridge(pi: ExtensionAPI): Promise<void> {
+    const runtime = createBridgeRuntime()
+    runtime.toolHints = toolHintsFrom(() => pi.getAllTools())
+    let mcpServer: McpServerHandle | undefined
+    let events: EventStreamHandle | undefined
+    let catalogue: ZenModel[] = []
+    let startupError: string | undefined
+    let starting: Promise<void> | undefined
+
+    async function loadModels(): Promise<PiModelEntry[]> {
+        const filter = bridgeModelsRaw()
+        catalogue = selectModels(await fetchZenModels(), filter)
+        if (filter && catalogue.length === 0) throw new Error(`no configured models matched "${filter}"`)
+        return catalogue.map(toPiModel)
+    }
+
+    function register(models: PiModelEntry[]): void {
+        pi.registerProvider(PROVIDER_ID, {
+            name: 'OpenCode Bridge',
+            baseUrl: 'opencode://local',
+            apiKey: 'opencode-z-local',
+            api: API_ID,
+            models,
+            streamSimple: (model, context, options) => streamOpenCodeBridge(runtime, model, context, options),
+            refreshModels: async () => {
+                await ensureStarted()
+                return loadModels()
+            }
+        })
+    }
+
+    async function start(): Promise<void> {
+        await resolveService()
+        mcpServer = await startMcpServer()
+        attachMcpServer(runtime, mcpServer)
+        events = startEventStream((event) => routeEvent(runtime, event))
+        register(await loadModels())
+        startupError = undefined
+    }
+
+    function ensureStarted(): Promise<void> {
+        if (mcpServer) return Promise.resolve()
+        starting ??= startBridge()
+        return starting
+    }
+
+    async function startBridge(): Promise<void> {
+        try {
+            await start()
+        } catch (error) {
+            startupError = error instanceof Error ? error.message : String(error)
+            starting = undefined
+            throw error
+        }
+    }
+
+    function modelLines(): string[] {
+        if (catalogue.length === 0) return ['No Zen models available.']
+        const free = catalogue.filter(isFreeModel)
+        const paid = catalogue.filter((model) => !isFreeModel(model))
+        return [
+            `${catalogue.length} model(s), ${free.length} free:`,
+            ...free.map((model) => `  ${PROVIDER_ID}/${model.id}  (free)`),
+            ...paid.map((model) => `  ${PROVIDER_ID}/${model.id}`)
+        ]
+    }
+
+    function statusLines(): string[] {
+        const service = currentService()
+        const lines = [
+            `opencode server: ${service ? service.url : 'not connected'}`,
+            `opencode binary: ${opencodeBin()}`,
+            `config: ${configPath()}`,
+            `project config: ${projectConfigPath()}`,
+            `models filter: ${bridgeModelsRaw() ?? 'all'}`,
+            `MCP endpoint: ${mcpServer ? `http://127.0.0.1:${mcpServer.port}/mcp` : 'not running'}`,
+            `live bridge sessions: ${allSessions(runtime.sessions).length}`
+        ]
+        if (startupError) lines.push(`startup problem: ${startupError}`)
+        return [...lines, '', ...modelLines()]
+    }
+
+    register([])
+
+    // Pi waits for async factories, so the Zen models are listed before --model is resolved.
+    await ensureStarted().catch(() => undefined)
+
+    pi.on('session_start', async (_event, ctx: ExtensionContext) => {
+        try {
+            await ensureStarted()
+        } catch {
+            ctx.ui.notify(
+                `opencode-z is off: ${startupError}. Check that ${opencodeBin()} service status works.`,
+                'warning'
+            )
+        }
+    })
+
+    pi.on('session_shutdown', async () => {
+        if (starting) await starting.catch(() => undefined)
+        events?.stop()
+        events = undefined
+        const server = mcpServer
+        mcpServer = undefined
+        runtime.mcp = undefined
+        starting = undefined
+        startupError = undefined
+        if (!server) return
+        await disposeAll(runtime.sessions, server.unregister)
+        await server.close()
+    })
+
+    const show = (text: string) =>
+        pi.sendMessage({ customType: 'opencode-z', display: true, content: text }, { triggerTurn: false })
+
+    pi.registerCommand('opencode-z', {
+        description: 'Status and model list for the opencode bridge',
+        getArgumentCompletions: (prefix: string) =>
+            [
+                { value: 'status', label: 'status', description: 'server, config, MCP endpoint and live sessions' },
+                { value: 'models', label: 'models', description: 'every Zen model the bridge exposes' },
+                { value: 'refresh', label: 'refresh', description: 're-read the config file and model catalogue' },
+                { value: 'config', label: 'config', description: 'resolved settings and where they come from' },
+                { value: 'help', label: 'help', description: 'usage and settings' }
+            ].filter((item) => item.value.startsWith(prefix.trim())),
+        handler: async (args: string) => {
+            const sub = args.trim().split(/\s+/).filter(Boolean)[0] ?? 'status'
+
+            if (sub === 'refresh') {
+                try {
+                    await ensureStarted()
+                    await resolveService(true)
+                    register(await loadModels())
+                    startupError = undefined
+                    await show(`opencode-z: refreshed, ${catalogue.length} model(s) available.`)
+                } catch (error) {
+                    await show(`opencode-z refresh failed: ${error instanceof Error ? error.message : String(error)}`)
+                }
+                return
+            }
+
+            if (sub === 'help') {
+                await show(
+                    [
+                        'Usage: /opencode-z [status|models|refresh|config|help]',
+                        '',
+                        `Settings live in ${configPath()} and ${projectConfigPath()}.`,
+                        'OPENCODE_Z_BIN and OPENCODE_Z_MODELS override the file.',
+                        'See the README for an example file.'
+                    ].join('\n')
+                )
+                return
+            }
+
+            if (sub === 'config') {
+                await show(
+                    [
+                        `file: ${configPath()}`,
+                        `project file: ${projectConfigPath()}`,
+                        `opencode binary: ${opencodeBin()}`,
+                        `models filter: ${bridgeModelsRaw() ?? 'all (every Zen model the account can reach)'}`
+                    ].join('\n')
+                )
+                return
+            }
+
+            if (sub === 'models') {
+                await show(modelLines().join('\n'))
+                return
+            }
+
+            await show(statusLines().join('\n'))
+        }
+    })
+}

package/src/mcp.ts

@@ -0,0 +1,315 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+const isStringOrNumber = new Validator(t.union([t.string(), t.number()])).isValidObject
+const isString = new Validator(t.string()).isValidObject
+
+export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject
+export type JsonObject = { [key: string]: JsonValue }
+
+export type McpToolAnnotations = {
+    readOnlyHint?: boolean
+    destructiveHint?: boolean
+    idempotentHint?: boolean
+    openWorldHint?: boolean
+}
+
+export type McpToolDef = {
+    name: string
+    description: string
+    inputSchema: JsonObject
+    annotations?: McpToolAnnotations
+}
+
+export type McpContent = { type: 'text'; text: string } | { type: 'image'; data: string; mimeType: string }
+
+export type McpResult = {
+    content: McpContent[]
+    isError?: boolean
+}
+
+export type McpHandlers = {
+    listTools(): McpToolDef[]
+    callTool(name: string, args: JsonObject, meta: JsonObject): Promise<McpResult>
+}
+
+export type McpServerHandle = {
+    port: number
+    urlFor(token: string): string
+    register(token: string, handlers: McpHandlers): void
+    unregister(token: string): void
+    notifyToolsChanged(token: string): Promise<boolean>
+    close(): Promise<void>
+}
+
+const SERVER_INFO = { name: 'pi-opencode-z', version: '1.0.0' }
+const DEFAULT_PROTOCOL = '2025-11-25'
+const MAX_BODY_BYTES = 8 * 1024 * 1024
+const LIST_WAIT_MS = 2_000
+
+type RpcId = string | number
+
+type McpRequest =
+    | { kind: 'malformed' }
+    | { kind: 'notification' }
+    | { kind: 'initialize'; id: RpcId; protocolVersion: string }
+    | { kind: 'ping'; id: RpcId }
+    | { kind: 'listTools'; id: RpcId }
+    | { kind: 'callTool'; id: RpcId; name: string; args: JsonObject; meta: JsonObject }
+    | { kind: 'unsupported'; id: RpcId; method: string }
+
+const RecordSchema = t.object({}, { additionalProperties: true })
+const isRecordSchema = new Validator(RecordSchema).isValidObject
+
+function isJsonRecord(value: JsonValue | undefined): value is JsonObject {
+    return isRecordSchema(value) && !Array.isArray(value)
+}
+
+function asObject(value: JsonValue | undefined): JsonObject {
+    if (!isJsonRecord(value)) return {}
+    return value
+}
+
+function parseRequest(body: string): McpRequest {
+    let frame: JsonValue
+    try {
+        frame = JSON.parse(body) as JsonValue
+    } catch {
+        return { kind: 'malformed' }
+    }
+    const message = asObject(frame)
+    const id = message['id']
+    if (!isStringOrNumber(id)) return { kind: 'notification' }
+
+    const method = message['method']
+    if (!isString(method)) return { kind: 'malformed' }
+    const params = asObject(message['params'])
+
+    switch (method) {
+        case 'initialize': {
+            const requested = params['protocolVersion']
+            return {
+                kind: 'initialize',
+                id,
+                protocolVersion: isString(requested) ? requested : DEFAULT_PROTOCOL
+            }
+        }
+        case 'ping':
+            return { kind: 'ping', id }
+        case 'tools/list':
+            return { kind: 'listTools', id }
+        case 'tools/call': {
+            const name = params['name']
+            if (!isString(name)) return { kind: 'malformed' }
+            return { kind: 'callTool', id, name, args: asObject(params['arguments']), meta: asObject(params['_meta']) }
+        }
+        default:
+            return { kind: 'unsupported', id, method }
+    }
+}
+
+class RequestBodyError extends Error {
+    readonly status = 413
+
+    constructor() {
+        super(`MCP request body exceeds ${MAX_BODY_BYTES} bytes`)
+        this.name = 'RequestBodyError'
+    }
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+        let body = ''
+        let bytes = 0
+        let rejected = false
+        req.setEncoding('utf8')
+        req.on('data', (chunk: string) => {
+            if (rejected) return
+            bytes += Buffer.byteLength(chunk, 'utf8')
+            if (bytes > MAX_BODY_BYTES) {
+                rejected = true
+                reject(new RequestBodyError())
+                return
+            }
+            body += chunk
+        })
+        req.on('end', () => {
+            if (!rejected) resolve(body)
+        })
+        req.on('error', reject)
+    })
+}
+
+function send(res: ServerResponse, status: number, payload?: RpcPayload): void {
+    if (payload === undefined) {
+        res.writeHead(status).end()
+        return
+    }
+    const body = JSON.stringify(payload)
+    res.writeHead(status, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) }).end(body)
+}
+
+type RpcResult =
+    | {
+          protocolVersion: string
+          capabilities: { tools: { listChanged?: boolean } }
+          serverInfo: { name: string; version: string }
+      }
+    | { alive?: true }
+    | { tools: McpToolDef[] }
+    | McpResult
+
+type RpcPayload =
+    | { jsonrpc: '2.0'; id: RpcId; result: RpcResult }
+    | { jsonrpc: '2.0'; id: RpcId; error: { code: number; message: string } }
+
+type RpcReply = { status: number; body?: RpcPayload }
+
+async function respond(request: McpRequest, handlers: McpHandlers): Promise<RpcReply> {
+    switch (request.kind) {
+        case 'malformed':
+            return { status: 400 }
+        case 'notification':
+            return { status: 202 }
+        case 'initialize':
+            return {
+                status: 200,
+                body: ok(request.id, {
+                    protocolVersion: request.protocolVersion,
+                    capabilities: { tools: { listChanged: true } },
+                    serverInfo: SERVER_INFO
+                })
+            }
+        case 'ping':
+            return { status: 200, body: ok(request.id, {}) }
+        case 'listTools':
+            return { status: 200, body: ok(request.id, { tools: handlers.listTools() }) }
+        case 'callTool': {
+            let result: McpResult
+            try {
+                result = await handlers.callTool(request.name, request.args, request.meta)
+            } catch (error) {
+                result = {
+                    content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+                    isError: true
+                }
+            }
+            return { status: 200, body: ok(request.id, result) }
+        }
+        case 'unsupported':
+            return {
+                status: 200,
+                body: {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    error: { code: -32601, message: `unsupported method: ${request.method}` }
+                }
+            }
+    }
+}
+
+function ok(id: RpcId, result: RpcResult): RpcPayload {
+    return { jsonrpc: '2.0', id, result }
+}
+
+export function startMcpServer(): Promise<McpServerHandle> {
+    const registry = new Map<string, McpHandlers>()
+    const streams = new Map<string, Set<ServerResponse>>()
+    const listWaiters = new Map<string, Set<() => void>>()
+
+    const server: Server = createServer((req, res) => {
+        void (async () => {
+            const token = /^\/mcp\/([A-Za-z0-9_-]+)\/?$/.exec(req.url ?? '')?.[1]
+            const handlers = token ? registry.get(token) : undefined
+            if (!token || !handlers) {
+                send(res, 404)
+                return
+            }
+            if (req.method === 'GET') {
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream',
+                    'cache-control': 'no-cache'
+                })
+                res.write(': connected\n\n')
+                const open = streams.get(token) ?? new Set<ServerResponse>()
+                open.add(res)
+                streams.set(token, open)
+                res.on('close', () => open.delete(res))
+                return
+            }
+            if (req.method !== 'POST') {
+                send(res, 405)
+                return
+            }
+
+            const request = parseRequest(await readBody(req))
+            const reply = await respond(request, handlers)
+            send(res, reply.status, reply.body)
+            if (request.kind === 'listTools') {
+                for (const wake of listWaiters.get(token) ?? []) wake()
+            }
+        })().catch((error) => {
+            if (!res.headersSent) send(res, error instanceof RequestBodyError ? error.status : 500)
+        })
+    })
+
+    return new Promise((resolve, reject) => {
+        server.on('error', reject)
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address()
+            if (address === null || isString(address)) {
+                reject(new Error('MCP server did not bind to a TCP port'))
+                return
+            }
+            server.unref()
+            resolve({
+                port: address.port,
+                urlFor: (token) => `http://127.0.0.1:${address.port}/mcp/${token}`,
+                register: (token, handlers) => {
+                    registry.set(token, handlers)
+                },
+                unregister: (token) => {
+                    registry.delete(token)
+                    for (const res of streams.get(token) ?? []) res.end()
+                    streams.delete(token)
+                    listWaiters.delete(token)
+                },
+                notifyToolsChanged: (token) => {
+                    const open = streams.get(token)
+                    if (!open || open.size === 0) return Promise.resolve(false)
+                    const frame = `event: message\ndata: ${JSON.stringify({
+                        jsonrpc: '2.0',
+                        method: 'notifications/tools/list_changed'
+                    })}\n\n`
+                    for (const res of open) res.write(frame)
+                    return new Promise<boolean>((done) => {
+                        const finish = (listed: boolean) => {
+                            clearTimeout(timer)
+                            listWaiters.get(token)?.delete(waiter)
+                            done(listed)
+                        }
+                        const waiter = () => finish(true)
+                        const timer = setTimeout(() => finish(false), LIST_WAIT_MS)
+                        const waiters = listWaiters.get(token) ?? new Set<() => void>()
+                        waiters.add(waiter)
+                        listWaiters.set(token, waiters)
+                    })
+                },
+                close: () =>
+                    new Promise((done) => {
+                        registry.clear()
+                        listWaiters.clear()
+                        for (const open of streams.values()) for (const res of open) res.end()
+                        streams.clear()
+                        server.closeAllConnections()
+                        server.close(() => done())
+                    })
+            })
+        })
+    })
+}
+
+export async function handleRpcFrame(body: string, handlers: McpHandlers): Promise<RpcReply> {
+    return respond(parseRequest(body), handlers)
+}

package/src/models.ts

@@ -0,0 +1,86 @@
+import type { ModelThinkingLevel, ThinkingLevelMap } from '@earendil-works/pi-ai'
+
+import type { ZenModel } from './client.js'
+import { bridgeModelsRaw } from './config.js'
+
+export type PiModelEntry = {
+    id: string
+    name: string
+    reasoning: boolean
+    thinkingLevelMap?: ThinkingLevelMap
+    input: ('text' | 'image')[]
+    cost: { input: number; output: number; cacheRead: number; cacheWrite: number }
+    contextWindow: number
+    maxTokens: number
+}
+
+const DEFAULT_CONTEXT_WINDOW = 128_000
+const DEFAULT_MAX_TOKENS = 16_384
+
+const THINKING_LEVELS: ModelThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+
+function variantName(level: ModelThinkingLevel, offered: Set<string>): string | null {
+    if (level === 'off') return offered.has('off') ? 'off' : offered.has('none') ? 'none' : null
+    if (offered.has(level)) return level
+    if (level === 'max' && offered.has('xhigh')) return 'xhigh'
+    return null
+}
+
+export function thinkingLevelMap(model: ZenModel): ThinkingLevelMap | undefined {
+    const offered = new Set((model.variants ?? []).map((variant) => variant.id))
+    if (offered.size === 0) return undefined
+
+    const map: ThinkingLevelMap = {}
+    for (const level of THINKING_LEVELS) map[level] = variantName(level, offered)
+    return map
+}
+
+export function variantFor(
+    map: ThinkingLevelMap | undefined,
+    level: ModelThinkingLevel | undefined
+): string | undefined {
+    if (!map || !level) return undefined
+    const variant = map[level]
+    return variant ?? undefined
+}
+
+export function isFreeModel(model: ZenModel): boolean {
+    const cost = model.cost?.[0]
+    return (cost?.input ?? 0) === 0 && (cost?.output ?? 0) === 0
+}
+
+export function toPiModel(model: ZenModel): PiModelEntry {
+    const cost = model.cost?.[0]
+    const map = thinkingLevelMap(model)
+    const accepts = model.capabilities?.input ?? ['text']
+    const entry: PiModelEntry = {
+        id: model.id,
+        name: `${model.name?.trim() || model.id}${isFreeModel(model) ? ' (free)' : ''}`,
+        reasoning: map !== undefined,
+        input: accepts.includes('image') ? ['text', 'image'] : ['text'],
+        cost: {
+            input: cost?.input ?? 0,
+            output: cost?.output ?? 0,
+            cacheRead: cost?.cache?.read ?? 0,
+            cacheWrite: cost?.cache?.write ?? 0
+        },
+        contextWindow: model.limit?.context || DEFAULT_CONTEXT_WINDOW,
+        maxTokens: model.limit?.output || DEFAULT_MAX_TOKENS
+    }
+    if (map) entry.thinkingLevelMap = map
+    return entry
+}
+
+export function selectModels(models: ZenModel[], rawOverride?: string): ZenModel[] {
+    const raw = rawOverride ?? bridgeModelsRaw()
+    if (!raw) return models
+    if (raw === 'free') return models.filter(isFreeModel)
+
+    const wanted = new Set(
+        raw
+            .split(/[\s,]+/)
+            .map((part) => part.trim().replace(/^opencode\//, ''))
+            .filter(Boolean)
+    )
+    return models.filter((model) => wanted.has(model.id))
+}