@meetopenbot/pi 0.1.0 → 0.1.1

package/dist/config.js

@@ -1,37 +1,11 @@
-import { resolveAuthMode } from './cloud-mode.js';
-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 = typeof config.thinkingLevel === 'string' && THINKING_LEVELS.has(config.thinkingLevel)
-        ? config.thinkingLevel
-        : undefined;
-    const asString = (value) => typeof value === 'string' && value.trim() ? value.trim() : undefined;
+    const raw = trimmedString(context.config.model);
+    const provider = raw?.includes('/') ? raw.split('/')[0] : undefined;
+    const model = vendorModelId(raw);
     return {
         cwd: channelCwd || process.cwd(),
-        agentDir: asString(config.agentDir),
-        provider: asString(config.provider),
-        model: asString(config.model),
-        thinkingLevel,
-        tools: asString(config.tools),
-        excludeTools: asString(config.excludeTools),
-        noTools: config.noTools === 'all' || config.noTools === 'builtin' ? config.noTools : undefined,
-        systemPrompt: asString(config.systemPrompt),
-        authMode: resolveAuthMode(config),
+        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,299 +1,18 @@
-import { agentOutput, buildDiffWidget, definePlugin, diffFileFromMutationTool, resolveRunDiffFiles, shouldHandleInvoke, snapshotWorkspace, toolTraceWidget, uiWidget, } from '@meetopenbot/plugin-sdk';
-import { isCloudMode } from './cloud-mode.js';
-import { resolveConfig } from './config.js';
-import { isAuthErrorMessage, remapPiError, } from './credits-auth.js';
-import { formatPiError, formatToolResult } from './format.js';
-import { disposePiSessionsForThread, getOrCreatePiSession } from './session.js';
-import { streamPiPrompt } from './stream.js';
-const BYOK_PROVIDERS = {
-    anthropic: {
-        envVar: 'ANTHROPIC_API_KEY',
-        label: 'Anthropic',
-        placeholder: 'sk-ant-...',
-    },
-    openai: {
-        envVar: 'OPENAI_API_KEY',
-        label: 'OpenAI',
-        placeholder: 'sk-...',
-    },
-    deepseek: {
-        envVar: 'DEEPSEEK_API_KEY',
-        label: 'DeepSeek',
-        placeholder: 'sk-...',
-    },
-    google: {
-        envVar: 'GEMINI_API_KEY',
-        label: 'Google Gemini',
-        placeholder: 'AIza...',
-    },
-};
-const resolveByokProvider = (provider) => BYOK_PROVIDERS[provider ?? ''] ?? BYOK_PROVIDERS.openai;
-const buildApiKeyWidget = (agentId, threadId, reason, provider) => {
-    const byok = resolveByokProvider(provider);
-    return uiWidget({
-        agentId,
-        threadId,
-        widget: {
-            kind: 'form',
-            widgetId: `pi_api_key_request_${Date.now()}`,
-            title: `${byok.label} API Key Required`,
-            description: `Pi could not authenticate (${reason}). ` +
-                `Provide a ${byok.label} API key to continue. ` +
-                'The key is stored as a workspace variable on your machine and never leaves your local runtime.',
-            fields: [
-                {
-                    id: 'apiKey',
-                    label: 'API Key',
-                    type: 'password',
-                    placeholder: byok.placeholder,
-                    required: true,
-                },
-            ],
-            submitLabel: 'Save API Key',
-            metadata: {
-                type: 'api_key_request',
-                provider: provider && BYOK_PROVIDERS[provider] ? provider : 'openai',
-                envVar: byok.envVar,
-                source: 'pi',
-            },
-        },
-    });
-};
-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: {
-            ...(isCloudMode()
-                ? {
-                    authMode: {
-                        type: 'string',
-                        description: 'Credits — use your workspace credit balance via OpenBot. BYOK — bring your own provider API key.',
-                        enum: ['credits', 'byok'],
-                        default: 'credits',
-                    },
-                }
-                : {}),
-            agentDir: {
-                type: 'string',
-                description: 'Pi config directory (default: ~/.pi/agent).',
-            },
-            provider: {
-                type: 'string',
-                description: 'Model provider (e.g. anthropic, openai, deepseek).',
-            },
-            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);
-            const fail = function* (message) {
-                const mapped = remapPiError(message, config.authMode);
-                if (config.authMode === 'byok' && isAuthErrorMessage(message)) {
-                    yield buildApiKeyWidget(context.agentId, threadId, mapped, config.provider);
-                }
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: `**Pi error:** ${mapped}`,
-                    threadId,
-                });
-            };
-            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': {
-                            const content = chunk.content.startsWith('**Pi error:** ')
-                                ? `**Pi error:** ${remapPiError(chunk.content.slice('**Pi error:** '.length), config.authMode)}`
-                                : chunk.content;
-                            if (fullTextContent)
-                                fullTextContent += '\n\n';
-                            fullTextContent += 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* fail(formatPiError(error));
-            }
-        });
-        builder.on('client:ui:widget:response', async function* (event, handlerCtx) {
-            const { metadata, values, widgetId } = event.data ?? {};
-            if (!metadata || metadata.type !== 'api_key_request')
-                return;
-            if (metadata.source !== 'pi')
-                return;
-            const apiKey = values?.apiKey;
-            if (typeof apiKey !== 'string' || !apiKey)
-                return;
-            const envVar = typeof metadata.envVar === 'string' ? metadata.envVar : 'OPENAI_API_KEY';
-            const storage = context.storage;
-            if (!storage) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: '[pi] no storage available; cannot persist API key.',
-                    threadId: handlerCtx.state.threadId,
-                });
-                return;
-            }
-            try {
-                await storage.createVariable({ key: envVar, value: apiKey, secret: true });
-                process.env[envVar] = apiKey;
-                disposePiSessionsForThread(handlerCtx.state);
-                yield uiWidget({
-                    agentId: context.agentId,
-                    widget: {
-                        widgetId: widgetId ?? `pi_api_key_saved_${Date.now()}`,
-                        kind: 'message',
-                        title: 'API Key Saved',
-                        body: `Saved ${envVar} as a workspace variable. You can now continue the conversation.`,
-                        state: 'submitted',
-                    },
-                });
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: `Saved ${envVar} to workspace variables. Re-send your last message to retry.`,
-                    threadId: handlerCtx.state.threadId,
-                });
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: `[pi] failed to save API key: ${errorMessage}`,
-                    threadId: handlerCtx.state.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,11 +1,19 @@
 import { AuthStorage, createAgentSession, DefaultResourceLoader, getAgentDir, ModelRegistry, SessionManager, SettingsManager, } from '@earendil-works/pi-coding-agent';
