@meetopenbot/openbot 0.1.13 → 0.1.15

package/dist/runtime.js

@@ -3,6 +3,7 @@ import { eventsToModelMessages } from './history.js';
 import { buildContext } from './context.js';
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
 import { isAuthErrorMessage, isCreditsErrorMessage } from './credits-auth.js';
+import { AUTO_MODEL_ID, isAutoModel, isRetryableModelError, listAutoModelCandidates, } from './auto-model.js';
 import { resolveModel } from './model.js';
 import { fetchModelRegistry, getProviderModelOptions, listApiKeyProviders, PROVIDER_API_KEY_LINKS, } from './model-registry.js';
 async function buildSystemPrompt(state, storage) {
@@ -68,10 +69,8 @@ function createToolBatchTracker(state, storage, channelId, threadId) {
  * - When a full batch of results is in, `runLLM` runs again with updated history.
  */
 export const openbotRuntime = (options) => (builder) => {
-    const { model: modelString = 'openai/gpt-4o-mini', authMode = 'byok', agentId, storage, toolDefinitions = {}, abortSignal, host, } = options;
-    let currentModelString = modelString;
-    const resolveCurrentModel = () => resolveModel(currentModelString, { authMode });
-    let model = resolveCurrentModel();
+    const { model: modelString = AUTO_MODEL_ID, authMode = 'byok', agentId, storage, toolDefinitions = {}, abortSignal, host, } = options;
+    let configuredModelString = modelString;
     const isCreditsCloudAgent = (id) => host.isCloudSystemAgent(id ?? '') && authMode === 'credits';
     const runLLM = async function* (context, threadId, trigger) {
         if (!storage)
@@ -84,27 +83,48 @@ export const openbotRuntime = (options) => (builder) => {
         const parentAgentId = triggerEvent?.meta?.parentAgentId;
         const parentToolCallId = triggerEvent?.meta?.parentToolCallId;
         const state = context.state;
-        state.model = currentModelString;
+        state.model = configuredModelString;
         const systemPrompt = await buildSystemPrompt(context.state, storage);
         const events = await storage.getEvents({
             channelId: context.state.channelId,
             threadId: context.state.threadId,
         });
         const messages = eventsToModelMessages(events);
-        // console.log('systemPrompt:::::::\n', systemPrompt);
-        // console.log('messages:::::::\n', JSON.stringify(messages));
-        // console.log('toolDefinitions:::::::\n', JSON.stringify(toolDefinitions));
+        const candidates = isAutoModel(configuredModelString)
+            ? listAutoModelCandidates({ authMode })
+            : [configuredModelString];
         try {
             // Single LLM request — tool execution happens externally via action:* handlers.
-            const result = await generateText({
-                model,
-                system: systemPrompt,
-                messages,
-                tools: toolDefinitions,
-                stopWhen: ({ steps }) => steps.length === 1,
-                allowSystemInMessages: true,
-                abortSignal,
-            });
+            const generate = async () => {
+                let lastError;
+                for (let i = 0; i < candidates.length; i++) {
+                    try {
+                        return await generateText({
+                            model: resolveModel(candidates[i], { authMode }),
+                            system: systemPrompt,
+                            messages,
+                            tools: toolDefinitions,
+                            stopWhen: ({ steps }) => steps.length === 1,
+                            allowSystemInMessages: true,
+                            abortSignal,
+                        });
+                    }
+                    catch (error) {
+                        lastError = error;
+                        if (abortSignal?.aborted)
+                            throw error;
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        if (isCreditsErrorMessage(errorMessage) || isAuthErrorMessage(errorMessage)) {
+                            throw error;
+                        }
+                        if (!isRetryableModelError(error) || i === candidates.length - 1) {
+                            throw error;
+                        }
+                    }
+                }
+                throw lastError ?? new Error('Model request failed.');
+            };
+            const result = await generate();
             const toolCalls = result.toolCalls ?? [];
             // if (result.usage) {
             //   const usage = result.usage;
@@ -252,8 +272,9 @@ export const openbotRuntime = (options) => (builder) => {
             return;
         if (metadata?.type === 'api_provider_selection') {
             const provider = actionId;
-            const [_, ...rest] = currentModelString.split('/');
-            const currentModelId = rest.join('/');
+            const configuredModelId = isAutoModel(configuredModelString)
+                ? ''
+                : configuredModelString.split('/').slice(1).join('/');
             const registry = await fetchModelRegistry();
             const providerData = registry?.providers?.[provider];
             const label = providerData?.label || provider;
@@ -273,8 +294,8 @@ export const openbotRuntime = (options) => (builder) => {
                 },
                 meta: { agentId: context.state.agentId, threadId },
             };
-            if (modelOptions && modelOptions.length > 0) {
-                const defaultModelId = modelOptions.find((m) => m.value === currentModelId)?.value || modelOptions[0].value;
+            if (modelOptions && modelOptions.length > 0 && !isAutoModel(configuredModelString)) {
+                const defaultModelId = modelOptions.find((m) => m.value === configuredModelId)?.value || modelOptions[0].value;
                 yield {
                     type: 'client:ui:widget',
                     data: {
@@ -302,23 +323,29 @@ export const openbotRuntime = (options) => (builder) => {
                     kind: 'form',
                     widgetId: `api_key_request_${Date.now()}`,
                     title: `${label} Setup`,
-                    description: `Enter your API key and model ID.`,
+                    description: isAutoModel(configuredModelString)
+                        ? `Enter your API key to continue.`
+                        : `Enter your API key and model ID.`,
                     fields: [
-                        {
-                            id: 'model',
-                            label: 'Model',
-                            type: 'text',
-                            description: 'Enter the model ID for this provider.',
-                            placeholder: provider === 'openai'
-                                ? 'gpt-4o-mini'
-                                : provider === 'anthropic'
-                                    ? 'claude-3-5-sonnet-20241022'
-                                    : provider === 'deepseek'
-                                        ? 'deepseek-chat'
-                                        : 'gemini-2.0-flash',
-                            required: true,
-                            defaultValue: currentModelId || '',
-                        },
+                        ...(isAutoModel(configuredModelString)
+                            ? []
+                            : [
+                                {
+                                    id: 'model',
+                                    label: 'Model',
+                                    type: 'text',
+                                    description: 'Enter the model ID for this provider.',
+                                    placeholder: provider === 'openai'
+                                        ? 'gpt-4o-mini'
+                                        : provider === 'anthropic'
+                                            ? 'claude-3-5-sonnet-20241022'
+                                            : provider === 'deepseek'
+                                                ? 'deepseek-chat'
+                                                : 'gemini-2.0-flash',
+                                    required: true,
+                                    defaultValue: configuredModelId || '',
+                                },
+                            ]),
                         {
                             id: 'apiKey',
                             label: 'API Key',
@@ -393,8 +420,9 @@ export const openbotRuntime = (options) => (builder) => {
         if (!values?.apiKey)
             return;
         const provider = String(values.provider || metadata.provider);
+        const keepAuto = isAutoModel(configuredModelString);
         const modelId = String(values.model || metadata.model || '').trim();
-        if (!modelId)
+        if (!keepAuto && !modelId)
             return;
         const apiKey = String(values.apiKey);
         if (provider !== 'openai' &&
@@ -415,16 +443,19 @@ export const openbotRuntime = (options) => (builder) => {
                 : provider === 'deepseek'
                     ? 'DEEPSEEK_API_KEY'
                     : 'GOOGLE_GENERATIVE_AI_API_KEY';
-        const newModelString = `${provider}/${modelId}`;
+        const newModelString = keepAuto ? AUTO_MODEL_ID : `${provider}/${modelId}`;
         if (!storage)
             return;
         try {
             await storage.createVariable({ key: envVar, value: apiKey, secret: true });
             process.env[envVar] = apiKey;
-            currentModelString = newModelString;
-            model = resolveCurrentModel();
+            if (!keepAuto) {
+                configuredModelString = newModelString;
+            }
             try {
-                host.saveConfig({ model: currentModelString });
+                if (!keepAuto) {
+                    host.saveConfig({ model: configuredModelString });
+                }
                 const details = await storage.getAgentDetails({ agentId: context.state.agentId });
                 const updatedPlugins = details.pluginRefs.map((ref) => {
                     if (ref.id === host.openbotPluginId) {
@@ -432,7 +463,7 @@ export const openbotRuntime = (options) => (builder) => {
                             ...ref,
                             config: {
                                 ...ref.config,
-                                model: currentModelString,
+                                ...(keepAuto ? {} : { model: configuredModelString }),
                                 ...(host.isCloudSystemAgent(context.state.agentId) ? { authMode: 'byok' } : {}),
                             },
                         };
@@ -450,7 +481,9 @@ export const openbotRuntime = (options) => (builder) => {
             yield {
                 type: 'agent:output',
                 data: {
-                    content: `Saved ${provider} API key and set model to \`${newModelString}\`.`,
+                    content: keepAuto
+                        ? `Saved ${provider} API key. Auto will use it when that provider is the cheapest available.`
+                        : `Saved ${provider} API key and set model to \`${newModelString}\`.`,
                 },
                 meta: { agentId: context.state.agentId },
             };
@@ -460,7 +493,9 @@ export const openbotRuntime = (options) => (builder) => {
                     widgetId: event.data.widgetId,
                     kind: 'message',
                     title: 'API Key Saved',
-                    body: `Successfully saved ${provider} API key and selected model \`${newModelString}\`. You can now continue your conversation.`,
+                    body: keepAuto
+                        ? `Successfully saved ${provider} API key. You can now continue your conversation.`
+                        : `Successfully saved ${provider} API key and selected model \`${newModelString}\`. You can now continue your conversation.`,
                     state: 'submitted',
                     display: 'collapsed',
                     disabled: true,

package/dist/space-id.js

@@ -0,0 +1,22 @@
+/** Default inbox Space. Wire id stays `general` (channelId). */
+export const GENERAL_SPACE_ID = "general";
+/** Dummy ids models invent when they feel forced to "place" work that has no Space. */
+const PLACEHOLDER_SPACE_IDS = new Set([
+    "noop",
+    "none",
+    "null",
+    "n-a",
+    "na",
+    "dummy",
+    "placeholder",
+    "untitled",
+    "misc",
+    "temp",
+    "tmp",
+]);
+export function isPlaceholderSpaceId(spaceId) {
+    return PLACEHOLDER_SPACE_IDS.has(spaceId);
+}
+export function placeholderSpaceError(spaceId) {
+    return `Refused to create #${spaceId}: that looks like a placeholder, not a real Space. Stay in #general for questions and listings. If project work needs a new Space, propose a concrete name and wait for the human to agree.`;
+}

package/dist/system-prompt.js

@@ -1,57 +1,54 @@
 export const OPENBOT_SYSTEM_PROMPT = [
-    '# ROLE',
-    'You are an OpenBot, the main coordinator and router agent. Your primary role is to orchestrate specialized agents and manage tasks methodically to help the human achieve their goals.',
-    '',
-    '# SECURITY POLICY',
-    '- **CRITICAL**: Never request API keys, passwords, or sensitive credentials via text or UI widgets; these are managed deterministically via secure forms and must never enter your context.',
+    "# ROLE",
+    "You are OpenBot, the coordinator. Humans talk only to you. Specialized agents have their own harnesses; you ask them to do work. You do not impersonate them, and you do not do their jobs yourself.",
+    "",
+    "# SECURITY POLICY",
+    "- **CRITICAL**: Never request API keys, passwords, or sensitive credentials via text or UI widgets; these are managed deterministically via secure forms and must never enter your context.",
     '- **Credential Guidance**: If an agent or tool requires credentials, inform the user they can be managed under "Settings > Variables".',
-    '',
-    '# CORE MISSION',
-    'You act as a high-level manager, ensuring the right specialized agent is working on the right task. However, when orchestrating or when specialized agents are not available, you are capable of executing complex steps yourself using a highly structured, stateful, and disciplined approach.',
-    '',
-    '# THE AGENT LOOP',
-    'You operate in an iterative agent loop to complete user-assigned tasks step-by-step:',
-    '1. **Analyze Events**: Understand user needs and the current state through the chronological event stream (focusing on latest user messages and execution/observation results).',
-    '2. **Select Tools**: Choose the next tool call based on current state, todos, and environment constraints. To maximize precision, choose only one tool call per iteration for complex tasks, or parallel calls if they are independent.',
-    '3. **Wait for Execution**: Let the system execute the tool action and add observations/results back into the event stream.',
-    '4. **Iterate**: Patiently repeat the above steps, analyzing results at each turn, until all steps of the task are completed.',
-    '5. **Submit Results**: Message the human with clear, polished, and detailed outcomes, attaching any relevant files or deliverables.',
-    '6. **Enter Standby**: Enter an idle state and wait for new tasks.',
-    '',
-    '# TASK TRACKING (TODOS)',
-    '- For any complex multi-step task (3+ steps), you **MUST** maintain a todo list with `todo_write`.',
-    '- Write the full intended list at task start. Each call replaces the previous list (not a partial patch).',
-    '- Keep exactly one item `in_progress` while working. Mark items `completed` immediately after finishing them.',
-    '- Use `cancelled` for steps that are no longer needed. When the overall task is done, mark all items `completed` and leave the list intact (do not clear with empty `items`).',
-    '- The current list is injected into context each turn as `## TODOS`; call `todo_read` only if you need an explicit refresh.',
-    '- Do not stop with open `pending` or `in_progress` items unless you are blocked and have told the user why.',
-    '',
-    '# OPERATIONAL GUIDELINES',
-    '- **Channel and Threads**: The main way to communicate and act is through channels and threads. There is a channel called "general" for getting started and conversations without a dedicated channel.',
-    '- **Delegation**: You can delegate tasks to any specialized agent in the `INSTALLED AGENTS` list using the `delegate` tool.',
-    '- **Durable Memory**: Use the `remember` tool to store important facts, preferences, or project details that should persist across sessions.',
-    '- **Hub-and-Spoke**: Specialized agents cannot communicate directly; as coordinator, you must pass relevant data from one agent to another.',
-    '',
-    '# SHELL & FILE EXECUTION RULES',
-    '- **Stateful Sessions**: Use `shell_exec` with a session `id` (e.g. `default`, `server`). Reuse the same id to keep shell state (cwd, env) across commands.',
-    '- **Working Directory**: Always pass an absolute `exec_dir` (use the channel workspace path from ENVIRONMENT).',
-    '- **Command Discipline**: Avoid interactive prompts when possible; use `-y`, `-f`, or non-interactive flags. For prompts, use `shell_write_to_process`.',
-    '- **Long-Running Processes**: Start dev servers with `shell_exec` using `&` at the end (e.g. `pnpm dev &`). If you forget `&`, `shell_exec` returns after ~15s with partial logs — the server may still be running.',
-    '- **Polling dev servers**: After starting (or after a timeout), poll with `shell_wait` (2–5s) then `shell_view` until logs show ready (URL/port). Do not start a duplicate server; reuse the same session id.',
-    '- **Stop dev servers**: Use `shell_kill_process` before restarting or when finished.',
-    '- **Preview URLs**: After a dev server is ready, use `expose_port` with its port to generate a public preview URL (stored on channel details as `previewUrl`). Expose tunnels are temporary; close with `unexpose_port`.',
-    '- **Calculations**: Use `bc` or Python for math. Do not calculate complex math mentally.',
-    '- **Chaining**: Chain related commands with `&&` in a single `shell_exec` when they must run sequentially.',
-    '',
-    '# COMMUNICATION & WRITING STYLE',
-    '- Be concise, professional, proactive, and polite.',
-    '- Confirm receipt of user messages quickly and outline your high-level strategy brief before executing a long series of steps.',
-    '- Inform the user via messages when you change methods or find strategic issues.',
-    '- Write in clean, continuous prose. Avoid excessive bullet points or lists in final responses unless explicitly requested.',
-    '- All major deliverables and documents must be highly detailed and complete; do not summarize or truncate final outputs unless specified.',
-    '',
-    '# ERROR HANDLING',
-    '- Tool failures are provided as events. When an error occurs, do not panic or immediately ask the user for help.',
-    '- Carefully analyze the stderr or failure logs, verify tool/argument names, and attempt alternative approaches or parameter fixes.',
-    '- Only report failure reasons and ask the human for help after multiple alternative approaches have failed.',
-].join('\n');
+    "",
+    "# CORE MISSION",
+    "You are a high-level manager. Not every message is project work.",
+    "- Questions, listings, setup, routing, and status stay in `#general`. Answer them from `## SPACES` and `## INSTALLED AGENTS`. Do not create a Space to look anything up.",
+    "- For real project work (build, code, design, ops) you decide **where** (which Space) and **who** (which installed agent), then ask that agent, report back in plain language, and keep todos current.",
+    "",
+    "# THE AGENT LOOP",
+    "You operate in an iterative loop:",
+    "1. **Analyze Events**: Understand the human, mentioned people, the current Space, and `## SPACES`.",
+    "2. **Place the work** (project work only): Stay in `#general` for questions, listings, setup, and routing. If this is `#general` and the ask is real project work, prefer an existing Space from `## SPACES` and `start_work` there before asking anyone. If no Space fits, propose a concrete name and why, then wait for the human to agree before creating one — unless they already named a new Space or explicitly asked you to create it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`). If you are already in the right Space, stay. Never `start_work` on a message that was already forwarded here.",
+    "3. **Ask people**: Use `ask_agent` to send a message to a specialist. Write it as a request to a colleague, not as a tool invocation.",
+    "4. **Wait**: Let the asked agent run in its own harness. Read their reply, then continue or ask someone else.",
+    "5. **Submit Results**: Message the human with clear outcomes. Name who you asked and where the work lives.",
+    "6. **Enter Standby**: Idle until the next human message.",
+    "",
+    "# TASK TRACKING (TODOS)",
+    "- For any complex multi-step task (3+ steps), you **MUST** maintain a todo list with `todo_write`.",
+    "- Write the full intended list at task start. Each call replaces the previous list (not a partial patch).",
+    "- Keep exactly one item `in_progress` while working. Mark items `completed` immediately after finishing them.",
+    "- Use `cancelled` for steps that are no longer needed. When the overall task is done, mark all items `completed` and leave the list intact (do not clear with empty `items`).",
+    "- The current list is injected into context each turn as `## TODOS`; call `todo_read` only if you need an explicit refresh.",
+    "- Do not stop with open `pending` or `in_progress` items unless you are blocked and have told the user why.",
+    "",
+    "# JOB STATUS",
+    "- Every thread is a job. Status is `working`, `needs_input`, `ready_for_review`, `completed`, or `archived`.",
+    "- When you need a blocking answer from the human, call `set_thread_status` with `needs_input` and a short `reason`.",
+    "- When you believe the job is done, set `ready_for_review`. Never set `completed` or `archived` — only the human can.",
+    "- The current status is injected each turn as `## THREAD STATUS`.",
+    "",
+    "# OPERATIONAL GUIDELINES",
+    '- **Spaces**: Work lives in Spaces (product name for channels). `#general` is dispatch — setup, questions, listings, routing, and "what should we do next." Project, coding, design, and ops work belongs in a dedicated Space. Prefer existing Spaces. Create a new Space only when the human asked for one, or they agreed after you suggested it.',
+    "- **Asking**: You ask specialists with `ask_agent`. If `## MENTIONED AGENTS` is present, you MUST ask those people. You may also ask others if needed. If nobody is mentioned, pick the best match from `## INSTALLED AGENTS` and tell the human who you asked.",
+    "- **Missing people**: If no installed agent can do the job, tell the human who to install. Do not attempt the specialist work yourself.",
+    "- **Hub-and-spoke**: Specialists cannot talk to each other. You pass context from one to the next.",
+    "- **Durable Memory**: Use the `remember` tool to store important facts, preferences, or project details that should persist across sessions.",
+    "",
+    "# COMMUNICATION & WRITING STYLE",
+    "- Be concise, professional, proactive, and polite.",
+    "- Confirm receipt quickly. For longer work, say where you are taking it and who you will ask.",
+    "- Write in clean, continuous prose. Avoid excessive bullet points unless requested.",
+    '- Talk about people, not tools: "I asked Claude Code to …" never "I used Claude Code to …".',
+    "",
+    "# ERROR HANDLING",
+    "- Tool failures are provided as events. When an error occurs, do not panic or immediately ask the user for help.",
+    "- If an asked agent fails, try a different agent or tell the human what blocked them.",
+    "- Only ask the human for help after you cannot route or ask anyone who can do the work.",
+].join("\n");

package/dist/tools/ask-agent.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+const askAgentToolDefinitions = {
+    ask_agent: {
+        description: "Ask another installed agent to do work in their own harness. Write the prompt as a message to a colleague, not as a command to a tool.",
+        inputSchema: z.object({
+            agentId: z
+                .string()
+                .describe("The ID of the agent to ask (from INSTALLED AGENTS)."),
+            prompt: z.string().describe("The message or question for that agent."),
+        }),
+    },
+};
+async function* runAskedAgent(pluginContext, event, context, resultType) {
+    if (context.state.agentId !== pluginContext.host.orchestratorAgentId) {
+        yield {
+            type: resultType,
+            data: {
+                success: false,
+                error: "Only OpenBot can ask other agents.",
+            },
+            meta: event.meta,
+        };
+        return;
+    }
+    const agentId = event.data.agentId;
+    const prompt = event.data.prompt;
+    const toolCallId = event.meta?.toolCallId;
+    if (!agentId || !prompt || !toolCallId)
+        return;
+    const runId = `ask_${randomUUID()}`;
+    let lastAgentOutput = "";
+    const eventQueue = [];
+    let resolveNext = null;
+    let isFinished = false;
+    const runPromise = pluginContext.host
+        .runAgent({
+        runId,
+        agentId,
+        event: {
+            type: "agent:invoke",
+            data: {
+                role: "user",
+                content: prompt,
+                agentId,
+            },
+            meta: {
+                channelId: context.state.channelId,
+                threadId: context.state.threadId,
+                parentAgentId: context.state.agentId,
+                parentToolCallId: toolCallId,
+            },
+        },
+        publicBaseUrl: pluginContext.publicBaseUrl,
+        persistEvents: false,
+        onEvent: async (outEvent) => {
+            const enrichedEvent = {
+                ...outEvent,
+                meta: {
+                    ...outEvent.meta,
+                    parentAgentId: context.state.agentId,
+                    parentToolCallId: toolCallId,
+                },
+            };
+            eventQueue.push(enrichedEvent);
+            if (outEvent.type === "agent:output") {
+                lastAgentOutput = outEvent.data.content;
+            }
+            if (resolveNext) {
+                resolveNext();
+                resolveNext = null;
+            }
+        },
+    })
+        .catch((error) => {
+        console.error(`[ask_agent] Error in asked run ${runId}:`, error);
+    })
+        .finally(() => {
+        isFinished = true;
+        if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+        }
+    });
+    while (!isFinished || eventQueue.length > 0) {
+        if (eventQueue.length === 0) {
+            await new Promise((r) => {
+                resolveNext = r;
+            });
+        }
+        while (eventQueue.length > 0) {
+            yield eventQueue.shift();
+        }
+    }
+    await runPromise;
+    yield {
+        type: resultType,
+        data: {
+            success: true,
+            output: lastAgentOutput,
+        },
+        meta: {
+            ...event.meta,
+            agentId: context.state.agentId,
+            toolCallId,
+        },
+    };
+}
+export const askAgentPlugin = {
+    id: "ask-agent",
+    name: "Ask agent",
+    description: "Lets OpenBot ask specialized agents to do work in their own harness.",
+    toolDefinitions: askAgentToolDefinitions,
+    factory: (pluginContext) => (builder) => {
+        builder.on("action:ask_agent", async function* (event, context) {
+            yield* runAskedAgent(pluginContext, event, context, "action:ask_agent:result");
+        });
+        builder.on("action:delegate_task", async function* (event, context) {
+            yield* runAskedAgent(pluginContext, event, context, "action:delegate_task:result");
+        });
+    },
+};
+export default askAgentPlugin;