@meetopenbot/pi 0.0.3 → 0.1.1

package/README.md

@@ -22,13 +22,21 @@ plugins:
       tools: read,bash,edit,write,grep,find,ls
 ```
 
+## Auth
+
+On cloud, `authMode: credits` (the default) uses your workspace credit balance via OpenBot for `openai`, `anthropic`, and `deepseek`. For BYOK, set `authMode: byok` and add the matching provider key under workspace settings (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `DEEPSEEK_API_KEY`, or `GEMINI_API_KEY`).
+
+Locally, Pi always uses BYOK from environment variables or `~/.pi/agent/auth.json`.
+
+Credits does not cover Google Gemini — Pi uses Gemini's native API, while OpenBot Credits proxies the OpenAI-compatible Gemini surface. Use openai/anthropic/deepseek on credits, or switch to BYOK for Gemini.
+
 ## Configuration
 
 | Option | Description |
 |--------|-------------|
-| `cwd` | Working directory for Pi tools and resource discovery. Defaults to the OpenBot channel `cwd`, then `process.cwd()`. |
+| `authMode` | Cloud only: `credits` (default) or `byok`. |
 | `agentDir` | Pi config directory (credentials, settings, sessions). Default: `~/.pi/agent`. |
-| `provider` | Model provider (e.g. `anthropic`, `openai`). |
+| `provider` | Model provider (e.g. `anthropic`, `openai`, `deepseek`). |
 | `model` | Model id (e.g. `claude-opus-4-5`). |
 | `thinkingLevel` | Extended thinking: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`. |
 | `tools` | Comma-separated built-in tools to enable. |
@@ -36,13 +44,7 @@ plugins:
 | `noTools` | `all` or `builtin` to disable tools. |
 | `systemPrompt` | Override Pi's system prompt for this agent. |
 