-import { parseToolList } from './config.js';
-import { applyCreditsProviders, CREDITS_NOT_CONFIGURED_MESSAGE, isCreditsProvider, resolveCreditsAuthConfig, unsupportedCreditsProviderMessage, } from './credits-auth.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, config) => {
+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}:${config.authMode}`;
+    return `${scope}:${byok ? 'byok' : 'credits'}`;
 };
 const resolveModel = async (config, modelRegistry) => {
     if (config.provider && config.model) {
@@ -16,23 +24,24 @@ const resolveModel = async (config, modelRegistry) => {
 };
 export const getOrCreatePiSession = async (args) => {
     const { config, state, storage } = args;
-    const sessionKey = buildSessionKey(state, config);
+    const byok = hasPiByok(config.provider);
+    const sessionKey = buildSessionKey(state, byok);
     const cached = sessionCache.get(sessionKey);
     if (cached)
         return cached;
-    if (config.authMode === 'credits' && config.provider && !isCreditsProvider(config.provider)) {
+    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`);
-    if (config.authMode === 'credits') {
-        const credits = resolveCreditsAuthConfig();
-        if (!credits) {
-            throw new Error(CREDITS_NOT_CONFIGURED_MESSAGE);
-        }
+    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);
@@ -41,7 +50,6 @@ export const getOrCreatePiSession = async (args) => {
         cwd,
         agentDir,
         settingsManager,
-        ...(config.systemPrompt ? { systemPromptOverride: () => config.systemPrompt } : {}),
     });
     await loader.reload();
     const sessionManager = persisted.sessionFile
