@meetopenbot/openbot 1.2.19 → 1.3.0

package/dist/build-tools.js

@@ -6,7 +6,6 @@ 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 { suggestSpaceTools } from "./tools/suggest-space.js";
 import { wrapToolsWithApproval } from "./tools/approval.js";
 export const DEFAULT_APPROVAL_ACTIONS = ["update_channel_spec"];
 /**
@@ -23,7 +22,6 @@ export function buildOpenbotTools(args) {
         ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
-        ...suggestSpaceTools,
         ...args.context.tools,
     };
     const approvalConfig = args.context.config?.approval;

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 { GENERAL_SPACE_ID } from "./space-id.js";
 import { todoService } from "./tools/todo-service.js";
+import { readInvokeSurface, surfaceSection } from "./surface.js";
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
 /**
@@ -30,6 +31,8 @@ export const getContextBudgetForModel = (modelString) => {
 export async function buildContext(state, storage, host) {
     const { channelId, threadId, channelDetails, agentId, threadDetails, } = state;
     const sections = [];
+    // Inline asks skip routing context (marketplace, other Spaces): they never move work.
+    const surface = readInvokeSurface(state.triggerEvent);
     // Fetch agents once if storage is available
     const allAgents = storage?.getAgents
         ? await storage.getAgents().catch(() => [])
@@ -118,7 +121,7 @@ export async function buildContext(state, storage, host) {
         sections.push(formatInstalledAgentsSection(otherAgents, catalogs));
     }
     // 2.7 Marketplace agents not yet installed
-    if (host?.listMarketplaceAgents) {
+    if (!surface && host?.listMarketplaceAgents) {
         try {
             const marketplace = await host.listMarketplaceAgents();
             const available = availableMarketplaceAgents(allAgents, marketplace);
@@ -130,7 +133,7 @@ export async function buildContext(state, storage, host) {
             console.warn("[context] Failed to fetch marketplace agents:", error);
         }
     }
-    if (storage?.getChannels) {
+    if (!surface && storage?.getChannels) {
         try {
             const spaces = (await storage.getChannels());
             if (spaces.length > 0) {
@@ -213,5 +216,7 @@ export async function buildContext(state, storage, host) {
             console.warn("[context] Failed to fetch memories:", error);
         }
     }
+    if (surface)
+        sections.push(surfaceSection(surface));
     return sections.join("\n\n");
 }

package/dist/fast-forward.js

@@ -0,0 +1,177 @@
+import { creditsProviderBaseUrl, resolveByokApiKey, resolveCreditsAuthConfig, shouldUseCreditsAuth, INTEGRATIONS_TOKEN_HEADER, } from '@meetopenbot/plugin-sdk';
+import { isAutoModel } from './auto-model.js';
+import { GENERAL_SPACE_ID } from './space-id.js';
+import { isManuallyNamedThread } from './thread-naming.js';
+/** Decisions model. Public beta supports only this id. */
+export const DECISION_MODEL = 'gpt-6-luna';
+/**
+ * Forward only when the predicate is confident the message is not OpenBot's
+ * to answer. The middle of the range falls through to the coordinator.
+ */
+export const SELF_ANSWER_FORWARD_MAX = 0.3;
+const DECISION_TIMEOUT_MS = 2500;
+const OPENAI_DECISIONS_URL = 'https://api.openai.com/v1/decisions';
+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 failed, say what blocked them.',
+    'Do not restate a successful reply.',
+].join('\n');
+function eventData(event) {
+    const data = event.data;
+    return data && typeof data === 'object' ? data : undefined;
+}
+function isUserInvoke(event) {
+    if (event.meta?.parentToolCallId)
+        return false;
+    if (event.type !== 'agent:invoke')
+        return false;
+    return eventData(event)?.role === 'user';
+}
+/**
+ * Auto, dedicated Space, first user message, exactly one installed @mention,
+ * no attachments. Anything else stays on the coordinator.
+ */
+export function selectFastForwardCandidate(input) {
+    if (!isAutoModel(input.model))
+        return undefined;
+    if (!input.channelId || input.channelId === GENERAL_SPACE_ID)
+        return undefined;
+    const userMessages = input.events.filter(isUserInvoke);
+    if (userMessages.length !== 1)
+        return undefined;
+    const message = userMessages[0];
+    const data = eventData(message);
+    const attachments = data?.attachments;
+    if (Array.isArray(attachments) && attachments.length > 0)
+        return undefined;
+    const mentioned = Array.isArray(data?.mentionedAgentIds)
+        ? data.mentionedAgentIds.filter((id) => typeof id === 'string' && id.length > 0)
+        : [];
+    if (mentioned.length !== 1)
+        return undefined;
+    const agentId = mentioned[0];
+    if (agentId === input.orchestratorAgentId)
+        return undefined;
+    const agent = input.installedAgents.find((item) => item.id === agentId);
+    if (!agent)
+        return undefined;
+    const prompt = typeof data?.content === 'string' ? data.content.trim() : '';
+    if (!prompt)
+        return undefined;
+    const alreadyAsked = input.events.some((event) => !event.meta?.parentToolCallId &&
+        (event.type === 'action:ask_agent' || event.type === 'action:delegate_task'));
+    if (alreadyAsked)
+        return undefined;
+    return { agentId, agentName: agent.name || agentId, prompt };
+}
+export function threadNeedsGeneratedTitle(state) {
+    const record = state && typeof state === 'object' ? state : {};
+    return record.isSmartNamed !== true && !isManuallyNamedThread(state);
+}
+export function sanitizeThreadTitle(raw) {
+    const line = raw.split('\n')[0]?.trim() ?? '';
+    const unquoted = line.replace(/^["'`]+|["'`]+$/g, '').trim();
+    const title = unquoted.replace(/\s+/g, ' ').slice(0, 80).trim();
+    return title || undefined;
+}
+/** Where to POST `/v1/decisions`. Credits when that mode is on, otherwise OpenAI BYOK. */
+export function resolveDecisionEndpoint(options) {
+    if (shouldUseCreditsAuth({ authMode: options.authMode })) {
+        const config = resolveCreditsAuthConfig();
+        if (!config)
+            return undefined;
+        return {
+            url: `${creditsProviderBaseUrl(config, 'openai')}/decisions`,
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                [INTEGRATIONS_TOKEN_HEADER]: config.token,
+                'Content-Type': 'application/json',
+            },
+        };
+    }
+    const apiKey = resolveByokApiKey('openai', [], options.env ?? process.env);
+    if (!apiKey)
+        return undefined;
+    return {
+        url: OPENAI_DECISIONS_URL,
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+    };
+}
+export function interpretHandoffDecision(body) {
+    const answers = body && typeof body === 'object' && Array.isArray(body.answers)
+        ? body.answers
+        : [];
+    const answer = answers.find((item) => item &&
+        typeof item === 'object' &&
+        item.name === SELF_ANSWER_QUESTION);
+    if (!answer)
+        return { forward: false, reason: 'no decision answer' };
+    if (answer.type === 'refusal')
+        return { forward: false, reason: 'decision refused' };
+    if (answer.type !== 'predicate' || typeof answer.probability !== 'number') {
+        return { forward: false, reason: 'decision was not a probability' };
+    }
+    if (!Number.isFinite(answer.probability)) {
+        return { forward: false, reason: 'decision was not a probability' };
+    }
+    if (answer.probability > SELF_ANSWER_FORWARD_MAX) {
+        return {
+            forward: false,
+            probability: answer.probability,
+            reason: `self-answer ${answer.probability}`,
+        };
+    }
+    return { forward: true, probability: answer.probability, reason: 'forward' };
+}
+function decisionInput(agentName, agentId, prompt) {
+    return `Specialist: ${agentName} (${agentId})\n\nMessage:\n${prompt}`;
+}
+/**
+ * One predicate: should OpenBot answer this instead of the mentioned specialist?
+ * Failures and low confidence return `forward: false` so the normal turn runs.
+ */
+export async function classifySpecialistHandoff(args) {
+    if (args.signal?.aborted)
+        return { forward: false, reason: 'aborted' };
+    const endpoint = resolveDecisionEndpoint({ authMode: args.authMode, env: args.env });
+    if (!endpoint)
+        return { forward: false, reason: 'no decisions auth' };
+    const timeout = AbortSignal.timeout(args.timeoutMs ?? DECISION_TIMEOUT_MS);
+    const signal = args.signal ? AbortSignal.any([args.signal, timeout]) : timeout;
+    const fetchImpl = args.fetchImpl ?? fetch;
+    try {
+        const response = await fetchImpl(endpoint.url, {
+            method: 'POST',
+            headers: endpoint.headers,
+            signal,
+            body: JSON.stringify({
+                model: DECISION_MODEL,
+                input: decisionInput(args.agentName, args.agentId, args.prompt),
+                questions: [
+                    {
+                        type: 'predicate',
+                        name: SELF_ANSWER_QUESTION,
+                        instructions: 'The human @mentioned one specialist. High probability if OpenBot should answer this itself: a question about the workspace, people, setup, status, or Spaces, or small talk that is not a task for that specialist. Low probability if the message is work, a change, or a question that specialist should handle.',
+                    },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            return { forward: false, reason: `decision HTTP ${response.status}` };
+        }
+        return interpretHandoffDecision(await response.json());
+    }
+    catch (error) {
+        if (args.signal?.aborted)
+            return { forward: false, reason: 'aborted' };
+        const message = error instanceof Error ? error.message : String(error);
+        return { forward: false, reason: message || 'decision failed' };
+    }
+}

package/dist/index.js

@@ -11,7 +11,6 @@ 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 { suggestSpaceTools } from './tools/suggest-space.js';
 import { buildOpenbotTools } from './build-tools.js';
 export const OPENBOT_PLUGIN_ID = '@meetopenbot/openbot';
 const modelField = await modelConfigField({
@@ -52,7 +51,6 @@ export const openbotPlugin = defineOpenbotPlugin({
         ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
-        ...suggestSpaceTools,
     },
     async *run(args) {
         const { context } = args;

package/dist/runtime.js

@@ -1,14 +1,17 @@
-import { streamText, stepCountIs } from 'ai';
+import { randomUUID } from 'node:crypto';
+import { generateText, hasToolCall, streamText, stepCountIs } from 'ai';
 import { BYOK_ENV_KEYS, isAuthErrorMessage, isCreditsErrorMessage, fetchModelRegistry, getProviderModelOptions, listApiKeyProviders, PROVIDER_API_KEY_LINKS, } from '@meetopenbot/plugin-sdk';
 import { eventsToModelMessages } from './history.js';
 import { addAttachmentParts, chooseTurnCandidates, eventsHaveAttachments, modelSupportsImages, } from './images.js';
 import { buildContext } from './context.js';
 import { OPENBOT_SYSTEM_PROMPT, withGithubGitInstructions, withUserInstructions, } from './system-prompt.js';
-import { AUTO_MODEL_ID, isAutoModel, isRetryableModelError, missingByokApiKeyMessage, } from './auto-model.js';
+import { AUTO_MODEL_ID, isAutoModel, isRetryableModelError, missingByokApiKeyMessage, pickAutoModel, } from './auto-model.js';
+import { classifySpecialistHandoff, FAST_FORWARD_CLOSE_HINT, sanitizeThreadTitle, selectFastForwardCandidate, threadNeedsGeneratedTitle, } from './fast-forward.js';
 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 { readInvokeSurface, RESPOND_TOOL, surfaceTools } from './surface.js';
 async function buildSystemPrompt(state, storage, instructions, host) {
     const context = await buildContext(state, storage, host);
     const sections = [
@@ -16,8 +19,10 @@ async function buildSystemPrompt(state, storage, instructions, host) {
         '',
         context,
     ];
-    const threadState = state.threadDetails?.state;
-    sections.push(...threadNamingHint(threadState));
+    if (!readInvokeSurface(state.triggerEvent)) {
+        const threadState = state.threadDetails?.state;
+        sections.push(...threadNamingHint(threadState));
+    }
     return sections.join('\n');
 }
 function toAiTools(tools, args, flushPendingOutput) {
@@ -86,8 +91,145 @@ function toAiTools(tools, args, flushPendingOutput) {
     }
     return mapped;
 }
+async function executeCoordinatorTool(args, tools, name, input) {
+    const def = tools[name];
+    if (!def?.execute)
+        return;
+    const toolCallId = `ff_${randomUUID()}`;
+    const threadId = args.threadId;
+    const agentId = args.context.agentId;
+    await args.emit({
+        type: `action:${name}`,
+        data: input,
+        meta: { toolCallId, agentId, threadId },
+    });
+    try {
+        const result = await def.execute(input, {
+            agentId,
+            channelId: args.state.channelId,
+            threadId,
+            runId: args.state.runId,
+            toolCallId,
+            abortSignal: args.context.abortSignal,
+            storage: args.context.storage,
+            host: args.context.host,
+            publicBaseUrl: args.context.publicBaseUrl,
+            config: args.context.config,
+            state: args.state,
+            emit: args.emit,
+        });
+        const data = typeof result === 'string'
+            ? { success: true, output: result }
+            : { success: result.success !== false, ...result };
+        await args.emit({
+            type: `action:${name}:result`,
+            data,
+            meta: { toolCallId, agentId, threadId },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await args.emit({
+            type: `action:${name}:result`,
+            data: { success: false, error: message, output: message },
+            meta: { toolCallId, agentId, threadId },
+        });
+    }
+}
+async function suggestThreadTitle(args) {
+    const model = pickAutoModel({ authMode: args.authMode });
+    const result = await generateText({
+        model: resolveModel(model, { authMode: args.authMode }),
+        system: 'Name this job. Reply with a concise human title of at most 6 words. No quotes.',
+        prompt: args.prompt,
+        maxOutputTokens: 24,
+        abortSignal: args.signal,
+        reasoning: reasoningForModel(model),
+    });
+    return sanitizeThreadTitle(result.text);
+}
+/**
+ * On Auto, a first message in a dedicated Space that @mentions one installed
+ * agent can skip the coordinator and ask that specialist immediately.
+ * Returns true when the specialist already ran and the caller should close.
+ */
+async function* attemptFastForward(args, options) {
+    if (args.context.agentId !== options.host.orchestratorAgentId)
+        return false;
+    if (!options.tools.ask_agent?.execute || options.abortSignal?.aborted)
+        return false;
+    let installed = [];
+    try {
+        const agents = await options.storage.getAgents?.();
+        if (Array.isArray(agents)) {
+            installed = agents.flatMap((agent) => {
+                if (!agent || typeof agent.id !== 'string' || !agent.id)
+                    return [];
+                const name = typeof agent.name === 'string' && agent.name.trim() ? agent.name.trim() : agent.id;
+                return [{ id: agent.id, name }];
+            });
+        }
+    }
+    catch (error) {
+        console.warn('[openbot] fast-forward could not list agents', error);
+        return false;
+    }
+    const candidate = selectFastForwardCandidate({
+        model: options.model,
+        channelId: args.state.channelId,
+        orchestratorAgentId: options.host.orchestratorAgentId,
+        installedAgents: installed,
+        events: options.events,
+    });
+    if (!candidate)
+        return false;
+    const decision = await classifySpecialistHandoff({
+        prompt: candidate.prompt,
+        agentId: candidate.agentId,
+        agentName: candidate.agentName,
+        authMode: options.authMode,
+        env: args.context.env,
+        signal: options.abortSignal,
+    });
+    if (!decision.forward) {
+        console.info(`[openbot] fast-forward skipped: ${decision.reason}`);
+        return false;
+    }
+    console.info(`[openbot] fast-forward ${candidate.agentId} (self-answer ${decision.probability ?? 'n/a'})`);
+    yield {
+        type: 'agent:output',
+        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))
+            return;
+        const title = await suggestThreadTitle({
+            prompt: candidate.prompt,
+            authMode: options.authMode,
+            signal: options.abortSignal,
+        });
+        if (!title || options.abortSignal?.aborted)
+            return;
+        await executeCoordinatorTool(args, options.tools, 'set_thread_title', { title });
+    })().catch((error) => {
+        console.warn('[openbot] fast-forward title failed', error);
+    });
+    await executeCoordinatorTool(args, options.tools, 'ask_agent', {
+        agentId: candidate.agentId,
+        prompt: candidate.prompt,
+    });
+    await titleTask;
+    return true;
+}
 export async function* runOpenbotTurn(args, options) {
-    const { model: modelString = AUTO_MODEL_ID, authMode = 'byok', instructions, storage, toolDefinitions = {}, abortSignal, host, } = options;
+    const { model: modelString = AUTO_MODEL_ID, authMode = 'byok', instructions, storage, toolDefinitions: allToolDefinitions = {}, abortSignal, host, } = options;
+    // Asked inline from a UI surface: no thread history, a narrowed tool set, and
+    // the run ends when OpenBot calls `respond`.
+    const surface = readInvokeSurface(args.event);
+    const toolDefinitions = surface ? surfaceTools(allToolDefinitions) : allToolDefinitions;
     let configuredModelString = modelString;
     const isCreditsCloudAgent = (id) => host.isCloudSystemAgent(id ?? '') && authMode === 'credits';
     if (!storage || abortSignal?.aborted)
@@ -95,11 +237,13 @@ export async function* runOpenbotTurn(args, options) {
     const state = args.state;
     state.model = configuredModelString;
     const threadId = args.threadId || state.threadId;
-    const systemPrompt = await buildSystemPrompt(state, storage, instructions, host);
-    const events = await storage.getEvents({
-        channelId: state.channelId ?? '',
-        threadId,
-    });
+    let systemPrompt = await buildSystemPrompt(state, storage, instructions, host);
+    let events = surface
+        ? [args.event]
+        : await storage.getEvents({
+            channelId: state.channelId ?? '',
+            threadId,
+        });
     const hasAttachments = eventsHaveAttachments(events);
     const candidates = chooseTurnCandidates({ model: configuredModelString, events, authMode });
     const readImage = async (name) => {
@@ -136,6 +280,24 @@ export async function* runOpenbotTurn(args, options) {
         const missingKey = missingByokApiKeyMessage(candidates[0], { authMode });
         if (missingKey)
             throw new Error(missingKey);
+        const forwarded = !surface && (yield* attemptFastForward(args, {
+            model: configuredModelString,
+            authMode,
+            storage,
+            tools: toolDefinitions,
+            events: events,
+            abortSignal,
+            host,
+        }));
+        if (abortSignal?.aborted)
+            return;
+        if (forwarded) {
+            events = await storage.getEvents({
+                channelId: state.channelId ?? '',
+                threadId,
+            });
+            systemPrompt = `${await buildSystemPrompt(state, storage, instructions, host)}\n\n${FAST_FORWARD_CLOSE_HINT}`;
+        }
         let lastError;
         let started = false;
         for (let i = 0; i < candidates.length; i++) {
@@ -165,7 +327,7 @@ export async function* runOpenbotTurn(args, options) {
                     tools,
                     abortSignal,
                     reasoning: reasoningForModel(candidate),
-                    stopWhen: stepCountIs(20),
+                    stopWhen: surface ? [stepCountIs(8), hasToolCall(RESPOND_TOOL)] : stepCountIs(20),
                     allowSystemInMessages: true,
                 });
                 for await (const part of result.fullStream) {

package/dist/surface.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export const RESPOND_TOOL = 'respond';
+/**
+ * Tools OpenBot keeps when asked inline from a UI surface. Anything that writes
+ * to a thread, a Space, or todos stays out: there is no thread, and the human
+ * did not ask for a job.
+ */
+const SURFACE_TOOL_ALLOWLIST = new Set(['ask_agent', 'recall', RESPOND_TOOL]);
+/** The surface an invoke came from, when it did not come from a thread. */
+export function readInvokeSurface(event) {
+    const raw = event?.meta?.surface;
+    if (!raw || typeof raw.id !== 'string' || !raw.id)
+        return undefined;
+    return {
+        id: raw.id,
+        label: typeof raw.label === 'string' && raw.label ? raw.label : raw.id,
+        intent: typeof raw.intent === 'string' ? raw.intent : '',
+    };
+}
+const respondTool = {
+    description: 'Give the surface the value it asked for. Call exactly once, as your final action; the text is shown to the human as-is.',
+    inputSchema: z.object({
+        text: z.string().describe('The value itself, ready to use. No preamble or quotes.'),
+    }),
+    execute: () => 'Delivered.',
+};
+/** Narrows the coordinator's tools to the surface allowlist and adds `respond`. */
+export function surfaceTools(tools) {
+    const out = {};
+    for (const [name, def] of Object.entries(tools)) {
+        if (SURFACE_TOOL_ALLOWLIST.has(name))
+            out[name] = def;
+    }
+    out[RESPOND_TOOL] = respondTool;
+    return out;
+}
+/** System-prompt section that switches OpenBot from thread mode to inline mode. */
+export function surfaceSection(surface) {
+    return [
+        '## SURFACE',
+        `- You were asked inline from ${surface.label}, not in a thread. There is no job, thread status, title, or todo list here.`,
+        `- Task: ${surface.intent}`,
+        '- The context the surface sent is in the human message. Do this yourself — it is a small, direct ask — and use `ask_agent` only when the answer needs something you cannot see.',
+        `- Finish by calling \`${RESPOND_TOOL}\` once with the result. Do not write anything else.`,
+    ].join('\n');
+}

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**: Use `## SPACES` to see where work belongs. If the human's intent clearly fits a different existing Space than the one you are in — especially project work posted in `#general` — call `suggest_space` with that Space id, a self-contained version of their ask, and a one-line reason, then stop. Do not also explain it in prose, and do not `ask_agent` in this thread. Do not move or copy their message. In `#general`, handle questions, listings, setup, and routing only; do not run project execution there. If they are already in the right Space, continue with `ask_agent`. If no Space fits, propose a concrete name and why, then wait for the human to agree before `create_channel` — unless they already named a new Space or explicitly asked you to create it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`). Never call `suggest_space` for a Space that is not in `## SPACES`.",
+    "2. **Right Space**: Use `## SPACES` to see where work belongs. If the human's intent clearly fits a different existing Space than the one you are in — especially project work posted in `#general` — explain in text which Space it belongs in and why, then wait for the human to continue there. Do not move or copy their message. In `#general`, handle questions, listings, setup, and routing only; do not run project execution there. If they are already in the right Space, continue with `ask_agent`. If no Space fits, propose a concrete name and why, then wait for the human to agree before `create_channel` — unless they already named a new Space or explicitly asked you to create 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**: 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.",
@@ -42,7 +42,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- The current status is injected each turn as `## THREAD STATUS`.",
     "",
     "# OPERATIONAL GUIDELINES",
-    '- **Spaces**: Work lives in Spaces (product name for channels). `#general` is dispatch — setup, questions, listings, routing, and "what should we do next." Project, coding, design, and ops work belongs in a dedicated Space. Prefer existing Spaces. When the human is in the wrong existing Space, call `suggest_space` and stop so they can edit the Space and the message, then send it as a new thread. Never auto-move threads or messages. Create a new Space only when the human asked for one, or they agreed after you suggested it.',
+    '- **Spaces**: Work lives in Spaces (product name for channels). `#general` is dispatch — setup, questions, listings, routing, and "what should we do next." Project, coding, design, and ops work belongs in a dedicated Space. Prefer existing Spaces. When the human is in the wrong existing Space, explain the appropriate Space in text and wait for them to continue there. Never auto-move threads or messages. 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.",
     "- **Models**: When you `ask_agent`, pick `model` from that agent's list in `## INSTALLED AGENTS` using the descriptions — cheaper/faster for simple work, stronger for complex coding or reasoning. Omit `model` to use their default. Do not reuse another agent's ids.",
     "- **Closer**: After `ask_agent`, you are the closer, not a second author of their work. Don't repeat. Add or close. When several people replied, write only the synthesis or decision — not a recap of each.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.2.19",
+  "version": "1.3.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": "^1.3.0"
+    "@meetopenbot/plugin-sdk": "^1.4.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",

package/dist/tools/suggest-space.js

@@ -1,115 +0,0 @@
-import z from 'zod';
-import { isPlaceholderSpaceId } from '../space-id.js';
-/** Widget metadata the client uses to render a Space handoff card. */
-export const SPACE_HANDOFF_TYPE = 'space_handoff';
-const MAX_MESSAGE_LENGTH = 8000;
-const MAX_REASON_LENGTH = 240;
-function normalizeChannelId(raw) {
-    return raw
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/(^-|-$)/g, '');
-}
-function spaceOptionLabel(space) {
-    const name = space.name?.trim();
-    if (!name || name.toLowerCase() === space.id)
-        return `#${space.id}`;
-    return `#${space.id} · ${name}`;
-}
-function failure(channelId, error) {
-    return { success: false, channelId, error, output: error };
-}
-async function suggestSpace(rawArgs, ctx) {
-    const data = (rawArgs ?? {});
-    const channelId = normalizeChannelId(typeof data.channelId === 'string' ? data.channelId : '');
-    const message = typeof data.message === 'string' ? data.message.trim() : '';
-    const reason = typeof data.reason === 'string' ? data.reason.trim().slice(0, MAX_REASON_LENGTH) : '';
-    const currentId = normalizeChannelId(ctx.channelId ?? ctx.state.channelId ?? '');
-    if (!channelId)
-        return failure('', 'channelId is required');
-    if (isPlaceholderSpaceId(channelId)) {
-        return failure(channelId, `Refused to suggest #${channelId}: that looks like a placeholder, not a real Space.`);
-    }
-    if (!message)
-        return failure(channelId, 'message is required');
-    if (message.length > MAX_MESSAGE_LENGTH) {
-        return failure(channelId, `message must be ${MAX_MESSAGE_LENGTH} characters or fewer.`);
-    }
-    if (currentId && channelId === currentId) {
-        return failure(channelId, `Already in #${channelId}. Continue here with ask_agent.`);
-    }
-    const channels = (await ctx.storage.getChannels());
-    const target = channels.find((space) => normalizeChannelId(space.id) === channelId);
-    if (!target) {
-        return failure(channelId, `Space #${channelId} does not exist. Suggest a name and wait before create_channel.`);
-    }
-    const targetId = target.id;
-    const options = channels
-        .filter((space) => normalizeChannelId(space.id) !== currentId)
-        .map((space) => ({ label: spaceOptionLabel(space), value: space.id }));
-    const threadId = ctx.threadId ?? ctx.state.threadId;
-    const description = reason || `This belongs in #${targetId}.`;
-    await ctx.emit({
-        type: 'client:ui:widget',
-        data: {
-            widgetId: ctx.toolCallId ?? `suggest_space:${targetId}`,
-            kind: 'form',
-            title: `Run this in #${targetId}`,
-            description,
-            fields: [
-                {
-                    id: 'channelId',
-                    label: 'Space',
-                    type: 'select',
-                    required: true,
-                    defaultValue: targetId,
-                    options,
-                },
-                {
-                    id: 'message',
-                    label: 'Message',
-                    type: 'textarea',
-                    required: true,
-                    defaultValue: message,
-                    placeholder: 'What should OpenBot do there?',
-                },
-            ],
-            actions: [
-                {
-                    id: 'start_in_space',
-                    label: 'Send',
-                    variant: 'primary',
-                    value: { channelId: targetId },
-                },
-            ],
-            display: 'expanded',
-            state: 'open',
-            metadata: { type: SPACE_HANDOFF_TYPE, channelId: targetId },
-        },
-        meta: {
-            agentId: ctx.agentId,
-            ...(threadId ? { threadId } : {}),
-        },
-    });
-    const output = `Showed a handoff to #${targetId}. Stop. Do not ask_agent in this thread and do not explain the handoff in prose. The human sends the message there if they confirm.`;
-    return { success: true, channelId: targetId, output };
-}
-export const suggestSpaceTools = {
-    suggest_space: {
-        description: 'When the human is in the wrong existing Space, show a card with that Space and a self-contained version of their ask. They can edit both, then send it as a new thread there. Call this and stop. Do not ask_agent in this thread. Only use a Space id from ## SPACES, never the current Space, and never a Space you have not created yet.',
-        inputSchema: z.object({
-            channelId: z
-                .string()
-                .describe('Existing Space id from ## SPACES. Not the Space you are in.'),
-            message: z
-                .string()
-                .describe("The human's ask, rewritten so it stands alone in that Space. They can edit it before sending."),
-            reason: z
-                .string()
-                .optional()
-                .describe('One line on why this Space fits. Shown on the card.'),
-        }),
-        execute: suggestSpace,
-    },
-};