omnius 1.0.180 → 1.0.182

package/dist/index.js

@@ -563701,7 +563701,7 @@ ${description}`
           const responseText = firstChoice ? String(firstChoice.message?.content ?? "") : "";
           const outcome = this.recordThinkOutcome(responseText, effectiveThink === true);
           const independentOutcome = effectiveThink !== true ? classifyThinkOutcome(responseText) : null;
-          const shouldRecoverFromEmpty = responseFormat !== void 0 && independentOutcome !== null && (independentOutcome === "empty_after_strip" || independentOutcome === "unclosed_think");
+          const shouldRecoverFromEmpty = request.disableEmptyContentRecovery !== true && 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) {
@@ -629151,6 +629151,27 @@ function telegramRouterTimeoutMs(configTimeoutMs, minMs = 1e4, maxMs) {
   const requested = Number.isFinite(configTimeoutMs) && (configTimeoutMs ?? 0) > 0 ? configTimeoutMs : cap;
   return Math.max(floor, Math.min(requested, cap));
 }
+function telegramRouterErrorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function compactTelegramRouterDiagnosticText(text, maxLength = 220) {
+  const compact3 = text.replace(/\s+/g, " ").trim();
+  return compact3.length > maxLength ? `${compact3.slice(0, Math.max(0, maxLength - 3))}...` : compact3;
+}
+function telegramRouterErrorLooksLikeTimeout(err) {
+  const text = telegramRouterErrorText(err);
+  return /\b(timeout|timed out|ETIMEDOUT)\b|aborted due to timeout|stream timeout/i.test(text);
+}
+function telegramRouterErrorLooksLikeBackendLiveness(err) {
+  const text = telegramRouterErrorText(err);
+  return telegramRouterErrorLooksLikeTimeout(err) || /fetch failed|ECONNREFUSED|ECONNRESET|EHOSTUNREACH|ENETUNREACH|ECONNABORTED|socket hang up|terminated|network error/i.test(text);
+}
+function telegramRouterDiagnosticAttemptLooksLikeTimeout(attempt) {
+  return attempt.status === "threw" && telegramRouterErrorLooksLikeTimeout(attempt.error ?? "");
+}
+function telegramRouterDiagnosticAttemptLooksLikeBackendLiveness(attempt) {
+  return attempt.status === "threw" && telegramRouterErrorLooksLikeBackendLiveness(attempt.error ?? "");
+}
 function telegramThinkSuppressedRequest(request) {
   const messages2 = Array.isArray(request.messages) ? request.messages.slice() : [];
   let appended = false;
@@ -635251,11 +635272,25 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
       async telegramRouterJsonCompletion(backend, request, diagnostics, inferenceKind = "router", sessionKey = "__router__") {
         let jsonModeResult;
         let jsonModeError;
+        const recordAttempt = (attempt) => {
+          if (!diagnostics) return;
+          diagnostics.attempts ??= [];
+          diagnostics.attempts.push({
+            stage: inferenceKind,
+            ...attempt
+          });
+        };
         const suppressed = telegramThinkSuppressedRequest(request);
+        const requestTimeoutMs = Number.isFinite(suppressed.timeoutMs) && (suppressed.timeoutMs ?? 0) > 0 ? suppressed.timeoutMs : void 0;
+        const jsonStartMs = Date.now();
         try {
           jsonModeResult = await this.telegramObservableInference(
             backend,
-            { ...suppressed, responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT },
+            {
+              ...suppressed,
+              responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT,
+              disableEmptyContentRecovery: true
+            },
             inferenceKind,
             sessionKey,
             { stream: false, reason: "router-json" }
@@ -635265,16 +635300,49 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           );
           if (visible) {
             if (diagnostics) diagnostics.jsonModeStatus = "visible";
+            recordAttempt({
+              mode: "json-mode",
+              status: "visible",
+              elapsedMs: Date.now() - jsonStartMs,
+              timeoutMs: requestTimeoutMs
+            });
             return jsonModeResult;
           }
           if (diagnostics) diagnostics.jsonModeStatus = "empty-after-strip";
+          recordAttempt({
+            mode: "json-mode",
+            status: "empty-after-strip",
+            elapsedMs: Date.now() - jsonStartMs,
+            timeoutMs: requestTimeoutMs
+          });
         } catch (err) {
           jsonModeError = err;
           if (diagnostics) {
             diagnostics.jsonModeStatus = "threw";
-            diagnostics.jsonModeError = err instanceof Error ? err.message : String(err);
+            diagnostics.jsonModeError = telegramRouterErrorText(err);
+          }
+          recordAttempt({
+            mode: "json-mode",
+            status: "threw",
+            error: telegramRouterErrorText(err),
+            elapsedMs: Date.now() - jsonStartMs,
+            timeoutMs: requestTimeoutMs
+          });
+          if (telegramRouterErrorLooksLikeBackendLiveness(err)) {
+            if (diagnostics) {
+              diagnostics.plainStatus = "skipped";
+              diagnostics.plainError = "skipped because json-mode backend liveness failed";
+            }
+            recordAttempt({
+              mode: "plain-retry",
+              status: "skipped",
+              error: "skipped because json-mode backend liveness failed",
+              timeoutMs: requestTimeoutMs
+            });
+            throw err;
           }
         }
+        const plainStartMs = Date.now();
         try {
           const plainResult = await this.telegramObservableInference(
             backend,
@@ -635288,13 +635356,26 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
               (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
             );
             diagnostics.plainStatus = plainVisible ? "visible" : "empty-after-strip";
+            recordAttempt({
+              mode: "plain-retry",
+              status: plainVisible ? "visible" : "empty-after-strip",
+              elapsedMs: Date.now() - plainStartMs,
+              timeoutMs: requestTimeoutMs
+            });
           }
           return plainResult;
         } catch (err) {
           if (diagnostics) {
             diagnostics.plainStatus = "threw";
-            diagnostics.plainError = err instanceof Error ? err.message : String(err);
+            diagnostics.plainError = telegramRouterErrorText(err);
           }
+          recordAttempt({
+            mode: "plain-retry",
+            status: "threw",
+            error: telegramRouterErrorText(err),
+            elapsedMs: Date.now() - plainStartMs,
+            timeoutMs: requestTimeoutMs
+          });
           if (jsonModeError instanceof Error && !(err instanceof Error)) throw jsonModeError;
           throw err;
         }
@@ -635667,7 +635748,7 @@ ${repairedText}`,
         } catch (err) {
           if (diagnostics) {
             diagnostics.repairStatus = "threw";
-            diagnostics.repairError = err instanceof Error ? err.message : String(err);
+            diagnostics.repairError = telegramRouterErrorText(err);
           }
           return null;
         }
