@meetopenbot/openbot 1.9.0 → 1.10.0

package/dist/build-tools.js

@@ -2,6 +2,7 @@ import { memoryTools } from "./tools/memory.js";
 import { todoTools } from "./tools/todo.js";
 import { storageTools } from "./tools/storage.js";
 import { startThreadTools } from "./tools/start-thread.js";
+import { tasksTools } from "./tools/tasks.js";
 import { askAgentTools } from "./tools/ask-agent.js";
 import { askUserTools } from "./tools/ask-user.js";
 import { installAgentTools } from "./tools/install-agent.js";
@@ -32,6 +33,7 @@ export function buildOpenbotTools(args) {
         ...todoTools,
         ...storageTools,
         ...startThreadTools,
+        ...tasksTools,
         ...askAgentTools,
         ...askUserTools,
         ...installAgentTools,

package/dist/context.js

@@ -3,6 +3,7 @@ import { formatAvailableAgentsSection, formatInstalledAgentsSection, loadAgentMo
 import { todoService } from "./tools/todo-service.js";
 import { readInvokeSurface, surfaceSection } from "./surface.js";
 import { CONVERSATION_INSTRUCTIONS, isConversationThread } from "./conversation.js";
+import { buildTasksSection } from "./tasks.js";
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
 /**
@@ -97,6 +98,17 @@ export async function buildContext(state, storage, host) {
             console.warn("[context] Failed to fetch todos:", error);
         }
     }
+    // 2.55 Tasks this thread started
+    if (!surface && channelId && threadId) {
+        try {
+            const tasks = await buildTasksSection(storage, host, { channelId, threadId });
+            if (tasks)
+                sections.push(tasks);
+        }
+        catch (error) {
+            console.warn("[context] Failed to fetch tasks:", error);
+        }
+    }
     // 2.6 Installed Agents
     const otherAgents = allAgents.filter((agent) => agent.id !== agentId);
     if (otherAgents.length > 0) {

package/dist/conversation.js

@@ -11,6 +11,7 @@ export const CONVERSATION_INSTRUCTIONS = [
     '## CONVERSATION',
     "This is the Space's main conversation with the human, not a task. It has no title and keeps going across many requests. The JOB TITLE rules do not apply here.",
     '- **Answer inline** when the reply needs no specialist and takes no lasting work: questions, explanations, advice, short drafts, status of Spaces or tasks, quick lookups, and setup questions.',
+    '- **Task status**: when the human asks how a task went, answer from `## TASKS`; call `get_task` for its full last reply, or `list_tasks` when it is not listed. Never say you cannot see a task before checking.',
     '- **Start a task** with `start_thread` when the request needs a specialist (build, code, files, design, research, ops), runs long, or should be tracked on its own. Pick the Space it belongs to from `## SPACES`; the current Space is a valid target. You cannot ask specialists from here — the task does that.',
     '- One request, one task. Several independent requests become several tasks. Follow-ups to an existing task belong in that task; tell the human to continue there instead of starting a duplicate.',
     '- After `start_thread`, reply in one short sentence. The human sees a live card for the task; do not restate the request or promise progress updates.',

package/dist/tasks.js

@@ -0,0 +1,169 @@
+/** Tasks listed in `## TASKS`; older ones are a `list_tasks` call away. */
+export const TASKS_SECTION_LIMIT = 10;
+const SECTION_RESULT_CHARS = 200;
+function clip(text, max) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max).trimEnd()}…` : flat;
+}
+export function withRunning(thread, host) {
+    const running = host?.isThreadRunning?.({
+        channelId: thread.channelId,
+        threadId: thread.id,
+    });
+    return typeof running === "boolean" ? { ...thread, running } : thread;
+}
+/**
+ * Where the task stands, in words. A task stays `working` after its run ends
+ * until someone moves it on, so the last run's outcome decides what that means.
+ */
+export function describeTaskState(task) {
+    const reason = task.statusReason ? `: ${task.statusReason}` : "";
+    // A run waiting on the human's answer is still "running"; the wait matters more.
+    if (task.status === "needs_input")
+        return `waiting for the human${reason}`;
+    if (task.running)
+        return "running now";
+    switch (task.status) {
+        case "ready_for_review":
+            return `ready for review${reason}`;
+        case "completed":
+            return "completed";
+        case "archived":
+            return "archived";
+    }
+    if (task.running === undefined)
+        return "working";
+    const result = task.result;
+    if (!result)
+        return "not running, no result recorded";
+    if (result.error)
+        return `last run failed: ${clip(result.error, SECTION_RESULT_CHARS)}`;
+    if (result.stopped)
+        return "stopped by the human";
+    return "last run finished";
+}
+function formatTaskLine(task) {
+    const title = task.name && task.name !== task.id ? task.name : "Untitled";
+    const lines = [
+        `- ${title} — #${task.channelId}, thread ${task.id} — ${describeTaskState(task)}`,
+    ];
+    const summary = task.result?.summary;
+    if (summary && !task.running) {
+        lines.push(`  Last reply: ${clip(summary, SECTION_RESULT_CHARS)}`);
+    }
+    return lines.join("\n");
+}
+export function formatTasksSection(tasks) {
+    if (tasks.length === 0)
+        return "";
+    return [
+        "## TASKS",
+        "Tasks started from this conversation, most recently active first. Answer questions about them from this list. Call `get_task` for a task's full last reply, and `list_tasks` for older tasks or tasks in other Spaces.",
+        ...tasks.map(formatTaskLine),
+    ].join("\n");
+}
+export function isFromOrigin(task, origin) {
+    return task.origin?.channelId === origin.channelId && task.origin?.threadId === origin.threadId;
+}
+export async function listTasks(storage, host, args) {
+    const page = await storage.getThreads({ sort: "updatedAt", order: "desc", ...args });
+    return { tasks: page.items.map((thread) => withRunning(thread, host)), total: page.total };
+}
+/** The `## TASKS` section for a thread, or "" when it started none. */
+export async function buildTasksSection(storage, host, origin) {
+    if (!storage?.getThreads)
+        return "";
+    const { tasks } = await listTasks(storage, host, {
+        origin,
+        limit: TASKS_SECTION_LIMIT,
+    });
+    // Older runtimes ignore the origin filter and list every thread.
+    return formatTasksSection(tasks.filter((task) => isFromOrigin(task, origin)));
+}
+const STATUSES = [
+    "working",
+    "needs_input",
+    "ready_for_review",
+    "completed",
+    "archived",
+];
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+/** Reads a task from its thread `state.json`, as `getThreadDetails` returns it. */
+export function taskFromState(channelId, threadId, rawState) {
+    const state = isRecord(rawState) ? rawState : {};
+    const status = STATUSES.find((value) => value === state.status) ?? "completed";
+    const statusReason = text(state.statusReason);
+    const origin = isRecord(state.origin) ? state.origin : undefined;
+    const originChannelId = text(origin?.channelId);
+    const originThreadId = text(origin?.threadId);
+    const result = isRecord(state.result) ? state.result : undefined;
+    const endedAt = text(result?.endedAt);
+    const error = text(result?.error);
+    const preview = isRecord(state.preview) ? state.preview : undefined;
+    const firstMessage = text(preview?.content);
+    const latestAgentOutput = text(preview?.latestAgentOutput);
+    const updatedAt = text(state.statusUpdatedAt);
+    return {
+        id: threadId,
+        name: text(state.name) ?? threadId,
+        channelId,
+        createdAt: new Date(0),
+        updatedAt: updatedAt ? new Date(updatedAt) : new Date(0),
+        status,
+        ...(statusReason ? { statusReason } : {}),
+        ...(originChannelId && originThreadId
+            ? { origin: { channelId: originChannelId, threadId: originThreadId } }
+            : {}),
+        ...(result && endedAt
+            ? {
+                result: {
+                    summary: text(result.summary) ?? "",
+                    endedAt,
+                    ...(error ? { error } : {}),
+                    ...(result.stopped === true ? { stopped: true } : {}),
+                },
+            }
+            : {}),
+        ...(firstMessage
+            ? {
+                preview: {
+                    content: firstMessage,
+                    ...(latestAgentOutput ? { latestAgentOutput } : {}),
+                },
+            }
+            : {}),
+    };
+}
+export function formatTaskList(tasks, total) {
+    if (tasks.length === 0)
+        return "No tasks match.";
+    const more = total > tasks.length ? `\n(${total - tasks.length} more not shown.)` : "";
+    return `${tasks.map(formatTaskLine).join("\n")}${more}`;
+}
+/** Everything `get_task` reports: state, the request, the last run's reply, and todos. */
+export function formatTaskDetail(task, todos = []) {
+    const title = task.name && task.name !== task.id ? task.name : "Untitled";
+    const lines = [
+        `Task: ${title} — #${task.channelId}, thread ${task.id}`,
+        `State: ${describeTaskState(task)}`,
+    ];
+    if (task.preview?.content)
+        lines.push(`Request: ${clip(task.preview.content, 600)}`);
+    if (task.result) {
+        lines.push(`Last run ended: ${task.result.endedAt}`);
+        if (task.result.summary)
+            lines.push(`Last reply:\n${task.result.summary}`);
+    }
+    else if (task.preview?.latestAgentOutput) {
+        lines.push(`Latest reply so far:\n${task.preview.latestAgentOutput}`);
+    }
+    if (todos.length > 0) {
+        lines.push("Todos:", ...todos.map((todo) => `- [${todo.status}] ${todo.content}`));
+    }
+    return lines.join("\n");
+}

