@meetopenbot/openbot 0.1.1

package/dist/tools/storage.js

@@ -0,0 +1,335 @@
+import z from 'zod';
+import { asActionBuilder } from '../types.js';
+import { buildWorkspaceFileUrl } from '../utils/workspace-url.js';
+const storageToolDefinitions = {
+    create_channel: {
+        description: 'Create a new channel. Use when the user intent is clearly different from the current channel and should be split. Always confirm before creating. Skip for simple Q&A.',
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .describe('Unique channel ID (e.g. product-launch, backend-platform, channel_roadmap).'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Optional initial markdown content for the channel spec.'),
+            initialState: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('Optional initial state object for the channel.'),
+            cwd: z
+                .string()
+                .optional()
+                .describe('Optional initial current working directory for the channel. Defaults to an absolute path under ~/openbot/{channelId}.'),
+        }),
+    },
+    patch_channel_details: {
+        description: 'Patch current channel details (state, spec, cwd).',
+        inputSchema: z
+            .object({
+            state: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe('JSON state object for the channel.'),
+            spec: z
+                .string()
+                .optional()
+                .describe('Markdown content for the channel specification (SPEC.md). Use for goals and rules.'),
+            cwd: z.string().optional().describe('Current working directory for the channel.'),
+        })
+            .refine((value) => value.state !== undefined ||
+            value.spec !== undefined ||
+            value.cwd !== undefined, { message: 'Provide at least one of state, spec, or cwd.' }),
+    },
+    patch_thread_details: {
+        description: 'Patch current thread details (state). Use for thread metadata such as `name` or `isSmartNamed`. For multi-step task tracking, use `todo_write` instead.',
+        inputSchema: z.object({
+            state: z
+                .record(z.string(), z.unknown())
+                .describe('JSON state object for the thread. Merges with existing state.'),
+        }),
+    },
+    create_variable: {
+        description: 'Create or update a variable in the workspace storage.',
+        inputSchema: z.object({
+            key: z.string().describe('The key of the variable.'),
+            value: z.string().describe('The value of the variable.'),
+            secret: z.boolean().optional().describe('Whether the variable is a secret.'),
+        }),
+    },
+    delete_variable: {
+        description: 'Delete a variable from the workspace storage.',
+        inputSchema: z.object({
+            key: z.string().describe('The key of the variable to delete.'),
+        }),
+    },
+    delete_channel: {
+        description: 'Permanently delete a channel and all its threads and events. Always confirm with the user before deleting.',
+        inputSchema: z.object({
+            channelId: z.string().describe('The channel ID to delete.'),
+        }),
+    },
+    get_workspace_file_url: {
+        description: 'Get a fetchable HTTP URL for a file in the current channel workspace (images, video, audio, documents).',
+        inputSchema: z.object({
+            path: z
+                .string()
+                .describe('Path relative to the channel working directory, e.g. "uploads/clip.mp4".'),
+        }),
+    },
+};
+export function registerStorageTools(context) {
+    const storage = context.storage;
+    const { publicBaseUrl } = context;
+    const resolvePublicBaseUrl = () => publicBaseUrl;
+    return (builder) => {
+        const actions = asActionBuilder(builder);
+        actions.on('create_channel', async function* (event, context) {
+            const { channelId, spec, initialState, cwd } = event.data;
+            const rawChannelId = (channelId || '').trim();
+            const channelSpec = typeof spec === 'string' ? spec : '';
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            if (!rawChannelId) {
+                yield {
+                    type: 'action:create_channel:result',
+                    data: { success: false, channelId: '', channelUrl: '' },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            const channelUrl = `/channels/${rawChannelId}`;
+            const mergedInitial = { ...(initialState || {}) };
+            try {
+                await storage.createChannel({
+                    channelId: rawChannelId,
+                    spec: channelSpec,
+                    initialState: mergedInitial,
+                    cwd,
+                });
+                yield {
+                    type: 'action:create_channel:result',
+                    data: { success: true, channelId: rawChannelId, channelUrl },
+                    meta: resultMeta,
+                };
+                yield {
+                    type: 'agent:output',
+                    data: { content: `Created channel \`${rawChannelId}\`.` },
+                    meta: resultMeta,
+                };
+            }
+            catch {
+                yield {
+                    type: 'action:create_channel:result',
+                    data: { success: false, channelId: rawChannelId, channelUrl },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('delete_channel', async function* (event, context) {
+            const rawChannelId = (event.data?.channelId || '').trim();
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            if (!rawChannelId) {
+                yield {
+                    type: 'action:delete_channel:result',
+                    data: { success: false, channelId: '', error: 'channelId is required' },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            try {
+                await storage.deleteChannel({ channelId: rawChannelId });
+                yield {
+                    type: 'action:delete_channel:result',
+                    data: { success: true, channelId: rawChannelId },
+                    meta: resultMeta,
+                };
+                yield {
+                    type: 'agent:output',
+                    data: { content: `Deleted channel \`${rawChannelId}\`.` },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:delete_channel:result',
+                    data: {
+                        success: false,
+                        channelId: rawChannelId,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('update_channel', async function* (event, context) {
+            const data = event.data;
+            const targetChannelId = (data.channelId || context.state.channelId || '').trim();
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            if (!targetChannelId) {
+                yield {
+                    type: 'action:update_channel:result',
+                    data: { success: false, channelId: '', updatedFields: [] },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            const patch = {};
+            const updatedFields = [];
+            if (typeof data.name === 'string' && data.name.trim()) {
+                patch.name = data.name.trim();
+                updatedFields.push('name');
+            }
+            if (typeof data.cwd === 'string' && data.cwd.trim()) {
+                patch.cwd = data.cwd.trim();
+                updatedFields.push('cwd');
+            }
+            try {
+                if (updatedFields.length > 0) {
+                    await storage.patchChannelState({ channelId: targetChannelId, state: patch });
+                }
+                if (targetChannelId === context.state.channelId) {
+                    context.state.channelDetails = await storage.getChannelDetails({
+                        channelId: context.state.channelId,
+                    });
+                }
+                yield {
+                    type: 'action:update_channel:result',
+                    data: { success: true, channelId: targetChannelId, updatedFields },
+                    meta: resultMeta,
+                };
+            }
+            catch {
+                yield {
+                    type: 'action:update_channel:result',
+                    data: { success: false, channelId: targetChannelId, updatedFields },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('patch_channel_details', async function* (event, context) {
+            const updatedFields = [];
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            const data = event.data;
+            try {
+                if (data.state !== undefined) {
+                    await storage.patchChannelState({
+                        channelId: context.state.channelId,
+                        state: data.state,
+                    });
+                    updatedFields.push('state');
+                }
+                if (typeof data.spec === 'string') {
+                    await storage.patchChannelSpec({
+                        channelId: context.state.channelId,
+                        spec: data.spec,
+                    });
+                    updatedFields.push('spec');
+                }
+                if (typeof data.cwd === 'string') {
+                    await storage.patchChannelState({
+                        channelId: context.state.channelId,
+                        state: { cwd: data.cwd },
+                    });
+                    updatedFields.push('cwd');
+                }
+                context.state.channelDetails = await storage.getChannelDetails({
+                    channelId: context.state.channelId,
+                });
+                yield {
+                    type: "client:ui:widget",
+                    data: {
+                        widgetId: "patch-channel-details-result" + Date.now(),
+                        kind: "message",
+                        title: "Channel details updated.",
+                        body: `The channel details have been updated. ${updatedFields.join(', ')}`,
+                        display: "collapsed",
+                    },
+                    meta: resultMeta,
+                };
+                yield {
+                    type: 'action:patch_channel_details:result',
+                    data: { success: true, updatedFields },
+                    meta: resultMeta,
+                };
+            }
+            catch {
+                yield {
+                    type: 'action:patch_channel_details:result',
+                    data: { success: false, updatedFields },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('patch_thread_details', async function* (event, context) {
+            const updatedFields = [];
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                if (!context.state.threadId) {
+                    throw new Error('Missing threadId in state for patch_thread_details');
+                }
+                if (event.data?.state !== undefined) {
+                    await storage.patchThreadState({
+                        channelId: context.state.channelId,
+                        threadId: context.state.threadId,
+                        state: event.data.state,
+                    });
+                    updatedFields.push('state');
+                }
+                context.state.threadDetails = await storage.getThreadDetails({
+                    channelId: context.state.channelId,
+                    threadId: context.state.threadId,
+                });
+                yield {
+                    type: 'action:patch_thread_details:result',
+                    data: { success: true, updatedFields },
+                    meta: resultMeta,
+                };
+            }
+            catch {
+                yield {
+                    type: 'action:patch_thread_details:result',
+                    data: { success: false, updatedFields },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('get_workspace_file_url', async function* (event, context) {
+            const channelId = context.state.channelId;
+            const filePath = event.data?.path;
+            const toolCallId = event.meta?.toolCallId;
+            if (!filePath) {
+                yield {
+                    type: 'action:get_workspace_file_url:result',
+                    data: { success: false, path: '', error: 'Path is required', output: 'Path is required' },
+                    meta: { ...(event.meta || {}), toolCallId },
+                };
+                return;
+            }
+            try {
+                const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId,
+                    filePath,
+                });
+                const output = JSON.stringify({ path: filePath, url, mimeType, size });
+                yield {
+                    type: 'action:get_workspace_file_url:result',
+                    data: { success: true, path: filePath, url, mimeType, size, output },
+                    meta: { ...(event.meta || {}), toolCallId },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                yield {
+                    type: 'action:get_workspace_file_url:result',
+                    data: { success: false, path: filePath, error: message, output: message },
+                    meta: { ...(event.meta || {}), toolCallId },
+                };
+            }
+        });
+    };
+}
+export const storageToolPlugin = {
+    toolDefinitions: storageToolDefinitions,
+    register: registerStorageTools,
+};

package/dist/tools/todo-service.d.ts

@@ -0,0 +1,28 @@
+export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
+export type TodoItem = {
+    id: string;
+    content: string;
+    status: TodoStatus;
+};
+export type TodoList = {
+    items: TodoItem[];
+    updatedAt: string;
+};
+export declare const MAX_TODO_ITEMS = 20;
+/**
+ * Validate and normalize a todo list write. Throws on invalid input.
+ * Enforces: non-empty content, known statuses, unique ids, max size,
+ * and at most one `in_progress` item.
+ */
+export declare function validateTodoItems(items: TodoItem[]): TodoItem[];
+export declare const todoService: {
+    getTodos: (args: {
+        channelId: string;
+        threadId: string;
+    }) => Promise<TodoList>;
+    writeTodos: (args: {
+        channelId: string;
+        threadId: string;
+        items: TodoItem[];
+    }) => Promise<TodoList>;
+};

package/dist/tools/todo-service.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_CHANNELS_DIR, getBaseDir, resolvePath } from '../utils/paths.js';
+export const MAX_TODO_ITEMS = 20;
+const TODO_STATUSES = new Set([
+    'pending',
+    'in_progress',
+    'completed',
+    'cancelled',
+]);
+const getThreadDir = (channelId, threadId) => {
+    const base = resolvePath(path.join(getBaseDir(), DEFAULT_CHANNELS_DIR, channelId));
+    return path.join(base, 'threads', threadId);
+};
+const getTodosPath = (channelId, threadId) => path.join(getThreadDir(channelId, threadId), 'todos.json');
+const emptyList = () => ({
+    items: [],
+    updatedAt: new Date().toISOString(),
+});
+/**
+ * Validate and normalize a todo list write. Throws on invalid input.
+ * Enforces: non-empty content, known statuses, unique ids, max size,
+ * and at most one `in_progress` item.
+ */
+export function validateTodoItems(items) {
+    if (!Array.isArray(items)) {
+        throw new Error('todos must be an array');
+    }
+    if (items.length > MAX_TODO_ITEMS) {
+        throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
+    }
+    const seen = new Set();
+    let inProgressCount = 0;
+    const normalized = [];
+    for (const raw of items) {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('Each todo must be an object');
+        }
+        const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+        const content = typeof raw.content === 'string' ? raw.content.trim() : '';
+        const status = raw.status;
+        if (!id)
+            throw new Error('Each todo requires a non-empty id');
+        if (!content)
+            throw new Error(`Todo "${id}" requires non-empty content`);
+        if (!TODO_STATUSES.has(status)) {
+            throw new Error(`Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`);
+        }
+        if (seen.has(id))
+            throw new Error(`Duplicate todo id "${id}"`);
+        seen.add(id);
+        if (status === 'in_progress')
+            inProgressCount += 1;
+        normalized.push({ id, content, status: status });
+    }
+    if (inProgressCount > 1) {
+        throw new Error('At most one todo may be in_progress');
+    }
+    return normalized;
+}
+export const todoService = {
+    getTodos: async (args) => {
+        const filePath = getTodosPath(args.channelId, args.threadId);
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const items = Array.isArray(parsed.items) ? parsed.items : [];
+            return {
+                items,
+                updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+            };
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return emptyList();
+            throw e;
+        }
+    },
+    writeTodos: async (args) => {
+        const items = validateTodoItems(args.items);
+        const list = {
+            items,
+            updatedAt: new Date().toISOString(),
+        };
+        const threadDir = getThreadDir(args.channelId, args.threadId);
+        await fs.mkdir(threadDir, { recursive: true });
+        const filePath = getTodosPath(args.channelId, args.threadId);
+        const tmp = `${filePath}.tmp`;
+        await fs.writeFile(tmp, `${JSON.stringify(list, null, 2)}\n`, 'utf-8');
+        await fs.rename(tmp, filePath);
+        return list;
+    },
+};

package/dist/tools/todo.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types.js';
+export declare const todoPlugin: Plugin;
+export default todoPlugin;

package/dist/tools/todo.js

@@ -0,0 +1,146 @@
+import z from 'zod';
+import { todoService } from './todo-service.js';
+/**
+ * `todo` — thread-scoped task checklist for multi-step agent work.
+ *
+ * Persisted at `~/.openbot/channels/<channelId>/threads/<threadId>/todos.json`.
+ * The agent replaces the full list via `todo_write`; the runtime injects the
+ * current list into context each turn.
+ */
+/** Map todo statuses onto UI list-item status label + variant. */
+function toWidgetItemStatus(status) {
+    switch (status) {
+        case 'pending':
+            return { status: 'Pending', statusVariant: 'default' };
+        case 'in_progress':
+            return { status: 'In progress', statusVariant: 'info' };
+        case 'completed':
+            return { status: 'Done', statusVariant: 'success' };
+        case 'cancelled':
+            return { status: 'Cancelled', statusVariant: 'danger' };
+    }
+}
+function formatTodoOutput(list) {
+    if (list.items.length === 0)
+        return 'Todo list is empty.';
+    const lines = list.items.map((t) => `- [${t.status}] (${t.id}) ${t.content}`);
+    return `Todos (${list.items.length}):\n${lines.join('\n')}`;
+}
+function todoListWidget(args) {
+    const items = args.list.items.map((t) => ({
+        id: t.id,
+        label: t.content,
+        ...toWidgetItemStatus(t.status),
+    }));
+    return {
+        type: 'client:ui:widget',
+        data: {
+            // One widget per agent run — repeated todo_write calls update in place.
+            widgetId: `todos:${args.runId}`,
+            kind: 'list',
+            title: 'Todos',
+            description: args.list.items.length === 0
+                ? 'No todos'
+                : `${args.list.items.filter((t) => t.status === 'completed').length}/${args.list.items.length} completed`,
+            items,
+            display: 'expanded',
+            state: 'open',
+        },
+        meta: {},
+    };
+}
+const todoItemSchema = z.object({
+    id: z.string().min(1).describe('Stable todo id (e.g. "1", "setup-repo").'),
+    content: z.string().min(1).describe('Short imperative description of the step.'),
+    status: z
+        .enum(['pending', 'in_progress', 'completed', 'cancelled'])
+        .describe('Todo status. At most one item may be in_progress.'),
+});
+const todoToolDefinitions = {
+    todo_write: {
+        description: 'Replace the current thread todo list with the provided items. Use for multi-step tasks: write the plan first, keep exactly one item in_progress while working, mark items completed immediately after finishing, and when done leave all items as completed (do not clear the list). Pass the full intended list each call (not a partial patch).',
+        inputSchema: z.object({
+            items: z
+                .array(todoItemSchema)
+                .max(20)
+                .describe('Full todo list for this thread (max 20). Replaces any previous list.'),
+        }),
+    },
+    todo_read: {
+        description: 'Read the current thread todo list. Usually unnecessary — the list is already injected into context each turn. Use only if you need an explicit refresh after an external change.',
+        inputSchema: z.object({}),
+    },
+};
+export const todoPlugin = {
+    id: 'todo',
+    name: 'Todo',
+    description: 'Thread-scoped todo checklist for multi-step task tracking (todo_write / todo_read).',
+    toolDefinitions: todoToolDefinitions,
+    factory: () => (builder) => {
+        builder.on('action:todo_write', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const channelId = context.state.channelId;
+                const threadId = context.state.threadId;
+                if (!channelId || !threadId) {
+                    throw new Error('Missing channelId or threadId for todo_write');
+                }
+                const items = event.data.items;
+                const list = await todoService.writeTodos({ channelId, threadId, items });
+                const runId = context.state.runId;
+                if (!runId) {
+                    throw new Error('Missing runId for todo_write widget');
+                }
+                const widget = todoListWidget({ runId, list });
+                widget.meta = { ...resultMeta, threadId, runId };
+                yield widget;
+                yield {
+                    type: 'action:todo_write:result',
+                    data: { success: true, list, output: formatTodoOutput(list) },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                yield {
+                    type: 'action:todo_write:result',
+                    data: {
+                        success: false,
+                        error: message,
+                        output: message,
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+        builder.on('action:todo_read', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const channelId = context.state.channelId;
+                const threadId = context.state.threadId;
+                if (!channelId || !threadId) {
+                    throw new Error('Missing channelId or threadId for todo_read');
+                }
+                const list = await todoService.getTodos({ channelId, threadId });
+                yield {
+                    type: 'action:todo_read:result',
+                    data: { success: true, list, output: formatTodoOutput(list) },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                yield {
+                    type: 'action:todo_read:result',
+                    data: {
+                        success: false,
+                        error: message,
+                        output: message,
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+    },
+};
+export default todoPlugin;

package/dist/tools/ui.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from '../types.js';
+/**
+ * `ui` — provides a tool for the agent to render interactive UI widgets.
+ *
+ * The model can choose which widget to render (form, choice, list, message)
+ * depending on the situation.
+ */
+export declare const uiPlugin: Plugin;
+export default uiPlugin;