@@ -635733,7 +635814,7 @@ ${retryText}`,
         } catch (err) {
           if (diagnostics) {
             diagnostics.strictRetryStatus = "threw";
-            diagnostics.strictRetryError = err instanceof Error ? err.message : String(err);
+            diagnostics.strictRetryError = telegramRouterErrorText(err);
           }
           return null;
         }
@@ -636221,20 +636302,21 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           }
           const invalidRouterPreview = telegramRouterRawPreview(text);
           const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
+          const backendLivenessFailure = (diagnostics.attempts ?? []).some(telegramRouterDiagnosticAttemptLooksLikeBackendLiveness) || telegramRouterErrorLooksLikeBackendLiveness(diagnostics.repairError ?? "") || telegramRouterErrorLooksLikeBackendLiveness(diagnostics.strictRetryError ?? "");
           const fallback = this.applyTelegramSilentReflectionNotes(this.buildTelegramRouterUnavailableDecision(msg, toolContext, {
-            reason: "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
+            reason: backendLivenessFailure ? "router recovery hit a backend liveness failure; no model-derived reply decision" : "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
             silentDisposition: reflectionNotes.silentDisposition,
             diagnosticNote: this.composeTelegramRouterDiagnosticNote(
               invalidRouterPreview,
               failureNarrative,
-              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"
+              backendLivenessFailure ? "router backend failed during attention-decision recovery; no usable router decision was available" : 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"
             ),
             raw: text
           }), reflectionNotes);
           return withRouterTelemetry(fallback);
         } catch (err) {
           const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
-          const errMsg = err instanceof Error ? err.message : String(err);
+          const errMsg = telegramRouterErrorText(err);
           const fallback = this.applyTelegramSilentReflectionNotes(this.buildTelegramRouterUnavailableDecision(msg, toolContext, {
             reason: `router inference failed; no model-derived reply decision (${errMsg.slice(0, 160)})`,
             silentDisposition: reflectionNotes.silentDisposition,
@@ -636247,46 +636329,93 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           return withRouterTelemetry(fallback);
         }
       }
+      formatTelegramRouterAttemptTrace(attempt) {
+        const elapsed = Number.isFinite(attempt.elapsedMs) ? ` elapsedMs=${Math.max(0, Math.round(attempt.elapsedMs ?? 0))}` : "";
+        const timeout2 = Number.isFinite(attempt.timeoutMs) ? ` timeoutMs=${Math.max(0, Math.round(attempt.timeoutMs ?? 0))}` : "";
+        const error = attempt.error ? ` (${compactTelegramRouterDiagnosticText(attempt.error, 180)})` : "";
+        return `${attempt.stage}/${attempt.mode}: ${attempt.status}${error}${elapsed}${timeout2}`;
+      }
+      telegramRouterBackendLivenessHint(timeoutSeen) {
+        const backendType = this.agentConfig?.backendType ?? "backend";
+        if (backendType === "ollama") {
+          return timeoutSeen ? "local Ollama did not return router tokens within the liveness window; likely queue backlog, cold model load, GPU/RAM contention, or a wedged runner. JSON repair cannot recover until the backend responds" : "local Ollama request failed before router content was available; check Ollama reachability, model availability, and runner health";
+        }
+        return timeoutSeen ? `${backendType} backend did not return router tokens within the liveness window; check provider latency, rate limits, and request queue depth` : `${backendType} backend request failed before router content was available; check provider reachability and rate limits`;
+      }
       /**
        * Reduce captured per-step diagnostics into:
        *   - `summary`: a short outcome-level diagnostic
        *   - `detail`: a longer ordered trace for operator debugging
-       *   - `operatorHint`: an operational hint (e.g. "ollama backend appears to be injecting <think> tags despite think:false")
+       *   - `operatorHint`: an operational hint with backend/model context
        */
       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`);
