@meetopenbot/openbot 0.2.6 → 1.0.0

package/dist/stream-error.js

@@ -0,0 +1,6 @@
+/** AI SDK `fullStream` reports failures as `{ type: 'error' }` instead of throwing. */
+export function errorFromStreamPart(part) {
+    if (part.type !== 'error')
+        return undefined;
+    return part.error ?? new Error('Model stream failed');
+}

package/dist/system-prompt.js

@@ -28,6 +28,10 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- 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 TITLE",
+    "- Unnamed jobs get a system hint to call `set_thread_title` once with a concise, human-readable title.",
+    "- Call `set_thread_title` again only if the topic clearly changes.",
+    "",
     "# JOB STATUS",
     "- Every thread is a job. Status is `working` (in progress), `needs_input`, `ready_for_review`, `completed`, or `archived`.",
     "- Status is the job's workflow state, not whether an agent is currently executing.",

package/dist/tools/approval.js

@@ -1,130 +1,159 @@
 import { randomUUID } from 'node:crypto';
+import { agentOutput } from '@meetopenbot/plugin-sdk';
 /**
- * `approval` — gates protected tool calls behind a UI confirmation widget.
+ * Gates protected tool calls behind a UI confirmation widget.
  *
- * This is a simplified version that intercepts specified actions (default: bash)
- * and requires user approval before they are allowed to proceed.
+ * Wraps `execute` for the listed actions: emit an approval widget, wait for
+ * the click via `host.awaitWidgetResponse`, then run the inner execute or
+ * return a denial result.
  */
-// In-memory tracking for pending approval IDs with TTL (shared across plugin instances)
 const pendingApprovals = new Map();
 const TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
