@meetopenbot/openbot 0.2.6 → 0.2.7

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/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/runtime.js

@@ -4,7 +4,7 @@ import { buildContext } from './context.js';
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
 import { isAuthErrorMessage, isCreditsErrorMessage } from '@meetopenbot/plugin-sdk';
 import { AUTO_MODEL_ID, isAutoModel, isRetryableModelError, listAutoModelCandidates, } from './auto-model.js';
-import { resolveModel } from './model.js';
+import { includeReasoningInHistory, reasoningForModel, resolveModel } from './model.js';
 import { fetchModelRegistry, getProviderModelOptions, listApiKeyProviders, PROVIDER_API_KEY_LINKS, } from '@meetopenbot/plugin-sdk';
 async function buildSystemPrompt(state, storage) {
     const context = await buildContext(state, storage);
@@ -89,7 +89,6 @@ export const openbotRuntime = (options) => (builder) => {
             channelId: context.state.channelId,
             threadId: context.state.threadId,
         });
-        const messages = eventsToModelMessages(events);
         const candidates = isAutoModel(configuredModelString)
             ? listAutoModelCandidates({ authMode })
             : [configuredModelString];
@@ -98,15 +97,18 @@ export const openbotRuntime = (options) => (builder) => {
             const generate = async () => {
                 let lastError;
                 for (let i = 0; i < candidates.length; i++) {
+                    const candidate = candidates[i];
                     try {
                         return await generateText({
-                            model: resolveModel(candidates[i], { authMode }),
+                            model: resolveModel(candidate, { authMode }),
                             system: systemPrompt,
-                            messages,
+                            messages: eventsToModelMessages(events, {
+                                includeReasoning: includeReasoningInHistory(candidate),
+                            }),
                             tools: toolDefinitions,
-                            stopWhen: ({ steps }) => steps.length === 1,
                             allowSystemInMessages: true,
                             abortSignal,
+                            reasoning: reasoningForModel(candidate),
                         });
                     }
                     catch (error) {
@@ -154,10 +156,27 @@ export const openbotRuntime = (options) => (builder) => {
                 parentToolCallId,
             };
             // Text before actions so history/UI show the model's intent first.
-            if (result.text) {
+            const reasoningParts = result.reasoning.flatMap((part) => {
+                if (part.type !== 'reasoning')
+                    return [];
+                if (!part.text.trim() && !part.providerMetadata)
+                    return [];
+                return [
+                    {
+                        text: part.text,
+                        ...(part.providerMetadata ? { providerOptions: part.providerMetadata } : {}),
+                    },
+                ];
+            });
+            const reasoning = result.reasoningText?.trim() || undefined;
+            if (result.text || reasoning || reasoningParts.length > 0) {
                 yield {
                     type: 'agent:output',
-                    data: { content: result.text },
+                    data: {
+                        content: result.text ?? '',
+                        ...(reasoning ? { reasoning } : {}),
+                        ...(reasoningParts.length > 0 ? { reasoningParts } : {}),
+                    },
                     meta: outputMeta,
                 };
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,11 +19,12 @@
     "dist"
   ],
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.33",
-    "@ai-sdk/openai": "^3.0.13",
-    "ai": "^6.0.42",
+    "@ai-sdk/anthropic": "^4.0.42",
+    "@ai-sdk/deepseek": "^3.0.32",
+    "@ai-sdk/openai": "^4.0.46",
+    "ai": "^7.0.77",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^0.5.0"
+    "@meetopenbot/plugin-sdk": "^0.5.1"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",
@@ -32,6 +33,7 @@
   "scripts": {
     "build": "tsc && node ../../scripts/write-plugin-declaration.mjs",
     "dev": "tsc --watch --preserveWatchOutput",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "node --experimental-strip-types --test src/*.test.ts"
   }
 }