@meetopenbot/openbot 1.2.0 → 1.2.2

package/dist/history.js

@@ -71,51 +71,75 @@ function appendAssistantOutput(message, text, reasoningParts) {
             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
- * 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]) => ({
+function isToolResultPart(part) {
+    return Boolean(part && typeof part === 'object' && part.type === 'tool-result');
+}
+function assistantToolCalls(message) {
+    if (message.role !== 'assistant' || !Array.isArray(message.content))
+        return [];
+    const calls = [];
+    for (const part of message.content) {
+        if (part.type !== 'tool-call')
+            continue;
+        const toolCall = part;
+        if (typeof toolCall.toolCallId !== 'string')
+            continue;
+        calls.push({
+            toolCallId: toolCall.toolCallId,
+            toolName: typeof toolCall.toolName === 'string' ? toolCall.toolName : 'tool',
+        });
+    }
+    return calls;
+}
+function collectToolResults(messages) {
+    const results = new Map();
+    for (const message of messages) {
+        if (message.role !== 'tool' || !Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            if (!isToolResultPart(part) || results.has(part.toolCallId))
+                continue;
+            results.set(part.toolCallId, part);
+        }
+    }
+    return results;
+}
+function toolMessageForCalls(calls, results) {
+    return {
+        role: 'tool',
+        content: calls.map(({ toolCallId, toolName }) => {
+            const existing = results.get(toolCallId);
+            if (existing) {
+                results.delete(toolCallId);
+                return existing;
+            }
+            return {
                 type: 'tool-result',
                 toolCallId,
                 toolName,
                 output: { type: 'text', value: '' },
-            })),
-        });
-        pending.clear();
+            };
+        }),
     };
+}
+/**
+ * Rebuild tool messages so every `tool-call` is followed immediately by matching
+ * results. Late results (user invoke between call and `:result`) are moved next
+ * to their call; unmatched results are dropped; interrupted calls get an empty
+ * result so the next LLM turn does not fail provider validation.
+ */
+function sanitizeToolPairing(messages) {
+    const results = collectToolResults(messages);
+    const sanitized = [];
     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);
-                }
-            }
+        if (message.role === 'tool')
             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);
-                }
-            }
-        }
+        sanitized.push(message);
+        const calls = assistantToolCalls(message);
+        if (calls.length > 0)
+            sanitized.push(toolMessageForCalls(calls, results));
     }
-    flushPending();
-    return filled;
+    return sanitized;
 }
 function toolResultText(data) {
     if (data && typeof data === 'object') {
@@ -235,5 +259,5 @@ export function eventsToModelMessages(events, options) {
                 break;
         }
     }
-    return fillMissingToolResults(messages);
+    return sanitizeToolPairing(messages);
 }

package/dist/runtime.js

@@ -3,14 +3,18 @@ import { BYOK_ENV_KEYS, isAuthErrorMessage, isCreditsErrorMessage, fetchModelReg
 import { eventsToModelMessages } from './history.js';
 import { addImageParts, eventsHaveImages, pickVisionModel } from './images.js';
 import { buildContext } from './context.js';
-import { OPENBOT_SYSTEM_PROMPT, withUserInstructions } from './system-prompt.js';
+import { OPENBOT_SYSTEM_PROMPT, withGithubGitInstructions, withUserInstructions, } from './system-prompt.js';
 import { AUTO_MODEL_ID, isAutoModel, isRetryableModelError, listAutoModelCandidates, missingByokApiKeyMessage, } from './auto-model.js';
 import { reasoningForModel, resolveModel } from './model.js';
 import { errorFromStreamPart } from './stream-error.js';
 import { createAgentOutputBuffer, isOutputBoundaryPart } from './output-buffer.js';
 async function buildSystemPrompt(state, storage, instructions, host) {
     const context = await buildContext(state, storage, host);
-    const sections = [withUserInstructions(OPENBOT_SYSTEM_PROMPT, instructions), '', context];
+    const sections = [
+        withGithubGitInstructions(withUserInstructions(OPENBOT_SYSTEM_PROMPT, instructions)),
+        '',
+        context,
+    ];
     const threadState = state.threadDetails?.state;
     if (!threadState?.isSmartNamed) {
         sections.push('', '## SYSTEM HINT', 'This thread is unnamed. Please use the `set_thread_title` tool to set a concise, descriptive title (e.g., "Project Brainstorming" instead of "project-brainstorm"). Only do this once.');

package/dist/system-prompt.js

@@ -49,6 +49,12 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- **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.",
     "",
+    "# CLOUD COMPUTER",
+    "This runtime is a remote cloud computer. The human is in the browser at openbot.one and cannot open localhost, 127.0.0.1, or any port on this machine.",
+    "- Never tell them to visit localhost. They need a public HTTPS URL.",
+    "- When you ask a coding agent to run a dev server, preview, or any local process the human should open, tell them to expose it with `cloudflared tunnel --url http://127.0.0.1:<port>` and to add `cloudflared` as a **project devDependency** (not a global install — this image is ephemeral and only workspace files persist).",
+    "- Share the `https://*.trycloudflare.com` URL they print. Quick tunnels change on restart — pass the new one through. If they report a localhost URL, ask them to tunnel it.",
+    "",
     "# 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.",
@@ -61,6 +67,27 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- 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");
+/**
+ * Appended when `GITHUB_TOKEN` is in the runtime env (workspace variables are
+ * merged in). Git does not read that variable; coding agents need an inline hint.
+ */
+export const GITHUB_GIT_INSTRUCTIONS = [
+    "# GITHUB GIT",
+    "`GITHUB_TOKEN` is set in this runtime's environment. Git does not read it automatically.",
+    "When you `ask_agent` a coding agent (Claude Code, Codex, Cursor, OpenCode, Pi) to clone, fetch, pull, or push GitHub, tell them in that prompt:",
+    "- `GITHUB_TOKEN` is already in their environment. Never paste the token value into the prompt, chat, or a command you write out.",
+    "- Use it inline and keep `$GITHUB_TOKEN` unexpanded, e.g. `git push https://x-access-token:$GITHUB_TOKEN@github.com/<owner>/<repo>.git <branch>`.",
+    "- Do not write the token into a git remote (`.git/config`) or print `git remote -v` after embedding it.",
+].join("\n");
+export function githubTokenIsSet(env = process.env) {
+    return Boolean(env.GITHUB_TOKEN?.trim());
+}
+/** Append GitHub git guidance when `GITHUB_TOKEN` is present. */
+export function withGithubGitInstructions(basePrompt, env = process.env) {
+    if (!githubTokenIsSet(env))
+        return basePrompt;
+    return `${basePrompt}\n\n${GITHUB_GIT_INSTRUCTIONS}`;
+}
 /** Max characters accepted from the OpenBot plugin `instructions` config field. */
 export const MAX_USER_INSTRUCTIONS_LENGTH = 4000;
 /** Trim and cap user-provided coordinator instructions. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "@ai-sdk/openai": "^4.0.46",
     "ai": "^7.0.77",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^1.1.0"
+    "@meetopenbot/plugin-sdk": "^1.1.3"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",