@amoshydra/oktoso 0.1.3 → 0.1.4

package/dist/hub.js

@@ -21289,7 +21289,8 @@ var zSendAnswer = external_exports.object({
 });
 var zSendInput = external_exports.object({
   text: external_exports.string().min(1),
-  answer: zSendAnswer.optional()
+  answer: zSendAnswer.optional(),
+  answers: external_exports.array(zSendAnswer).min(1).max(20).optional()
 });
 var zSendResult = external_exports.object({
   accepted: external_exports.boolean(),
@@ -21342,6 +21343,20 @@ var zQuestionPrompt = external_exports.object({
 var zQuestionResponse = external_exports.object({
   data: zQuestionPrompt.nullable()
 });
+var zPendingQuestionSummary = external_exports.object({
+  sessionRef: external_exports.string(),
+  messageId: external_exports.string(),
+  revision: external_exports.string(),
+  askedAt: external_exports.number().int(),
+  questionCount: external_exports.number().int().min(1),
+  text: external_exports.string(),
+  context: external_exports.string().optional(),
+  attentionID: external_exports.string().optional()
+});
+var zQuestionSummaryPage = external_exports.object({
+  data: external_exports.array(zPendingQuestionSummary),
+  failed: external_exports.array(external_exports.string()).optional()
+});
 
 // packages/contracts/src/events.ts
 var zHubEventType = external_exports.enum([
@@ -26769,7 +26784,10 @@ function splitSentences(value) {
   return (normalized.match(/[^.!?]+[.!?]+|[^.!?]+$/g) ?? []).map((sentence) => sentence.trim()).filter(Boolean);
 }
 function cleanQuestion(value) {
-  return value.trim().replace(/^[“"'‘]+/, "").replace(/[”"'’]+$/, "").replace(/\s+/g, " ").trim();
+  return value.trim().replace(/^[“"'‘]+/, "").replace(/[”"'’]+$/, "").replace(/^(?:\d+[.)]|[A-Za-z][.)]|[-*•])\s+/, "").replace(/\s+/g, " ").trim();
+}
+function questionCore(value) {
+  return value.replace(/^(?:and|also|then|so)\s+/i, "").trim();
 }
 function truncate2(value, max) {
   const clean = value.replace(/\s+/g, " ").trim();
@@ -26814,7 +26832,8 @@ function listGroups(lines) {
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index] ?? "";
     const item = parseListLine(line);
-    if (item) {
+    const questionItem = item ? /\?\s*$/.test(item) && !COURTESY.test(item) : false;
+    if (item && !questionItem) {
       if (!current) {
         current = { start: index, end: index, items: [] };
       }
@@ -26910,15 +26929,15 @@ function makeChoice(messageID, questionIndex, index, text, options) {
     ...risk.sensitive ? { sensitive: true } : {}
   };
 }
-function buildQuestion(message, questionText, context, lines, rawText) {
-  const items = listItemsNearQuestion(lines, questionText);
+function buildQuestion(message, questionText, context, items, rawText, questionIndex) {
   let choices = [];
   let kind = "freeform";
   let source = "heuristic";
   let confidence = "high";
+  const core = questionCore(questionText);
   if (items) {
     choices = items.map(
-      (item, index) => makeChoice(message.id, 0, index, item, {
+      (item, index) => makeChoice(message.id, questionIndex, index, item, {
         kind: "choice",
         source: "explicit"
       })
@@ -26927,10 +26946,10 @@ function buildQuestion(message, questionText, context, lines, rawText) {
     source = "explicit";
     confidence = "high";
   } else {
-    const alternatives = inlineAlternatives(questionText) ?? (/\b(which|what|choose|prefer|option)\b/i.test(questionText) ? contextAlternatives(context) : void 0);
+    const alternatives = inlineAlternatives(core) ?? (/\b(which|what|choose|prefer|option)\b/i.test(core) ? contextAlternatives(context) : void 0);
     if (alternatives) {
       choices = alternatives.map(
-        (item, index) => makeChoice(message.id, 0, index, item, {
+        (item, index) => makeChoice(message.id, questionIndex, index, item, {
           kind: "choice",
           source: "heuristic"
         })
@@ -26938,15 +26957,15 @@ function buildQuestion(message, questionText, context, lines, rawText) {
       kind = "choice";
       source = "heuristic";
       confidence = "medium";
-    } else if (AUXILIARY.test(questionText) && !INFORMATION_REQUEST.test(questionText)) {
+    } else if (AUXILIARY.test(core) && !INFORMATION_REQUEST.test(core)) {
       const confirm = isDestructive(questionText) || isDestructive(rawText);
       choices = [
-        makeChoice(message.id, 0, 0, "Yes", {
+        makeChoice(message.id, questionIndex, 0, "Yes", {
           kind: "boolean",
           source: "heuristic",
           confirm
         }),
-        makeChoice(message.id, 0, 1, "No", {
+        makeChoice(message.id, questionIndex, 1, "No", {
           kind: "boolean",
           source: "heuristic"
         })
@@ -26958,7 +26977,7 @@ function buildQuestion(message, questionText, context, lines, rawText) {
   }
   const risk = riskFor(questionText, choices, rawText);
   return {
-    id: `${message.id}:q0`,
+    id: `${message.id}:q${questionIndex}`,
     text: questionText,
     ...context ? { context } : {},
     kind,
@@ -26983,6 +27002,70 @@ function choiceCueLine(lines) {
   }
   return void 0;
 }
+function isQuotedQuestion(sentence) {
+  return /(?:asked|said|wrote|quoted)\s*[:,]?\s*[“"]/i.test(sentence);
+}
+function questionEntries(lines) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (text, line) => {
+    if (!text || seen.has(text)) return;
+    seen.add(text);
+    entries.push({ text, line });
+  };
+  for (const [index, line] of lines.entries()) {
+    const item = parseListLine(line);
+    if (!item) continue;
+    if (!/\?\s*$/.test(item) || COURTESY.test(item)) continue;
+    if (isQuotedQuestion(line)) continue;
+    add(cleanQuestion(item), index);
+  }
+  const prose = lines.filter(
+    (line) => !parseListLine(line) && !/^\s*[-*]\s+\[[ xX]\]/.test(line)
+  ).join(" ");
+  for (const sentence of splitSentences(prose)) {
+    const trimmed = sentence.trim();
+    if (!/\?\s*$/.test(trimmed) || COURTESY.test(trimmed)) continue;
+    if (isQuotedQuestion(trimmed)) continue;
+    const text = cleanQuestion(trimmed);
+    if (!text) continue;
+    const prefix = text.slice(0, Math.min(24, text.length)).toLowerCase();
+    const line = lines.findIndex(
+      (value) => value.toLowerCase().includes(prefix)
+    );
+    add(text, line >= 0 ? line : 0);
+  }
+  return entries.sort((left, right) => left.line - right.line);
+}
+function multipleChoiceItems(lines, entry, nextLine, previousLine, groups, used) {
+  const after = groups.find(
+    (group2) => !used.has(group2.start) && group2.start > entry.line && group2.start <= entry.line + 3 && group2.end < nextLine
+  );
+  const before = groups.find(
+    (group2) => !used.has(group2.start) && group2.end < entry.line && entry.line - group2.end <= 3 && group2.start > previousLine
+  );
+  const group = after ?? before;
+  if (!group) return void 0;
+  if (group.items.length < 2 || group.items.length > 6) return void 0;
+  if (group.items.some((item) => item.length < 2 || item.length > 80)) {
+    return void 0;
+  }
+  if (group.items.some(
+    (item) => /\?\s*$/.test(item) && !COURTESY.test(item)
+  )) {
+    return void 0;
+  }
+  const core = questionCore(entry.text);
+  const cue = /\b(which|choose|pick|prefer|option|one of)\b/i.test(core) || /:\s*$/.test(entry.text);
+  if (!cue && AUXILIARY.test(core)) {
+    if (group.items.some((item) => IMPERATIVE.test(item))) return void 0;
+    if (group.items.some((item) => item.split(/\s+/).length > 8)) {
+      return void 0;
+    }
+  }
+  used.add(group.start);
+  return group.items;
+}
 function parseQuestion(messages, options) {
   const latest = messages[0];
   if (!latest || latest.role !== "assistant" || latest.streaming === true) {
@@ -26999,68 +27082,116 @@ function parseQuestion(messages, options) {
   const paragraph = paragraphs[paragraphIndex];
   if (!paragraph) return null;
   const localLines = stripNonProseLines(stripFencedCode(raw2)).split("\n");
-  const proseParagraph = paragraph.split("\n").filter(
+  const paragraphLines = paragraph.split("\n");
+  const entries = questionEntries(paragraphLines);
+  const proseParagraph = paragraphLines.filter(
     (line) => !parseListLine(line) && !/^\s*[-*]\s+\[[ xX]\]/.test(line)
   ).join("\n").trim();
   const sentences = splitSentences(proseParagraph || paragraph);
-  const questionIndexes = sentences.map((sentence, index) => ({ sentence, index })).filter(
-    ({ sentence }) => /\?\s*$/.test(sentence) && !COURTESY.test(sentence.trim())
-  );
-  if (questionIndexes.length > 1) {
-    return null;
-  }
-  let question = "";
-  let context;
-  if (questionIndexes.length === 1) {
-    const questionIndex = questionIndexes[0].index;
-    question = cleanQuestion(sentences[questionIndex] ?? "");
-    if (!question) return null;
-    const questionSentence = sentences[questionIndex] ?? "";
-    if (/(?:asked|said|wrote|quoted)\s*[:,]?\s*[“"]/i.test(questionSentence)) {
-      return null;
+  let questions;
+  if (entries.length > 1) {
+    if (entries.length > 20) return null;
+    const groups = listGroups(paragraphLines);
+    const used = /* @__PURE__ */ new Set();
+    questions = [];
+    for (const [index, entry] of entries.entries()) {
+      const nextLine = entries[index + 1]?.line ?? paragraphLines.length;
+      const previousLine = entries[index - 1]?.line ?? -1;
+      const items = multipleChoiceItems(
+        paragraphLines,
+        entry,
+        nextLine,
+        previousLine,
+        groups,
+        used
+      );
+      const pending = buildQuestion(
+        latest,
+        entry.text,
+        void 0,
+        items,
+        raw2,
+        index
+      );
+      if (!pending) return null;
+      questions.push(pending);
     }
-    const trailing = sentences.slice(questionIndex + 1).filter(
+  } else if (entries.length === 1) {
+    const entry = entries[0];
+    const questionIndex = sentences.findIndex(
+      (sentence) => cleanQuestion(sentence) === entry.text
+    );
+    const trailing = questionIndex >= 0 ? sentences.slice(questionIndex + 1).filter(
       (sentence) => !/^(let me know|thanks|thank you|cheers|please let me know)\b/i.test(
         sentence
       )
-    );
+    ) : [];
     if (trailing.length > 2) return null;
-    const previous = sentences[questionIndex - 1]?.trim();
-    context = previous && previous.length <= 120 && !COURTESY.test(previous) ? previous : void 0;
+    const previous = questionIndex > 0 ? sentences[questionIndex - 1]?.trim() : void 0;
+    const context = previous && previous.length <= 120 && !COURTESY.test(previous) ? previous : void 0;
+    const pending = buildQuestion(
+      latest,
+      entry.text,
+      context,
+      listItemsNearQuestion(localLines, entry.text),
+      raw2,
+      0
+    );
+    if (!pending) return null;
+    questions = [pending];
   } else {
-    question = choiceCueLine(localLines) ?? "";
+    const question = choiceCueLine(localLines) ?? "";
     if (!question) return null;
+    const pending = buildQuestion(
+      latest,
+      question,
+      void 0,
+      listItemsNearQuestion(localLines, question),
+      raw2,
+      0
+    );
+    if (!pending) return null;
+    questions = [pending];
   }
-  const pending = buildQuestion(
-    latest,
-    question,
-    context,
-    localLines,
-    raw2
-  );
-  if (!pending) return null;
   const hash2 = createHash("sha256").update(raw2).digest("hex").slice(0, 8);
   return {
     sessionRef: options.sessionRef,
     messageId: latest.id,
     revision: `${latest.id}:${hash2}`,
     askedAt: latest.createdAt,
-    questions: [pending],
+    questions,
     ...options.attentionID ? { attentionID: options.attentionID } : {},
     generatedAt: options.now ?? Date.now()
   };
 }
 
 // packages/hub/src/services/question-service.ts
+var MAX_SUMMARY_REFS = 10;
+function summarize(prompt) {
+  const first = prompt.questions[0];
+  return {
+    sessionRef: prompt.sessionRef,
+    messageId: prompt.messageId,
+    revision: prompt.revision,
+    askedAt: prompt.askedAt,
+    questionCount: prompt.questions.length,
+    text: first.text,
+    ...first.context ? { context: first.context } : {},
+    ...prompt.attentionID ? { attentionID: prompt.attentionID } : {}
+  };
+}
 var QuestionService = class {
   constructor(sessions, options = {}) {
     this.sessions = sessions;
     this.ttlMs = options.ttlMs ?? 3e4;
+    this.summaryTtlMs = options.summaryTtlMs ?? 15e3;
     this.now = options.now ?? Date.now;
   }
   sessions;
   cache = /* @__PURE__ */ new Map();
+  summaryCache = /* @__PURE__ */ new Map();
   ttlMs;
+  summaryTtlMs;
   now;
   async get(ref) {
     const page = await this.sessions.messages(ref, {
@@ -27068,13 +27199,22 @@ var QuestionService = class {
       order: "desc"
     });
     const latest = page.data[0];
-    if (!latest) return null;
-    if (latest.streaming === true) return null;
+    if (!latest) {
+      this.rememberSummary(ref, null);
+      return null;
+    }
+    if (latest.streaming === true) {
+      this.rememberSummary(ref, null);
+      return null;
+    }
     const text = latest.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
     const hash2 = createHash2("sha256").update(text).digest("hex").slice(0, 8);
     const key = `${ref}:${latest.id}:${hash2}`;
     const cached2 = this.cache.get(key);
-    if (cached2 && cached2.expiresAt > this.now()) return cached2.value;
+    if (cached2 && cached2.expiresAt > this.now()) {
+      this.rememberSummary(ref, cached2.value);
+      return cached2.value;
+    }
     const value = parseQuestion(page.data, {
       sessionRef: ref,
       now: this.now()
@@ -27087,10 +27227,58 @@ var QuestionService = class {
       const oldest = this.cache.keys().next().value;
       if (oldest) this.cache.delete(oldest);
     }
+    this.rememberSummary(ref, value);
     return value;
   }
+  /**
+   * Cheap discovery for the glass home and inbox. Results are cached briefly
+   * and provider failures are reported separately so callers do not treat an
+   * outage as a resolved question.
+   */
+  async summaries(refs) {
+    const unique = [...new Set(refs.map((ref) => ref.trim()).filter(Boolean))];
+    const limited = unique.slice(0, MAX_SUMMARY_REFS);
+    const failed = [];
+    const results = await Promise.all(
+      limited.map(async (ref) => {
+        const cached2 = this.summaryCache.get(ref);
+        if (cached2 && cached2.expiresAt > this.now()) return cached2.value;
+        try {
+          const prompt = await this.get(ref);
+          return prompt ? summarize(prompt) : null;
+        } catch {
+          failed.push(ref);
+          return null;
+        }
+      })
+    );
+    return {
+      data: results.filter(
+        (item) => item !== null
+      ),
+      failed
+    };
+  }
   clear() {
     this.cache.clear();
+    this.summaryCache.clear();
+  }
+  invalidate(ref) {
+    if (ref) {
+      this.summaryCache.delete(ref);
+      return;
+    }
+    this.summaryCache.clear();
+  }
+  rememberSummary(ref, prompt) {
+    this.summaryCache.set(ref, {
+      value: prompt ? summarize(prompt) : null,
+      expiresAt: this.now() + this.summaryTtlMs
+    });
+    if (this.summaryCache.size > 100) {
+      const oldest = this.summaryCache.keys().next().value;
+      if (oldest) this.summaryCache.delete(oldest);
+    }
   }
 };
 
@@ -29256,7 +29444,7 @@ var IdempotencyService = class {
 };
 
 // package.json
-var version2 = "0.1.3";
+var version2 = "0.1.4";
 
 // packages/hub/src/version.ts
 var VERSION = version2;
@@ -29843,7 +30031,49 @@ function registerSessionRoutes(app, sessions, replies, questions, idempotency) {
       }
     }
     const answer = parsed.data.answer;
-    if (answer) {
+    const answers = parsed.data.answers;
+    if (answer && answers) {
+      throw badRequest("Use either answer or answers, not both");
+    }
+    if (answers) {
+      const prompt = await questions.get(ref);
+      if (!prompt) {
+        throw conflict("This question is no longer pending", {
+          reason: "question_resolved"
+        });
+      }
+      if (answers.some(
+        (item) => item.messageId !== prompt.messageId || item.revision !== prompt.revision
+      )) {
+        throw conflict("Question changed", {
+          reason: "question_changed",
+          current: prompt
+        });
+      }
+      const known = new Set(prompt.questions.map((question) => question.id));
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of answers) {
+        if (!known.has(item.questionId)) {
+          throw conflict("Question changed", {
+            reason: "question_changed",
+            current: prompt
+          });
+        }
+        if (seen.has(item.questionId)) {
+          throw badRequest("Duplicate question in answer batch");
+        }
+        seen.add(item.questionId);
+      }
+      const missing = prompt.questions.filter(
+        (question) => !seen.has(question.id)
+      );
+      if (missing.length > 0) {
+        throw conflict("Answer every question in this batch", {
+          reason: "question_incomplete",
+          current: prompt
+        });
+      }
+    } else if (answer) {
       const prompt = await questions.get(ref);
       if (!prompt) {
         throw conflict("This question is no longer pending", {
@@ -29861,6 +30091,7 @@ function registerSessionRoutes(app, sessions, replies, questions, idempotency) {
       }
     }
     const result = await sessions.sendMessage(ref, { text: parsed.data.text });
+    questions.invalidate(ref);
     if (cacheKey2) await idempotency.set(cacheKey2, result);
     return c.json(result, 202);
   });
@@ -29880,7 +30111,38 @@ function registerSessionRoutes(app, sessions, replies, questions, idempotency) {
 }
 
 // packages/hub/src/http/routes/questions.ts
+var MAX_SUMMARY_REFS2 = 10;
+function summaryRefs(values) {
+  const refs = (values ?? []).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  return [...new Set(refs)];
+}
 function registerQuestionRoutes(app, questions, attention) {
+  app.get("/api/v1/questions", async (c) => {
+    const refs = summaryRefs(c.req.queries("ref"));
+    if (refs.length === 0) {
+      throw badRequest("At least one session ref is required");
+    }
+    if (refs.length > MAX_SUMMARY_REFS2) {
+      throw badRequest(`At most ${MAX_SUMMARY_REFS2} session refs are allowed`);
+    }
+    if (refs.some((ref) => ref.length > 256)) {
+      throw badRequest("Session ref is too long");
+    }
+    const [summaryResult, attentionPage] = await Promise.all([
+      questions.summaries(refs),
+      attention.list({ type: "question" })
+    ]);
+    const attentionBySession = new Map(
+      attentionPage.data.map((item) => [item.sessionRef, item.id])
+    );
+    return c.json({
+      data: summaryResult.data.map((summary) => {
+        const attentionID = attentionBySession.get(summary.sessionRef);
+        return attentionID ? { ...summary, attentionID } : summary;
+      }),
+      failed: summaryResult.failed
+    });
+  });
   app.get("/api/v1/sessions/:ref/question", async (c) => {
     const ref = c.req.param("ref");
     if (!ref) throw notFound("Session not found");