-export const approvalPlugin = {
-    id: 'approval',
-    name: 'Approval',
-    description: 'Gate protected tool calls behind a UI confirmation widget.',
-    factory: ({ config, storage }) => (builder) => {
-        // Actions that require approval. Defaults to bash.
-        const actionsToApprove = config.actions || ['action:shell_exec'];
-        for (const action of actionsToApprove) {
-            builder.intercept(action, (event, context) => {
-                // If already approved in this flow, let it pass to the actual handler
-                if (event.meta?.approvalStatus === 'approved')
-                    return event;
-                // Otherwise, intercept and ask for approval via a UI widget
-                const displayData = JSON.stringify(event?.data) || '';
+function actionToolName(action) {
+    return action.startsWith('action:') ? action.slice('action:'.length) : action;
+}
+function normalizeResult(result) {
+    return typeof result === 'string' ? { output: result } : result;
+}
+async function emitApprovalWidget(execCtx, args) {
+    const threadId = execCtx.threadId ?? execCtx.state.threadId;
+    await execCtx.emit({
+        type: 'client:ui:widget',
+        data: {
+            widgetId: args.widgetId,
+            kind: 'message',
+            title: args.title,
+            body: args.body,
+            ...(args.state ? { state: args.state } : {}),
+            ...(args.state && args.state !== 'open'
+                ? { display: 'collapsed', disabled: true, actions: [] }
+                : { actions: args.actions }),
+            metadata: {
+                type: 'approval:request',
+                originalEvent: {
+                    type: args.action,
+                    data: args.toolArgs,
+                    meta: {
+                        toolCallId: execCtx.toolCallId,
+                        agentId: execCtx.agentId,
+                        threadId,
+                    },
+                },
+            },
+        },
+        meta: { agentId: execCtx.agentId, threadId },
+    });
+}
+/**
+ * Wrap `execute` on tools whose names appear in `actionsToApprove`
+ * (bare name or `action:<name>`).
+ */
+export function wrapToolsWithApproval(tools, actionsToApprove, ctx) {
+    if (!actionsToApprove.length)
+        return tools;
+    const namesToWrap = new Set(actionsToApprove.map(actionToolName));
+    const wrapped = { ...tools };
+    for (const [name, definition] of Object.entries(tools)) {
+        if (!namesToWrap.has(name) || !definition.execute)
+            continue;
+        const inner = definition.execute;
+        const action = `action:${name}`;
+        wrapped[name] = {
+            ...definition,
+            async execute(args, execCtx) {
+                const displayData = JSON.stringify(args ?? '') || '';
                 const widgetId = randomUUID();
                 pendingApprovals.set(widgetId, Date.now());
-                return {
-                    type: 'client:ui:widget',
-                    data: {
+                await emitApprovalWidget(execCtx, {
+                    widgetId,
+                    action,
+                    toolArgs: args,
+                    title: `The agent wants to perform \`${action}\``,
+                    body: displayData,
+                    actions: [
+                        { id: 'approve', label: 'Approve', variant: 'primary' },
+                        { id: 'deny', label: 'Deny', variant: 'danger' },
+                    ],
+                });
+                let response;
+                try {
+                    response = await execCtx.host.awaitWidgetResponse(widgetId, execCtx.abortSignal);
+                }
+                catch (error) {
+                    pendingApprovals.delete(widgetId);
+                    const message = error instanceof Error ? error.message : 'Approval interrupted';
+                    await emitApprovalWidget(execCtx, {
                         widgetId,
-                        kind: 'message',
-                        title: `The agent wants to perform \`${action}\``,
+                        action,
+                        toolArgs: args,
+                        title: 'Action Denied',
                         body: displayData,
-                        metadata: {
-                            type: 'approval:request',
-                            originalEvent: event,
-                        },
-                        actions: [
-                            { id: 'approve', label: 'Approve', variant: 'primary' },
-                            { id: 'deny', label: 'Deny', variant: 'danger' },
-                        ],
-                    },
-                    meta: { agentId: context.state.agentId, threadId: context.state.threadId },
-                };
-            });
-        }
-        // Handle the user's response from the UI widget
-        builder.on('client:ui:widget:response', async function* (event, context) {
-            const { widgetId, actionId } = event.data;
-            const metadata = event.data?.metadata;
-            if (metadata?.type !== 'approval:request')
-                return;
-            // Verify the widget is still pending and hasn't expired
-            if (!widgetId || !pendingApprovals.has(widgetId)) {
-                console.warn(`[approval] Received response for unknown or already handled widget: ${widgetId}`);
-                return;
-            }
-            const timestamp = pendingApprovals.get(widgetId);
-            if (Date.now() - timestamp > TTL_MS) {
+                        state: 'cancelled',
+                    });
+                    return { success: false, error: message, output: message };
+                }
+                const timestamp = pendingApprovals.get(widgetId);
                 pendingApprovals.delete(widgetId);
-                console.warn(`[approval] Received response for expired widget: ${widgetId}`);
-                return;
-            }
-            // Mark as handled
-            pendingApprovals.delete(widgetId);
-            const originalEvent = metadata.originalEvent;
-            const approved = actionId === 'approve';
-            const displayData = JSON.stringify(event?.data) || '';
-            // Yield a "responded" widget update to the UI
-            yield {
-                type: 'client:ui:widget',
-                data: {
+                if (timestamp == null) {
+                    console.warn(`[approval] Received response for unknown or already handled widget: ${widgetId}`);
+                    return {
+                        success: false,
+                        error: 'Approval request is no longer pending.',
+                        output: 'Approval request is no longer pending.',
+                    };
+                }
+                if (Date.now() - timestamp > TTL_MS) {
+                    console.warn(`[approval] Received response for expired widget: ${widgetId}`);
+                    return {
+                        success: false,
+                        error: 'Approval request expired.',
+                        output: 'Approval request expired.',
+                    };
+                }
+                const approved = response.actionId === 'approve';
+                await emitApprovalWidget(execCtx, {
                     widgetId,
-                    kind: 'message',
+                    action,
+                    toolArgs: args,
                     title: `Action ${approved ? 'Approved' : 'Denied'}`,
                     body: displayData,
                     state: approved ? 'submitted' : 'cancelled',
-                    display: 'collapsed',
-                    disabled: true,
-                    actions: [], // Clear actions to disable buttons in UI
-                },
-                meta: { agentId: context.state.agentId, threadId: context.state.threadId },
-            };
-            if (approved) {
-                // Re-emit the original event with approved status so the actual handler can run
-                yield {
-                    ...originalEvent,
+                });
+                if (approved) {
+                    return normalizeResult(await inner(args, execCtx));
+                }
+                const threadId = execCtx.threadId ?? execCtx.state.threadId;
+                const originalEvent = {
+                    type: action,
+                    data: args,
                     meta: {
-                        ...(originalEvent.meta || {}),
-                        approvalStatus: 'approved',
+                        toolCallId: execCtx.toolCallId,
+                        agentId: execCtx.agentId,
+                        threadId,
+                        approvalStatus: 'denied',
                     },
                 };
-            }
-            else {
-                // Manually store the original event with denied status so it's recorded in history
-                // but NOT re-emitted to the pipeline (to avoid actual execution).
-                if (storage) {
+                const storage = ctx.storage;
+                if (storage.storeEvent) {
                     await storage.storeEvent({
-                        channelId: context.state.channelId,
-                        threadId: context.state.threadId,
-                        event: {
-                            ...originalEvent,
-                            meta: {
-                                ...(originalEvent.meta || {}),
-                                approvalStatus: 'denied',
-                            },
-                        },
+                        channelId: execCtx.channelId ?? execCtx.state.channelId ?? '',
+                        threadId,
+                        event: originalEvent,
                     });
                 }
-                // Emit a failure result event for the denied action to clear the pending tool batch
-                yield {
-                    type: `${originalEvent.type}:result`,
-                    data: {
-                        success: false,
-                        error: 'Action denied by user.',
-                        stderr: 'Action denied by user.',
-                        output: 'Action denied by user.',
-                    },
-                    meta: originalEvent.meta,
-                };
-                yield {
-                    type: 'agent:output',
-                    data: { content: `Action \`${originalEvent.type}\` was denied.` },
-                    meta: { agentId: context.state.agentId },
+                await execCtx.emit(agentOutput({
+                    agentId: execCtx.agentId,
+                    threadId,
+                    content: `Action \`${action}\` was denied.`,
+                }));
+                return {
+                    success: false,
+                    error: 'Action denied by user.',
+                    stderr: 'Action denied by user.',
+                    output: 'Action denied by user.',
                 };
-            }
-        });
-    },
-};
-export default approvalPlugin;
+            },
+        };
+    }
+    return wrapped;
+}

package/dist/tools/ask-agent.js

@@ -1,6 +1,11 @@
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
-const askAgentToolDefinitions = {
+/**
+ * `ask_agent` — OpenBot sends a message to another agent in its own harness.
+ * Only the orchestrator may ask. Child events stream into this thread so the
+ * human sees the specialist speak; the child's last message is the tool result.
+ */
+export const toolDefinitions = {
     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. The human sees their reply in this thread; do not restate it when you close.",
         inputSchema: z.object({
@@ -11,29 +16,30 @@ const askAgentToolDefinitions = {
         }),
     },
 };
-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,
+async function runAskedAgent(ctx, args) {
+    if (ctx.agentId !== ctx.host.orchestratorAgentId) {
+        return {
+            success: false,
+            error: "Only OpenBot can ask other agents.",
+            output: "Only OpenBot can ask other agents.",
+        };
+    }
+    const agentId = args.agentId;
+    const prompt = args.prompt;
+    const toolCallId = ctx.toolCallId;
+    if (!agentId || !prompt || !toolCallId) {
+        return {
+            success: false,
+            error: "agentId, prompt, and toolCallId are required",
+            output: "agentId, prompt, and toolCallId are required",
         };
-        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
+    const runPromise = ctx.host
         .runAgent({
         runId,
         agentId,
@@ -45,20 +51,20 @@ async function* runAskedAgent(pluginContext, event, context, resultType) {
                 agentId,
             },
             meta: {
-                channelId: context.state.channelId,
-                threadId: context.state.threadId,
-                parentAgentId: context.state.agentId,
+                channelId: ctx.channelId ?? ctx.state.channelId ?? '',
+                threadId: ctx.threadId ?? ctx.state.threadId,
+                parentAgentId: ctx.agentId,
                 parentToolCallId: toolCallId,
             },
         },
-        publicBaseUrl: pluginContext.publicBaseUrl,
+        publicBaseUrl: ctx.publicBaseUrl,
         persistEvents: false,
         onEvent: async (outEvent) => {
             const enrichedEvent = {
                 ...outEvent,
                 meta: {
                     ...outEvent.meta,
-                    parentAgentId: context.state.agentId,
+                    parentAgentId: ctx.agentId,
                     parentToolCallId: toolCallId,
                 },
             };
@@ -89,35 +95,21 @@ async function* runAskedAgent(pluginContext, event, context, resultType) {
             });
         }
         while (eventQueue.length > 0) {
-            yield eventQueue.shift();
+            await ctx.emit(eventQueue.shift());
         }
     }
     await runPromise;
-    yield {
-        type: resultType,
-        data: {
-            success: true,
-            output: lastAgentOutput,
-        },
-        meta: {
-            ...event.meta,
-            agentId: context.state.agentId,
-            toolCallId,
-        },
+    return {
+        success: true,
+        output: lastAgentOutput,
     };
 }
-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 const tools = {
+    ask_agent: {
+        ...toolDefinitions.ask_agent,
+        execute: async (rawArgs, ctx) => {
+            return runAskedAgent(ctx, (rawArgs ?? {}));
+        },
     },
 };
-export default askAgentPlugin;
+export const askAgentTools = tools;

package/dist/tools/memory.js

@@ -1,9 +1,8 @@
 import z from 'zod';
-import { asActionBuilder } from '../types.js';
 /**
  * Resolve a scope alias to a concrete scope string. Aliases let tools accept
- * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
- * them using `context.state`.
+ * `agent`/`channel`/`global` without knowing the active ids; they are rewritten
+ * using execute context state.
  */
 function resolveMemoryScope(alias, state) {
     switch (alias) {
@@ -24,11 +23,11 @@ function resolveMemoryScopeFilter(alias, state) {
     }
     return [resolveMemoryScope(alias, state)];
 }
-/**
- * `memory` — exposes the global memory store as agent tools and provides
- * platform-level memory handlers.
- */
-const memoryToolDefinitions = {
+function fail(error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    return { success: false, error: message, output: message };
+}
+export const toolDefinitions = {
     remember: {
         description: 'Persist a durable fact, preference, or note to long-term memory so it can be recalled in future turns and runs. Use for stable information (user preferences, project conventions, contact details, decisions); avoid using it for transient chatter or per-step scratch state — that belongs in thread state. Keep entries short and self-contained.',
         inputSchema: z.object({
@@ -74,90 +73,59 @@ const memoryToolDefinitions = {
         }),
     },
 };
-export const memoryPlugin = {
-    id: 'memory',
-    name: 'Memory',
-    description: 'Global long-term memory: remember/recall/forget facts across runs and agents.',
-    toolDefinitions: memoryToolDefinitions,
-    factory: ({ storage }) => (builder) => {
-        const store = storage;
-        const actions = asActionBuilder(builder);
-        actions.on('remember', async function* (event, context) {
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+export const tools = {
+    remember: {
+        ...toolDefinitions.remember,
+        execute: async (rawArgs, ctx) => {
             try {
-                const { content, scope, tags } = event.data;
-                const record = await store.appendMemory({
-                    scope: resolveMemoryScope(scope, context.state),
+                const { content, scope, tags } = (rawArgs ?? {});
+                const record = await ctx.storage.appendMemory({
+                    scope: resolveMemoryScope(scope, ctx.state),
                     content,
                     tags,
                 });
-                yield {
-                    type: 'action:remember:result',
-                    data: { success: true, record },
-                    meta: resultMeta,
-                };
+                return { success: true, record, output: JSON.stringify(record) };
             }
             catch (error) {
-                yield {
-                    type: 'action:remember:result',
-                    data: {
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    },
-                    meta: resultMeta,
-                };
+                return fail(error);
             }
-        });
-        actions.on('recall', async function* (event, context) {
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        },
+    },
+    recall: {
+        ...toolDefinitions.recall,
+        execute: async (rawArgs, ctx) => {
             try {
-                const { query, tag, scope, limit } = event.data;
-                const records = await store.listMemories({
-                    scopes: resolveMemoryScopeFilter(scope, context.state),
+                const { query, tag, scope, limit } = (rawArgs ?? {});
+                const records = await ctx.storage.listMemories({
+                    scopes: resolveMemoryScopeFilter(scope, ctx.state),
                     query,
                     tag,
                     limit,
                 });
-                yield {
-                    type: 'action:recall:result',
-                    data: { success: true, records },
-                    meta: resultMeta,
-                };
+                return { success: true, records, output: JSON.stringify(records) };
             }
             catch (error) {
-                yield {
-                    type: 'action:recall:result',
-                    data: {
-                        success: false,
-                        records: [],
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    },
-                    meta: resultMeta,
-                };
+                return { ...fail(error), records: [] };
             }
-        });
-        actions.on('forget', async function* (event, context) {
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        },
+    },
+    forget: {
+        ...toolDefinitions.forget,
+        execute: async (rawArgs, ctx) => {
             try {
-                const deleted = await store.deleteMemory({ id: event.data.id });
-                yield {
-                    type: 'action:forget:result',
-                    data: { success: true, deleted },
-                    meta: resultMeta,
+                const deleted = await ctx.storage.deleteMemory({
+                    id: (rawArgs ?? {}).id,
+                });
+                return {
+                    success: true,
+                    deleted,
+                    output: deleted ? 'Memory deleted.' : 'Memory not found.',
                 };
             }
             catch (error) {
-                yield {
-                    type: 'action:forget:result',
-                    data: {
-                        success: false,
-                        deleted: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    },
-                    meta: resultMeta,
-                };
+                return { ...fail(error), deleted: false };
             }
-        });
+        },
     },
 };
-export default memoryPlugin;
+export const memoryTools = tools;