@meetopenbot/openbot 0.1.1

package/dist/cloud-mode.d.ts

@@ -0,0 +1,5 @@
+export type OpenbotAuthMode = 'credits' | 'byok';
+/** True when this runtime is a platform-managed cloud deployment. */
+export declare const isCloudMode: () => boolean;
+/** Default auth mode: Credits on cloud, BYOK locally. */
+export declare const defaultAuthMode: () => OpenbotAuthMode;

package/dist/cloud-mode.js

@@ -0,0 +1,4 @@
+/** 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');

package/dist/context.d.ts

@@ -0,0 +1,11 @@
+import { OpenBotState } from './types.js';
+export declare const DEFAULT_CONTEXT_BUDGET = 8000;
+export declare const MAX_CONTEXT_FILES = 50;
+/**
+ * Returns the known context window budget (in tokens) for a given model string.
+ */
+export declare const getContextBudgetForModel: (modelString: string) => number;
+/**
+ * Simplified context builder for MVP.
+ */
+export declare function buildContext(state: OpenBotState, storage?: Record<string, any>): Promise<string>;

package/dist/context.js

@@ -0,0 +1,120 @@
+import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+import { todoService } from './tools/todo-service.js';
+export const DEFAULT_CONTEXT_BUDGET = 8000;
+export const MAX_CONTEXT_FILES = 50;
+/**
+ * Returns the known context window budget (in tokens) for a given model string.
+ */
+export const getContextBudgetForModel = (modelString) => {
+    const budgets = {
+        'openai/gpt-4o': 128000,
+        'openai/gpt-4o-mini': 128000,
+        'openai/o1-preview': 128000,
+        'openai/o1-mini': 128000,
+        'anthropic/claude-3-5-sonnet-20240620': 200000,
+        'anthropic/claude-3-5-sonnet-latest': 200000,
+        'anthropic/claude-3-opus-20240229': 200000,
+        'anthropic/claude-3-sonnet-20240229': 200000,
+        'anthropic/claude-3-haiku-20240307': 200000,
+    };
+    return budgets[modelString] || DEFAULT_CONTEXT_BUDGET;
+};
+/**
+ * Simplified context builder for MVP.
+ */
+export async function buildContext(state, storage) {
+    const { channelId, threadId, channelDetails, agentId, threadDetails, agentDetails } = state;
+    const sections = [];
+    // Fetch agents once if storage is available
+    const allAgents = storage?.getAgents ? await storage.getAgents().catch(() => []) : [];
+    // 1. User
+    if (state.currentUser?.userName) {
+        sections.push(`## HUMAN\n- Name: ${state.currentUser.userName}`);
+    }
+    // 2. Environment
+    let env = '## ENVIRONMENT\n';
+    const channelName = channelDetails?.name || channelId;
+    env += `- Mode: Channel (#${channelName})\n`;
+    if (channelDetails?.cwd) {
+        env += `- Workspace: ${channelDetails.cwd}\n`;
+    }
+    if (threadId) {
+        env += `- Thread: ${threadDetails?.name || threadId}\n`;
+    }
+    sections.push(env);
+    // 2.5 Thread todos
+    if (channelId && threadId) {
+        try {
+            const list = await todoService.getTodos({ channelId, threadId });
+            if (list.items.length > 0) {
+                const formatted = list.items
+                    .map((t) => `- [${t.status}] (${t.id}) ${t.content}`)
+                    .join('\n');
+                sections.push(`## TODOS\n${formatted}`);
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch todos:', error);
+        }
+    }
+    // 2.6 Installed Agents
+    if (allAgents.length > 0) {
+        const formatted = allAgents
+            .map((a) => `- ${a.id}: ${a.name}${a.description ? ` - ${a.description}` : ''}`)
+            .join('\n');
+        sections.push(`## INSTALLED AGENTS\n${formatted}`);
+    }
+    // 3. Channel Spec
+    const spec = channelDetails?.spec?.trim();
+    if (spec) {
+        sections.push(`## CHANNEL SPECIFICATION\n${spec}`);
+    }
+    // 4. Files
+    if (storage?.listFiles && channelId && channelDetails?.cwd) {
+        try {
+            const files = await storage.listFiles({ channelId });
+            if (files.length > 0) {
+                const limited = files.slice(0, MAX_CONTEXT_FILES);
+                const formatted = limited
+                    .map((f) => `- ${f.name}${f.isDirectory ? '/' : ''}`)
+                    .join('\n');
+                let fileSection = `## FILES\n${formatted}`;
+                if (files.length > MAX_CONTEXT_FILES) {
+                    fileSection += `\n- ... and ${files.length - MAX_CONTEXT_FILES} more files`;
+                }
+                sections.push(fileSection);
+            }
+            else {
+                sections.push('## FILES\n- (No files in workspace)');
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch files:', error);
+        }
+    }
+    // 5. Agent Instructions
+    const rawInstructions = agentDetails?.instructions?.trim();
+    if (rawInstructions &&
+        rawInstructions !== OPENBOT_SYSTEM_PROMPT.trim()) {
+        sections.push(`## Instructions\n${rawInstructions}`);
+    }
+    // 6. Memories
+    if (storage?.listMemories) {
+        try {
+            const scopes = ['global', `agent:${agentId}`];
+            if (channelId)
+                scopes.push(`channel:${channelId}`);
+            const records = await storage.listMemories({ scopes, limit: 20 });
+            if (records.length > 0) {
+                const formatted = records
+                    .map((r) => `- (${r.scope}) ${r.content}`)
+                    .join('\n');
+                sections.push(`## MEMORIES\n${formatted}`);
+            }
+        }
+        catch (error) {
+            console.warn('[context] Failed to fetch memories:', error);
+        }
+    }
+    return sections.join('\n\n');
+}

package/dist/history.d.ts

@@ -0,0 +1,9 @@
+import { OpenBotEvent } from './types.js';
+import { type ModelMessage } from 'ai';
+/**
+ * Converts a raw event log into a valid chain of ModelMessages for the AI SDK.
+ *
+ * This is a basic implementation that maps events to messages and filters out
+ * events from sub-processes (delegation) to avoid duplication in history.
+ */
+export declare function eventsToModelMessages(events: OpenBotEvent[]): ModelMessage[];

package/dist/history.js

@@ -0,0 +1,145 @@
+/**
+ * Ensures every tool-call has a matching tool-result before calling the LLM.
+ * Orphaned calls (interrupted run, missing :result event, etc.) get an empty
+ * result so the conversation can resume instead of failing validation.
+ */
+function fillMissingToolResults(messages) {
+    const filled = [];
+    const pending = new Map();
+    const flushPending = () => {
+        if (pending.size === 0)
+            return;
+        filled.push({
+            role: 'tool',
+            content: [...pending.entries()].map(([toolCallId, toolName]) => ({
+                type: 'tool-result',
+                toolCallId,
+                toolName,
+                output: { type: 'text', value: '' },
+            })),
+        });
+        pending.clear();
+    };
+    for (const message of messages) {
+        if (message.role === 'tool' && Array.isArray(message.content)) {
+            filled.push(message);
+            for (const part of message.content) {
+                if (part.type === 'tool-result') {
+                    pending.delete(part.toolCallId);
+                }
+            }
+            continue;
+        }
+        flushPending();
+        filled.push(message);
+        if (message.role === 'assistant' && Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (part.type === 'tool-call') {
+                    const toolCall = part;
+                    pending.set(toolCall.toolCallId, toolCall.toolName);
+                }
+            }
+        }
+    }
+    flushPending();
+    return filled;
+}
+/**
+ * Converts a raw event log into a valid chain of ModelMessages for the AI SDK.
+ *
+ * This is a basic implementation that maps events to messages and filters out
+ * events from sub-processes (delegation) to avoid duplication in history.
+ */
+export function eventsToModelMessages(events) {
+    const messages = [];
+    for (const event of events) {
+        // Skip events that belong to a sub-process (like delegation)
+        // so they don't pollute the main conversation history.
+        if (event.meta?.parentToolCallId) {
+            continue;
+        }
+        switch (event.type) {
+            case 'agent:output': {
+                const content = event.data.content;
+                const last = messages[messages.length - 1];
+                if (last && last.role === 'assistant' && typeof last.content === 'string') {
+                    last.content += content;
+                }
+                else {
+                    messages.push({ role: 'assistant', content });
+                }
+                break;
+            }
+            case 'agent:invoke': {
+                const invokeEvent = event;
+                if (invokeEvent.data?.content && invokeEvent.data?.role) {
+                    messages.push({
+                        role: invokeEvent.data.role,
+                        content: invokeEvent.data.content
+                    });
+                }
+                break;
+            }
+            default:
+                // Handle tool calls (action:*)
+                if (event.type.startsWith('action:') && !event.type.endsWith(':result')) {
+                    const toolName = event.type.slice(7);
+                    const toolCallId = event.meta?.toolCallId;
+                    if (typeof toolCallId !== 'string')
+                        break;
+                    const toolCall = {
+                        type: 'tool-call',
+                        toolCallId,
+                        toolName,
+                        input: event.data,
+                    };
+                    const last = messages[messages.length - 1];
+                    if (last && last.role === 'assistant') {
+                        if (typeof last.content === 'string') {
+                            last.content = [
+                                { type: 'text', text: last.content },
+                                toolCall,
+                            ];
+                        }
+                        else if (Array.isArray(last.content)) {
+                            last.content.push(toolCall);
+                        }
+                    }
+                    else {
+                        messages.push({
+                            role: 'assistant',
+                            content: [toolCall],
+                        });
+                    }
+                }
+                // Handle tool results (action:*:result)
+                else if (event.type.startsWith('action:') && event.type.endsWith(':result')) {
+                    const toolName = event.type.slice(7, -7);
+                    const toolCallId = event.meta?.toolCallId;
+                    if (typeof toolCallId !== 'string')
+                        break;
+                    const toolResult = {
+                        type: 'tool-result',
+                        toolCallId,
+                        toolName,
+                        output: {
+                            type: 'text',
+                            value: event?.data?.output || "No output", // ?.output is from delegation result
+                        },
+                    };
+                    const last = messages[messages.length - 1];
+                    if (last && last.role === 'tool' && Array.isArray(last.content)) {
+                        last.content.push(toolResult);
+                    }
+                    else {
+                        messages.push({
+                            role: 'tool',
+                            content: [toolResult],
+                        });
+                    }
+                }
+                break;
+        }
+    }
+    return fillMissingToolResults(messages);
+}

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+export declare const OPENBOT_PLUGIN_ID = "@meetopenbot/openbot";
+/**
+ * `@meetopenbot/openbot` — the standard, opinionated OpenBot agent runtime.
+ *
+ * Batteries-included: shell, memory, todo, storage tools, delegation, approval,
+ * preview, and the LLM loop.
+ */
+export declare const openbotPlugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        properties: {
+            model: {
+                type: "string";
+                description: string;
+            };
+            authMode?: {
+                type: "string";
+                description: string;
+                enum: string[];
+                default: string;
+            } | undefined;
+        };
+    };
+    toolDefinitions: {
+        create_channel: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                channelId: import("zod").ZodString;
+                spec: import("zod").ZodOptional<import("zod").ZodString>;
+                initialState: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                cwd: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        };
+        patch_channel_details: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                state: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                spec: import("zod").ZodOptional<import("zod").ZodString>;
+                cwd: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        };
+        patch_thread_details: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                state: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>;
+        };
+        create_variable: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                key: import("zod").ZodString;
+                value: import("zod").ZodString;
+                secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>;
+        };
+        delete_variable: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                key: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        delete_channel: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                channelId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        get_workspace_file_url: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                path: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    };
+    factory: (context: import("./types.js").PluginContext) => (builder: import("melony").MelonyBuilder<import("@meetopenbot/plugin-sdk").OpenBotState, import("./types.js").OpenBotEvent>) => void;
+};
+export default openbotPlugin;

