@jack200714/mafw 4.5.1

package/gateway/dist/runtime/pi/pi-session.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiSessionRegistry = void 0;
+const crypto_1 = require("crypto");
+const pi_approval_bridge_1 = require("./pi-approval-bridge");
+const pi_approval_extension_1 = require("./pi-approval-extension");
+class PiSessionRegistry {
+    deps;
+    opts;
+    sessions = new Map();
+    bySession = new Map();
+    lastUsed = new Map();
+    approvalBridges = new Map();
+    warnedNoReply = new Set();
+    pendingMedia = new Map();
+    emitEvent;
+    policy;
+    constructor(deps, opts = {}) {
+        this.deps = deps;
+        this.opts = opts;
+        this.emitEvent = opts.emitEvent ?? (() => { });
+        this.policy = opts.policy;
+    }
+    async create(cwd, createOpts, agentExtensions = []) {
+        const id = `pi_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+        const bridge = new pi_approval_bridge_1.ApprovalBridge();
+        this.approvalBridges.set(id, bridge);
+        const approvalExtension = (0, pi_approval_extension_1.createMafwApprovalExtension)(bridge, this.emitEvent, this.policy);
+        // Compaction listener: pi fires session_before_compact / session_compact to
+        // extensions; re-emit as normalized runtime events (compaction facet).
+        const compactionExtension = this.makeCompactionExtension(id);
+        // Media injector: partsToPromptInput 收集的 video/audio（dataURL）经
+        // before_provider_request 注入 provider payload 的最后一条 user message
+        // （小米 wire 格式），随后清空 pending——pi 内容层不认识这两种类型，只能在
+        // 出 wire 前合并。
+        const mediaExtension = this.makeMediaExtension(id);
+        // Combine approval extension with agent-specific extensions
+        // These will be passed to createAgentSession via extensionFactories
+        const allExtensions = [
+            { name: 'mafw-approval', factory: (pi) => approvalExtension.on(pi) },
+            compactionExtension,
+            mediaExtension,
+            ...agentExtensions,
+        ];
+        try {
+            const { session } = await this.deps.createSession({ cwd, ...createOpts, extensionFactories: allExtensions });
+            this.sessions.set(id, session);
+            this.bySession.set(session, id);
+            this.lastUsed.set(id, Date.now());
+        }
+        catch (err) {
+            this.approvalBridges.delete(id);
+            throw err;
+        }
+        return { id };
+    }
+    sessionFor(id) { return this.sessions.get(id); }
+    sessionIdFor(session) { return this.bySession.get(session); }
+    async promptAsync(id, text, opts) {
+        const s = this.requireSession(id);
+        this.touch(id);
+        this.warnNoReplyOnce(id, opts);
+        const piOpts = this.buildPiPromptOpts(opts);
+        if (s.isStreaming) {
+            const images = opts?.images ?? [];
+            const deliverAs = this.resolveDelivery(opts);
+            if (images.length > 0) {
+                // sendUserMessage accepts a TextContent|ImageContent array; a bare
+                // string would drop the attachments.
+                const content = [
+                    { type: 'text', text },
+                    ...images.map((i) => ({ type: 'image', data: i.data, mimeType: i.mimeType })),
+                ];
+                await s.sendUserMessage(content, { deliverAs });
+            }
+            else {
+                await s.sendUserMessage(text, { deliverAs });
+            }
+        }
+        else {
+            await s.prompt(text, piOpts);
+            await s.waitForIdle();
+        }
+    }
+    async prompt(id, text, opts) {
+        const s = this.requireSession(id);
+        this.touch(id);
+        this.warnNoReplyOnce(id, opts);
+        const piOpts = this.buildPiPromptOpts(opts);
+        piOpts.streamingBehavior = this.resolveDelivery(opts);
+        const before = (s.messages || []).length;
+        await s.prompt(text, piOpts);
+        await s.waitForIdle();
+        const after = s.messages || [];
+        const assistant = after.slice(before).filter((m) => m?.role === 'assistant');
+        const last = assistant[assistant.length - 1];
+        const u = last?.usage;
+        return {
+            parts: (last?.content || []).map((c) => ({ type: 'text', text: c?.text || '' })),
+            finish: last?.stopReason,
+            usage: u
+                ? {
+                    input: u.input ?? u.promptTokens ?? 0,
+                    output: u.output ?? u.completionTokens ?? 0,
+                    cached: u.cacheRead ?? u.cachedTokens ?? 0,
+                    reasoning: u.reasoning,
+                    costUsd: typeof u.totalCost === 'number' ? u.totalCost : undefined,
+                }
+                : undefined,
+        };
+    }
+    buildPiPromptOpts(opts) {
+        if (!opts)
+            return {};
+        const piOpts = {};
+        if (opts.system)
+            piOpts.system = opts.system;
+        if (opts.agent)
+            piOpts.agent = opts.agent;
+        if (opts.noReply)
+            piOpts.noReply = opts.noReply;
+        if (opts.images?.length)
+            piOpts.images = opts.images;
+        return piOpts;
+    }
+    /** delivery → pi 原生投递时机（busy 时 sendUserMessage/prompt 消费）。 */
+    resolveDelivery(opts) {
+        return opts?.delivery === 'steer' ? 'steer' : 'followUp';
+    }
+    /** pi 无原生 noReply：expectReply=false 全路径降级为普通消息，每会话 warn 一次（已拍板）。 */
+    warnNoReplyOnce(id, opts) {
+        if (opts?.expectReply !== false && !opts?.noReply)
+            return;
+        if (this.warnedNoReply.has(id))
+            return;
+        this.warnedNoReply.add(id);
+        (opts?.logWarn ?? ((m) => { }))(`[PiRuntime] expectReply=false has no native pi equivalent — message delivered as normal (session ${id}, warned once)`);
+    }
+    /** 暂存 video/audio 附件（mafw-media extension 在 before_provider_request 时消费）。 */
+    attachMedia(id, media) {
+        if (!media?.length)
+            return;
+        const list = this.pendingMedia.get(id) ?? [];
+        list.push(...media);
+        this.pendingMedia.set(id, list);
+    }
+    takePendingMedia(id) {
+        const list = this.pendingMedia.get(id);
+        this.pendingMedia.delete(id);
+        return list ?? [];
+    }
+    makeCompactionExtension(id) {
+        return {
+            name: 'mafw-compaction',
+            factory: (pi) => {
+                pi.on('session_before_compact', () => {
+                    this.emitEvent({ payload: { type: 'session.compacting', properties: { sessionID: id } } });
+                });
+                pi.on('session_compact', () => {
+                    this.emitEvent({ payload: { type: 'session.compacted', properties: { sessionID: id } } });
+                });
+            },
+        };
+    }
+    makeMediaExtension(id) {
+        return {
+            name: 'mafw-media',
+            factory: (pi) => {
+                pi.on('before_provider_request', (event) => {
+                    const media = this.takePendingMedia(id);
+                    if (media.length === 0)
+                        return undefined;
+                    const payload = event?.payload;
+                    if (!payload || !Array.isArray(payload.messages))
+                        return undefined;
+                    const lastUser = [...payload.messages].reverse().find((m) => m?.role === 'user');
+                    if (!lastUser)
+                        return undefined;
+                    const content = Array.isArray(lastUser.content)
+                        ? lastUser.content
+                        : (lastUser.content = [{ type: 'text', text: String(lastUser.content ?? '') }]);
+                    for (const m of media) {
+                        content.push(m.type === 'video'
+                            ? { type: 'video_url', video_url: { url: m.url } }
+                            : { type: 'input_audio', input_audio: { data: m.url } });
+                    }
+                    return payload;
+                });
+            },
+        };
+    }
+    async messages(id) {
+        const s = this.requireSession(id);
+        this.touch(id);
+        return { data: s.messages || [] };
+    }
+    async delete(id) {
+        const bridge = this.approvalBridges.get(id);
+        if (bridge) {
+            bridge.dispose();
+            this.approvalBridges.delete(id);
+        }
+        const s = this.sessions.get(id);
+        if (s) {
+            try {
+                await s.dispose();
+            }
+            catch { /* ignore */ }
+        }
+        this.sessions.delete(id);
+        this.bySession.delete(s);
+        this.lastUsed.delete(id);
+        this.warnedNoReply.delete(id);
+        this.pendingMedia.delete(id);
+    }
+    async permissionReply(sessionID, requestId, reply, message) {
+        const bridge = this.approvalBridges.get(sessionID);
+        if (!bridge)
+            return false;
+        return bridge.reply(requestId, reply, message);
+    }
+    async abort(id) {
+        const s = this.sessions.get(id);
+        if (s) {
+            try {
+                await s.abort();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /**
+     * 分叉为新会话：SessionManager.createBranchedSession 写出截至 leaf 的新
+     * 会话文件，再经 deps.createSession({ fromFile }) 加载为独立 AgentSession。
+     * 原会话不动。busy 也允许（fork 只读文件，不动 live session）。
+     */
+    async fork(id, messageID) {
+        const s = this.requireSession(id);
+        const sm = s.sessionManager;
+        if (!sm?.createBranchedSession)
+            throw new Error('pi session does not expose sessionManager');
+        const leafId = messageID ?? sm.getLeafId?.();
+        if (!leafId)
+            throw new Error(`pi fork failed: no leaf for session ${id}`);
+        const file = sm.createBranchedSession(leafId);
+        if (!file)
+            throw new Error(`pi fork failed: createBranchedSession returned nothing for leaf ${leafId}`);
+        const bridge = new pi_approval_bridge_1.ApprovalBridge();
+        const approvalExtension = (0, pi_approval_extension_1.createMafwApprovalExtension)(bridge, this.emitEvent, this.policy);
+        const newId = `pi_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+        const compactionExtension = this.makeCompactionExtension(newId);
+        const mediaExtension = this.makeMediaExtension(newId);
+        try {
+            const { session } = await this.deps.createSession({
+                cwd: sm.getCwd?.() ?? undefined,
+                fromFile: file,
+                extensionFactories: [
+                    { name: 'mafw-approval', factory: (pi) => approvalExtension.on(pi) },
+                    compactionExtension,
+                    mediaExtension,
+                ],
+            });
+            this.sessions.set(newId, session);
+            this.bySession.set(session, newId);
+            this.lastUsed.set(newId, Date.now());
+            this.approvalBridges.set(newId, bridge);
+        }
+        catch (err) {
+            bridge.dispose();
+            throw err;
+        }
+        return { id: newId };
+    }
+    /**
+     * 消息级回退 = SessionManager.branch(branchFromId) 原地移动 leaf。
+     * 不回滚文件、不可逆（entry 保留在文件，可凭 id 再 branch 回去）。
+     * streaming 中拒绝——branch 移动 leaf 会与进行中的写入竞争。
+     */
+    async revert(id, messageID) {
+        const s = this.requireSession(id);
+        if (s.isStreaming)
+            throw new Error(`pi session ${id} is busy (streaming) — abort before revert`);
+        const sm = s.sessionManager;
+        if (!sm?.branch)
+            throw new Error('pi session does not expose sessionManager');
+        sm.branch(messageID);
+        this.touch(id);
+    }
+    async list() {
+        return [...this.sessions.keys()].map((id) => ({ id, directory: '', title: '', time: { created: 0, updated: 0 } }));
+    }
+    async get(id) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return undefined;
+        return { id, directory: '', title: '', time: { created: 0, updated: this.lastUsed.get(id) ?? 0 } };
+    }
+    async todo() { return []; }
+    async children() { return []; }
+    async summarize(id) {
+        const s = this.requireSession(id);
+        return s.compact();
+    }
+    async disposeAll() {
+        for (const bridge of this.approvalBridges.values()) {
+            bridge.dispose();
+        }
+        this.approvalBridges.clear();
+        for (const s of this.sessions.values()) {
+            try {
+                await s.dispose();
+            }
+            catch { /* ignore */ }
+        }
+        this.sessions.clear();
+        this.bySession.clear();
+        this.lastUsed.clear();
+        this.warnedNoReply.clear();
+        this.pendingMedia.clear();
+    }
+    requireSession(id) {
+        const s = this.sessions.get(id);
+        if (!s)
+            throw new Error(`Pi session not found: ${id}`);
+        return s;
+    }
+    touch(id) { this.lastUsed.set(id, Date.now()); }
+}
+exports.PiSessionRegistry = PiSessionRegistry;

