@meetopenbot/openbot 0.1.14 → 0.1.15

package/dist/tools/storage.js

@@ -1,30 +1,31 @@
-import z from 'zod';
-import { asActionBuilder } from '../types.js';
-import { buildWorkspaceFileUrl } from '../utils/workspace-url.js';
+import z from "zod";
+import { asActionBuilder } from "../types.js";
+import { buildWorkspaceFileUrl } from "../utils/workspace-url.js";
+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',
+        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,
@@ -32,71 +33,79 @@ function createChannelWidget(args) {
 }
 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.',
+        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 channel ID (e.g. product-launch, backend-platform, channel_roadmap).'),
+                .describe("Unique Space id (e.g. product-launch, backend-platform)."),
             name: z
                 .string()
                 .optional()
-                .describe('Optional display name. Defaults to a title-cased channel 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 current channel details (state, spec, cwd).',
+        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.'),
+                .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.'),
+                .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.' }),
+            .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.',
+        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.'),
+                .describe("JSON state object for the thread. Merges with existing state."),
         }),
     },
     create_variable: {
-        description: 'Create or update a variable in the workspace storage.',
+        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.'),
+            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.',
+        description: "Delete a variable from the workspace storage.",
         inputSchema: z.object({
-            key: z.string().describe('The key of the variable to delete.'),
+            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.',
+        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.'),
+            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).',
+        description: "Get a fetchable HTTP URL for a file in the current channel workspace (images, video, audio, documents).",
         inputSchema: z.object({
             path: z
                 .string()
@@ -110,32 +119,54 @@ export function registerStorageTools(context) {
     const resolvePublicBaseUrl = () => publicBaseUrl;
     return (builder) => {
         const actions = asActionBuilder(builder);
-        actions.on('create_channel', async function* (event, context) {
+        actions.on("create_channel", async function* (event, context) {
             const { channelId, name, spec, initialState } = event.data;
-            const rawChannelId = normalizeChannelId(channelId || '');
+            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'
+            const widgetId = typeof event.meta?.toolCallId === "string"
                 ? event.meta.toolCallId
                 : `create_channel:${rawChannelId || Date.now()}`;
             if (!rawChannelId) {
-                const error = 'channelId is required';
+                const error = "channelId is required";
+                yield createChannelWidget({
+                    widgetId,
+                    channelId: "",
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:create_channel:result",
+                    data: {
+                        success: false,
+                        channelId: "",
+                        channelUrl: "",
+                        error,
+                        output: error,
+                    },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            if (isPlaceholderSpaceId(rawChannelId)) {
+                const error = placeholderSpaceError(rawChannelId);
                 yield createChannelWidget({
                     widgetId,
-                    channelId: '',
+                    channelId: rawChannelId,
                     body: error,
-                    state: 'error',
+                    state: "error",
                     meta: resultMeta,
                 });
                 yield {
-                    type: 'action:create_channel:result',
+                    type: "action:create_channel:result",
                     data: {
                         success: false,
-                        channelId: '',
-                        channelUrl: '',
+                        channelId: rawChannelId,
+                        channelUrl: "",
                         error,
                         output: error,
                     },
@@ -144,9 +175,9 @@ export function registerStorageTools(context) {
                 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 = {
@@ -154,12 +185,12 @@ export function registerStorageTools(context) {
                 name: displayName,
             };
             delete mergedInitial.cwd;
-            const channelSpec = typeof spec === 'string' && spec.trim() ? spec : `# ${displayName}\n\n`;
+            const channelSpec = typeof spec === "string" && spec.trim() ? spec : `# ${displayName}\n\n`;
             yield createChannelWidget({
                 widgetId,
                 channelId: rawChannelId,
-                body: 'Creating…',
-                state: 'open',
+                body: "Creating…",
+                state: "open",
                 meta: resultMeta,
             });
             try {
@@ -173,27 +204,27 @@ export function registerStorageTools(context) {
                     widgetId,
                     channelId: rawChannelId,
                     body: output,
-                    state: 'submitted',
+                    state: "submitted",
                     meta: resultMeta,
                 });
                 yield {
-                    type: 'action:create_channel:result',
+                    type: "action:create_channel:result",
                     data: { success: true, channelId: rawChannelId, channelUrl, output },
                     meta: resultMeta,
                 };
             }
             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({
                     widgetId,
                     channelId: rawChannelId,
                     body: output,
-                    state: 'error',
+                    state: "error",
                     meta: resultMeta,
                 });
                 yield {
-                    type: 'action:create_channel:result',
+                    type: "action:create_channel:result",
                     data: {
                         success: false,
                         channelId: rawChannelId,
@@ -205,19 +236,19 @@ export function registerStorageTools(context) {
                 };
             }
         });
-        actions.on('delete_channel', async function* (event, context) {
-            const rawChannelId = (event.data?.channelId || '').trim();
+        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',
+                    type: "action:delete_channel:result",
                     data: {
                         success: false,
-                        channelId: '',
-                        error: 'channelId is required',
+                        channelId: "",
+                        error: "channelId is required",
                     },
                     meta: resultMeta,
                 };
@@ -226,41 +257,43 @@ export function registerStorageTools(context) {
             try {
                 await storage.deleteChannel({ channelId: rawChannelId });
                 yield {
-                    type: 'action:delete_channel:result',
+                    type: "action:delete_channel:result",
                     data: { success: true, channelId: rawChannelId },
                     meta: resultMeta,
                 };
                 yield {
-                    type: 'agent:output',
+                    type: "agent:output",
                     data: { content: `Deleted channel \`${rawChannelId}\`.` },
                     meta: resultMeta,
                 };
             }
             catch (error) {
                 yield {
-                    type: 'action:delete_channel:result',
+                    type: "action:delete_channel:result",
                     data: {
                         success: false,
                         channelId: rawChannelId,
-                        error: error instanceof Error ? error.message : 'Unknown error',
+                        error: error instanceof Error ? error.message : "Unknown error",
                     },
                     meta: resultMeta,
                 };
             }
         });
-        actions.on('update_channel', async function* (event, context) {
+        actions.on("update_channel", async function* (event, context) {
             const data = event.data;
-            const targetChannelId = (data.channelId || context.state.channelId || '').trim();
+            const targetChannelId = (data.channelId ||
+                context.state.channelId ||
+                "").trim();
             const resultMeta = {
                 ...(event.meta || {}),
                 agentId: context.state.agentId,
             };
             if (!targetChannelId) {
                 yield {
-                    type: 'action:update_channel:result',
+                    type: "action:update_channel:result",
                     data: {
                         success: false,
-                        channelId: '',
+                        channelId: "",
                         updatedFields: [],
                     },
                     meta: resultMeta,
@@ -269,13 +302,13 @@ export function registerStorageTools(context) {
             }
             const patch = {};
             const updatedFields = [];
-            if (typeof data.name === 'string' && data.name.trim()) {
+            if (typeof data.name === "string" && data.name.trim()) {
                 patch.name = data.name.trim();
-                updatedFields.push('name');
+                updatedFields.push("name");
             }
-            if (typeof data.cwd === 'string' && data.cwd.trim()) {
+            if (typeof data.cwd === "string" && data.cwd.trim()) {
                 patch.cwd = data.cwd.trim();
-                updatedFields.push('cwd');
+                updatedFields.push("cwd");
             }
             try {
                 if (updatedFields.length > 0) {
@@ -290,20 +323,20 @@ export function registerStorageTools(context) {
                     });
                 }
                 yield {
-                    type: 'action:update_channel:result',
+                    type: "action:update_channel:result",
                     data: { success: true, channelId: targetChannelId, updatedFields },
                     meta: resultMeta,
                 };
             }
             catch {
                 yield {
-                    type: 'action:update_channel:result',
+                    type: "action:update_channel:result",
                     data: { success: false, channelId: targetChannelId, updatedFields },
                     meta: resultMeta,
                 };
             }
         });
-        actions.on('patch_channel_details', async function* (event, context) {
+        actions.on("patch_channel_details", async function* (event, context) {
             const updatedFields = [];
             const resultMeta = {
                 ...(event.meta || {}),
@@ -316,51 +349,51 @@ export function registerStorageTools(context) {
                         channelId: context.state.channelId,
                         state: data.state,
                     });
-                    updatedFields.push('state');
+                    updatedFields.push("state");
                 }
-                if (typeof data.spec === 'string') {
+                if (typeof data.spec === "string") {
                     await storage.patchChannelSpec({
                         channelId: context.state.channelId,
                         spec: data.spec,
                     });
-                    updatedFields.push('spec');
+                    updatedFields.push("spec");
                 }
-                if (typeof data.cwd === 'string') {
+                if (typeof data.cwd === "string") {
                     await storage.patchChannelState({
                         channelId: context.state.channelId,
                         state: { cwd: data.cwd },
                     });
-                    updatedFields.push('cwd');
+                    updatedFields.push("cwd");
                 }
                 context.state.channelDetails = await storage.getChannelDetails({
                     channelId: context.state.channelId,
                 });
                 yield {
-                    type: 'client:ui:widget',
+                    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',
+                        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',
+                    type: "action:patch_channel_details:result",
                     data: { success: true, updatedFields },
                     meta: resultMeta,
                 };
             }
             catch {
                 yield {
-                    type: 'action:patch_channel_details:result',
+                    type: "action:patch_channel_details:result",
                     data: { success: false, updatedFields },
                     meta: resultMeta,
                 };
             }
         });
-        actions.on('patch_thread_details', async function* (event, context) {
+        actions.on("patch_thread_details", async function* (event, context) {
             const updatedFields = [];
             const resultMeta = {
                 ...(event.meta || {}),
@@ -368,46 +401,50 @@ export function registerStorageTools(context) {
             };
             try {
                 if (!context.state.threadId) {
-                    throw new Error('Missing threadId in state for patch_thread_details');
+                    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: event.data.state,
+                        state,
                     });
-                    updatedFields.push('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',
+                    type: "action:patch_thread_details:result",
                     data: { success: true, updatedFields },
                     meta: resultMeta,
                 };
             }
             catch {
                 yield {
-                    type: 'action:patch_thread_details:result',
+                    type: "action:patch_thread_details:result",
                     data: { success: false, updatedFields },
                     meta: resultMeta,
                 };
             }
         });
-        actions.on('get_workspace_file_url', async function* (event, context) {
+        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',
+                    type: "action:get_workspace_file_url:result",
                     data: {
                         success: false,
-                        path: '',
-                        error: 'Path is required',
-                        output: 'Path is required',
+                        path: "",
+                        error: "Path is required",
+                        output: "Path is required",
                     },
                     meta: { ...(event.meta || {}), toolCallId },
                 };
@@ -430,7 +467,7 @@ export function registerStorageTools(context) {
                     size,
                 });
                 yield {
-                    type: 'action:get_workspace_file_url:result',
+                    type: "action:get_workspace_file_url:result",
                     data: {
                         success: true,
                         path: filePath,
@@ -443,9 +480,9 @@ export function registerStorageTools(context) {
                 };
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : 'Unknown error';
+                const message = error instanceof Error ? error.message : "Unknown error";
                 yield {
-                    type: 'action:get_workspace_file_url:result',
+                    type: "action:get_workspace_file_url:result",
                     data: {
                         success: false,
                         path: filePath,

package/dist/tools/thread-status.js

@@ -0,0 +1,91 @@
+import z from "zod";
+const AGENT_THREAD_STATUSES = [
+    "working",
+    "needs_input",
+    "ready_for_review",
+];
+function formatStatusOutput(args) {
+    const reason = args.reason?.trim();
+    return reason
+        ? `Job status set to ${args.status}: ${reason}`
+        : `Job status set to ${args.status}.`;
+}
+const threadStatusToolDefinitions = {
+    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 while you are doing it. Never mark completed or archived — only the human can.",
+        inputSchema: z.object({
+            status: z
+                .enum(AGENT_THREAD_STATUSES)
+                .describe("working — in progress; needs_input — blocked on the human; ready_for_review — you believe the job is done."),
+            reason: z
+                .string()
+                .optional()
+                .describe("Short reason shown in the job list, e.g. what you need from the human."),
+        }),
+    },
+};
+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 };
+            try {
+                const channelId = context.state.channelId;
+                const threadId = context.state.threadId;
+                if (!channelId || !threadId) {
+                    throw new Error("Missing channelId or threadId for set_thread_status");
+                }
+                const status = event.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.');
+                }
+                const reasonRaw = event.data.reason;
+                const reason = typeof reasonRaw === "string" && reasonRaw.trim()
+                    ? reasonRaw.trim()
+                    : "";
+                await pluginContext.storage.patchThreadState({
+                    channelId,
+                    threadId,
+                    state: {
+                        status,
+                        statusUpdatedAt: new Date().toISOString(),
+                        statusReason: reason,
+                    },
+                });
+                context.state.threadDetails = await pluginContext.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,
+                };
+            }
+            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,
+                };
+            }
+        });
+    },
+};
+export default threadStatusPlugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "0.1.14",
-  "description": "Monolithic OpenBot agent runtime with batteries-included tools.",
+  "version": "0.1.15",
+  "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",