@meetopenbot/openbot 1.8.0 → 1.9.0

package/dist/build-tools.js

@@ -5,13 +5,23 @@ import { startThreadTools } from "./tools/start-thread.js";
 import { askAgentTools } from "./tools/ask-agent.js";
 import { askUserTools } from "./tools/ask-user.js";
 import { installAgentTools } from "./tools/install-agent.js";
-import { threadStatusTools } from "./tools/thread-status.js";
 import { threadTitleTools } from "./tools/thread-title.js";
 import { previewTools } from "./tools/preview.js";
 import { variablesRequestTools } from "./tools/variables-request.js";
 import { renderWidgetTools } from "./tools/render-widget.js";
 import { wrapToolsWithApproval } from "./tools/approval.js";
+import { isConversationThread } from "./conversation.js";
 export const DEFAULT_APPROVAL_ACTIONS = ["update_channel_spec", "start_thread"];
+/**
+ * A Space conversation answers inline or starts tasks; specialist work, todos,
+ * and job title/status belong to the task.
+ */
+export const CONVERSATION_EXCLUDED_TOOLS = [
+    "ask_agent",
+    "todo_write",
+    "todo_read",
+    "set_thread_title",
+];
 /**
  * Merge first-party OpenBot coordinator tools and wrap configured actions
  * with approval.
@@ -25,7 +35,6 @@ export function buildOpenbotTools(args) {
         ...askAgentTools,
         ...askUserTools,
         ...installAgentTools,
-        ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
         ...variablesRequestTools,
@@ -33,5 +42,12 @@ export function buildOpenbotTools(args) {
         ...args.context.tools,
     };
     const approvalConfig = args.context.config?.approval;
-    return wrapToolsWithApproval(tools, approvalConfig?.actions ?? DEFAULT_APPROVAL_ACTIONS, args.context);
+    const conversation = isConversationThread(args.threadId);
+    if (conversation) {
+        for (const name of CONVERSATION_EXCLUDED_TOOLS)
+            delete tools[name];
+    }
+    // Starting tasks is what a Space conversation is for, so it does not ask first.
+    const actions = (approvalConfig?.actions ?? DEFAULT_APPROVAL_ACTIONS).filter((action) => !(action === "start_thread" && conversation));
+    return wrapToolsWithApproval(tools, actions, args.context);
 }

package/dist/context.js

@@ -2,6 +2,7 @@ import { formatGitIdentity, readGitIdentity, } from "@meetopenbot/plugin-sdk";
 import { formatAvailableAgentsSection, formatInstalledAgentsSection, loadAgentModelCatalogs, availableMarketplaceAgents, } from "./agent-models.js";
 import { todoService } from "./tools/todo-service.js";
 import { readInvokeSurface, surfaceSection } from "./surface.js";
+import { CONVERSATION_INSTRUCTIONS, isConversationThread } from "./conversation.js";
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
 /**
@@ -63,23 +64,8 @@ export async function buildContext(state, storage, host) {
         env += `- Thread: ${threadDetails?.name || threadId}\n`;
     }
     sections.push(env);
-    if (threadId) {
-        const threadState = threadDetails?.state && typeof threadDetails.state === "object"
-            ? threadDetails.state
-            : undefined;
-        const threadStatus = typeof threadState?.status === "string" && threadState.status.trim()
-            ? threadState.status.trim()
-            : "completed";
-        const threadStatusReason = typeof threadState?.statusReason === "string" && threadState.statusReason.trim()
-            ? threadState.statusReason.trim()
-            : undefined;
-        let statusSection = `## THREAD STATUS\n- Status: ${threadStatus}`;
-        if (threadStatusReason) {
-            statusSection += `\n- Reason: ${threadStatusReason}`;
-        }
-        statusSection +=
-            "\nUse `set_thread_status` to update this. needs_input when blocked on the human; ready_for_review when you believe the job is done; working when the job is still in progress. Never set completed or archived.";
-        sections.push(statusSection);
+    if (isConversationThread(threadId)) {
+        sections.push(CONVERSATION_INSTRUCTIONS);
     }
     const invokeData = state.triggerEvent?.type === "agent:invoke"
         ? state.triggerEvent.data

package/dist/conversation.js

@@ -0,0 +1,78 @@
+/**
+ * Reserved thread that holds a Space's own conversation with OpenBot. The
+ * runtime keeps the same id; task listings skip it.
+ */
+export const CONVERSATION_THREAD_ID = 'conversation';
+export function isConversationThread(threadId) {
+    return threadId === CONVERSATION_THREAD_ID;
+}
+/** Added to a Space conversation's context: it is a chat, not a task. */
+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.',
+    '- **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.',
+    '- If you are unsure whether the human wants a task, ask in one line instead of starting one.',
+].join('\n');
+/** Human turns kept verbatim when a Space conversation is replayed to the model. */
+export const CONVERSATION_KEPT_TURNS = 20;
+const DIGEST_MESSAGE_LIMIT = 30;
+const DIGEST_TEXT_LIMIT = 200;
+function isHumanTurn(event) {
+    if (event.type !== 'agent:invoke' || event.meta?.parentToolCallId)
+        return false;
+    return event.data?.role === 'user';
+}
+function clip(text) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > DIGEST_TEXT_LIMIT ? `${flat.slice(0, DIGEST_TEXT_LIMIT)}…` : flat;
+}
+function startedTask(event) {
+    if (event.type !== 'client:ui:widget')
+        return null;
+    const data = event.data;
+    if (data?.metadata?.type !== 'thread_started' || data.state !== 'submitted')
+        return null;
+    const { channelId, threadId, title } = data.metadata;
+    if (typeof channelId !== 'string' || typeof threadId !== 'string')
+        return null;
+    return { channelId, threadId, ...(typeof title === 'string' && title ? { title } : {}) };
+}
+/**
+ * Keeps the last {@link CONVERSATION_KEPT_TURNS} human turns (and everything
+ * after the first of them) and folds older history into a plain-text digest:
+ * what the human asked and which tasks were started. No model call.
+ */
+export function compactConversation(events, keptTurns = CONVERSATION_KEPT_TURNS) {
+    const turnStarts = [];
+    events.forEach((event, index) => {
+        if (isHumanTurn(event))
+            turnStarts.push(index);
+    });
+    if (turnStarts.length <= keptTurns)
+        return { events, digest: '' };
+    const cut = turnStarts[turnStarts.length - keptTurns];
+    const dropped = events.slice(0, cut);
+    const asked = dropped
+        .filter(isHumanTurn)
+        .map((event) => clip(String(event.data.content ?? '')))
+        .filter(Boolean)
+        .slice(-DIGEST_MESSAGE_LIMIT);
+    const tasks = dropped
+        .map(startedTask)
+        .filter((task) => task !== null)
+        .slice(-DIGEST_MESSAGE_LIMIT);
+    const lines = [
+        '## EARLIER IN THIS CONVERSATION',
+        'Older messages were compacted. This is what remains of them; ask the human if you need more.',
+    ];
+    if (asked.length > 0) {
+        lines.push('Human asked:', ...asked.map((text) => `- ${text}`));
+    }
+    if (tasks.length > 0) {
+        lines.push('Tasks started:', ...tasks.map((task) => `- ${task.title ?? 'Untitled'} — #${task.channelId}, thread ${task.threadId}`));
+    }
+    return { events: events.slice(cut), digest: lines.join('\n') };
+}