@@ -53,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,

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.1.0",
+  "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",

package/dist/cloud-mode.js

@@ -1,10 +0,0 @@
-/** True when this runtime is a platform-managed cloud deployment. */
-export const isCloudMode = () => process.env.OPENBOT_CLOUD_MODE === '1';
-/** Default auth mode: Credits on cloud, BYOK locally. */
-export const defaultAuthMode = () => (isCloudMode() ? 'credits' : 'byok');
-export function resolveAuthMode(config) {
-    if (config.authMode === 'byok' || config.authMode === 'credits') {
-        return config.authMode;
-    }
-    return defaultAuthMode();
-}

package/dist/credits-auth.js

@@ -1,90 +0,0 @@
-export const INTEGRATIONS_TOKEN_HEADER = 'x-openbot-integrations-token';
-export const CREDITS_API_KEY_PLACEHOLDER = 'openbot-credits';
-/**
- * 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));
-export function isCreditsProvider(provider) {
-    return CREDITS_PROVIDER_IDS.has(provider);
-}
-/** Cloud host injects these when routing LLM calls through OpenBot Credits. */
-export function resolveCreditsAuthConfig() {
-    const baseUrl = process.env.OPENBOT_INTEGRATIONS_BASE_URL?.trim();
-    const token = process.env.OPENBOT_INTEGRATIONS_TOKEN?.trim();
-    if (!baseUrl || !token)
-        return undefined;
-    return { baseUrl: baseUrl.replace(/\/$/, ''), token };
-}
-export function creditsProviderBaseUrl(config, provider) {
-    const match = CREDITS_PROVIDERS.find((entry) => entry.id === provider);
-    if (!match) {
-        throw new Error(`Unsupported credits provider: ${provider}`);
-    }
-    return `${config.baseUrl}/${match.basePath}`;
-}
-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 function isCreditsErrorMessage(message) {
-    const lower = message.toLowerCase();
-    return (lower.includes('insufficient_credits') ||
-        lower.includes('insufficient credits') ||
-        lower.includes('402'));
-}
-export function isAuthErrorMessage(message) {
-    const lower = message.toLowerCase();
-    return (lower.includes('api key') ||
-        lower.includes('apikey') ||
-        lower.includes('401') ||
-        lower.includes('unauthorized') ||
-        lower.includes('authentication') ||
-        lower.includes('not logged in') ||
-        lower.includes('login'));
-}
-export function isIntegrationsProviderError(message) {
-    const lower = message.toLowerCase();
-    return (lower.includes('provider api key not configured') ||
-        (lower.includes('503') && lower.includes('provider')));
-}
-export const CREDITS_NOT_CONFIGURED_MESSAGE = 'OpenBot Credits is not configured on this runtime. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN (try redeploying the workspace).';
-export const CREDITS_PROVIDER_UNAVAILABLE_MESSAGE = 'OpenBot Credits could not reach the model provider — the platform provider API key is not configured yet. Try again later or switch this agent to BYOK mode.';
-export const CREDITS_AUTH_FAILED_MESSAGE = 'Pi could not authenticate via OpenBot Credits. Check your workspace credit balance in settings, or switch this agent to BYOK mode.';
-export function creditsErrorMessage(message) {
-    if (isIntegrationsProviderError(message)) {
-        return CREDITS_PROVIDER_UNAVAILABLE_MESSAGE;
-    }
-    if (isCreditsErrorMessage(message)) {
-        return 'Insufficient workspace credits. Add credits in workspace settings or switch this agent to BYOK mode.';
-    }
-    if (isAuthErrorMessage(message))
-        return CREDITS_AUTH_FAILED_MESSAGE;
-    return undefined;
-}
-export function remapPiError(message, authMode) {
-    if (authMode !== 'credits')
-        return message;
-    return creditsErrorMessage(message) ?? message;
-}
-export function unsupportedCreditsProviderMessage(provider) {
-    return (`OpenBot Credits does not support the "${provider}" provider. ` +
-        'Use openai, anthropic, or deepseek, or switch this agent to BYOK mode.');
-}

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);
-};