-## API Keys
-
-Pi resolves credentials via `AuthStorage` (see [Pi SDK docs](https://pi.dev/docs/latest/sdk)):
-
-1. Runtime overrides
-2. `~/.pi/agent/auth.json`
-3. Environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.)
+Working directory always comes from the OpenBot channel `cwd`.
 
 ## Sessions
 

package/dist/config.js

@@ -1,34 +1,11 @@
-const THINKING_LEVELS = new Set([
-    'off',
-    'minimal',
-    'low',
-    'medium',
-    'high',
-    'xhigh',
-]);
+import { trimmedString, vendorModelId } from '@meetopenbot/plugin-sdk';
 export const resolveConfig = (context, channelCwd) => {
-    const config = context.config;
-    const thinkingLevel = config.thinkingLevel && THINKING_LEVELS.has(config.thinkingLevel)
-        ? config.thinkingLevel
-        : undefined;
+    const raw = trimmedString(context.config.model);
+    const provider = raw?.includes('/') ? raw.split('/')[0] : undefined;
+    const model = vendorModelId(raw);
     return {
-        cwd: channelCwd || config.cwd,
-        agentDir: config.agentDir,
-        provider: config.provider?.trim() || undefined,
-        model: config.model?.trim() || undefined,
-        thinkingLevel,
-        tools: config.tools?.trim() || undefined,
-        excludeTools: config.excludeTools?.trim() || undefined,
-        noTools: config.noTools,
-        systemPrompt: config.systemPrompt?.trim() || undefined,
+        cwd: channelCwd || process.cwd(),
+        provider,
+        model,
     };
 };
-export const parseToolList = (value) => {
-    if (!value)
-        return undefined;
-    const tools = value
-        .split(',')
-        .map((tool) => tool.trim())
-        .filter(Boolean);
-    return tools.length > 0 ? tools : undefined;
-};

package/dist/credits.js

@@ -0,0 +1,51 @@
+import { CREDITS_API_KEY_PLACEHOLDER, CREDITS_NOT_CONFIGURED_MESSAGE, INTEGRATIONS_TOKEN_HEADER, creditsErrorMessage as mapCreditsError, creditsAuthFailedMessage, creditsProviderBaseUrl as sdkCreditsProviderBaseUrl, isAuthErrorMessage, llmAuthNotConfiguredMessage, resolveByokApiKey, resolveCreditsAuthConfig, } from '@meetopenbot/plugin-sdk';
+export { CREDITS_API_KEY_PLACEHOLDER, CREDITS_NOT_CONFIGURED_MESSAGE, INTEGRATIONS_TOKEN_HEADER, isAuthErrorMessage, llmAuthNotConfiguredMessage, resolveByokApiKey, resolveCreditsAuthConfig, };
+/**
+ * Gateway paths matching each Pi provider's default base URL shape:
+ * - openai models use `https://api.openai.com/v1`
+ * - anthropic models use `https://api.anthropic.com` (SDK appends `/v1`)
+ * - deepseek is OpenAI-compat; `/v1` keeps metering on `/v1/chat/completions`
+ *
+ * Google Gemini is omitted: Pi speaks the native Generative Language API, while
+ * the credits gateway only proxies Gemini's OpenAI-compatible surface.
+ */
+export const CREDITS_PROVIDERS = [
+    { id: 'openai', basePath: 'openai/v1', envVar: 'OPENAI_API_KEY' },
+    { id: 'anthropic', basePath: 'anthropic', envVar: 'ANTHROPIC_API_KEY' },
+    { id: 'deepseek', basePath: 'deepseek/v1', envVar: 'DEEPSEEK_API_KEY' },
+];
+const CREDITS_PROVIDER_IDS = new Set(CREDITS_PROVIDERS.map((provider) => provider.id));
+const PI_CREDITS_PATHS = Object.fromEntries(CREDITS_PROVIDERS.map((provider) => [provider.id, provider.basePath]));
+export function isCreditsProvider(provider) {
+    return CREDITS_PROVIDER_IDS.has(provider);
+}
+export function creditsProviderBaseUrl(config, provider) {
+    return sdkCreditsProviderBaseUrl(config, provider, PI_CREDITS_PATHS);
+}
+export function applyCreditsProviders(modelRegistry, authStorage, config) {
+    const apiKey = config.token || CREDITS_API_KEY_PLACEHOLDER;
+    const headers = { [INTEGRATIONS_TOKEN_HEADER]: config.token };
+    for (const provider of CREDITS_PROVIDERS) {
+        modelRegistry.registerProvider(provider.id, {
+            baseUrl: creditsProviderBaseUrl(config, provider.id),
+            headers,
+        });
+        authStorage.setRuntimeApiKey(provider.id, apiKey);
+    }
+}
+export const CREDITS_AUTH_FAILED_MESSAGE = creditsAuthFailedMessage('Pi');
+export function creditsErrorMessage(message) {
+    return mapCreditsError(message, { agentName: 'Pi' });
+}
+export function remapPiError(message) {
+    if (resolveByokApiKey('openai') ||
+        resolveByokApiKey('anthropic') ||
+        resolveByokApiKey('google') ||
+        resolveByokApiKey('deepseek')) {
+        return message;
+    }
+    return creditsErrorMessage(message) ?? message;
+}
+export function unsupportedCreditsProviderMessage(provider) {
+    return `OpenBot Credits does not support the "${provider}" provider. Use openai, anthropic, or deepseek.`;
+}

package/dist/index.js

@@ -1,178 +1,18 @@
-import { agentOutput, buildDiffWidget, definePlugin, diffFileFromMutationTool, resolveRunDiffFiles, shouldHandleInvoke, snapshotWorkspace, toolTraceWidget, uiWidget, } from '@meetopenbot/plugin-sdk';
-import { resolveConfig } from './config.js';
-import { formatPiError, formatToolResult } from './format.js';
-import { getOrCreatePiSession } from './session.js';
-import { streamPiPrompt } from './stream.js';
-export default definePlugin({
-    id: 'pi',
+import { defineAgentPlugin } from '@meetopenbot/plugin-sdk';
+import { remapPiError } from './credits.js';
+import { runPiTurn } from './runtime.js';
+export const plugin = await defineAgentPlugin({
     name: 'Pi',
     description: 'Pi coding agent — read, edit, and run code in your workspace.',
-    configSchema: {
-        type: 'object',
-        properties: {
-            cwd: {
-                type: 'string',
-                description: 'Working directory for Pi tools and resource discovery.',
-            },
-            agentDir: {
-                type: 'string',
-                description: 'Pi config directory (default: ~/.pi/agent).',
-            },
-            provider: {
-                type: 'string',
-                description: 'Model provider (e.g. anthropic, openai).',
-            },
-            model: {
-                type: 'string',
-                description: 'Model id (e.g. claude-opus-4-5).',
-            },
-            thinkingLevel: {
-                type: 'string',
-                description: 'Extended thinking level.',
-                enum: ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'],
-                default: 'off',
-            },
-            tools: {
-                type: 'string',
-                description: 'Comma-separated built-in tools to enable (e.g. read,bash,edit,write,grep,find,ls).',
-            },
-            excludeTools: {
-                type: 'string',
-                description: 'Comma-separated tool names to disable.',
-            },
-            noTools: {
-                type: 'string',
-                description: 'Disable tools: "all" or "builtin".',
-                enum: ['all', 'builtin'],
-            },
-            systemPrompt: {
-                type: 'string',
-                description: 'Override Pi system prompt for this agent.',
-            },
-        },
+    models: {
+        providers: ['openai', 'anthropic', 'deepseek'],
+        default: 'openai/gpt-5.6-luna',
     },
-    factory: (context) => (builder) => {
-        builder.on('agent:invoke', async function* (event, handlerCtx) {
-            if (!shouldHandleInvoke(event, context.agentId))
-                return;
-            const threadId = event.meta?.threadId ?? handlerCtx.state.threadId;
-            const prompt = (event.data.content ?? '').trim();
-            if (!prompt) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: 'Send a message to run Pi in this workspace — for example, "List the files here" or "Fix the failing test in src/foo.test.ts".',
-                    threadId,
-                });
-                return;
-            }
-            const channelCwd = handlerCtx.state.channelDetails?.cwd;
-            const config = resolveConfig(context, channelCwd);
-            try {
-                const { session } = await getOrCreatePiSession({
-                    config,
-                    state: handlerCtx.state,
-                    storage: context.storage,
-                });
-                let fullTextContent = '';
-                const toolInfoMap = new Map();
-                const changedFiles = new Map();
-                const snapshot = snapshotWorkspace(config.cwd);
-                for await (const chunk of streamPiPrompt(session, prompt, {
-                    streaming: session.isStreaming,
-                })) {
-                    switch (chunk.type) {
-                        case 'tool_start':
-                            toolInfoMap.set(chunk.toolCallId, {
-                                statusLine: chunk.statusLine,
-                                args: chunk.args,
-                            });
-                            yield uiWidget({
-                                agentId: context.agentId,
-                                threadId,
-                                widget: toolTraceWidget({
-                                    widgetId: chunk.toolCallId,
-                                    groupId: 'pi:tools',
-                                    title: chunk.statusLine,
-                                    body: `**Input**\n\`\`\`json\n${JSON.stringify(chunk.args, null, 2)}\n\`\`\``,
-                                }),
-                            });
-                            break;
-                        case 'tool_end': {
-                            const info = toolInfoMap.get(chunk.toolCallId);
-                            const inputMd = info
-                                ? `**Input**\n\`\`\`json\n${JSON.stringify(info.args, null, 2)}\n\`\`\`\n\n`
-                                : '';
-                            const outputMd = `**Output**\n${formatToolResult(chunk.result)}`;
-                            yield uiWidget({
-                                agentId: context.agentId,
-                                threadId,
-                                widget: toolTraceWidget({
-                                    widgetId: chunk.toolCallId,
-                                    groupId: 'pi:tools',
-                                    title: chunk.statusLine || info?.statusLine || `Tool ${chunk.toolName} finished`,
-                                    body: inputMd + outputMd,
-                                    state: chunk.isError ? 'error' : 'submitted',
-                                }),
-                            });
-                            if (!chunk.isError) {
-                                const file = diffFileFromMutationTool({
-                                    toolName: chunk.toolName,
-                                    input: info?.args,
-                                    result: chunk.result,
-                                });
-                                if (file)
-                                    changedFiles.set(file.path, file);
-                            }
-                            break;
-                        }
-                        case 'status':
-                            yield uiWidget({
-                                agentId: context.agentId,
-                                threadId,
-                                widget: toolTraceWidget({
-                                    widgetId: `status-${Date.now()}`,
-                                    groupId: 'pi:tools',
-                                    title: 'Status',
-                                    body: chunk.statusLine,
-                                }),
-                            });
-                            break;
-                        case 'text':
-                            if (fullTextContent)
-                                fullTextContent += '\n\n';
-                            fullTextContent += chunk.content;
-                            break;
-                    }
-                }
-                if (fullTextContent.trim()) {
-                    yield agentOutput({
-                        agentId: context.agentId,
-                        content: fullTextContent.trim(),
-                        threadId,
-                    });
-                }
-                const diff = buildDiffWidget({
-                    widgetId: `pi-diff:${threadId ?? 'run'}:${Date.now()}`,
-                    files: resolveRunDiffFiles({
-                        snapshot,
-                        fallback: changedFiles.values(),
-                    }),
-                });
-                if (diff) {
-                    yield uiWidget({
-                        agentId: context.agentId,
-                        threadId,
-                        widget: diff,
-                    });
-                }
-            }
-            catch (error) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: `**Pi error:** ${formatPiError(error)}`,
-                    threadId,
-                });
-            }
-        });
+    emptyPrompt: 'Send a message to run Pi in this workspace — for example, "List the files here" or "Fix the failing test in src/foo.test.ts".',
+    run: runPiTurn,
+    mapError: (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        return { kind: 'reply', content: `Pi error: ${remapPiError(message)}` };
     },
 });
