@meetopenbot/pi 0.0.1

package/README.md

@@ -0,0 +1,53 @@
+# @meetopenbot/pi
+
+OpenBot agent plugin powered by the [Pi coding agent SDK](https://pi.dev/docs/latest/sdk).
+
+Pi provides a full agent runtime with built-in tools (`read`, `bash`, `edit`, `write`, `grep`, `find`, `ls`), session management, and model/provider support. This plugin wraps Pi as an OpenBot **agent runtime** — each `agent:invoke` runs a Pi turn and streams progress back via `agent:output`.
+
+## Installation
+
+```bash
+npm install @meetopenbot/pi
+```
+
+Add the plugin to your agent in `AGENT.md`:
+
+```yaml
+plugins:
+  - id: '@meetopenbot/pi'
+    config:
+      provider: anthropic
+      model: claude-opus-4-5
+      thinkingLevel: medium
+      tools: read,bash,edit,write,grep,find,ls
+```
+
+## Configuration
+
+| Option | Description |
+|--------|-------------|
+| `cwd` | Working directory for Pi tools and resource discovery. Defaults to the OpenBot channel `cwd`, then `process.cwd()`. |
+| `agentDir` | Pi config directory (credentials, settings, sessions). Default: `~/.pi/agent`. |
+| `provider` | Model provider (e.g. `anthropic`, `openai`). |
+| `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. |
+| `excludeTools` | Comma-separated tool names to disable. |
+| `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.)
+
+## Sessions
+
+Each OpenBot thread gets its own Pi session. The session file path is stored in thread state so conversations continue across turns.
+
+## License
+
+MIT

package/dist/config.js

@@ -0,0 +1,34 @@
+const THINKING_LEVELS = new Set([
+    'off',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+]);
+export const resolveConfig = (context, channelCwd) => {
+    const config = context.config;
+    const thinkingLevel = config.thinkingLevel && THINKING_LEVELS.has(config.thinkingLevel)
+        ? config.thinkingLevel
+        : undefined;
+    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,
+    };
+};
+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/format.js

@@ -0,0 +1,120 @@
+const isAssistantMessage = (message) => message.role === 'assistant';
+export const createStreamState = () => ({
+    assistantText: '',
+    lastYieldedText: '',
+});
+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;
+            if (state.assistantText === state.lastYieldedText)
+                return undefined;
+            state.lastYieldedText = state.assistantText;
+            return state.assistantText;
+        }
+        case 'tool_execution_start': {
+            state.statusLine = formatToolStart(event.toolName, event.args);
+            return state.statusLine;
+        }
+        case 'tool_execution_end': {
+            if (!event.isError)
+                return undefined;
+            state.statusLine = `Tool **${event.toolName}** failed.`;
+            return state.statusLine;
+        }
+        case 'auto_retry_start': {
+            state.statusLine = `Retrying (${event.attempt}/${event.maxAttempts})…`;
+            return state.statusLine;
+        }
+        case 'compaction_start': {
+            state.statusLine = 'Compacting conversation context…';
+            return state.statusLine;
+        }
+        case 'agent_end': {
+            const lastAssistant = [...event.messages].reverse().find(isAssistantMessage);
+            if (lastAssistant?.stopReason === 'error' && lastAssistant.errorMessage?.trim()) {
+                return `**Pi error:** ${lastAssistant.errorMessage.trim()}`;
+            }
+            if (state.assistantText.trim()) {
+                return state.assistantText;
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+};
+export const formatPiError = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+};

package/dist/index.js

@@ -0,0 +1,95 @@
+import { agentOutput, definePlugin, shouldHandleInvoke, } from '@meetopenbot/plugin-sdk';
+import { resolveConfig } from './config.js';
+import { formatPiError } from './format.js';
+import { getOrCreatePiSession } from './session.js';
+import { streamPiPrompt } from './stream.js';
+export default definePlugin({
+    id: 'pi',
+    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.',
+            },
+        },
+    },
+    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,
+                });
+                for await (const chunk of streamPiPrompt(session, prompt, {
+                    streaming: session.isStreaming,
+                })) {
+                    yield agentOutput({
+                        agentId: context.agentId,
+                        content: chunk,
+                        threadId,
+                    });
+                }
+            }
+            catch (error) {
+                yield agentOutput({
+                    agentId: context.agentId,
+                    content: `**Pi error:** ${formatPiError(error)}`,
+                    threadId,
+                });
+            }
+        });
+    },
+});

package/dist/session.js