package/gateway/dist/runtime/plugins/pi-runtime.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PI_CAPABILITIES = void 0;
+exports.partsToPromptInput = partsToPromptInput;
+exports.createPiRuntime = createPiRuntime;
+const pi_session_1 = require("../pi/pi-session");
+const pi_messages_1 = require("../pi/pi-messages");
+const pi_events_1 = require("../pi/pi-events");
+const pi_provider_1 = require("../pi/pi-provider");
+const auth_1 = require("../auth");
+const config_1 = require("../../config");
+const pi_session_storage_1 = require("../pi/pi-session-storage");
+const pi_adapter_1 = require("../../media/pi-adapter");
+const piAgentConfig = __importStar(require("../pi/pi-agent-config"));
+exports.PI_CAPABILITIES = {
+    sessionApi: true,
+    promptWhileBusy: true,
+    eventStream: true,
+    nativeApprovals: true,
+    providerConfigApi: true,
+    perLlmCallTransform: true,
+    sessionStorageApi: true,
+    agentConfigApi: true,
+    completionApi: true,
+    sessionBranchApi: true,
+};
+/**
+ * Convert runtime prompt parts into pi prompt input. File parts carrying
+ * image data URLs (or raw base64 with a mime) become ImageContent
+ * attachments; text parts join into the prompt text.
+ *
+ * Video/audio file parts are NOT dropped: they are collected as `media`
+ * (dataURL carrier) and the caller feeds registry.attachMedia — the
+ * mafw-media extension injects them into the provider request payload
+ * (before_provider_request) in the xiaomi wire format. (Probe 2026-09-14:
+ * the earlier "promptAsync flattens parts and loses images" report no
+ * longer matches the code — image conversion happens here since the fix;
+ * only video/audio was silently dropped, which this return value adds.)
+ */
+function partsToPromptInput(parts) {
+    if (!parts?.length)
+        return {};
+    const images = [];
+    const media = [];
+    const texts = [];
+    for (const p of parts) {
+        if (p?.type === 'file' && typeof p.url === 'string' && p.url) {
+            const m = /^data:([^;,]+)?(;base64)?,([\s\S]*)$/.exec(p.url);
+            const mime = m?.[1] || p.mime || '';
+            const data = m?.[3];
+            if (mime.startsWith('image/') && data) {
+                images.push({ type: 'image', mimeType: mime, data });
+            }
+            else if (mime.startsWith('video/') || mime.startsWith('audio/')) {
+                media.push({ type: mime.startsWith('video/') ? 'video' : 'audio', url: p.url, mime, filename: p.filename });
+            }
+            else if (typeof p.mime === 'string' && p.mime.startsWith('image/')) {
+                images.push({ type: 'image', mimeType: p.mime, data: p.url });
+            }
+        }
+        else if (typeof p?.text === 'string' && p.text) {
+            texts.push(p.text);
+        }
+    }
+    return {
+        text: texts.length ? texts.join('\n') : undefined,
+        images: images.length ? images : undefined,
+        media: media.length ? media : undefined,
+    };
+}
+async function createPiRuntime(ctx, deps = {}) {
+    const authPath = deps.authPath ?? (0, auth_1.DEFAULT_AUTH_PATH)();
+    const cfg = ctx.pluginConfig('pi');
+    const provider = cfg.provider ?? 'xiaomi';
+    const modelID = cfg.model ?? 'mimo-v2.5';
+    const thinkingLevel = cfg.thinkingLevel ?? 'medium';
+    const imp = deps.loadPi ?? new Function('spec', 'return import(spec)');
+    let mrPromise;
+    function modelRuntime() {
+        if (!mrPromise) {
+            mrPromise = (async () => {
+                const { ModelRuntime } = await imp('@earendil-works/pi-coding-agent');
+                const mr = await ModelRuntime.create({ signal: AbortSignal.timeout(30_000) });
+                const key = ctx.credentials?.getApiKey?.(provider) ?? (0, auth_1.readOpencodeAuth)(authPath)[provider]?.key;
+                if (key)
+                    await mr.setRuntimeApiKey(provider, key);
+                return mr;
+            })();
+            mrPromise.catch(() => { mrPromise = undefined; });
+        }
+        return mrPromise;
+    }
+    const eventStream = new pi_events_1.PiEventStream((session) => undefined);
+    const registry = new pi_session_1.PiSessionRegistry({
+        createSession: async (opts) => {
+            const pi = await imp('@earendil-works/pi-coding-agent');
+            const { createAgentSession } = pi;
+            const DefaultResourceLoader = pi.DefaultResourceLoader;
+            const mr = await modelRuntime();
+            const model = mr.getModel(opts.model?.provider ?? provider, opts.model?.modelID ?? modelID);
+            // Build session options
+            const sessionOpts = {
+                cwd: opts.cwd,
+                modelRuntime: mr,
+                model,
+                thinkingLevel,
+            };
+            // fromFile: registry.fork() passes a branched session file — load it as
+            // the session's SessionManager so the new AgentSession carries the
+            // forked history (SessionManager.open reads the JSONL tree).
+            if (opts.fromFile && pi.SessionManager) {
+                sessionOpts.sessionManager = pi.SessionManager.open(opts.fromFile, undefined, opts.cwd);
+            }
+            // If DefaultResourceLoader is available and we have extensions, create a resource loader
+            const extensionFactories = opts.extensionFactories ?? [];
+            if (DefaultResourceLoader && extensionFactories.length > 0) {
+                const resourceLoader = new DefaultResourceLoader({
+                    cwd: opts.cwd,
+                    agentDir: piAgentConfig.getAgentDir(),
+                    extensionFactories,
+                });
+                await resourceLoader.reload();
+                sessionOpts.resourceLoader = resourceLoader;
+            }
+            const { session } = await createAgentSession(sessionOpts);
+            eventStream.trackSession(session);
+            return { session };
+        },
+    }, { sessionTtlMs: cfg.sessionTtlMs, emitEvent: (evt) => eventStream.push(evt), policy: cfg.approvalPolicy });
+    const sessionAPI = {
+        create: async (opts) => {
+            const { id } = await registry.create(opts?.directory ?? config_1.config.raw.paths.projectDir, { model: { provider, modelID } });
+            return { id };
+        },
+        promptAsync: async (opts) => {
+            const converted = partsToPromptInput(opts.parts);
+            const text = opts.message ?? converted.text ?? '';
+            if (converted.media?.length)
+                registry.attachMedia(opts.sessionID, converted.media);
+            await registry.promptAsync(opts.sessionID, text, { system: opts.system, agent: opts.agent, noReply: opts.noReply, expectReply: opts.expectReply, delivery: opts.delivery, images: converted.images });
+        },
+        prompt: async (opts) => {
+            const converted = partsToPromptInput(opts.parts);
+            const text = opts.message ?? converted.text ?? '';
+            if (converted.media?.length)
+                registry.attachMedia(opts.sessionID, converted.media);
+            return registry.prompt(opts.sessionID, text, { system: opts.system, agent: opts.agent, noReply: opts.noReply, expectReply: opts.expectReply, delivery: opts.delivery, images: converted.images });
+        },
+        messages: async (opts) => {
+            const { data } = await registry.messages(opts.sessionID);
+            return { data: (0, pi_messages_1.translatePiMessages)(data, opts.sessionID), nextCursor: undefined };
+        },
+        get: async (opts) => registry.get(opts.sessionID),
+        delete: async (opts) => { await registry.delete(opts.sessionID); },
+        abort: async (opts) => { await registry.abort(opts.sessionID); },
+        list: async () => registry.list(),
+        todo: async () => registry.todo(),
+        children: async () => registry.children(),
+        summarize: async (opts) => registry.summarize(opts.sessionID),
+        listByDirectory: async (directory, limit) => {
+            return (0, pi_session_storage_1.listByDirectory)(directory, limit);
+        },
+        permissionReply: (sessionID, requestId, reply, message) => registry.permissionReply(sessionID, requestId, reply, message),
+        fork: async (opts) => registry.fork(opts.sessionID, opts.messageID),
+        revert: async (opts) => registry.revert(opts.sessionID, opts.messageID),
+    };
+    return {
+        name: 'pi',
+        capabilities: exports.PI_CAPABILITIES,
+        external: true,
+        session: sessionAPI,
+        global: { event: () => Promise.resolve({ stream: eventStream.stream() }) },
+        provider: { list: () => modelRuntime().then((mr) => (0, pi_provider_1.translateProviders)(mr)) },
+        app: { agents: () => (0, pi_provider_1.translateAgents)() },
+        config: { get: () => (0, pi_provider_1.translateConfigGet)(), update: (c) => (0, pi_provider_1.translateConfigUpdate)(c) },
+        credentials: { getApiKey: (p) => ctx.credentials?.getApiKey?.(p) ?? (0, auth_1.readOpencodeAuth)(authPath)[p]?.key ?? null },
+        completion: {
+            async complete(req) {
+                const mr = await modelRuntime();
+                const model = mr.getModel(req.model.providerID, req.model.modelID);
+                if (!model)
+                    throw new Error(`Model ${req.model.providerID}/${req.model.modelID} not found in pi registry`);
+                const apiKey = ctx.credentials?.getApiKey?.(req.model.providerID)
+                    ?? (0, auth_1.readOpencodeAuth)(authPath)[req.model.providerID]?.key;
+                if (!apiKey)
+                    throw new Error(`No API key for provider "${req.model.providerID}"`);
+                await mr.setRuntimeApiKey(req.model.providerID, apiKey);
+                const content = [];
+                for (const p of req.user) {
+                    if (p.type === 'text' && p.text.trim())
+                        content.push({ type: 'text', text: p.text });
+                    if (p.type === 'image')
+                        content.push({ type: 'image', data: p.data, mimeType: p.mimeType });
+                }
+                const response = await mr.complete(model, {
+                    systemPrompt: (req.system ?? []).map((b) => b.text).join('\n\n'),
+                    messages: [{ role: 'user', content, timestamp: Date.now() }],
+                }, {
+                    apiKey,
+                    onPayload: pi_adapter_1.fixMediaPayload,
+                    signal: AbortSignal.timeout(req.timeoutMs ?? 180_000),
+                });
+                if (response.stopReason === 'error' || response.stopReason === 'aborted') {
+                    throw new Error(response.errorMessage || `completion failed (${response.stopReason})`);
+                }
+                const text = (response.content || [])
+                    .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                    .map((c) => c.text)
+                    .join('\n')
+                    .trim();
+                // Tolerant usage mapping — pi field names vary across versions.
+                const u = response.usage;
+                const input = u?.promptTokens ?? u?.prompt_tokens ?? u?.input;
+                const output = u?.completionTokens ?? u?.completion_tokens ?? u?.output;
+                const cached = u?.cachedTokens ?? u?.cached_tokens ?? 0;
+                return {
+                    text,
+                    usage: typeof input === 'number' || typeof output === 'number'
+                        ? { input: input ?? 0, cached: cached ?? 0, output: output ?? 0 }
+                        : undefined,
+                };
+            },
+        },
+        agents: {
+            install: async (name, definition) => {
+                await piAgentConfig.install(name, definition);
+            },
+            remove: async (name) => {
+                await piAgentConfig.remove(name);
+            },
+            list: async () => {
+                return piAgentConfig.list();
+            },
+            get: async (name) => {
+                return piAgentConfig.get(name);
+            },
+        },
+        registry,
+        getBaseUrl: () => `http://127.0.0.1:${config_1.config.server.apiPort ?? 3000}`,
+        healthCheck: async () => { try {
+            await modelRuntime();
+            return true;
+        }
+        catch {
+            return false;
+        } },
+        dispose: async () => {
+            await registry.disposeAll();
+            await eventStream.dispose();
+        },
+    };
+}

package/gateway/dist/runtime/serve-for-runtime.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureServeForBuiltinRuntime = ensureServeForBuiltinRuntime;
+/**
+ * Make sure the opencode serve sidecar exists before handing out a builtin
+ * opencode runtime. A gateway started under an external runtime (pi) never
+ * spawns serve; switching back to opencode without this step yields a client
+ * pointing at a dead port. Idempotent: ensureStarted() adopts an already
+ * running serve or spawns a fresh one.
+ */
+async function ensureServeForBuiltinRuntime(supervisor, hooks, log) {
+    try {
+        const url = await supervisor.ensureStarted();
+        hooks.startWatchdog();
+        log.info(`[Runtime] opencode serve ready at ${url}`);
+    }
+    catch (err) {
+        // external serve mode (user-managed) or spawn failure: surface but do not
+        // block the switch — the runtime will surface connection errors on use.
+        log.warn(`[Runtime] serve ensureStarted failed (non-fatal): ${err.message}`);
+    }
+}