+        let timeoutSeen = false;
+        const attempts = diag.attempts ?? [];
+        if (attempts.length > 0) {
+          const livenessAttempts = attempts.filter(telegramRouterDiagnosticAttemptLooksLikeBackendLiveness);
+          const timeoutAttempts = attempts.filter(telegramRouterDiagnosticAttemptLooksLikeTimeout);
+          const emptyAttempts = attempts.filter((attempt) => attempt.status === "empty-after-strip");
+          const visibleAttempts = attempts.filter((attempt) => attempt.status === "visible");
+          const skippedAttempts = attempts.filter((attempt) => attempt.status === "skipped");
+          networkErrorSeen = livenessAttempts.length > 0;
+          timeoutSeen = timeoutAttempts.length > 0;
+          thinkInjectionSuspected = emptyAttempts.length > 0;
+          if (livenessAttempts.length > 0) {
+            const affected = livenessAttempts.map((attempt) => `${attempt.stage}/${attempt.mode}`).join(", ");
+            parts.push(timeoutSeen ? `backend timeout/liveness failure during ${affected}` : `backend liveness failure during ${affected}`);
+          }
+          if (emptyAttempts.length > 0) {
+            const affected = emptyAttempts.map((attempt) => `${attempt.stage}/${attempt.mode}`).join(", ");
+            parts.push(`empty visible content after <think> strip during ${affected}`);
+          }
+          if (visibleAttempts.length > 0 && diag.repairStatus !== "recovered" && diag.strictRetryStatus !== "recovered") {
+            parts.push(`visible router text remained unparseable`);
+          }
+          if (skippedAttempts.length > 0) {
+            const affected = skippedAttempts.map((attempt) => `${attempt.stage}/${attempt.mode}`).join(", ");
+            parts.push(`fallback attempt skipped during ${affected}`);
+          }
+          detailParts.push(...attempts.map((attempt) => this.formatTelegramRouterAttemptTrace(attempt)));
+        } else {
+          if (diag.jsonModeStatus === "threw") {
+            parts.push(`json-mode call threw`);
+            detailParts.push(`json-mode: threw (${diag.jsonModeError ?? "no detail"})`);
+            networkErrorSeen = true;
+            timeoutSeen = telegramRouterErrorLooksLikeTimeout(diag.jsonModeError ?? "");
+          } 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;
+            timeoutSeen ||= telegramRouterErrorLooksLikeTimeout(diag.plainError ?? "");
+          } 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 === "skipped-truncation-rerun") {
+          detailParts.push(`repair: skipped for truncation rerun`);
         } 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;