package/dist/index.js

@@ -0,0 +1,77 @@
+import { defineOpenbotPlugin } from './types.js';
+import { isCloudMode } from './cloud-mode.js';
+import { openbotRuntime } from './runtime.js';
+import { bashPlugin } from './tools/bash.js';
+import { memoryPlugin } from './tools/memory.js';
+import { todoPlugin } from './tools/todo.js';
+import { approvalPlugin } from './tools/approval.js';
+import { delegationPlugin } from './tools/delegation.js';
+import { uiPlugin } from './tools/ui.js';
+import { previewPlugin } from './tools/preview.js';
+import { storageToolPlugin } from './tools/storage.js';
+export const OPENBOT_PLUGIN_ID = '@meetopenbot/openbot';
+/**
+ * `@meetopenbot/openbot` — the standard, opinionated OpenBot agent runtime.
+ *
+ * Batteries-included: shell, memory, todo, storage tools, delegation, approval,
+ * preview, and the LLM loop.
+ */
+export const openbotPlugin = defineOpenbotPlugin({
+    id: OPENBOT_PLUGIN_ID,
+    name: 'OpenBot Agent',
+    description: 'The standard OpenBot agent runtime with inbuilt tools (shell, memory, todo, storage, delegation, and approval).',
+    configSchema: {
+        type: 'object',
+        properties: {
+            ...(isCloudMode()
+                ? {
+                    authMode: {
+                        type: 'string',
+                        description: 'Credits — use your workspace credit balance via OpenBot. BYOK — bring your own API key.',
+                        enum: ['credits', 'byok'],
+                        default: 'credits',
+                    },
+                }
+                : {}),
+            model: {
+                type: 'string',
+                description: 'Model from the hosted marketplace registry.',
+            },
+        },
+    },
+    toolDefinitions: {
+        ...bashPlugin.toolDefinitions,
+        ...memoryPlugin.toolDefinitions,
+        ...todoPlugin.toolDefinitions,
+        ...storageToolPlugin.toolDefinitions,
+        ...delegationPlugin.toolDefinitions,
+        ...previewPlugin.toolDefinitions,
+    },
+    factory: (context) => (builder) => {
+        const { agentId, config, storage, tools, abortSignal, host } = context;
+        bashPlugin.factory(context)(builder);
+        memoryPlugin.factory(context)(builder);
+        todoPlugin.factory(context)(builder);
+        storageToolPlugin.register(context)(builder);
+        delegationPlugin.factory(context)(builder);
+        uiPlugin.factory(context)(builder);
+        previewPlugin.factory(context)(builder);
+        const approvalConfig = config?.approval ?? {
+            actions: [],
+        };
+        approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
+        const authMode = host.isCloudSystemAgent(agentId)
+            ? host.parseOpenbotAuthMode(config?.authMode)
+            : 'byok';
+        return openbotRuntime({
+            model: config?.model,
+            authMode,
+            agentId,
+            storage,
+            toolDefinitions: tools,
+            abortSignal,
+            host,
+        })(builder);
+    },
+});
+export default openbotPlugin;

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModel } from 'ai';
+export declare function resolveModel(modelString: string, _agentId?: string): LanguageModel;