+export default plugin;

package/dist/runtime.js

@@ -0,0 +1,17 @@
+import { resolveConfig } from './config.js';
+import { remapPiError } from './credits.js';
+import { getOrCreatePiSession } from './session.js';
+import { runPiPrompt } from './stream.js';
+export async function runPiTurn({ prompt, handlerCtx, context }) {
+    const config = resolveConfig(context, handlerCtx.state.channelDetails?.cwd);
+    const { session } = await getOrCreatePiSession({
+        config,
+        state: handlerCtx.state,
+        storage: context.storage,
+    });
+    const text = await runPiPrompt(session, prompt, { streaming: session.isStreaming });
+    if (text.startsWith('Pi error: ')) {
+        return `Pi error: ${remapPiError(text.slice('Pi error: '.length))}`;
+    }
+    return text;
+}

package/dist/session.js

@@ -1,8 +1,20 @@
 import { AuthStorage, createAgentSession, DefaultResourceLoader, getAgentDir, ModelRegistry, SessionManager, SettingsManager, } from '@earendil-works/pi-coding-agent';
-import { parseToolList } from './config.js';
+import { isCloudMode } from '@meetopenbot/plugin-sdk';
+import { applyCreditsProviders, isCreditsProvider, llmAuthNotConfiguredMessage, resolveByokApiKey, resolveCreditsAuthConfig, unsupportedCreditsProviderMessage, } from './credits.js';
 import { persistPiState, readPersistedState } from './state.js';
 const sessionCache = new Map();
