omnius 1.0.76 → 1.0.77

package/dist/index.js

@@ -610245,44 +610245,157 @@ function telegramDecisionNote(parsed, keys, nestedKeys = ["internal_notes", "int
   }
   return void 0;
 }
+function uniqueTelegramJsonCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const candidate of candidates) {
+    const clean5 = candidate.trim();
+    if (!clean5 || seen.has(clean5)) continue;
+    seen.add(clean5);
+    unique.push(clean5);
+  }
+  return unique;
+}
+function extractBalancedTelegramJsonObjects(text) {
+  const objects = [];
+  let start2 = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let idx = 0; idx < text.length; idx++) {
+    const ch = text[idx];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0) start2 = idx;
+      depth += 1;
+      continue;
+    }
+    if (ch === "}" && depth > 0) {
+      depth -= 1;
+      if (depth === 0 && start2 >= 0) {
+        objects.push(text.slice(start2, idx + 1));
+        start2 = -1;
+      }
+    }
+  }
+  return objects;
+}
+function telegramDecisionJsonCandidates(text) {
+  const cleaned = stripTelegramHiddenThinking(text).trim();
+  if (!cleaned) return [];
+  const candidates = [];
+  const fenced = cleaned.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi);
+  for (const match of fenced) {
+    if (match[1]) candidates.push(match[1]);
+  }
+  candidates.push(cleaned);
+  candidates.push(cleaned.replace(/```(?:json)?/gi, "").replace(/```/g, "").trim());
+  candidates.push(cleaned.replace(/^\s*(?:json|decision|router decision)\s*:?\s*/i, "").trim());
+  const expanded = [];
+  for (const candidate of candidates) {
+    if (!candidate.trim()) continue;
+    expanded.push(candidate);
+    expanded.push(...extractBalancedTelegramJsonObjects(candidate));
+  }
+  return uniqueTelegramJsonCandidates(expanded);
+}
+function telegramDecisionOutputHasDanglingJson(text) {
+  const cleaned = stripTelegramHiddenThinking(text).trim();
+  if (!cleaned || extractBalancedTelegramJsonObjects(cleaned).length > 0) return false;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let idx = 0; idx < cleaned.length; idx++) {
+    const ch = cleaned[idx];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") depth += 1;
+    if (ch === "}" && depth > 0) depth -= 1;
+  }
+  return depth > 0;
+}
+function telegramRouterRawPreview(text, maxLength = 320) {
+  const clean5 = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
+  if (!clean5) return void 0;
+  return clean5.length > maxLength ? `${clean5.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...` : clean5;
+}
+function telegramDecisionRecoverableFlag(text) {
+  for (const jsonText of telegramDecisionJsonCandidates(text)) {
+    try {
+      const parsed = JSON.parse(jsonText);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      const recoverable = parsed["recoverable"];
+      if (typeof recoverable === "boolean") return recoverable;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
-  const cleaned = stripTelegramHiddenThinking(text).replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
-  const jsonText = cleaned.startsWith("{") ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? "";
-  if (!jsonText) return null;
-  try {
-    const parsed = JSON.parse(jsonText);
-    const parsedRoute = parsed["route"] === "chat" || parsed["route"] === "action" ? parsed["route"] : null;
-    const route = forcedRoute ?? parsedRoute;
-    if (!route) return null;
-    const shouldReplyRaw = parsed["should_reply"] ?? parsed["shouldReply"];
-    const shouldReply = typeof shouldReplyRaw === "boolean" ? shouldReplyRaw : options2.defaultShouldReply ?? true;
-    const confidenceRaw = Number(parsed["confidence"]);
-    const confidence2 = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
-    const reason = String(parsed["reason"] ?? "live inference decision").slice(0, 240);
-    const attentionDeltaRaw = Number(parsed["attention_delta"] ?? parsed["attentionDelta"]);
-    const attentionScoreRaw = Number(parsed["attention_score"] ?? parsed["attentionScore"]);
-    const nextMessagesRaw = Number(parsed["next_check_after_messages"] ?? parsed["nextCheckAfterMessages"]);
-    const nextMsRaw = Number(parsed["next_check_after_ms"] ?? parsed["nextCheckAfterMs"]);
-    return {
-      route,
-      shouldReply,
-      confidence: confidence2,
-      reason,
-      source: forcedRoute ? "forced-mode" : "live-inference",
-      raw: text,
-      attentionState: parseStimulationPhase(parsed["attention_state"] ?? parsed["attentionState"]),
-      attentionDelta: Number.isFinite(attentionDeltaRaw) ? Math.max(-1, Math.min(1, attentionDeltaRaw)) : void 0,
-      attentionScore: Number.isFinite(attentionScoreRaw) ? Math.max(0, Math.min(1, attentionScoreRaw)) : void 0,
-      nextCheckAfterMessages: Number.isFinite(nextMessagesRaw) ? Math.max(1, Math.floor(nextMessagesRaw)) : void 0,
-      nextCheckAfterMs: Number.isFinite(nextMsRaw) ? Math.max(0, Math.floor(nextMsRaw)) : void 0,
-      silentDisposition: telegramDecisionNote(parsed, ["silent_disposition", "silentDisposition", "disposition"]),
-      mentalNote: telegramDecisionNote(parsed, ["mental_note", "mentalNote", "observation", "insight"]),
-      memoryNote: telegramDecisionNote(parsed, ["memory_note", "memoryNote", "memory"]),
-      relationshipNote: telegramDecisionNote(parsed, ["relationship_note", "relationshipNote", "relationship"])
-    };
-  } catch {
-    return null;
+  for (const jsonText of telegramDecisionJsonCandidates(text)) {
+    try {
+      const parsed = JSON.parse(jsonText);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      const parsedRoute = parsed["route"] === "chat" || parsed["route"] === "action" ? parsed["route"] : null;
+      const route = forcedRoute ?? parsedRoute;
+      if (!route) continue;
+      const shouldReplyRaw = parsed["should_reply"] ?? parsed["shouldReply"];
+      const shouldReply = typeof shouldReplyRaw === "boolean" ? shouldReplyRaw : options2.defaultShouldReply ?? true;
+      const confidenceRaw = Number(parsed["confidence"]);
+      const confidence2 = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
+      const reason = String(parsed["reason"] ?? "live inference decision").slice(0, 240);
+      const attentionDeltaRaw = Number(parsed["attention_delta"] ?? parsed["attentionDelta"]);
+      const attentionScoreRaw = Number(parsed["attention_score"] ?? parsed["attentionScore"]);
+      const nextMessagesRaw = Number(parsed["next_check_after_messages"] ?? parsed["nextCheckAfterMessages"]);
+      const nextMsRaw = Number(parsed["next_check_after_ms"] ?? parsed["nextCheckAfterMs"]);
+      return {
+        route,
+        shouldReply,
+        confidence: confidence2,
+        reason,
+        source: forcedRoute ? "forced-mode" : "live-inference",
+        raw: text,
+        attentionState: parseStimulationPhase(parsed["attention_state"] ?? parsed["attentionState"]),
+        attentionDelta: Number.isFinite(attentionDeltaRaw) ? Math.max(-1, Math.min(1, attentionDeltaRaw)) : void 0,
+        attentionScore: Number.isFinite(attentionScoreRaw) ? Math.max(0, Math.min(1, attentionScoreRaw)) : void 0,
+        nextCheckAfterMessages: Number.isFinite(nextMessagesRaw) ? Math.max(1, Math.floor(nextMessagesRaw)) : void 0,
+        nextCheckAfterMs: Number.isFinite(nextMsRaw) ? Math.max(0, Math.floor(nextMsRaw)) : void 0,
+        silentDisposition: telegramDecisionNote(parsed, ["silent_disposition", "silentDisposition", "disposition"]),
+        mentalNote: telegramDecisionNote(parsed, ["mental_note", "mentalNote", "observation", "insight"]),
+        memoryNote: telegramDecisionNote(parsed, ["memory_note", "memoryNote", "memory"]),
+        relationshipNote: telegramDecisionNote(parsed, ["relationship_note", "relationshipNote", "relationship"])
+      };
+    } catch {
+      continue;
+    }
   }
+  return null;
 }
 function parseTelegramTimeRangeQuery(query, now = /* @__PURE__ */ new Date()) {
   const original = String(query || "");
@@ -615233,6 +615346,57 @@ ${lines.join("\n")}`);
           nextAnalysisAfterMs: decision.nextCheckAfterMs
         });
       }
+      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs) {
+        const rawPreview = telegramRouterRawPreview(rawOutput, 4e3);
+        if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) return null;
+        const routeInstruction = forcedRoute ? `The route is operator-forced and must be "${forcedRoute}".` : `Preserve the original route if present; otherwise choose chat or action only if the original output clearly implies one.`;
+        const prompt = [
+          `Repair this Telegram attention-router output into strict JSON.`,
+          `Do not make a new social decision from the Telegram message. Only preserve the decision already present in the router output.`,
+          `If the original output does not contain a recoverable route and should_reply decision, return recoverable=false with should_reply=false and confidence=0.`,
+          routeInstruction,
+          ``,
+          `Return JSON only with this schema:`,
+          `{"recoverable":true|false,"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note"}`,
+          ``,
+          `Original router output:`,
+          rawPreview
+        ].join("\n");
+        try {
+          const result = await backend.chatCompletion({
+            messages: [
+              {
+                role: "system",
+                content: "You repair a Telegram router response into strict JSON without changing the underlying decision."
+              },
+              { role: "user", content: prompt }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 500,
+            timeoutMs: Math.min(Math.max(timeoutMs, 3e3), 8e3),
+            think: false
+          });
+          const repairedText = result.choices[0]?.message?.content ?? "";
+          if (telegramDecisionRecoverableFlag(repairedText) === false) return null;
+          const parsed = parseTelegramInteractionDecision(repairedText, forcedRoute, {
+            defaultShouldReply: false
+          });
+          if (!parsed) return null;
+          return {
+            ...parsed,
+            reason: `recovered router decision: ${parsed.reason}`.slice(0, 240),
+            raw: `${rawOutput}
+
+[repaired router decision]
+${repairedText}`,
+            mentalNote: parsed.mentalNote ?? "router decision recovered from non-JSON model output",
+            memoryNote: parsed.memoryNote ?? "router repair preserved the model-derived attention decision"
+          };
+        } catch {
+          return null;
+        }
+      }
       async inferTelegramInteractionDecision(msg, toolContext) {
         const config = this.agentConfig;
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
@@ -615338,6 +615502,17 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             this.applyTelegramStimulationDecision(sessionKey, parsed);
             return parsed;
           }
+          const repaired = await this.repairTelegramInteractionDecision(
+            backend,
+            text,
+            forcedRoute,
+            config.timeoutMs ?? 3e4
+          );
+          if (repaired) {
+            this.applyTelegramStimulationDecision(sessionKey, repaired);
+            return repaired;
+          }
+          const invalidRouterPreview = telegramRouterRawPreview(text);
           const fallback2 = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
             shouldReply: false,
@@ -615346,6 +615521,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying because the router decision could not be parsed",
             mentalNote: "router produced an invalid attention decision payload",
+            memoryNote: invalidRouterPreview ? `invalid router output preview: ${invalidRouterPreview}` : void 0,
             raw: text
           };
           this.applyTelegramStimulationDecision(sessionKey, fallback2);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.76",
+  "version": "1.0.77",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.76",
+      "version": "1.0.77",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.76",
+  "version": "1.0.77",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",