openmausbot 0.1.85 → 0.1.87

package/dist-server/shared/ask-question.js

@@ -29,7 +29,7 @@ function text(value, limit) {
     if (typeof value !== "string")
         return undefined;
     const trimmed = value.trim();
-    return trimmed ? trimmed.slice(0, limit) : undefined;
+    return trimmed ? trimmed.slice(0, limit).trim() : undefined;
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -94,6 +94,36 @@ export function parseAskQuestions(input) {
     }
     return questions.length ? questions : null;
 }
+/** The fenced block a turn-boundary agent ends its run with when it wants
+ * to ask the person something (the BoxAgent transport): the harness cannot
+ * pause mid-run, so the questions ride the final output and OMB parses them
+ * at settle. The block is model-authored — untrusted input like any tool
+ * call — so its body runs through parseAskQuestions and the same caps. */
+const OMB_ASK_FENCE = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}\2[ \t]*(?=\r?\n|$)/;
+const OMB_ASK_FENCE_GLOBAL = new RegExp(OMB_ASK_FENCE.source, OMB_ASK_FENCE.flags + "g");
+/** The questions inside the first fenced omb-ask block in an output, or
+ * null when there is nothing worth showing (no fence, invalid JSON, or no
+ * entry that parses as a question). The first fence wins: a second block
+ * in the same output is ignored, not merged. */
+export function parseOmbAskQuestions(output) {
+    const match = OMB_ASK_FENCE.exec(output);
+    if (!match)
+        return null;
+    try {
+        return parseAskQuestions(JSON.parse(match[3]));
+    }
+    catch {
+        return null;
+    }
+}
+/** The output with its omb-ask block(s) removed, for display: the person
+ * reads the prose around the ask, never the raw protocol JSON. Text
+ * without a block is returned untouched. */
+export function stripOmbAskBlock(output) {
+    if (!OMB_ASK_FENCE.test(output))
+        return output;
+    return output.replace(OMB_ASK_FENCE_GLOBAL, "").replace(/\n{3,}/g, "\n\n").trim();
+}
 /** The one line the card subtitle and a spoken prompt show. */
 export function askQuestionSummary(questions) {
     const first = questions[0]?.question ?? "";
@@ -139,6 +169,61 @@ export function questionChoices(questions) {
         return undefined;
     return only.options.map((option) => option.label);
 }
+/** The chat runtime's own ask tool: the OpenAI-compatible engines'
+ * counterpart of ASK_USER_QUESTION. Named ask_user so the ASKS_A_PERSON
+ * backstop already covers it — no auto mode may answer a question. */
+export const ASK_USER_TOOL = "ask_user";
+/** The ask_user definition shared by every chat-runtime engine, shaped for
+ * an OpenAI function-calling tool list. The schema states the caps; the
+ * parser enforces them again on arrival, because a model-authored argument
+ * is a request to follow the schema, not a guarantee that it did. */
+export const ASK_USER_TOOL_DEFINITION = {
+    type: "function",
+    function: {
+        name: ASK_USER_TOOL,
+        description: "Ask the person questions when the decision is theirs. Offer concrete options where they exist; they can always answer in their own words. Ask up to six questions in one call rather than one at a time.",
+        parameters: {
+            type: "object",
+            properties: {
+                questions: {
+                    type: "array",
+                    minItems: 1,
+                    maxItems: MAX_QUESTIONS,
+                    items: {
+                        type: "object",
+                        properties: {
+                            question: { type: "string", description: "The question to show the person." },
+                            header: { type: "string", description: "A short label for the question's tab." },
+                            multiSelect: { type: "boolean", description: "Whether several options may be picked." },
+                            options: {
+                                type: "array",
+                                maxItems: MAX_OPTIONS,
+                                description: "Suggested answers; the person may always write their own.",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        label: { type: "string" },
+                                        description: { type: "string" },
+                                    },
+                                    required: ["label"],
+                                    additionalProperties: false,
+                                },
+                            },
+                        },
+                        required: ["question"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["questions"],
+            additionalProperties: false,
+        },
+    },
+};
+/** The synthetic tool string for an ask parsed out of model-authored final
+ * output (the BoxAgent turn-held transport): there is no tool call to name,
+ * but the event and the ASKS_A_PERSON backstop need one string. */
+export const OMB_ASK_TOOL = "omb-ask";
 /** The lead-in on a formatted answer. It exists for the model — the answer
  * is delivered on the deny channel, so it has to say what it is — and the
  * card strips it back off when it shows the person what they sent. */
@@ -164,6 +249,23 @@ export function formatQuestionAnswers(questions, answers) {
 export function answerWithoutPreamble(answer) {
     return answer.startsWith(`${ANSWER_PREAMBLE}\n\n`) ? answer.slice(ANSWER_PREAMBLE.length + 2) : answer;
 }
+/** The longest formatted answer OMB will echo back into a follow-up prompt
+ * (the BoxAgent continuation). formatQuestionAnswers itself does not
+ * truncate — the tool-result channel has no stated limit — but a prompt is
+ * not the place to find one: six answers at the custom-answer cap is the
+ * most a legitimate reply weighs, so that is the ceiling. */
+export const MAX_ANSWER_ECHO = 6 * MAX_CUSTOM_ANSWER;
+/** Cap a formatted answer for echoing into a follow-up prompt. An over-cap
+ * echo is cut back to the last whole block so no partial answer reads as
+ * one, and says it was truncated. */
+export function capAnswerEcho(answer, limit = MAX_ANSWER_ECHO) {
+    if (answer.length <= limit)
+        return answer;
+    const cut = answer.slice(0, limit);
+    const boundary = cut.lastIndexOf("\n\nQ: ");
+    const kept = boundary > 0 ? cut.slice(0, boundary) : cut;
+    return kept + "\n\n[answer truncated]";
+}
 /**
  * The answer text, read back as one value per question.
  *
@@ -180,21 +282,95 @@ export function answerWithoutPreamble(answer) {
  * With more than one there is, and nothing is filed.
  */
 export function questionAnswersByQuestion(message, questions) {
-    const answers = {};
-    const known = new Map(questions.map((entry) => [entry.question, entry.question]));
-    for (const block of message.split("\n\n")) {
-        const match = /^Q: ([\s\S]+?)\nA: ([\s\S]+)$/.exec(block.trim());
-        if (!match)
+    return questionAnswersById(message, questions.map(question => ({ id: question.question, question })));
+}
+/** Longest protocol id accepted. Ids are harness-internal keys, never shown
+ * on the card, but they ride the reply — so they are capped like the rest. */
+const MAX_QUESTION_ID = 200;
+/** Parse a protocol questions array whose entries carry their own string
+ * ids (codex's item/tool/requestUserInput). The same caps and skip rules
+ * as parseAskQuestions; an entry without both a usable id and a usable
+ * question is skipped rather than fatal, and nothing answerable parses to
+ * null. */
+export function parseProtocolAskQuestions(entries) {
+    if (!Array.isArray(entries))
+        return null;
+    const parsed = [];
+    const seenIds = new Set();
+    for (const raw of entries) {
+        if (!isRecord(raw))
+            continue;
+        const question = parseQuestion(raw);
+        // The id is opaque protocol data echoed back verbatim in the answer, so
+        // it is preserved exactly as sent — trimmed only to reject an
+        // all-whitespace id — and an overlong id is rejected whole rather than
+        // truncated. A duplicate id fails the whole request: two questions
+        // cannot share one answer slot, and silently dropping one would ask
+        // the person a question whose answer could never be delivered.
+        const id = raw.id;
+        if (!question || typeof id !== "string" || !id.trim() || id.length > MAX_QUESTION_ID)
+            continue;
+        if (seenIds.has(id))
+            return null;
+        seenIds.add(id);
+        parsed.push({ id, question });
+        if (parsed.length === MAX_QUESTIONS)
+            break;
+    }
+    return parsed.length ? parsed : null;
+}
+/**
+ * The id-keyed counterpart of questionAnswersByQuestion, for a protocol
+ * that answers by id (codex's requestUserInput) rather than by question
+ * text.
+ *
+ * Each protocol entry's id is paired with the AskQuestion parsed from that
+ * same entry, so a Q:/A: block the card wrote is matched against the text
+ * that produced it and filed under the id that asked. Only ids with a real
+ * block are answered — a question left unanswered gets no entry rather
+ * than a guess. When the reply carries no blocks at all, the flat path
+ * applies with exactly one question: the whole message is that question's
+ * answer, as it is for a phone or an older client. With more than one,
+ * nothing is filed.
+ */
+export function questionAnswersById(message, questions) {
+    const answers = Object.create(null);
+    const idByText = new Map();
+    const ambiguous = new Set();
+    for (const { id, question } of questions) {
+        if (idByText.has(question.question)) {
+            // Two questions with identical text cannot be told apart in a block;
+            // answering either id would be a guess, so neither is answered.
+            ambiguous.add(question.question);
+            continue;
+        }
+        idByText.set(question.question, id);
+    }
+    // A block runs from one Q: header to the next (blank lines inside an
+    // answer are the answer's, not block boundaries), so the reply is scanned
+    // for header-to-header spans instead of split on every blank line.
+    const blocks = message.matchAll(/(?:^|\n\n)Q: ([\s\S]+?)\nA: ([\s\S]*?)(?=\n\nQ: |$)/g);
+    let sawBlock = false;
+    for (const match of blocks) {
+        sawBlock = true;
+        const asked = match[1].trim();
+        if (ambiguous.has(asked))
             continue;
-        // Only a question this ask actually posed. An unrecognized block is
-        // dropped rather than filed under a key the tool never asked about.
-        const question = known.get(match[1].trim());
-        if (question)
-            answers[question] = match[2].trim();
+        const id = idByText.get(asked);
+        const answer = match[2].trim();
+        // A blank A: is no answer: the id stays unanswered rather than filed
+        // as an empty string.
+        if (id && answer)
+            answers[id] = answer;
     }
     if (Object.keys(answers).length)
         return answers;
+    // A structured reply that matched a block is authoritative even when it
+    // answered nothing: falling through to the flat fallback would file the
+    // literal Q:/A: text as the person's answer.
+    if (sawBlock)
+        return {};
     const only = questions.length === 1 ? questions[0] : undefined;
     const flat = message.trim();
-    return only && flat ? { [only.question]: flat } : {};
+    return only && flat ? { [only.id]: flat } : {};
 }

package/dist-server/shared/bot-profile.js

@@ -9,3 +9,18 @@ export const BOT_PROFILE_LIMITS = {
     voice: 200,
     soul: 24_000,
 };
+/** A name or title is quoted inside prompts and cards as one line — a
+ * roster entry, a "Name: …" speaker line, the bracketed provenance note.
+ * Text that can break out of that line (a newline, a control byte, the
+ * Unicode separators) is refused at the door rather than flattened later,
+ * so what the person sees in the sidebar is what every prompt sees too.
+ * Written as a scan because a control-character class is the kind of
+ * literal the linter (rightly) refuses. */
+export function fitsOnOneLine(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        if (code < 0x20 || (code >= 0x7f && code <= 0x9f) || code === 0x2028 || code === 0x2029)
+            return false;
+    }
+    return true;
+}

package/dist-server/shared/command-allowlist.js

@@ -0,0 +1 @@
+export {};

package/dist-server/shared/credential-request.js

@@ -14,7 +14,7 @@ export const CREDENTIAL_TARGETS = {
         label: "Box API key",
         description: "Gives bots an isolated cloud computer when Box is selected.",
         placeholder: "Paste your Box API key",
-        helpUrl: "https://docs.ascii.dev/box/api-keys",
+        helpUrl: "https://docs.boat.dev/api-keys",
     },
     opencodeGoApiKey: {
         label: "OpenCode API key",

package/dist-server/shared/mention-boundary.js

@@ -0,0 +1,15 @@
+// Keep mention recognition identical in the renderer and server routing.
+// Deliberately allow only opening punctuation/Markdown markers here: `/@bot`
+// remains a URL path, while `(@bot)`, `【@bot】`, and `**@bot**` are tags.
+const OPENING_MENTION_BOUNDARY = /[(*_~[{<'"\u2018\u201c\u3008\u300a\u300c\u300e\u3010\uff08]/u;
+/** Return whether an at-sign starts a standalone mention at this offset. */
+export function isMentionBoundary(text, at) {
+    if (at === 0)
+        return true;
+    const before = text[at - 1];
+    return /\s/u.test(before) || OPENING_MENTION_BOUNDARY.test(before);
+}
+/** A matched name must not be the prefix of a longer Unicode word. */
+export function isMentionNameContinuation(value) {
+    return value !== undefined && /^[\p{L}\p{N}\p{M}_]/u.test(value);
+}