package/dist/model.js

@@ -0,0 +1,20 @@
+import { openai as defaultOpenai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
+export function resolveModel(modelString, _agentId) {
+    const [provider, ...rest] = modelString.split('/');
+    const modelId = rest.join('/');
+    if (!modelId) {
+        throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
+    }
+    switch (provider) {
+        case 'openai':
+            return defaultOpenai(modelId);
+        case 'anthropic':
+            return anthropic(modelId);
+        case 'google':
+            return google(modelId);
+        default:
+            throw new Error(`Unsupported AI provider: "${provider}"`);
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,25 @@
+import { PluginHost, PluginFactory } from './types.js';
+export interface OpenBotRuntimeOptions {
+    /** Provider model string (e.g. `openai/gpt-4o-mini`, `anthropic/claude-3-5-sonnet-20240620`). */
+    model?: string;
+    /** Cloud system agent auth mode; self-hosted agents always use BYOK. */
+    authMode?: 'credits' | 'byok';
+    agentId?: string;
+    storage?: Record<string, any>;
+    /** Tool definitions merged from all tool plugins attached to this agent. */
+    toolDefinitions?: Record<string, {
+        description: string;
+        inputSchema: unknown;
+    }>;
+    /** Fires when the run is stopped; cancels the in-flight LLM call. */
+    abortSignal?: AbortSignal;
+    host: PluginHost;
+}
+/**
+ * OpenBot agent runtime.
+ *
+ * - One `generateText` call per `runLLM` (tools have no `execute`; SDK stops at 1 step).
+ * - Tool calls become `action:*` events; plugins emit `:result` when done.
+ * - When a full batch of results is in, `runLLM` runs again with updated history.
+ */
+export declare const openbotRuntime: (options: OpenBotRuntimeOptions) => PluginFactory;