omnius 1.0.79 → 1.0.80

package/dist/index.js

@@ -538985,6 +538985,28 @@ function stripThinkBlocks(s2) {
     return s2;
   return s2.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
+function injectNoThinkDirective(messages2) {
+  if (!Array.isArray(messages2) || messages2.length === 0)
+    return messages2;
+  let lastUserIdx = -1;
+  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
+    if (messages2[i2]?.role === "user") {
+      lastUserIdx = i2;
+      break;
+    }
+  }
+  if (lastUserIdx === -1)
+    return messages2;
+  const target = messages2[lastUserIdx];
+  if (!target || typeof target.content !== "string")
+    return messages2;
+  if (/\/no_think\b/i.test(target.content))
+    return messages2;
+  const annotated = `${target.content}
+
+/no_think`;
+  return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: annotated } : m2);
+}
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
     return false;
@@ -551435,14 +551457,40 @@ ${description}`
         }) : null;
         const requestBaseUrl = poolSlot?.baseUrl ?? this.baseUrl;
         let poolSuccess = false;
+        const combineAbortSignals = (signals) => {
+          const filtered = signals.filter((s2) => s2 instanceof AbortSignal);
+          if (filtered.length === 0)
+            return void 0;
+          if (filtered.length === 1)
+            return filtered[0];
+          const anyFn = AbortSignal.any;
+          if (typeof anyFn === "function")
+            return anyFn(filtered);
+          const controller = new AbortController();
+          for (const sig of filtered) {
+            if (sig.aborted) {
+              controller.abort(sig.reason);
+              break;
+            }
+            sig.addEventListener("abort", () => {
+              if (!controller.signal.aborted) {
+                controller.abort(sig.reason);
+              }
+            });
+          }
+          return controller.signal;
+        };
+        const effectiveTimeoutMs = Number.isFinite(request.timeoutMs) && request.timeoutMs > 0 ? request.timeoutMs : 0;
+        const timeoutSignal = effectiveTimeoutMs > 0 && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(effectiveTimeoutMs) : void 0;
+        const combinedAbortSignal = combineAbortSignals([this._abortSignal, timeoutSignal]);
         try {
           const fetchOpts = {
             method: "POST",
             headers: this.authHeaders(),
             body: JSON.stringify(body)
           };
-          if (this._abortSignal)
-            fetchOpts.signal = this._abortSignal;
+          if (combinedAbortSignal)
+            fetchOpts.signal = combinedAbortSignal;
           const resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, fetchOpts);
           if (!resp.ok) {
             const text = await resp.text().catch(() => "");
@@ -551456,34 +551504,42 @@ ${description}`
           const firstChoice = choices[0];
           const responseText = firstChoice ? String(firstChoice.message?.content ?? "") : "";
           const outcome = this.recordThinkOutcome(responseText, effectiveThink === true);