@@ -0,0 +1,68 @@
+import { AuthStorage, createAgentSession, DefaultResourceLoader, getAgentDir, ModelRegistry, SessionManager, SettingsManager, } from '@earendil-works/pi-coding-agent';
+import { parseToolList } from './config.js';
+import { persistPiState, readPersistedState } from './state.js';
+const sessionCache = new Map();
+const buildSessionKey = (state) => state.threadId ? `${state.channelId}:${state.threadId}` : state.channelId;
+const resolveModel = async (config, modelRegistry) => {
+    if (config.provider && config.model) {
+        return modelRegistry.find(config.provider, config.model) ?? undefined;
+    }
+    const available = await modelRegistry.getAvailable();
+    return available[0];
+};
+export const getOrCreatePiSession = async (args) => {
+    const { config, state, storage } = args;
+    const sessionKey = buildSessionKey(state);
+    const cached = sessionCache.get(sessionKey);
+    if (cached)
+        return cached;
+    const cwd = config.cwd || process.cwd();
+    const agentDir = config.agentDir || getAgentDir();
+    const persisted = readPersistedState(state);
+    const authStorage = AuthStorage.create(`${agentDir}/auth.json`);
+    const modelRegistry = ModelRegistry.create(authStorage, `${agentDir}/models.json`);
+    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
+        ? SessionManager.open(persisted.sessionFile)
+        : SessionManager.create(cwd);
+    const { session, modelFallbackMessage } = await createAgentSession({
+        cwd,
+        agentDir,
+        authStorage,
+        modelRegistry,
+        model,
+        thinkingLevel: config.thinkingLevel,
+        tools: parseToolList(config.tools),
+        excludeTools: parseToolList(config.excludeTools),
+        noTools: config.noTools,
+        resourceLoader: loader,
+        sessionManager,
+        settingsManager,
+    });
+    if (modelFallbackMessage) {
+        console.warn(`[pi-plugin] ${modelFallbackMessage}`);
+    }
+    if (session.sessionFile && session.sessionFile !== persisted.sessionFile) {
+        await persistPiState(state, storage, { sessionFile: session.sessionFile });
+    }
+    const handle = { session, sessionKey };
+    sessionCache.set(sessionKey, handle);
+    return handle;
+};
+export const disposePiSession = (sessionKey) => {
+    const cached = sessionCache.get(sessionKey);
+    if (!cached)
+        return;
+    cached.session.dispose();
+    sessionCache.delete(sessionKey);
+};

package/dist/state.js

@@ -0,0 +1,19 @@
+const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {};
+export const readPersistedState = (state) => {
+    const source = state.threadDetails?.state ?? state.channelDetails?.state;
+    const record = asRecord(source);
+    return typeof record.sessionFile === 'string' ? { sessionFile: record.sessionFile } : {};
+};
+export const persistPiState = async (state, storage, patch) => {
+    if (state.threadId) {
+        await storage.patchThreadState({
+            channelId: state.channelId,
+            threadId: state.threadId,
+            state: patch,
+        });
+        return;
+    }
+    await storage.patchChannelState({ channelId: state.channelId, state: patch });
+};

package/dist/stream.js

@@ -0,0 +1,58 @@
+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 = [];
+    let wake;
+    let finished = false;
+    let error;
+    const wakeUp = () => {
+        wake?.();
+        wake = undefined;
+    };
+    const unsubscribe = session.subscribe((event) => {
+        const chunk = formatPiEvent(event, state);
+        if (chunk) {
+            pending.push(chunk);
+            wakeUp();
+        }
+        if (event.type === 'agent_end') {
+            finished = true;
+            wakeUp();
+        }
+    });
+    const run = (async () => {
+        try {
+            if (options?.streaming && session.isStreaming) {
+                await session.followUp(prompt);
+            }
+            else {
+                await session.prompt(prompt);
+            }
+        }
+        catch (err) {
+            error = err instanceof Error ? err : new Error(String(err));
+        }
+        finally {
+            finished = true;
+            wakeUp();
+        }
+    })();
+    try {
+        while (!finished || pending.length > 0) {
+            if (pending.length === 0) {
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+                continue;
+            }
+            yield pending.shift();
+        }
+        await run;
+        if (error)
+            throw error;
+    }
+    finally {
+        unsubscribe();
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@meetopenbot/pi",
+  "version": "0.0.1",
+  "description": "OpenBot agent plugin powered by the Pi coding agent SDK.",
+  "type": "module",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@earendil-works/pi-ai": "^0.79.1",
+    "@earendil-works/pi-coding-agent": "^0.79.1",
+    "@meetopenbot/plugin-sdk": "^0.1.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "typescript": "^6.0.3"
+  }
+}