-const buildSessionKey = (state) => state.threadId ? `${state.channelId}:${state.threadId}` : state.channelId;
+const hasPiByok = (provider) => {
+    if (provider)
+        return Boolean(resolveByokApiKey(provider));
+    return Boolean(resolveByokApiKey('openai') ||
+        resolveByokApiKey('anthropic') ||
+        resolveByokApiKey('google') ||
+        resolveByokApiKey('deepseek'));
+};
+const buildSessionKey = (state, byok) => {
+    const scope = state.threadId ? `${state.channelId}:${state.threadId}` : state.channelId;
+    return `${scope}:${byok ? 'byok' : 'credits'}`;
+};
 const resolveModel = async (config, modelRegistry) => {
     if (config.provider && config.model) {
         return modelRegistry.find(config.provider, config.model) ?? undefined;
@@ -12,24 +24,32 @@ const resolveModel = async (config, modelRegistry) => {
 };
 export const getOrCreatePiSession = async (args) => {
     const { config, state, storage } = args;
-    const sessionKey = buildSessionKey(state);
+    const byok = hasPiByok(config.provider);
+    const sessionKey = buildSessionKey(state, byok);
     const cached = sessionCache.get(sessionKey);
     if (cached)
         return cached;
+    if (!byok && config.provider && !isCreditsProvider(config.provider)) {
+        throw new Error(unsupportedCreditsProviderMessage(config.provider));
+    }
     const cwd = config.cwd || process.cwd();
-    const agentDir = config.agentDir || getAgentDir();
+    const agentDir = getAgentDir();
     const persisted = readPersistedState(state);
     const authStorage = AuthStorage.create(`${agentDir}/auth.json`);
     const modelRegistry = ModelRegistry.create(authStorage, `${agentDir}/models.json`);
+    const credits = !byok && isCloudMode() ? resolveCreditsAuthConfig() : undefined;
+    if (!byok && !credits) {
+        throw new Error(llmAuthNotConfiguredMessage(config.provider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'));
+    }
+    if (credits) {
+        applyCreditsProviders(modelRegistry, authStorage, credits);
+    }
     const model = await resolveModel(config, modelRegistry);
     const settingsManager = SettingsManager.create(cwd, agentDir);
     const loader = new DefaultResourceLoader({
         cwd,
         agentDir,
         settingsManager,
-        ...(config.systemPrompt
-            ? { systemPromptOverride: () => config.systemPrompt }
-            : {}),
     });
     await loader.reload();
     const sessionManager = persisted.sessionFile
@@ -41,10 +61,6 @@ export const getOrCreatePiSession = async (args) => {
         authStorage,
         modelRegistry,
         model,
-        thinkingLevel: config.thinkingLevel,
-        tools: parseToolList(config.tools),
-        excludeTools: parseToolList(config.excludeTools),
-        noTools: config.noTools,
         resourceLoader: loader,
         sessionManager,
         settingsManager,
@@ -66,3 +82,10 @@ export const disposePiSession = (sessionKey) => {
     cached.session.dispose();
     sessionCache.delete(sessionKey);
 };
+export const disposePiSessionsForThread = (state) => {
+    const prefix = state.threadId ? `${state.channelId}:${state.threadId}:` : `${state.channelId}:`;
+    for (const key of sessionCache.keys()) {
+        if (key.startsWith(prefix))
+            disposePiSession(key);
+    }
+};

package/dist/stream.js

@@ -1,8 +1,8 @@
-import { createStreamState, formatPiEvent } from './format.js';
-/** Bridge Pi session events into an async generator of output chunks. */
-export async function* streamPiPrompt(session, prompt, options) {
-    const state = createStreamState();
-    const pending = [];
+const isAssistantMessage = (message) => message.role === 'assistant';
+/** Run a Pi prompt and return the final assistant text. */
+export async function runPiPrompt(session, prompt, options) {
+    let assistantText = '';
+    let result = '';
     let wake;
     let finished = false;
     let error;
@@ -10,17 +10,26 @@ export async function* streamPiPrompt(session, prompt, options) {
         wake?.();
         wake = undefined;
     };
-    const unsubscribe = session.subscribe((event) => {
-        const result = formatPiEvent(event, state);
-        if (result) {
-            pending.push(result);
-            wakeUp();
+    const onEvent = (event) => {
+        if (event.type === 'message_update') {
+            const assistantEvent = event.assistantMessageEvent;
+            if (assistantEvent.type === 'text_delta')
+                assistantText += assistantEvent.delta;
+            return;
         }
         if (event.type === 'agent_end') {
+            const lastAssistant = [...event.messages].reverse().find(isAssistantMessage);
+            if (lastAssistant?.stopReason === 'error' && lastAssistant.errorMessage?.trim()) {
+                result = `Pi error: ${lastAssistant.errorMessage.trim()}`;
+            }
+            else {
+                result = assistantText;
+            }
             finished = true;
             wakeUp();
         }
-    });
+    };
+    const unsubscribe = session.subscribe(onEvent);
     const run = (async () => {
         try {
             if (options?.streaming && session.isStreaming) {
@@ -39,18 +48,19 @@ export async function* streamPiPrompt(session, prompt, options) {
         }
     })();
     try {
-        while (!finished || pending.length > 0) {
-            if (pending.length === 0) {
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
-                continue;
-            }
-            yield pending.shift();
+        while (!finished) {
+            await new Promise((resolve) => {
+                if (finished) {
+                    resolve();
+                    return;
+                }
+                wake = resolve;
+            });
         }
         await run;
         if (error)
             throw error;
+        return result.trim();
     }
     finally {
         unsubscribe();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/pi",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "OpenBot agent plugin powered by the Pi coding agent SDK.",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
   "dependencies": {
     "@earendil-works/pi-ai": "^0.79.1",
     "@earendil-works/pi-coding-agent": "^0.79.1",
-    "@meetopenbot/plugin-sdk": "^0.2.0"
+    "@meetopenbot/plugin-sdk": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",
@@ -31,7 +31,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && node ../../scripts/write-plugin-declaration.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --experimental-strip-types --test src/diff.test.ts",
+    "test": "node --experimental-strip-types --test src/*.test.ts",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput"
   }
 }

package/dist/diff.js

@@ -1 +0,0 @@
-export { buildDiffWidget as runDiffWidget, diffFileFromMutationTool as diffFileFromPiTool, } from '@meetopenbot/plugin-sdk';

package/dist/format.js

@@ -1,148 +0,0 @@
-const isAssistantMessage = (message) => message.role === 'assistant';
-export const createStreamState = () => ({
-    assistantText: '',
-});
-const strArg = (args, ...keys) => {
-    if (!args || typeof args !== 'object')
-        return undefined;
-    const record = args;
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === 'string' && value.trim())
-            return value.trim();
-        if (typeof value === 'number' && Number.isFinite(value))
-            return String(value);
-    }
-    return undefined;
-};
-const truncate = (text, max = 80) => text.length > max ? `${text.slice(0, max - 3)}…` : text;
-const quoteDetail = (detail) => detail.includes('`') ? `"${detail}"` : `\`${detail}\``;
-const formatToolDetail = (toolName, args) => {
-    switch (toolName) {
-        case 'bash': {
-            const command = strArg(args, 'command');
-            return command ? truncate(command.replace(/\s+/g, ' ')) : undefined;
-        }
-        case 'read':
-        case 'edit':
-        case 'write': {
-            const path = strArg(args, 'path', 'file_path');
-            if (!path)
-                return undefined;
-            let detail = truncate(path, 120);
-            if (toolName === 'read') {
-                const offset = strArg(args, 'offset');
-                const limit = strArg(args, 'limit');
-                const parts = [offset && `offset=${offset}`, limit && `limit=${limit}`].filter(Boolean);
-                if (parts.length)
-                    detail += ` (${parts.join(', ')})`;
-            }
-            return detail;
-        }
-        case 'grep': {
-            const pattern = strArg(args, 'pattern');
-            const path = strArg(args, 'path') ?? '.';
-            if (!pattern)
-                return undefined;
-            return `${truncate(pattern)} in ${truncate(path, 60)}`;
-        }
-        case 'find': {
-            const pattern = strArg(args, 'pattern');
-            const path = strArg(args, 'path') ?? '.';
-            if (!pattern)
-                return undefined;
-            return `${truncate(pattern)} in ${truncate(path, 60)}`;
-        }
-        case 'ls': {
-            const path = strArg(args, 'path') ?? '.';
-            return truncate(path, 120);
-        }
-        default:
-            return undefined;
-    }
-};
-const formatToolStart = (toolName, args) => {
-    const detail = formatToolDetail(toolName, args);
-    if (detail)
-        return `Running **${toolName}** (${quoteDetail(detail)})…`;
-    return `Running **${toolName}**…`;
-};
-/** Map Pi session events to user-visible output chunks. */
-export const formatPiEvent = (event, state) => {
-    switch (event.type) {
-        case 'message_update': {
-            const assistantEvent = event.assistantMessageEvent;
-            if (assistantEvent.type !== 'text_delta')
-                return undefined;
-            state.assistantText += assistantEvent.delta;
-            return undefined;
-        }
-        case 'tool_execution_start': {
-            const statusLine = formatToolStart(event.toolName, event.args);
-            return {
-                type: 'tool_start',
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                args: event.args,
-                statusLine,
-            };
-        }
-        case 'tool_execution_end': {
-            let statusLine;
-            if (event.isError) {
-                statusLine = `Tool **${event.toolName}** failed.`;
-            }
-            return {
-                type: 'tool_end',
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                result: event.result,
-                isError: event.isError,
-                statusLine,
-            };
-        }
-        case 'auto_retry_start': {
-            const statusLine = `Retrying (${event.attempt}/${event.maxAttempts})…`;
-            return { type: 'status', statusLine };
-        }
-        case 'compaction_start': {
-            const statusLine = 'Compacting conversation context…';
-            return { type: 'status', statusLine };
-        }
-        case 'agent_end': {
-            const lastAssistant = [...event.messages].reverse().find(isAssistantMessage);
-            if (lastAssistant?.stopReason === 'error' && lastAssistant.errorMessage?.trim()) {
-                return { type: 'text', content: `**Pi error:** ${lastAssistant.errorMessage.trim()}` };
-            }
-            if (state.assistantText.trim()) {
-                return { type: 'text', content: state.assistantText };
-            }
-            return undefined;
-        }
-        default:
-            return undefined;
-    }
-};
-export const formatPiError = (error) => {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-};
-export const formatToolResult = (result) => {
-    if (!result)
-        return '';
-    if (typeof result === 'string')
-        return result;
-    if (result && typeof result === 'object' && Array.isArray(result.content)) {
-        return result.content
-            .map((c) => {
-            if (c.type === 'text')
-                return c.text;
-            if (c.type === 'image')
-                return `[Image: ${c.source?.data?.slice(0, 20)}...]`;
-            return `[${c.type}]`;
-        })
-            .join('\n');
-    }
-    return JSON.stringify(result, null, 2);
-};