-          if (outcome !== null && effectiveThink === true) {
-            const justSuppressed = this._thinkSuppressed && this._thinkFailStreak === _OllamaAgenticBackend._thinkFailThreshold;
-            if (justSuppressed || outcome === "empty_after_strip" || outcome === "unclosed_think") {
-              const retryBody = {
-                model: this.model,
-                messages: cleanedMessages,
-                tools: request.tools,
-                temperature: request.temperature,
-                max_tokens: request.maxTokens,
-                think: false
+          const independentOutcome = effectiveThink !== true ? classifyThinkOutcome(responseText) : null;
+          const shouldRecoverFromEmpty = responseFormat !== void 0 && independentOutcome !== null && (independentOutcome === "empty_after_strip" || independentOutcome === "unclosed_think");
+          const justSuppressed = this._thinkSuppressed && this._thinkFailStreak === _OllamaAgenticBackend._thinkFailThreshold;
+          const shouldRetryThinkGuard = outcome !== null && effectiveThink === true && (justSuppressed || outcome === "empty_after_strip" || outcome === "unclosed_think");
+          if (shouldRetryThinkGuard || shouldRecoverFromEmpty) {
+            const retryMessages = injectNoThinkDirective(cleanedMessages);
+            const retryBody = {
+              model: this.model,
+              messages: retryMessages,
+              tools: request.tools,
+              temperature: request.temperature,
+              max_tokens: request.maxTokens,
+              think: false
+            };
+            if (responseFormat !== void 0 && shouldRetryThinkGuard && !shouldRecoverFromEmpty) {
+              retryBody["response_format"] = responseFormat;
+            }
+            try {
+              const retryOpts = {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify(retryBody)
               };
-              if (responseFormat !== void 0) {
-                retryBody["response_format"] = responseFormat;
-              }
-              try {
-                const retryOpts = {
-                  method: "POST",
-                  headers: this.authHeaders(),
-                  body: JSON.stringify(retryBody)
-                };
-                if (this._abortSignal)
-                  retryOpts.signal = this._abortSignal;
-                const retryResp = await fetch(`${requestBaseUrl}/v1/chat/completions`, retryOpts);
-                if (retryResp.ok) {
-                  const retryData = await retryResp.json();
-                  const retryChoices = retryData.choices ?? [];
-                  const retryUsage = retryData.usage;
-                  if (retryChoices.length > 0) {
+              if (combinedAbortSignal)
+                retryOpts.signal = combinedAbortSignal;
+              const retryResp = await fetch(`${requestBaseUrl}/v1/chat/completions`, retryOpts);
+              if (retryResp.ok) {
+                const retryData = await retryResp.json();
+                const retryChoices = retryData.choices ?? [];
+                const retryUsage = retryData.usage;
+                if (retryChoices.length > 0) {
+                  const retryFirst = retryChoices[0];
+                  const retryText = retryFirst ? String(retryFirst.message?.content ?? "") : "";
+                  const retryClass = classifyThinkOutcome(retryText);
+                  const retryUsable = retryClass !== "empty_after_strip" && retryClass !== "unclosed_think";
+                  if (retryUsable) {
                     poolSuccess = true;
                     return {
                       choices: retryChoices.map((c9) => {
@@ -551501,8 +551557,8 @@ ${description}`
                     };
                   }
                 }
-              } catch {
               }
+            } catch {
             }
           }
           poolSuccess = true;
@@ -615356,23 +615412,56 @@ ${lines.join("\n")}`);
           nextAnalysisAfterMs: decision.nextCheckAfterMs
         });
       }
-      async telegramRouterJsonCompletion(backend, request) {
+      async telegramRouterJsonCompletion(backend, request, diagnostics) {
+        let jsonModeResult;
+        let jsonModeError;
         try {
-          const result = await backend.chatCompletion({
+          jsonModeResult = await backend.chatCompletion({
             ...request,
             responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
           });
-          const visible = result.choices.some(
+          const visible = jsonModeResult.choices.some(
             (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
           );
-          if (visible) return result;
-        } catch {
+          if (visible) {
+            if (diagnostics) diagnostics.jsonModeStatus = "visible";
+            return jsonModeResult;
+          }
+          if (diagnostics) diagnostics.jsonModeStatus = "empty-after-strip";
+        } catch (err) {
+          jsonModeError = err;
+          if (diagnostics) {
+            diagnostics.jsonModeStatus = "threw";
+            diagnostics.jsonModeError = err instanceof Error ? err.message : String(err);
+          }
+        }
+        try {
+          const plainResult = await backend.chatCompletion(request);
+          if (diagnostics) {
+            const plainVisible = plainResult.choices.some(
+              (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
+            );
+            diagnostics.plainStatus = plainVisible ? "visible" : "empty-after-strip";
+          }
+          return plainResult;
+        } catch (err) {
+          if (diagnostics) {
+            diagnostics.plainStatus = "threw";
+            diagnostics.plainError = err instanceof Error ? err.message : String(err);
+          }
+          if (jsonModeError instanceof Error && !(err instanceof Error)) throw jsonModeError;
+          throw err;
         }
-        return backend.chatCompletion(request);
       }
-      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs) {
+      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs, diagnostics) {
         const rawPreview = telegramRouterRawPreview(rawOutput, 4e3);
-        if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) return null;
+        if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) {
+          if (diagnostics) {
+            diagnostics.repairStatus = "skipped";
+            diagnostics.repairError = !rawPreview ? "no recoverable text in router output (empty after <think> strip)" : "router output was dangling JSON; repair would only re-produce a truncation";
+          }
+          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.`,
@@ -615384,7 +615473,9 @@ ${lines.join("\n")}`);
           `{"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
+          rawPreview,
+          ``,
+          `/no_think`
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
@@ -615402,11 +615493,18 @@ ${lines.join("\n")}`);
             think: false
           });
           const repairedText = result.choices[0]?.message?.content ?? "";
-          if (telegramDecisionRecoverableFlag(repairedText) === false) return null;
+          if (telegramDecisionRecoverableFlag(repairedText) === false) {
+            if (diagnostics) diagnostics.repairStatus = "no-recoverable-output";
+            return null;
+          }
           const parsed = parseTelegramInteractionDecision(repairedText, forcedRoute, {
             defaultShouldReply: false
           });
-          if (!parsed) return null;
+          if (!parsed) {
+            if (diagnostics) diagnostics.repairStatus = "no-recoverable-output";
+            return null;
+          }
+          if (diagnostics) diagnostics.repairStatus = "recovered";
           return {
             ...parsed,
             reason: `recovered router decision: ${parsed.reason}`.slice(0, 240),
@@ -615417,17 +615515,23 @@ ${repairedText}`,
             mentalNote: parsed.mentalNote ?? "router decision recovered from non-JSON model output",
             memoryNote: parsed.memoryNote ?? "router repair preserved the model-derived attention decision"
           };
-        } catch {
+        } catch (err) {
+          if (diagnostics) {
+            diagnostics.repairStatus = "threw";
+            diagnostics.repairError = err instanceof Error ? err.message : String(err);
+          }
           return null;
         }
       }
-      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs) {
+      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs, diagnostics) {
         const invalidPreview = telegramRouterRawPreview(rawOutput, 1200) ?? "(empty assistant content)";
         const routeInstruction = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field must be "${forcedRoute}", but should_reply must still be inferred from context.` : `Infer route live from context.`;
+        const trimmedUserPrompt = userPrompt.length > 4e3 ? `…
+${userPrompt.slice(-4e3)}` : userPrompt;
         const retryPrompt = [
           `The previous Telegram attention-router response was not usable JSON.`,
-          `Make a fresh model-derived attention decision from the full context below. Do not use hard-coded mention or keyword triggers.`,
-          `Return exactly one JSON object and no prose.`,
+          `Make a fresh model-derived attention decision from the context below. Do not use hard-coded mention or keyword triggers.`,
+          `Return exactly one JSON object and no prose. No <think> tags. No commentary.`,
           routeInstruction,
           ``,
           `Required schema: {"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"}`,
@@ -615435,15 +615539,17 @@ ${repairedText}`,
           `Invalid previous output, for diagnostics only:`,
           invalidPreview,
           ``,
-          `Full router context:`,
-          userPrompt
+          `Router context (trailing-window):`,
+          trimmedUserPrompt,
+          ``,
+          `/no_think`
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
             messages: [
               {
                 role: "system",
-                content: "You are a strict JSON Telegram attention router. Output one valid JSON object only."
+                content: "You are a strict JSON Telegram attention router. Output one valid JSON object only. Never emit <think> tags."
               },
               { role: "user", content: retryPrompt }
             ],
@@ -615454,10 +615560,18 @@ ${repairedText}`,
             think: false
           });
           const retryText = result.choices[0]?.message?.content ?? "";
+          if (diagnostics) diagnostics.strictRetryPreview = telegramRouterRawPreview(retryText, 320);
           const parsed = parseTelegramInteractionDecision(retryText, forcedRoute, {
             defaultShouldReply: false
           });
-          if (!parsed) return null;
+          if (!parsed) {
+            if (diagnostics) {
+              const cleaned = stripTelegramHiddenThinking(retryText).trim();
+              diagnostics.strictRetryStatus = cleaned ? "unparseable" : "empty";
+            }
+            return null;
+          }
+          if (diagnostics) diagnostics.strictRetryStatus = "recovered";
           return {
             ...parsed,
             reason: `strict router retry: ${parsed.reason}`.slice(0, 240),
@@ -615467,7 +615581,11 @@ ${repairedText}`,
 ${retryText}`,
             mentalNote: parsed.mentalNote ?? "strict router retry produced a valid attention decision"
           };
-        } catch {
+        } catch (err) {
+          if (diagnostics) {
+            diagnostics.strictRetryStatus = "threw";
+            diagnostics.strictRetryError = err instanceof Error ? err.message : String(err);
+          }
           return null;
         }
       }
@@ -615488,7 +615606,7 @@ ${retryText}`,
           forceAnalyze: daydreamForceCheck
         });
         if (!config) {
-          const fallback2 = {
+          const fallback = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
             shouldReply: false,
             confidence: 0,
@@ -615497,8 +615615,8 @@ ${retryText}`,
             silentDisposition: "retained as context without replying",
             mentalNote: "router unavailable, so no model-derived attention note was produced"
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback2);
-          return fallback2;
+          this.applyTelegramStimulationDecision(sessionKey, fallback);
+          return fallback;
         }
         const backend = new OllamaAgenticBackend(
           config.backendUrl,
@@ -615553,6 +615671,7 @@ ${stimulationProbe.context}`,
           `Current Telegram message text (untrusted user data):
 ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         ].filter(Boolean).join("\n");
+        const diagnostics = {};
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
             messages: [
@@ -615567,7 +615686,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             maxTokens: 700,
             timeoutMs: Math.min(Math.max(config.timeoutMs ?? 3e4, 5e3), 15e3),
             think: false
-          });
+          }, diagnostics);
           const text = result.choices[0]?.message?.content ?? "";
           const parsed = parseTelegramInteractionDecision(text, forcedRoute, {
             defaultShouldReply: false
@@ -615580,7 +615699,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             backend,
             text,
             forcedRoute,
-            config.timeoutMs ?? 3e4
+            config.timeoutMs ?? 3e4,
+            diagnostics
           );
           if (repaired) {
             this.applyTelegramStimulationDecision(sessionKey, repaired);
@@ -615591,39 +615711,122 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             userPrompt,
             text,
             forcedRoute,
-            config.timeoutMs ?? 3e4
+            config.timeoutMs ?? 3e4,
+            diagnostics
           );
           if (strictRetry) {
             this.applyTelegramStimulationDecision(sessionKey, strictRetry);
             return strictRetry;
           }
           const invalidRouterPreview = telegramRouterRawPreview(text);
-          const fallback2 = {
+          const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
+          const fallback = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
             shouldReply: false,
             confidence: 0,
             reason: "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying because the router decision could not be parsed",
-            mentalNote: invalidRouterPreview ? "router produced an invalid attention decision payload; repair and strict retry did not recover it" : "router produced an empty attention decision payload; strict retry did not recover it",
-            memoryNote: invalidRouterPreview ? `invalid router output preview: ${invalidRouterPreview}` : void 0,
+            // Preserve the well-known mental-note strings (existing tests rely
+            // on them) but append the per-step diagnostic so operators get a
+            // real explanation of what actually failed.
+            mentalNote: (invalidRouterPreview ? "router produced an invalid attention decision payload; repair and strict retry did not recover it" : "router produced an empty attention decision payload; strict retry did not recover it") + (failureNarrative.summary ? ` — ${failureNarrative.summary}` : ""),
+            memoryNote: this.composeTelegramRouterMemoryNote(invalidRouterPreview, failureNarrative.detail),
+            relationshipNote: failureNarrative.relationshipHint,
             raw: text
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback2);
-          return fallback2;
-        } catch {
+          this.applyTelegramStimulationDecision(sessionKey, fallback);
+          return fallback;
+        } catch (err) {
+          const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
+          const errMsg = err instanceof Error ? err.message : String(err);
+          const fallback = {
+            route: forcedRoute ?? (isGroup ? "action" : "chat"),
+            shouldReply: false,
+            confidence: 0,
+            reason: `router inference failed; no model-derived reply decision (${errMsg.slice(0, 160)})`,
+            source: "inference-unavailable",
+            silentDisposition: "retained as context without replying",
+            mentalNote: `router failed, so no model-derived attention note was produced` + (failureNarrative.summary ? ` — ${failureNarrative.summary}` : ` — ${errMsg.slice(0, 160)}`),
+            memoryNote: failureNarrative.detail ? `router-failure trace: ${failureNarrative.detail}` : `router-failure trace: ${errMsg.slice(0, 240)}`,
+            relationshipNote: failureNarrative.relationshipHint
+          };
+          this.applyTelegramStimulationDecision(sessionKey, fallback);
+          return fallback;
         }
-        const fallback = {
-          route: forcedRoute ?? (isGroup ? "action" : "chat"),
-          shouldReply: false,
-          confidence: 0,
-          reason: "router inference failed; no model-derived reply decision",
-          source: "inference-unavailable",
-          silentDisposition: "retained as context without replying",
-          mentalNote: "router failed, so no model-derived attention note was produced"
-        };
-        this.applyTelegramStimulationDecision(sessionKey, fallback);
-        return fallback;
+      }
+      /**
+       * Reduce captured per-step diagnostics into:
+       *   - `summary`: a short outcome-level line for the mental note
+       *   - `detail`: a longer ordered trace for the memory note
+       *   - `relationshipHint`: an operational hint (e.g. "ollama backend appears to be injecting <think> tags despite think:false")
+       */
+      summarizeTelegramRouterFailure(diag) {
+        const parts = [];
+        const detailParts = [];
+        let thinkInjectionSuspected = false;
+        let networkErrorSeen = false;
+        if (diag.jsonModeStatus === "threw") {
+          parts.push(`json-mode call threw`);
+          detailParts.push(`json-mode: threw (${diag.jsonModeError ?? "no detail"})`);
+          networkErrorSeen = true;
+        } else if (diag.jsonModeStatus === "empty-after-strip") {
+          parts.push(`json-mode returned empty content (likely <think>-only)`);
+          detailParts.push(`json-mode: empty-after-strip`);
+          thinkInjectionSuspected = true;
+        } else if (diag.jsonModeStatus === "visible") {
+          detailParts.push(`json-mode: visible`);
+        }
+        if (diag.plainStatus === "threw") {
+          parts.push(`plain call threw`);
+          detailParts.push(`plain: threw (${diag.plainError ?? "no detail"})`);
+          networkErrorSeen = true;
+        } else if (diag.plainStatus === "empty-after-strip") {
+          parts.push(`plain call returned empty content`);
+          detailParts.push(`plain: empty-after-strip`);
+          thinkInjectionSuspected = true;
+        } else if (diag.plainStatus === "visible") {
+          detailParts.push(`plain: visible-but-unparseable`);
+        }
+        if (diag.repairStatus === "skipped") {
+          detailParts.push(`repair: skipped (${diag.repairError ?? "no recoverable input"})`);
+        } else if (diag.repairStatus === "no-recoverable-output") {
+          detailParts.push(`repair: returned non-recoverable JSON`);
+        } else if (diag.repairStatus === "threw") {
+          detailParts.push(`repair: threw (${diag.repairError ?? "no detail"})`);
+          networkErrorSeen = true;
+        } else if (diag.repairStatus === "recovered") {
+          detailParts.push(`repair: recovered`);
+        }
+        if (diag.strictRetryStatus === "empty") {
+          detailParts.push(`strict-retry: empty`);
+          thinkInjectionSuspected = true;
+        } else if (diag.strictRetryStatus === "unparseable") {
+          detailParts.push(`strict-retry: unparseable (preview="${diag.strictRetryPreview ?? ""}")`);
+        } else if (diag.strictRetryStatus === "threw") {
+          detailParts.push(`strict-retry: threw (${diag.strictRetryError ?? "no detail"})`);
+          networkErrorSeen = true;
+        } else if (diag.strictRetryStatus === "recovered") {
+          detailParts.push(`strict-retry: recovered`);
+        }
+        let relationshipHint;
+        if (networkErrorSeen) {
+          relationshipHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
+        } else if (thinkInjectionSuspected) {
+          relationshipHint = "router model emitted <think>-only or unclosed-think output; conversation continuity preserved but inference is degraded";
+        }
+        return {
+          summary: parts.join("; "),
+          detail: detailParts.join("; "),
+          relationshipHint
+        };
+      }
+      composeTelegramRouterMemoryNote(invalidRouterPreview, detail) {
+        const segments = [];
+        if (invalidRouterPreview) segments.push(`invalid router output preview: ${invalidRouterPreview}`);
+        if (detail) segments.push(`router-failure trace: ${detail}`);
+        if (segments.length === 0) return void 0;
+        return segments.join(" | ");
       }
       buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
         if (!this.repoRoot) return "";

package/npm-shrinkwrap.json

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

package/package.json

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