@meetopenbot/openbot 0.1.14 → 0.2.0

package/dist/tools/start-work.js

@@ -0,0 +1,262 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { GENERAL_SPACE_ID, isPlaceholderSpaceId, placeholderSpaceError, } from "../space-id.js";
+import { asActionBuilder, } from "../types.js";
+function normalizeSpaceId(raw) {
+    return raw
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "");
+}
+function startWorkWidget(args) {
+    return {
+        type: "client:ui:widget",
+        data: {
+            widgetId: args.widgetId,
+            kind: "message",
+            title: "start_work",
+            description: args.spaceId || undefined,
+            body: args.body,
+            display: "collapsed",
+            state: args.state,
+        },
+        meta: args.meta,
+    };
+}
+const startWorkToolDefinitions = {
+    start_work: {
+        description: "Start the human's ask in an existing Space. Use from #general for real project work only — not questions, listings, or setup. If the Space does not exist, do not invent one: propose it to the human, then create_channel after they agree. Do not call this on work that was already forwarded.",
+        inputSchema: z.object({
+            spaceId: z
+                .string()
+                .describe("Target Space id (channel id), e.g. checkout, website, backend-platform."),
+            prompt: z
+                .string()
+                .describe("The human's ask, restated for the thread in that Space. Include enough context to start."),
+            title: z
+                .string()
+                .optional()
+                .describe("Optional thread title in the target Space."),
+            mentionedAgentIds: z
+                .array(z.string())
+                .optional()
+                .describe("Agents the human named; OpenBot in the target Space must ask them."),
+        }),
+    },
+};
+export const startWorkPlugin = {
+    id: "start-work",
+    name: "Start work",
+    description: "Forwards an ask into the right Space and starts OpenBot there.",
+    toolDefinitions: startWorkToolDefinitions,
+    factory: (pluginContext) => (builder) => {
+        const actions = asActionBuilder(builder);
+        actions.on("start_work", async function* (event, context) {
+            const data = event.data;
+            const toolCallId = event.meta?.toolCallId;
+            const resultMeta = {
+                ...(event.meta || {}),
+                agentId: context.state.agentId,
+                threadId: event.meta?.threadId || context.state.threadId,
+            };
+            const widgetId = typeof toolCallId === "string"
+                ? toolCallId
+                : `start_work:${Date.now()}`;
+            if (context.state.agentId !== pluginContext.host.orchestratorAgentId) {
+                const error = "Only OpenBot can start work in another Space.";
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId: "",
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, error, output: error },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            const invokeData = context.state.triggerEvent?.type === "agent:invoke"
+                ? context.state.triggerEvent.data
+                : undefined;
+            if (typeof invokeData?.forwardedFromSpaceId === "string") {
+                const error = "This thread was already forwarded. Stay here and ask agents; do not start_work again.";
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId: "",
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, error, output: error },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            const spaceId = normalizeSpaceId(data.spaceId || "");
+            const prompt = typeof data.prompt === "string" ? data.prompt.trim() : "";
+            if (spaceId && isPlaceholderSpaceId(spaceId)) {
+                const error = placeholderSpaceError(spaceId);
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId,
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, spaceId, error, output: error },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            if (!spaceId || !prompt) {
+                const error = "spaceId and prompt are required";
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId,
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, spaceId, error, output: error },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            if (spaceId === context.state.channelId) {
+                const error = `Already in #${spaceId}. Ask an agent here instead of start_work.`;
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId,
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, spaceId, error, output: error },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            const storage = pluginContext.storage;
+            const existing = (await storage.getChannels?.().catch(() => []));
+            const exists = Array.isArray(existing) &&
+                existing.some((space) => space.id === spaceId);
+            if (!exists) {
+                const error = `Space #${spaceId} does not exist. Propose it to the human (name + why). After they agree, use create_channel, then start_work. Do not invent a placeholder Space.`;
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId,
+                    body: error,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, spaceId, error, output: error },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            const threadId = randomUUID();
+            const threadTitle = typeof data.title === "string" && data.title.trim()
+                ? data.title.trim()
+                : undefined;
+            const threadUrl = `/channels/${encodeURIComponent(spaceId)}/threads/${encodeURIComponent(threadId)}`;
+            const fromSpace = context.state.channelId || GENERAL_SPACE_ID;
+            yield startWorkWidget({
+                widgetId,
+                spaceId,
+                body: `Starting in #${spaceId}…`,
+                state: "open",
+                meta: resultMeta,
+            });
+            try {
+                await storage.createThread({
+                    channelId: spaceId,
+                    threadId,
+                    threadTitle,
+                    initialState: {
+                        respondingAgentId: pluginContext.host.orchestratorAgentId,
+                        ...(threadTitle ? { name: threadTitle } : {}),
+                    },
+                });
+                const mentionedAgentIds = Array.isArray(data.mentionedAgentIds)
+                    ? data.mentionedAgentIds.filter((id) => typeof id === "string" && id.length > 0)
+                    : [];
+                const invokeEvent = {
+                    type: "agent:invoke",
+                    data: {
+                        role: "user",
+                        content: prompt,
+                        ...(mentionedAgentIds.length > 0 ? { mentionedAgentIds } : {}),
+                        forwardedFromSpaceId: fromSpace,
+                    },
+                    meta: {
+                        channelId: spaceId,
+                        threadId,
+                        userId: context.state.triggerEvent?.meta?.userId,
+                        userName: context.state.triggerEvent?.meta?.userName,
+                        userAvatarUrl: context.state.triggerEvent?.meta?.userAvatarUrl,
+                    },
+                };
+                await pluginContext.host.runAgent({
+                    runId: `sw_${randomUUID()}`,
+                    agentId: pluginContext.host.orchestratorAgentId,
+                    event: invokeEvent,
+                    publicBaseUrl: pluginContext.publicBaseUrl,
+                    persistEvents: true,
+                    onEvent: async () => {
+                        // Persist in the target Space via the inner harness. Do not echo into this thread.
+                    },
+                });
+                const output = `Started work in #${spaceId}. Open ${threadUrl}`;
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId,
+                    body: output,
+                    state: "submitted",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: {
+                        success: true,
+                        spaceId,
+                        threadId,
+                        threadUrl,
+                        output,
+                    },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                const output = `Failed to start work in #${spaceId}: ${message}`;
+                yield startWorkWidget({
+                    widgetId,
+                    spaceId,
+                    body: output,
+                    state: "error",
+                    meta: resultMeta,
+                });
+                yield {
+                    type: "action:start_work:result",
+                    data: { success: false, spaceId, threadId, error: message, output },
+                    meta: resultMeta,
+                };
+            }
+        });
+    },
+};
+export default startWorkPlugin;