@meetopenbot/openbot 0.1.15 → 0.2.0

package/dist/history.js

@@ -89,8 +89,9 @@ export function eventsToModelMessages(events) {
             case 'agent:invoke': {
                 const invokeEvent = event;
                 if (invokeEvent.data?.content && invokeEvent.data?.role) {
+                    const role = invokeEvent.data.role === 'agent' ? 'user' : invokeEvent.data.role;
                     messages.push({
-                        role: invokeEvent.data.role,
+                        role,
                         content: invokeEvent.data.content,
                     });
                 }

package/dist/system-prompt.js

@@ -9,7 +9,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "# 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.",
+    "- For real project work (build, code, design, ops) you decide **where** (which Space) and **who** (which installed agent), then ask that agent, close without restating their work, and keep todos current.",
     "",
     "# THE AGENT LOOP",
     "You operate in an iterative loop:",
@@ -17,7 +17,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "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.",
+    "5. **Close**: The human already saw the specialist speak in this thread. Do not restate, re-bullet, or paraphrase their findings. Name who you asked, then add only what is new — a decision, a conflict, a next step, or a caveat. If nothing is new, close in one or two sentences.",
     "6. **Enter Standby**: Idle until the next human message.",
     "",
     "# TASK TRACKING (TODOS)",
@@ -37,6 +37,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "# 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.",
+    "- **Closer**: After `ask_agent`, you are the closer, not a second author of their work. Don't repeat. Add or close. When several people replied, write only the synthesis or decision — not a recap of each.",
     "- **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.",
@@ -46,6 +47,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- 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 …".',
+    '- After one specialist replies and you agree, close like: "I asked Codex to check the diff. Workspace is clean — nothing to review." Never paste or re-list their last message.',
     "",
     "# ERROR HANDLING",
     "- Tool failures are provided as events. When an error occurs, do not panic or immediately ask the user for help.",

package/dist/tools/ask-agent.js

@@ -2,7 +2,7 @@ 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.",
+        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. The human sees their reply in this thread; do not restate it when you close.",
         inputSchema: z.object({
             agentId: z
                 .string()
@@ -40,7 +40,7 @@ async function* runAskedAgent(pluginContext, event, context, resultType) {
         event: {
             type: "agent:invoke",
             data: {
-                role: "user",
+                role: "agent",
                 content: prompt,
                 agentId,
             },

package/dist/tools/start-work.js

@@ -210,13 +210,6 @@ export const startWorkPlugin = {
                         userAvatarUrl: context.state.triggerEvent?.meta?.userAvatarUrl,
                     },
                 };
-                if (typeof storage.storeEvent === "function") {
-                    await storage.storeEvent({
-                        channelId: spaceId,
-                        threadId,
-                        event: invokeEvent,
-                    });
-                }
                 await pluginContext.host.runAgent({
                     runId: `sw_${randomUUID()}`,
                     agentId: pluginContext.host.orchestratorAgentId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "0.1.15",
+  "version": "0.2.0",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,12 +18,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc && node ../../scripts/write-plugin-declaration.mjs",
-    "dev": "tsc --watch --preserveWatchOutput",
-    "typecheck": "tsc --noEmit",
-    "prepack": "pnpm build"
-  },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.33",
     "@ai-sdk/openai": "^3.0.13",
@@ -34,5 +28,10 @@
   "devDependencies": {
     "@types/node": "^20.10.1",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc && node ../../scripts/write-plugin-declaration.mjs",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/tools/delegation.js

@@ -1,137 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-/**
- * `delegation` — allows agents to delegate tasks to other agents.
- *
- * Only the 'system' agent is allowed to delegate by default.
- * It uses runAgent to execute the delegated agent in its own isolated runtime,
- * bridging events back to the caller's stream.
- */
-const delegationToolDefinitions = {
-    delegate_task: {
-        description: "Delegate a specific task or question to another specialized agent.",
-        inputSchema: z.object({
-            agentId: z
-                .string()
-                .describe('The ID of the agent to delegate to (e.g., "researcher", "coder").'),
-            prompt: z
-                .string()
-                .describe("The instructions or question for the delegated agent."),
-        }),
-    },
-};
-export const delegationPlugin = {
-    id: "delegation",
-    name: "Delegation",
-    description: "Allows agents to call upon other agents to solve sub-tasks.",
-    toolDefinitions: delegationToolDefinitions,
-    factory: (pluginContext) => (builder) => {
-        // Handle the tool execution
-        builder.on("action:delegate_task", async function* (event, context) {
-            const delegateEvent = event;
-            // POLICY: Only the 'system' agent can delegate
-            if (context.state.agentId !== pluginContext.host.orchestratorAgentId) {
-                yield {
-                    type: "action:delegate_task:result",
-                    data: {
-                        success: false,
-                        error: "Only the system agent can delegate.",
-                    },
-                    meta: delegateEvent.meta,
-                };
-                return;
-            }
-            const { agentId, prompt } = delegateEvent.data;
-            const toolCallId = delegateEvent.meta?.toolCallId;
-            if (!toolCallId)
-                return;
-            const runAgent = pluginContext.host.runAgent;
-            const runId = `dg_${randomUUID()}`;
-            let lastAgentOutput = "";
-            // Queue to bridge the async onEvent callback to this generator
-            const eventQueue = [];
-            let resolveNext = null;
-            let isFinished = false;
-            // Start the delegated agent in its own runtime.
-            // We don't await this immediately so we can yield events as they arrive.
-            const runPromise = runAgent({
-                runId,
-                agentId,
-                event: {
-                    type: "agent:invoke",
-                    data: {
-                        role: "user",
-                        content: prompt,
-                        agentId: agentId,
-                    },
-                    meta: {
-                        channelId: context.state.channelId,
-                        threadId: context.state.threadId,
-                        parentAgentId: context.state.agentId,
-                        parentToolCallId: toolCallId,
-                    },
-                },
-                publicBaseUrl: pluginContext.publicBaseUrl,
-                // Child events are re-yielded to the parent harness, which persists them once.
-                persistEvents: false,
-                onEvent: async (outEvent) => {
-                    // Enrich events with parent metadata so the UI can track the hierarchy
-                    const enrichedEvent = {
-                        ...outEvent,
-                        meta: {
-                            ...outEvent.meta,
-                            parentAgentId: context.state.agentId,
-                            parentToolCallId: toolCallId,
-                        },
-                    };
-                    eventQueue.push(enrichedEvent);
-                    if (outEvent.type === "agent:output") {
-                        lastAgentOutput = outEvent.data.content;
-                    }
-                    // Wake up the generator loop if it's waiting
-                    if (resolveNext) {
-                        resolveNext();
-                        resolveNext = null;
-                    }
-                },
-            })
-                .catch((error) => {
-                console.error(`[delegation] Error in delegated run ${runId}:`, error);
-            })
-                .finally(() => {
-                isFinished = true;
-                if (resolveNext) {
-                    resolveNext();
-                    resolveNext = null;
-                }
-            });
-            // Yield events from the delegated agent as they arrive
-            while (!isFinished || eventQueue.length > 0) {
-                if (eventQueue.length === 0) {
-                    await new Promise((r) => {
-                        resolveNext = r;
-                    });
-                }
-                while (eventQueue.length > 0) {
-                    yield eventQueue.shift();
-                }
-            }
-            // Ensure the run is fully complete (though isFinished already implies this)
-            await runPromise;
-            // Yield the result back to our own LLM runtime.
-            yield {
-                type: "action:delegate_task:result",
-                data: {
-                    success: true,
-                    output: lastAgentOutput,
-                },
-                meta: {
-                    ...delegateEvent.meta,
-                    agentId: context.state.agentId,
-                    toolCallId: toolCallId,
-                },
-            };
-        });
-    },
-};
-export default delegationPlugin;