package/dist/fast-forward.js

@@ -14,8 +14,8 @@ const SELF_ANSWER_QUESTION = 'openbot_should_answer';
 export const FAST_FORWARD_CLOSE_HINT = [
     '## THIS TURN',
     'You already asked the specialist. Do not call ask_agent again.',
-    'If they finished, close in one or two sentences and set ready_for_review.',
-    'If they are blocked on the human, set needs_input.',
+    'If they finished, close in one or two sentences.',
+    'If they are blocked on the human, ask with `ask_user`.',
     'If they failed, say what blocked them.',
     'Do not restate a successful reply.',
 ].join('\n');

package/dist/index.js

@@ -8,7 +8,6 @@ import { todoTools } from './tools/todo.js';
 import { storageTools } from './tools/storage.js';
 import { askAgentTools } from './tools/ask-agent.js';
 import { installAgentTools } from './tools/install-agent.js';
-import { threadStatusTools } from './tools/thread-status.js';
 import { threadTitleTools } from './tools/thread-title.js';
 import { previewTools } from './tools/preview.js';
 import { variablesRequestTools } from './tools/variables-request.js';
@@ -50,7 +49,6 @@ export const openbotPlugin = defineOpenbotPlugin({
         ...storageTools,
         ...askAgentTools,
         ...installAgentTools,
-        ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
         ...variablesRequestTools,
@@ -61,7 +59,7 @@ export const openbotPlugin = defineOpenbotPlugin({
         const authMode = context.host.isCloudSystemAgent(context.agentId)
             ? context.host.parseOpenbotAuthMode(context.config?.authMode)
             : 'byok';
-        const toolDefinitions = buildOpenbotTools({ context });
+        const toolDefinitions = buildOpenbotTools({ context, threadId: args.threadId });
         yield* runOpenbotTurn(args, {
             model: context.config?.model || AUTO_MODEL_ID,
             authMode,

package/dist/runtime.js

@@ -12,6 +12,7 @@ import { reasoningForModel, resolveModel } from './model.js';
 import { errorFromStreamPart } from './stream-error.js';
 import { createAgentOutputBuffer, isOutputBoundaryPart } from './output-buffer.js';
 import { threadNamingHint } from './thread-naming.js';
+import { compactConversation, isConversationThread } from './conversation.js';
 import { readInvokeSurface, RESPOND_TOOL, surfaceTools } from './surface.js';
 async function buildSystemPrompt(state, storage, instructions, host) {
     const context = await buildContext(state, storage, host);
@@ -20,7 +21,8 @@ async function buildSystemPrompt(state, storage, instructions, host) {
         '',
         context,
     ];
-    if (!readInvokeSurface(state.triggerEvent)) {
+    // A Space conversation is a chat, not a job: it never gets a title.
+    if (!readInvokeSurface(state.triggerEvent) && !isConversationThread(state.threadId)) {
         const threadState = state.threadDetails?.state;
         sections.push(...threadNamingHint(threadState));
     }
@@ -202,7 +204,6 @@ async function* attemptFastForward(args, options) {
         data: { content: `Asking ${candidate.agentName}.` },
         meta: { agentId: args.context.agentId, threadId: args.threadId },
     };
-    await executeCoordinatorTool(args, options.tools, 'set_thread_status', { status: 'working' });
     const titleTask = (async () => {
         const threadState = args.state.threadDetails?.state;
         if (!threadNeedsGeneratedTitle(threadState))
@@ -239,12 +240,21 @@ export async function* runOpenbotTurn(args, options) {
     state.model = configuredModelString;
     const threadId = args.threadId || state.threadId;
     let systemPrompt = await buildSystemPrompt(state, storage, instructions, host);
+    // A Space conversation runs indefinitely; replay only its recent turns plus a digest.
+    const compactHistory = (loaded) => {
+        if (surface || !isConversationThread(threadId))
+            return loaded;
+        const compacted = compactConversation(loaded);
+        if (compacted.digest)
+            systemPrompt = `${systemPrompt}\n\n${compacted.digest}`;
+        return compacted.events;
+    };
     let events = surface
         ? [args.event]
-        : await storage.getEvents({
+        : compactHistory(await storage.getEvents({
             channelId: state.channelId ?? '',
             threadId,
-        });
+        }));
     const hasAttachments = eventsHaveAttachments(events);
     const candidates = chooseTurnCandidates({ model: configuredModelString, events, authMode });
     const readImage = async (name) => {
@@ -293,11 +303,11 @@ export async function* runOpenbotTurn(args, options) {
         if (abortSignal?.aborted)
             return;
         if (forwarded) {
-            events = await storage.getEvents({
+            systemPrompt = `${await buildSystemPrompt(state, storage, instructions, host)}\n\n${FAST_FORWARD_CLOSE_HINT}`;
+            events = compactHistory(await storage.getEvents({
                 channelId: state.channelId ?? '',
                 threadId,
-            });
-            systemPrompt = `${await buildSystemPrompt(state, storage, instructions, host)}\n\n${FAST_FORWARD_CLOSE_HINT}`;
+            }));
         }
         // Messages the human sent while this run is going. They join the conversation
         // before the next model step, like a reply typed between tool calls, and stay in

package/dist/system-prompt.js

@@ -15,7 +15,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "# THE AGENT LOOP",
     "You operate in an iterative loop:",
     "1. **Analyze Events**: Understand the human, mentioned people, the current Space, and `## SPACES`.",
-    "2. **Right Space**: Every Space, `#general` included, is a place to do work. Do it in the current Space by default. Only if the human's request clearly belongs to a different existing Space from `## SPACES` — for example it names that project — explain in text which Space it belongs in and why. Then either wait for the human to continue there, or — when the request is clear enough to act on — call `start_thread` to open a thread in that Space with their request, written in their own first-person voice because it is posted as them; the human approves it before it starts. Never start a thread in the Space you are already in. Otherwise continue here with `ask_agent`. Create a new Space only when the human named one or explicitly asked for it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`).",
+    "2. **Right Space**: Every Space, `#general` included, is a place to do work. Do it in the current Space by default. Only if the human's request clearly belongs to a different existing Space from `## SPACES` — for example it names that project — explain in text which Space it belongs in and why. Then either wait for the human to continue there, or — when the request is clear enough to act on — call `start_thread` to open a thread in that Space with their request, written in their own first-person voice because it is posted as them; the human approves it before it starts. Inside a task, never start a thread in the Space you are already in; otherwise continue there with `ask_agent`. In a Space conversation (`## CONVERSATION`), follow its rules instead: answer inline or start a task with `start_thread`. Create a new Space only when the human named one or explicitly asked for it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`).",
     "3. **Ask people**: Use `ask_agent` to send a message to a specialist. Write it as a request to a colleague, not as a tool invocation.",
     "4. **Wait**: Let the asked agent run in its own harness. Read their reply, then continue or ask someone else.",
     "5. **Close**: Write one short final message when the task is done or blocked. The human already saw the specialist speak in this thread. Do not restate, re-bullet, or paraphrase their findings. Name who you asked, then add only what is new — a decision, a conflict, a next step, or a caveat. If nothing is new, close in one or two sentences. Never post progress recaps between steps; the todo list shows progress.",
@@ -47,13 +47,6 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- Call `set_thread_title` again only if the topic clearly changes.",
     "- Never re-title a job the user renamed.",
     "",
-    "# JOB STATUS",
-    "- Every thread is a job. Status is `working` (in progress), `needs_input`, `ready_for_review`, `completed`, or `archived`.",
-    "- Status is the job's workflow state, not whether an agent is currently executing.",
-    "- `ask_user`, `request_variables`, and connect cards set `needs_input` while they wait; do not set it yourself for those.",
-    "- When you believe the job is done, set `ready_for_review`. Never set `completed` or `archived` — only the human can.",
-    "- The current status is injected each turn as `## THREAD STATUS`.",
-    "",
     "# OPERATIONAL GUIDELINES",
     '- **Spaces**: Work lives in Spaces (product name for channels). `#general` is the default Space and works like any other. Prefer existing Spaces. When the request clearly belongs to another existing Space, explain the appropriate Space in text, then let them continue there or hand it over with `start_thread`. Never auto-move threads or messages; `start_thread` opens a new thread and leaves this one in place. Create a new Space only when the human asked for one, or they agreed after you suggested it.',
     "- **Asking**: You ask specialists with `ask_agent`. If `## MENTIONED AGENTS` is present, you MUST ask those people. You may also ask others if needed. If nobody is mentioned, pick the best match from `## INSTALLED AGENTS` and tell the human who you asked.",

package/dist/tools/start-thread.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import z from 'zod';
 import { isPlaceholderSpaceId } from '../space-id.js';
 import { normalizeChannelId } from './storage.js';
+import { isConversationThread } from '../conversation.js';
 async function emitStartThreadWidget(ctx, args) {
     const actions = args.state === 'submitted' && args.threadUrl
         ? [
@@ -24,7 +25,13 @@ async function emitStartThreadWidget(ctx, args) {
             display: args.state === 'submitted' ? 'expanded' : 'collapsed',
             state: args.state,
             ...(actions ? { actions } : {}),
-            metadata: { type: 'thread_started', channelId: args.channelId || undefined },
+            metadata: {
+                type: 'thread_started',
+                channelId: args.channelId || undefined,
+                // The task card follows this thread's live status.
+                ...(args.threadId ? { threadId: args.threadId } : {}),
+                ...(args.title ? { title: args.title } : {}),
+            },
         },
         meta: {
             agentId: ctx.agentId,
@@ -35,7 +42,7 @@ async function emitStartThreadWidget(ctx, args) {
 }
 export const startThreadTools = {
     start_thread: {
-        description: "Start a new thread in another existing Space and hand the human's request to that Space's agent. Use when work asked here clearly belongs in a different Space from `## SPACES`. The new thread runs on its own; the human follows it there. Never use it for the Space you are already in.",
+        description: "Start a new thread (task) in an existing Space and hand the human's request to that Space's agent. From a Space conversation (`## CONVERSATION`), use it for every real piece of work, in the current Space or another one. From inside a task, use it only when work clearly belongs in a different Space from `## SPACES`. The new thread runs on its own; the human follows it there.",
         inputSchema: z.object({
             channelId: z.string().describe('Existing Space id from `## SPACES` (e.g. backend-platform).'),
             prompt: z
@@ -69,7 +76,8 @@ export const startThreadTools = {
             if (isPlaceholderSpaceId(targetChannelId)) {
                 return fail(`Refused to start a thread in #${targetChannelId}: that is not a real Space.`);
             }
-            if (targetChannelId === (ctx.channelId ?? ctx.state.channelId)) {
+            const fromConversation = isConversationThread(ctx.threadId ?? ctx.state.threadId);
+            if (!fromConversation && targetChannelId === (ctx.channelId ?? ctx.state.channelId)) {
                 return fail(`You are already in #${targetChannelId}. Continue here instead of starting a thread.`);
             }
             if (!ctx.host.startThreadRun) {
@@ -84,6 +92,7 @@ export const startThreadTools = {
             await emitStartThreadWidget(ctx, {
                 widgetId,
                 channelId: targetChannelId,
+                threadId,
                 title: threadTitle,
                 body: 'Starting…',
                 state: 'open',
@@ -103,6 +112,7 @@ export const startThreadTools = {
                 await emitStartThreadWidget(ctx, {
                     widgetId,
                     channelId: targetChannelId,
+                    threadId,
                     title: threadTitle,
                     body: `Started a thread in #${targetChannelId}.`,
                     state: 'submitted',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/tools/thread-status.js

@@ -1,75 +0,0 @@
-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}.`;
-}
-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({
-            status: z
-                .enum(AGENT_THREAD_STATUSES)
-                .describe("working — job is 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 tools = {
-    set_thread_status: {
-        ...toolDefinitions.set_thread_status,
-        execute: async (rawArgs, ctx) => {
-            try {
-                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 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.");
-                }
-                const reason = typeof data.reason === "string" && data.reason.trim()
-                    ? data.reason.trim()
-                    : "";
-                await ctx.storage.patchThreadState({
-                    channelId,
-                    threadId,
-                    state: {
-                        status,
-                        statusUpdatedAt: new Date().toISOString(),
-                        statusReason: reason,
-                    },
-                });
-                ctx.state.threadDetails = await ctx.storage.getThreadDetails({
-                    channelId,
-                    threadId,
-                });
-                const output = formatStatusOutput({ status, reason });
-                return {
-                    success: true,
-                    status,
-                    ...(reason ? { reason } : {}),
-                    output,
-                };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "Unknown error";
-                return { success: false, error: message, output: message };
-            }
-        },
-    },
-};
-export const threadStatusTools = tools;