+          timeoutSeen ||= telegramRouterErrorLooksLikeTimeout(diag.repairError ?? "");
         } else if (diag.repairStatus === "recovered") {
           detailParts.push(`repair: recovered`);
         }
@@ -636298,14 +636427,15 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         } else if (diag.strictRetryStatus === "threw") {
           detailParts.push(`strict-retry: threw (${diag.strictRetryError ?? "no detail"})`);
           networkErrorSeen = true;
+          timeoutSeen ||= telegramRouterErrorLooksLikeTimeout(diag.strictRetryError ?? "");
         } else if (diag.strictRetryStatus === "recovered") {
           detailParts.push(`strict-retry: recovered`);
         }
         let operatorHint;
         if (networkErrorSeen) {
-          operatorHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
+          operatorHint = this.telegramRouterBackendLivenessHint(timeoutSeen);
         } else if (thinkInjectionSuspected) {
-          operatorHint = "router model emitted <think>-only or unclosed-think output; conversation continuity preserved but inference is degraded";
+          operatorHint = "router model emitted <think>-only or unclosed-think output despite think suppression; visible decision content was empty after stripping hidden reasoning";
         }
         return {
           summary: parts.join("; "),
@@ -636321,7 +636451,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         if (invalidRouterPreview) segments.push(`invalid router output preview: ${invalidRouterPreview}`);
         if (failureNarrative.detail) segments.push(`router-failure trace: ${failureNarrative.detail}`);
         if (failureNarrative.operatorHint) segments.push(failureNarrative.operatorHint);
-        return segments.join(" | ").slice(0, 900);
+        return segments.join(" | ").slice(0, 1400);
       }
       buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
         if (!this.repoRoot) return "";
@@ -637014,6 +637144,25 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         subAgent.liveMessageId = state.messageId ?? null;
         return state.messageId ?? null;
       }
