@meetopenbot/openbot 1.2.18 → 1.2.20

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/runtime.js

@@ -1,10 +1,12 @@
-import { streamText, stepCountIs } from 'ai';
+import { randomUUID } from 'node:crypto';
+import { generateText, 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';
@@ -86,6 +88,139 @@ 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;
     let configuredModelString = modelString;
@@ -95,8 +230,8 @@ 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({
+    let systemPrompt = await buildSystemPrompt(state, storage, instructions, host);
+    let events = await storage.getEvents({
         channelId: state.channelId ?? '',
         threadId,
     });
@@ -136,6 +271,24 @@ export async function* runOpenbotTurn(args, options) {
         const missingKey = missingByokApiKeyMessage(candidates[0], { authMode });
         if (missingKey)
             throw new Error(missingKey);
+        const forwarded = 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++) {

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` — do not move or copy their message. Reply in plain text: name the Space (e.g. `#checkout`), why it fits, and that they can open that Space and send the same ask there to start a thread. 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`).",
+    "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 Space, tell them which Space to use and let them post 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.',
+    '- **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.18",
+  "version": "1.2.20",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",