package/dist/tools/start-thread.js

@@ -97,12 +97,17 @@ export const startThreadTools = {
                 body: 'Starting…',
                 state: 'open',
             });
+            const originChannelId = ctx.channelId ?? ctx.state.channelId;
+            const originThreadId = ctx.threadId ?? ctx.state.threadId;
             try {
                 await ctx.storage.createThread({
                     channelId: targetChannelId,
                     threadId,
                     ...(threadTitle ? { threadTitle } : {}),
-                    initialState: {},
+                    // Lets the thread that started it list it under `## TASKS`.
+                    initialState: originChannelId && originThreadId
+                        ? { origin: { channelId: originChannelId, threadId: originThreadId } }
+                        : {},
                 });
                 const { agentId } = await ctx.host.startThreadRun({
                     channelId: targetChannelId,

package/dist/tools/tasks.js

@@ -0,0 +1,89 @@
+import z from "zod";
+import { normalizeChannelId } from "./storage.js";
+import { todoService } from "./todo-service.js";
+import { formatTaskDetail, formatTaskList, listTasks, taskFromState, withRunning, } from "../tasks.js";
+const LIST_DEFAULT_LIMIT = 20;
+const LIST_MAX_LIMIT = 50;
+const STATUS_VALUES = [
+    "working",
+    "needs_input",
+    "ready_for_review",
+    "completed",
+    "archived",
+];
+export const tasksTools = {
+    list_tasks: {
+        description: "List tasks (threads) with their state and last reply, most recently active first. Use it when a task the human asks about is not in `## TASKS`, or to see tasks in a Space. Read-only.",
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .optional()
+                .describe("Space id from `## SPACES`. Omit to list tasks in every Space."),
+            fromThisThread: z
+                .boolean()
+                .optional()
+                .describe("Only tasks started from the current thread with `start_thread`."),
+            status: z
+                .array(z.enum(STATUS_VALUES))
+                .optional()
+                .describe("Only these statuses. Archived tasks are left out unless listed here."),
+            limit: z.number().int().min(1).max(LIST_MAX_LIMIT).optional(),
+        }),
+        execute: async (raw, ctx) => {
+            const args = (raw ?? {});
+            try {
+                const channelId = args.channelId ? normalizeChannelId(args.channelId) : undefined;
+                const currentChannelId = ctx.channelId ?? ctx.state.channelId;
+                const currentThreadId = ctx.threadId ?? ctx.state.threadId;
+                const origin = args.fromThisThread && currentChannelId && currentThreadId
+                    ? { channelId: currentChannelId, threadId: currentThreadId }
+                    : undefined;
+                const { tasks, total } = await listTasks(ctx.storage, ctx.host, {
+                    ...(channelId ? { channelId } : {}),
+                    ...(origin ? { origin } : {}),
+                    ...(args.status?.length ? { status: args.status, excludeStatus: [] } : {}),
+                    limit: Math.min(args.limit ?? LIST_DEFAULT_LIMIT, LIST_MAX_LIMIT),
+                });
+                return { success: true, total, output: formatTaskList(tasks, total) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                return { success: false, error: message, output: `Failed to list tasks: ${message}` };
+            }
+        },
+    },
+    get_task: {
+        description: "Read one task: its state, the request, the full last reply, and its todos. Use it to answer how a task went. Read-only.",
+        inputSchema: z.object({
+            channelId: z.string().describe("The task's Space id."),
+            threadId: z.string().describe("The task's thread id."),
+        }),
+        execute: async (raw, ctx) => {
+            const args = (raw ?? {});
+            const channelId = normalizeChannelId(args.channelId ?? "");
+            const threadId = typeof args.threadId === "string" ? args.threadId.trim() : "";
+            if (!channelId || !threadId) {
+                const error = "channelId and threadId are required";
+                return { success: false, error, output: error };
+            }
+            try {
+                const details = await ctx.storage.getThreadDetails({ channelId, threadId });
+                const state = details.state;
+                if (!state || typeof state !== "object" || Object.keys(state).length === 0) {
+                    const error = `No task ${threadId} in #${channelId}.`;
+                    return { success: false, error, output: error };
+                }
+                const task = withRunning(taskFromState(channelId, threadId, state), ctx.host);
+                const todos = await todoService
+                    .getTodos({ channelId, threadId })
+                    .then((list) => list.items)
+                    .catch(() => []);
+                return { success: true, output: formatTaskDetail(task, todos) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                return { success: false, error: message, output: `Failed to read task: ${message}` };
+            }
+        },
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "@ai-sdk/openai": "^4.0.72",
     "ai": "^7.0.111",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^2.4.0"
+    "@meetopenbot/plugin-sdk": "^2.5.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",