+      telegramAdminRunCompleted(subAgent) {
+        return subAgent.runnerCompleted === true || subAgent.completionBoundarySeen;
+      }
+      telegramAdminIncompleteRunText(subAgent, finalText) {
+        const stats = [
+          typeof subAgent.runnerTurns === "number" ? `${subAgent.runnerTurns} turn(s)` : "",
+          typeof subAgent.runnerToolCalls === "number" ? `${subAgent.runnerToolCalls} tool call(s)` : ""
+        ].filter(Boolean).join(", ");
+        const summary = cleanTelegramVisibleReply(subAgent.runnerSummary || "");
+        const parts = [
+          `INCOMPLETE: admin run exited before task_complete${stats ? ` after ${stats}` : ""}.`,
+          "This is not a completed task. The run should be resumed or retried; no successful completion boundary was observed.",
+          finalText ? `Last visible draft:
+${finalText}` : "",
+          summary ? `Runner summary:
+${summary}` : ""
+        ].filter(Boolean);
+        return parts.join("\n\n");
+      }
       async sendOrEditFinalTelegramHTML(msg, html, liveMessageId) {
         const chunks = splitTelegramMessageText(html, 3900);
         if (chunks.length === 0) return null;
@@ -637350,6 +637499,18 @@ Join: ${newUrl}`);
             subAgent.typingInterval = null;
           }
           const finalText = cleanTelegramVisibleReply(result || "");
+          if (isAdminDM && !this.telegramAdminRunCompleted(subAgent)) {
+            const incompleteText = this.telegramAdminIncompleteRunText(subAgent, finalText);
+            this.subAgentViewCallbacks?.onWrite(subAgent.viewId, incompleteText);
+            this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "failed");
+            if (!msg.guestQueryId) {
+              await this.finalizeTelegramAdminLivePanel(subAgent, msg, incompleteText, "failed");
+            } else if (subAgent.liveMessageId) {
+              await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
+              });
+            }
+            return;
+          }
           if (!finalText) {
             if (msg.chatType !== "private") {
               this.maybeLogTelegramGroupSkip(msg, "discretion: skipped reply");
@@ -637492,6 +637653,18 @@ Join: ${newUrl}`);
             await subAgent.liveMessagePromise.catch(() => {
             });
           }
+          if (!this.telegramAdminRunCompleted(subAgent)) {
+            const incompleteText = this.telegramAdminIncompleteRunText(subAgent, finalText);
+            this.subAgentViewCallbacks?.onWrite(subAgent.viewId, incompleteText);
+            this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "failed");
+            if (!msg.guestQueryId) {
+              await this.finalizeTelegramAdminLivePanel(subAgent, msg, incompleteText, "failed");
+            } else if (subAgent.liveMessageId) {
+              await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
+              });
+            }
+            return;
+          }
           if (!finalText) {
             if (!msg.guestQueryId) {
               await this.finalizeTelegramAdminLivePanel(subAgent, msg, "", "completed");
@@ -637864,12 +638037,16 @@ ${conversationStream}`
           config.model,
           config.apiKey
         );
+        const requestTimeoutMs = config.timeoutMs ?? 3e5;
         const runner = new AgenticRunner(backend, {
-          maxTurns: isAdminDM ? profile === "chat" ? 16 : 30 : isAdminGroup ? 12 : 8,
-          maxTokens: isAdminDM ? profile === "chat" ? 6144 : 8192 : 2048,
+          // Admin DMs are operator-directed work sessions. A hard turn cap turns
+          // active tool progress into a false "completed" Telegram panel when the
+          // model has not reached task_complete yet. Public/group runs stay bounded.
+          maxTurns: isAdminDM ? 0 : isAdminGroup ? 12 : 8,
+          maxTokens: isAdminDM ? 8192 : 2048,
           temperature: 0.3,
-          requestTimeoutMs: config.timeoutMs,
-          taskTimeoutMs: isAdminDM ? config.timeoutMs * 3 : config.timeoutMs,
+          requestTimeoutMs,
+          taskTimeoutMs: isAdminDM ? Math.max(requestTimeoutMs * 3, 9e5) : requestTimeoutMs,
           compactionThreshold: this.telegramFallbackCompactionThreshold(modelTier),
           contextWindowSize,
           modelTier,
@@ -638096,6 +638273,11 @@ Telegram ${isGroup ? "group" : "public"} chat. Respond concisely. Safety filter:
 
 ${creativeWorkspace}` : ""}`;
         const result = await runner.run(userPrompt, systemCtx);
+        subAgent.runnerCompleted = result.completed;
+        subAgent.runnerTurns = result.turns;
+        subAgent.runnerToolCalls = result.toolCalls;
+        subAgent.runnerSummary = result.summary;
+        if (result.completed) subAgent.completionBoundarySeen = true;
         return selectTelegramFinalResponse({
           visibleReplyText: subAgent.visibleReplyText,
           assistantText: subAgent.assistantText,

package/npm-shrinkwrap.json

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

package/package.json

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