@meetopenbot/openbot 0.2.6 → 1.0.0

package/dist/tools/storage.js

@@ -1,183 +1,88 @@
-import z from "zod";
-import { asActionBuilder } from "../types.js";
-import { buildWorkspaceFileUrl } from "../utils/workspace-url.js";
-import { isPlaceholderSpaceId, placeholderSpaceError, } from "../space-id.js";
+import z from 'zod';
+import { isPlaceholderSpaceId, placeholderSpaceError } from '../space-id.js';
 function normalizeChannelId(raw) {
     return raw
         .trim()
         .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/(^-|-$)/g, "");
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/(^-|-$)/g, '');
 }
 function displayNameFromChannelId(channelId) {
     return channelId
-        .split("-")
+        .split('-')
         .filter(Boolean)
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ");
+        .join(' ');
 }
-function createChannelWidget(args) {
-    return {
-        type: "client:ui:widget",
+async function emitCreateChannelWidget(ctx, args) {
+    await ctx.emit({
+        type: 'client:ui:widget',
         data: {
             widgetId: args.widgetId,
-            kind: "message",
-            title: "create_channel",
+            kind: 'message',
+            title: 'create_channel',
             description: args.channelId || undefined,
             body: args.body,
-            display: "collapsed",
+            display: 'collapsed',
             state: args.state,
         },
-        meta: args.meta,
-    };
+        meta: { agentId: ctx.agentId, threadId: ctx.threadId ?? ctx.state.threadId },
+    });
 }
-const storageToolDefinitions = {
+export const storageTools = {
     create_channel: {
-        description: "Create a new Space after the human asked for it or agreed to your suggestion. Prefer an existing Space and start_work. Skip questions, listings, and Q&A in #general. Never use placeholder ids (noop, temp, misc).",
+        description: 'Create a new Space after the human asked for it or agreed to your suggestion. Prefer an existing Space and start_work. Skip questions, listings, and Q&A in #general. Never use placeholder ids (noop, temp, misc).',
         inputSchema: z.object({
             channelId: z
                 .string()
-                .describe("Unique Space id (e.g. product-launch, backend-platform)."),
+                .describe('Unique Space id (e.g. product-launch, backend-platform).'),
             name: z
                 .string()
                 .optional()
-                .describe("Optional display name. Defaults to a title-cased Space id."),
+                .describe('Optional display name. Defaults to a title-cased Space id.'),
             spec: z
                 .string()
                 .optional()
-                .describe("Optional initial markdown content for the channel spec."),
+                .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. Do not set cwd; the runtime assigns the workspace path."),
+                .describe('Optional initial state object for the channel. Do not set cwd; the runtime assigns the workspace path.'),
         }),
-    },
-    patch_channel_details: {
-        description: "Patch the current Space (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 job status use `set_thread_status`. For multi-step task tracking, use `todo_write`.",
-        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 Space and all its threads. 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, name, spec, initialState } = event.data;
-            const rawChannelId = normalizeChannelId(channelId || "");
-            const resultMeta = {
-                ...(event.meta || {}),
-                agentId: context.state.agentId,
-                threadId: event.meta?.threadId || context.state.threadId,
-            };
-            const widgetId = typeof event.meta?.toolCallId === "string"
-                ? event.meta.toolCallId
-                : `create_channel:${rawChannelId || Date.now()}`;
+        execute: async (raw, ctx) => {
+            const { channelId, name, spec, initialState } = (raw ?? {});
+            const rawChannelId = normalizeChannelId(channelId || '');
+            const widgetId = ctx.toolCallId ?? `create_channel:${rawChannelId || Date.now()}`;
             if (!rawChannelId) {
-                const error = "channelId is required";
-                yield createChannelWidget({
+                const error = 'channelId is required';
+                await emitCreateChannelWidget(ctx, {
                     widgetId,
-                    channelId: "",
+                    channelId: '',
                     body: error,
-                    state: "error",
-                    meta: resultMeta,
+                    state: 'error',
                 });
-                yield {
-                    type: "action:create_channel:result",
-                    data: {
-                        success: false,
-                        channelId: "",
-                        channelUrl: "",
-                        error,
-                        output: error,
-                    },
-                    meta: resultMeta,
-                };
-                return;
+                return { success: false, channelId: '', channelUrl: '', error, output: error };
             }
             if (isPlaceholderSpaceId(rawChannelId)) {
                 const error = placeholderSpaceError(rawChannelId);
-                yield createChannelWidget({
+                await emitCreateChannelWidget(ctx, {
                     widgetId,
                     channelId: rawChannelId,
                     body: error,
-                    state: "error",
-                    meta: resultMeta,
+                    state: 'error',
                 });
-                yield {
-                    type: "action:create_channel:result",
-                    data: {
-                        success: false,
-                        channelId: rawChannelId,
-                        channelUrl: "",
-                        error,
-                        output: error,
-                    },
-                    meta: resultMeta,
+                return {
+                    success: false,
+                    channelId: rawChannelId,
+                    channelUrl: '',
+                    error,
+                    output: error,
                 };
-                return;
             }
             const channelUrl = `/channels/${rawChannelId}`;
-            const displayName = typeof name === "string" && name.trim()
+            const displayName = typeof name === 'string' && name.trim()
                 ? name.trim()
-                : typeof initialState?.name === "string" && initialState.name.trim()
+                : typeof initialState?.name === 'string' && initialState.name.trim()
                     ? initialState.name.trim()
                     : displayNameFromChannelId(rawChannelId);
             const mergedInitial = {
@@ -185,317 +90,50 @@ export function registerStorageTools(context) {
                 name: displayName,
             };
             delete mergedInitial.cwd;
-            const channelSpec = typeof spec === "string" && spec.trim() ? spec : `# ${displayName}\n\n`;
-            yield createChannelWidget({
+            const channelSpec = typeof spec === 'string' && spec.trim() ? spec : `# ${displayName}\n\n`;
+            await emitCreateChannelWidget(ctx, {
                 widgetId,
                 channelId: rawChannelId,
-                body: "Creating…",
-                state: "open",
-                meta: resultMeta,
+                body: 'Creating…',
+                state: 'open',
             });
             try {
-                await storage.createChannel({
+                await ctx.storage.createChannel({
                     channelId: rawChannelId,
                     spec: channelSpec,
                     initialState: mergedInitial,
                 });
                 const output = `Created channel \`${rawChannelId}\`.`;
-                yield createChannelWidget({
+                await emitCreateChannelWidget(ctx, {
                     widgetId,
                     channelId: rawChannelId,
                     body: output,
-                    state: "submitted",
-                    meta: resultMeta,
+                    state: 'submitted',
                 });
-                yield {
-                    type: "action:create_channel:result",
-                    data: { success: true, channelId: rawChannelId, channelUrl, output },
-                    meta: resultMeta,
-                };
+                return { success: true, channelId: rawChannelId, channelUrl, output };
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : "Unknown error";
+                const message = error instanceof Error ? error.message : 'Unknown error';
                 const output = `Failed to create channel: ${message}`;
-                yield createChannelWidget({
+                await emitCreateChannelWidget(ctx, {
                     widgetId,
                     channelId: rawChannelId,
                     body: output,
-                    state: "error",
-                    meta: resultMeta,
-                });
-                yield {
-                    type: "action:create_channel:result",
-                    data: {
-                        success: false,
-                        channelId: rawChannelId,
-                        channelUrl,
-                        error: message,
-                        output,
-                    },
-                    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) {
-                    const state = { ...event.data.state };
-                    delete state.status;
-                    delete state.statusUpdatedAt;
-                    delete state.statusReason;
-                    await storage.patchThreadState({
-                        channelId: context.state.channelId,
-                        threadId: context.state.threadId,
-                        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,
+                    state: 'error',
                 });
-                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 },
+                return {
+                    success: false,
+                    channelId: rawChannelId,
+                    channelUrl,
+                    error: message,
+                    output,
                 };
             }
-        });
-    };
-}
+        },
+    },
+};
+export const tools = storageTools;
 export const storageToolPlugin = {
-    toolDefinitions: storageToolDefinitions,
-    register: registerStorageTools,
+    toolDefinitions: storageTools,
+    tools: storageTools,
 };

package/dist/tools/thread-status.js

@@ -10,7 +10,7 @@ function formatStatusOutput(args) {
         ? `Job status set to ${args.status}: ${reason}`
         : `Job status set to ${args.status}.`;
 }
-const threadStatusToolDefinitions = {
+export const toolDefinitions = {
     set_thread_status: {
         description: "Set this job's workflow status. Use needs_input when blocked on the human, ready_for_review when you believe the work is done, working when the job is still in progress. Do not use working to mean you are currently executing — that is tracked automatically. Never mark completed or archived — only the human can.",
         inputSchema: z.object({
@@ -24,31 +24,27 @@ const threadStatusToolDefinitions = {
         }),
     },
 };
-export const threadStatusPlugin = {
-    id: "thread-status",
-    name: "Thread status",
-    description: "Sets the durable workflow status for the current job/thread.",
-    toolDefinitions: threadStatusToolDefinitions,
-    factory: (pluginContext) => (builder) => {
-        builder.on("action:set_thread_status", async function* (event, context) {
-            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+export const tools = {
+    set_thread_status: {
+        ...toolDefinitions.set_thread_status,
+        execute: async (rawArgs, ctx) => {
             try {
-                const channelId = context.state.channelId;
-                const threadId = context.state.threadId;
+                const channelId = ctx.channelId ?? ctx.state.channelId ?? '';
+                const threadId = ctx.threadId ?? ctx.state.threadId;
                 if (!channelId || !threadId) {
                     throw new Error("Missing channelId or threadId for set_thread_status");
                 }
-                const status = event.data.status;
+                const data = (rawArgs ?? {});
+                const status = data.status;
                 if (status !== "working" &&
                     status !== "needs_input" &&
                     status !== "ready_for_review") {
-                    throw new Error('Agents may only set working, needs_input, or ready_for_review. The human marks completed and archived.');
+                    throw new Error("Agents may only set working, needs_input, or ready_for_review. The human marks completed and archived.");
                 }
-                const reasonRaw = event.data.reason;
-                const reason = typeof reasonRaw === "string" && reasonRaw.trim()
-                    ? reasonRaw.trim()
+                const reason = typeof data.reason === "string" && data.reason.trim()
+                    ? data.reason.trim()
                     : "";
-                await pluginContext.storage.patchThreadState({
+                await ctx.storage.patchThreadState({
                     channelId,
                     threadId,
                     state: {
@@ -57,35 +53,23 @@ export const threadStatusPlugin = {
                         statusReason: reason,
                     },
                 });
-                context.state.threadDetails = await pluginContext.storage.getThreadDetails({
+                ctx.state.threadDetails = await ctx.storage.getThreadDetails({
                     channelId,
                     threadId,
                 });
                 const output = formatStatusOutput({ status, reason });
-                yield {
-                    type: "action:set_thread_status:result",
-                    data: {
-                        success: true,
-                        status,
-                        ...(reason ? { reason } : {}),
-                        output,
-                    },
-                    meta: resultMeta,
+                return {
+                    success: true,
+                    status,
+                    ...(reason ? { reason } : {}),
+                    output,
                 };
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : "Unknown error";
-                yield {
-                    type: "action:set_thread_status:result",
-                    data: {
-                        success: false,
-                        error: message,
-                        output: message,
-                    },
-                    meta: resultMeta,
-                };
+                return { success: false, error: message, output: message };
             }
-        });
+        },
     },
 };
-export default threadStatusPlugin;
+export const threadStatusTools = tools;