@meetopenbot/openbot 0.2.6 → 1.0.0

package/dist/auto-model.js

@@ -49,6 +49,19 @@ export function expandModelString(modelString, ctx) {
         return pickAutoModel(ctx);
     return modelString.trim();
 }
+/** BYOK message when the resolved provider has no API key in env. */
+export function missingByokApiKeyMessage(modelString, ctx) {
+    if (shouldUseCreditsAuth(ctx))
+        return undefined;
+    const env = ctx?.env ?? process.env;
+    const provider = providerOf(expandModelString(modelString, ctx));
+    if (providerHasByokKey(provider, env))
+        return undefined;
+    const envVar = PROVIDER_BYOK_ENV[provider];
+    if (!envVar)
+        return undefined;
+    return `${provider} API key is missing`;
+}
 export function isRetryableModelError(error) {
     const message = error instanceof Error ? error.message : String(error);
     const lower = message.toLowerCase();

package/dist/build-tools.js

@@ -0,0 +1,26 @@
+import { memoryTools } from "./tools/memory.js";
+import { todoTools } from "./tools/todo.js";
+import { storageTools } from "./tools/storage.js";
+import { askAgentTools } from "./tools/ask-agent.js";
+import { startWorkTools } from "./tools/start-work.js";
+import { threadStatusTools } from "./tools/thread-status.js";
+import { threadTitleTools } from "./tools/thread-title.js";
+import { wrapToolsWithApproval } from "./tools/approval.js";
+/**
+ * Merge first-party OpenBot coordinator tools and wrap configured actions
+ * with approval.
+ */
+export function buildOpenbotTools(args) {
+    const tools = {
+        ...memoryTools,
+        ...todoTools,
+        ...storageTools,
+        ...askAgentTools,
+        ...startWorkTools,
+        ...threadStatusTools,
+        ...threadTitleTools,
+        ...args.context.tools,
+    };
+    const approvalConfig = args.context.config?.approval ?? { actions: [] };
+    return wrapToolsWithApproval(tools, approvalConfig.actions ?? [], args.context);
+}

package/dist/history.js

@@ -1,3 +1,76 @@
+function asReasoningPart(part) {
+    const text = typeof part.text === 'string' ? part.text : '';
+    if (!text.trim() && !part.providerOptions)
+        return undefined;
+    return {
+        type: 'reasoning',
+        text,
+        ...(part.providerOptions
+            ? { providerOptions: part.providerOptions }
+            : {}),
+    };
+}
+function outputReasoningParts(event, includeReasoning) {
+    if (!includeReasoning)
+        return [];
+    const stored = event.data.reasoningParts;
+    if (Array.isArray(stored) && stored.length > 0) {
+        return stored
+            .map(asReasoningPart)
+            .filter((part) => Boolean(part));
+    }
+    const fallback = event.data.reasoning;
+    if (typeof fallback === 'string' && fallback.trim()) {
+        return [{ type: 'reasoning', text: fallback }];
+    }
+    return [];
+}
+function firstToolCallIndex(parts) {
+    return parts.findIndex((part) => part.type === 'tool-call');
+}
+function insertBeforeToolCalls(parts, extra) {
+    if (extra.length === 0)
+        return;
+    const toolIndex = firstToolCallIndex(parts);
+    if (toolIndex === -1)
+        parts.push(...extra);
+    else
+        parts.splice(toolIndex, 0, ...extra);
+}
+function makeAssistantMessage(text, reasoningParts) {
+    if (reasoningParts.length === 0) {
+        return { role: 'assistant', content: text };
+    }
+    const content = [...reasoningParts];
+    if (text)
+        content.push({ type: 'text', text });
+    return { role: 'assistant', content };
+}
+function appendAssistantOutput(message, text, reasoningParts) {
+    if (typeof message.content === 'string') {
+        if (reasoningParts.length === 0) {
+            message.content += text;
+            return;
+        }
+        const content = [...reasoningParts];
+        const combined = message.content + text;
+        if (combined)
+            content.push({ type: 'text', text: combined });
+        message.content = content;
+        return;
+    }
+    if (!Array.isArray(message.content))
+        return;
+    const parts = message.content;
+    insertBeforeToolCalls(parts, reasoningParts);
+    if (text) {
+        const lastText = [...parts].reverse().find((part) => part.type === 'text');
+        if (lastText && lastText.type === 'text')
+            lastText.text += text;
+        else
+            insertBeforeToolCalls(parts, [{ type: 'text', text }]);
+    }
+}
 /**
  * Ensures every tool-call has a matching tool-result before calling the LLM.
  * Orphaned calls (interrupted run, missing :result event, etc.) get an empty
@@ -66,7 +139,8 @@ function toolResultText(data) {
  * 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) {
+export function eventsToModelMessages(events, options) {
+    const includeReasoning = options?.includeReasoning !== false;
     const messages = [];
     for (const event of events) {
         // Skip events that belong to a sub-process (like delegation)
@@ -76,13 +150,15 @@ export function eventsToModelMessages(events) {
         }
         switch (event.type) {
             case 'agent:output': {
-                const content = event.data.content;
+                const output = event;
+                const content = output.data.content ?? '';
+                const reasoningParts = outputReasoningParts(output, includeReasoning);
                 const last = messages[messages.length - 1];
-                if (last && last.role === 'assistant' && typeof last.content === 'string') {
-                    last.content += content;
+                if (last && last.role === 'assistant') {
+                    appendAssistantOutput(last, content, reasoningParts);
                 }
                 else {
-                    messages.push({ role: 'assistant', content });
+                    messages.push(makeAssistantMessage(content, reasoningParts));
                 }
                 break;
             }

package/dist/index.js

@@ -1,90 +1,89 @@
-import { defineOpenbotPlugin } from "./types.js";
-import { cloudAuthModeProperties, modelConfigField, } from "@meetopenbot/plugin-sdk";
-import { AUTO_MODEL_ID, AUTO_MODEL_OPTION } from "./auto-model.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 { askAgentPlugin } from "./tools/ask-agent.js";
-import { startWorkPlugin } from "./tools/start-work.js";
-import { threadStatusPlugin } from "./tools/thread-status.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";
+import { defineOpenbotPlugin } from './types.js';
+import { cloudAuthModeProperties, modelConfigField, } from '@meetopenbot/plugin-sdk';
+import { AUTO_MODEL_ID, AUTO_MODEL_OPTION } from './auto-model.js';
+import { handleOpenbotWidgetResponse, runOpenbotTurn } from './runtime.js';
+import { memoryTools } from './tools/memory.js';
+import { todoTools } from './tools/todo.js';
+import { storageTools } from './tools/storage.js';
+import { askAgentTools } from './tools/ask-agent.js';
+import { startWorkTools } from './tools/start-work.js';
+import { threadStatusTools } from './tools/thread-status.js';
+import { threadTitleTools } from './tools/thread-title.js';
+import { buildOpenbotTools } from './build-tools.js';
+export const OPENBOT_PLUGIN_ID = '@meetopenbot/openbot';
 const modelField = await modelConfigField({
-    providers: ["openai", "anthropic", "google", "deepseek"],
+    providers: ['openai', 'anthropic', 'google', 'deepseek'],
     extraOptions: [AUTO_MODEL_OPTION],
     defaultValue: AUTO_MODEL_ID,
-    description: "Auto, or a model from the OpenBot registry.",
-    fallbackDescription: "Auto, or a provider model in provider/model-id format (e.g. openai/gpt-4o-mini).",
+    description: 'Auto, or a model from the OpenBot registry.',
+    fallbackDescription: 'Auto, or a provider model in provider/model-id format (e.g. openai/gpt-4o-mini).',
 });
-const SPECIALIST_TOOL_NAMES = new Set([
-    ...Object.keys(bashPlugin.toolDefinitions ?? {}),
-    ...Object.keys(previewPlugin.toolDefinitions ?? {}),
-]);
 /**
  * `@meetopenbot/openbot` — the standard, opinionated OpenBot agent runtime.
  *
  * The orchestrator (`system`) is a coordinator: ask agents, start work in
- * Spaces, memory, todos, storage. Specialist tools (shell, preview) stay on
- * non-orchestrator agents that opt into this runtime.
+ * Spaces, memory, todos, storage. Coding and preview work belongs to
+ * specialist harnesses, not this plugin.
  */
 export const openbotPlugin = defineOpenbotPlugin({
-    id: OPENBOT_PLUGIN_ID,
-    name: "OpenBot Agent",
-    description: "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
+    name: 'OpenBot Agent',
+    description: 'OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.',
     configSchema: {
-        type: "object",
+        type: 'object',
         properties: {
             ...cloudAuthModeProperties(),
             model: modelField,
         },
     },
-    toolDefinitions: {
-        ...bashPlugin.toolDefinitions,
-        ...memoryPlugin.toolDefinitions,
-        ...todoPlugin.toolDefinitions,
-        ...storageToolPlugin.toolDefinitions,
-        ...askAgentPlugin.toolDefinitions,
-        ...startWorkPlugin.toolDefinitions,
-        ...threadStatusPlugin.toolDefinitions,
-        ...previewPlugin.toolDefinitions,
+    tools: {
+        ...memoryTools,
+        ...todoTools,
+        ...storageTools,
+        ...askAgentTools,
+        ...startWorkTools,
+        ...threadStatusTools,
+        ...threadTitleTools,
     },
-    factory: (context) => (builder) => {
-        const { agentId, config, storage, tools, abortSignal, host } = context;
-        const isOrchestrator = agentId === host.orchestratorAgentId;
-        memoryPlugin.factory(context)(builder);
-        todoPlugin.factory(context)(builder);
-        storageToolPlugin.register(context)(builder);
-        askAgentPlugin.factory(context)(builder);
-        startWorkPlugin.factory(context)(builder);
-        threadStatusPlugin.factory(context)(builder);
-        uiPlugin.factory(context)(builder);
-        if (!isOrchestrator) {
-            bashPlugin.factory(context)(builder);
-            previewPlugin.factory(context)(builder);
-        }
-        const approvalConfig = config?.approval ?? {
-            actions: [],
+    async *run(args) {
+        const { context } = args;
+        const authMode = context.host.isCloudSystemAgent(context.agentId)
+            ? context.host.parseOpenbotAuthMode(context.config?.authMode)
+            : 'byok';
+        const toolDefinitions = buildOpenbotTools({ context });
+        yield* runOpenbotTurn(args, {
+            model: context.config?.model || AUTO_MODEL_ID,
+            authMode,
+            agentId: context.agentId,
+            storage: context.storage,
+            toolDefinitions,
+            abortSignal: context.abortSignal,
+            host: context.host,
+        });
+    },
+    async *onWidgetResponse(args) {
+        const { context } = args;
+        const authMode = context.host.isCloudSystemAgent(context.agentId)
+            ? context.host.parseOpenbotAuthMode(context.config?.authMode)
+            : 'byok';
+        const toolDefinitions = buildOpenbotTools({ context });
+        const turnArgs = {
+            prompt: '',
+            threadId: args.state.threadId,
+            event: args.state.triggerEvent,
+            handlerCtx: args.handlerCtx,
+            context,
+            state: args.state,
+            emit: args.emit,
         };
-        approvalPlugin.factory({ ...context, config: approvalConfig })(builder);
-        const authMode = host.isCloudSystemAgent(agentId)
-            ? host.parseOpenbotAuthMode(config?.authMode)
-            : "byok";
-        const toolDefinitions = isOrchestrator
-            ? Object.fromEntries(Object.entries(tools).filter(([name]) => !SPECIALIST_TOOL_NAMES.has(name)))
-            : tools;
-        return openbotRuntime({
-            model: config?.model || AUTO_MODEL_ID,
+        yield* handleOpenbotWidgetResponse(turnArgs, {
+            model: context.config?.model || AUTO_MODEL_ID,
             authMode,
-            agentId,
-            storage,
+            agentId: context.agentId,
+            storage: context.storage,
             toolDefinitions,
-            abortSignal,
-            host,
-        })(builder);
+            abortSignal: context.abortSignal,
+            host: context.host,
+        });
     },
 });
 export default openbotPlugin;

package/dist/model.js

@@ -1,13 +1,8 @@
 import { createOpenAI, openai as defaultOpenai } from '@ai-sdk/openai';
 import { createAnthropic, anthropic } from '@ai-sdk/anthropic';
+import { createDeepSeek, deepSeek } from '@ai-sdk/deepseek';
 import { expandModelString } from './auto-model.js';
 import { CREDITS_API_KEY_PLACEHOLDER, INTEGRATIONS_TOKEN_HEADER, creditsProviderBaseUrl, resolveCreditsAuthConfig, shouldUseCreditsAuth, } from '@meetopenbot/plugin-sdk';
-function deepseekChat(modelId) {
-    return createOpenAI({
-        baseURL: 'https://api.deepseek.com',
-        apiKey: process.env.DEEPSEEK_API_KEY,
-    }).chat(modelId);
-}
 function googleChat(modelId) {
     return createOpenAI({
         baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai',
@@ -15,14 +10,14 @@ function googleChat(modelId) {
     }).chat(modelId);
 }
 /**
- * OpenAI-compatible Chat Completions. Gemini/DeepSeek gateways only speak this.
+ * OpenAI-compatible Chat Completions. Gemini's gateway only speaks this.
  * Do not use for OpenAI itself — gpt-5.6-luna rejects function tools on
  * `/v1/chat/completions` unless `reasoning_effort` is `none`.
  */
 function openAiChatModel(options, modelId) {
     return createOpenAI(options).chat(modelId);
 }
-/** AI SDK 5+ default: OpenAI Responses API (`/v1/responses`), required for tools on Luna. */
+/** AI SDK default: OpenAI Responses API (`/v1/responses`), required for tools on Luna. */
 function openAiResponsesModel(options, modelId) {
     return createOpenAI(options)(modelId);
 }
@@ -31,19 +26,20 @@ function resolveCreditsProvider(provider, modelId) {
     if (!config) {
         throw new Error('OpenBot Credits is not configured. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN.');
     }
-    const baseURL = creditsProviderBaseUrl(config, provider);
-    const headers = { [INTEGRATIONS_TOKEN_HEADER]: config.token };
-    // Any non-empty key satisfies the SDK; the integrations gateway authenticates via header.
-    const apiKey = config.token || CREDITS_API_KEY_PLACEHOLDER;
+    const options = {
+        baseURL: creditsProviderBaseUrl(config, provider),
+        headers: { [INTEGRATIONS_TOKEN_HEADER]: config.token },
+        apiKey: config.token || CREDITS_API_KEY_PLACEHOLDER,
+    };
     switch (provider) {
         case 'openai':
-            return openAiResponsesModel({ baseURL, apiKey, headers }, modelId);
+            return openAiResponsesModel(options, modelId);
         case 'anthropic':
-            return createAnthropic({ baseURL, apiKey, headers })(modelId);
+            return createAnthropic(options)(modelId);
         case 'google':
-            return openAiChatModel({ baseURL, apiKey, headers }, modelId);
+            return openAiChatModel(options, modelId);
         case 'deepseek':
-            return openAiChatModel({ baseURL, apiKey, headers }, modelId);
+            return createDeepSeek(options)(modelId);
     }
 }
 export function resolveModel(modelString, options) {
@@ -62,8 +58,24 @@ export function resolveModel(modelString, options) {
         case 'google':
             return useCredits ? resolveCreditsProvider('google', modelId) : googleChat(modelId);
         case 'deepseek':
-            return useCredits ? resolveCreditsProvider('deepseek', modelId) : deepseekChat(modelId);
+            return useCredits ? resolveCreditsProvider('deepseek', modelId) : deepSeek(modelId);
         default:
             throw new Error(`Unsupported AI provider: "${provider}"`);
     }
 }
+function providerOf(modelString) {
+    return expandModelString(modelString).split('/')[0] ?? '';
+}
+/** Low thinking for DeepSeek (Auto). Google Chat Completions cannot round-trip thinking. */
+export function reasoningForModel(modelString) {
+    const provider = providerOf(modelString);
+    if (provider === 'deepseek')
+        return 'low';
+    if (provider === 'google')
+        return 'none';
+    return undefined;
+}
+/** Gemini's OpenAI Chat path drops thinking; omit parts so tool turns stay valid. */
+export function includeReasoningInHistory(modelString) {
+    return providerOf(modelString) !== 'google';
+}

package/dist/output-buffer.js

@@ -0,0 +1,31 @@
+/** Persist one `agent:output` per model step so jsonl stays thought → tools → reply. */
+export function createAgentOutputBuffer(meta) {
+    let text = '';
+    let reasoning = '';
+    return {
+        addText(delta) {
+            text += delta;
+        },
+        addReasoning(delta) {
+            reasoning += delta;
+        },
+        take() {
+            if (!text && !reasoning)
+                return null;
+            const event = {
+                type: 'agent:output',
+                data: {
+                    content: text,
+                    ...(reasoning ? { reasoning } : {}),
+                },
+                meta,
+            };
+            text = '';
+            reasoning = '';
+            return event;
+        },
+    };
+}
+export function isOutputBoundaryPart(type) {
+    return type === 'tool-call' || type === 'finish-step' || type === 'step-finish' || type === 'finish';
+}