omnius 1.0.846 → 1.0.847

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 37075842 bytes
-sha256: f568a8a54e037eb22f21193f7f589f8769b6b94369c0e9dfa7446ca6e8a5f87b
+size: 37088449 bytes
+sha256: f5581b26f6b472a9af893e906670aabb393bc4c63944d2daeadbec245809eb01

package/dist/library.js

@@ -342649,8 +342649,31 @@ var FREE_INFERENCE_SEEDS = Object.freeze([
     modelsUrl: "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/models",
     model: "gpt-oss-20b",
     nativeToolsHint: true
+  }),
+  Object.freeze({
+    id: "chat",
+    name: "ch.at",
+    chatUrl: "https://ch.at/v1/chat/completions",
+    model: "provider-default",
+    nativeToolsHint: false,
+    providerDefaultModel: true
   })
 ]);
+function mergeKeylessInferenceProviders(discovered) {
+  const routes = new Map(FREE_INFERENCE_SEEDS.map((provider) => [provider.chatUrl, { ...provider }]));
+  for (const provider of discovered) {
+    const known = routes.get(provider.chatUrl);
+    if (!known)
+      routes.set(provider.chatUrl, { ...provider });
+    else if (known.id === provider.id && known.modelsUrl === provider.modelsUrl)
+      routes.set(provider.chatUrl, {
+        ...provider,
+        ...known,
+        nativeToolsHint: known.nativeToolsHint || provider.nativeToolsHint
+      });
+  }
+  return [...routes.values()];
+}
 var object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var boundedString3 = (value, max = 256) => typeof value === "string" && value.length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
 function publicHttpsSyntax(value) {
@@ -342704,11 +342727,12 @@ function parseKeylessInferenceRegistry(html) {
             continue;
           const chat = provider.endpoints.find((e) => object2(e) && e.method === "POST" && typeof e.url === "string" && e.url.endsWith("/chat/completions"));
           const models = provider.endpoints.find((e) => object2(e) && e.method === "GET" && typeof e.url === "string" && e.url.endsWith("/models"));
-          if (!object2(chat) || !object2(models))
+          if (!object2(chat))
             continue;
           const chatUrl = publicHttpsSyntax(chat.url);
-          const modelsUrl = publicHttpsSyntax(models.url);
-          if (!chatUrl || !modelsUrl || new URL(chatUrl).origin !== new URL(modelsUrl).origin)
+          const modelsUrl = object2(models) ? publicHttpsSyntax(models.url) : void 0;
+          const pinnedDefault = FREE_INFERENCE_SEEDS.find((seed) => seed.providerDefaultModel && seed.id === provider.id && seed.chatUrl === chatUrl);
+          if (!chatUrl || !modelsUrl && !pinnedDefault || modelsUrl && new URL(chatUrl).origin !== new URL(modelsUrl).origin)
             continue;
           if (sentinel && new URL(chatUrl).origin !== "https://api.llm7.io")
             continue;
@@ -342717,9 +342741,10 @@ function parseKeylessInferenceRegistry(html) {
             id: provider.id,
             name: boundedString3(provider.name, 80) ? provider.name : provider.id,
             chatUrl,
-            modelsUrl,
-            model: boundedString3(example.model) ? example.model : "",
+            ...modelsUrl ? { modelsUrl } : {},
+            model: pinnedDefault?.model ?? (boundedString3(example.model) ? example.model : ""),
             nativeToolsHint: provider.capabilities.some((cap) => cap === "function_calling_on_supported_models" || cap === "tools_on_supported_models"),
+            ...pinnedDefault ? { providerDefaultModel: true, nativeToolsHint: false } : {},
             ...sentinel ? { anonymousAuthorization: "Bearer unused" } : {}
           });
           if (providers.length >= MAX_ROUTES)
@@ -349052,6 +349077,7 @@ var localCooldowns = /* @__PURE__ */ new Map();
 var registryCaches = /* @__PURE__ */ new WeakMap();
 var catalogCaches = /* @__PURE__ */ new WeakMap();
 var MAX_ROUTES2 = 6;
+var MAX_MODELS_PER_PROVIDER = 3;
 var MAX_REGISTRY_BYTES = 1048576;
 var MAX_CATALOG_BYTES = 262144;
 var MAX_REQUEST_BYTES = 2097152;
@@ -349121,6 +349147,12 @@ function publicHttps(value) {
 function hasImages(request) {
   return request.messages.some((message) => Array.isArray(message.content) && message.content.some((part) => object4(part) && (String(part.type) === "image_url" || String(part.type) === "image")));
 }
+function chatCatalogModel(model) {
+  if (!object4(model) || typeof model.id !== "string" || !/^[A-Za-z0-9_./:+@-]{1,200}$/.test(model.id) || model.max_completion_tokens === 0 || model.usage_based_only === true || model.model_type !== void 0 && model.model_type !== "chat" || /embedding|^bge-|^whisper|^flux|qwen\d*guard|(?:^|[/_-])(?:llama[-_])?guard(?:[-_/]|$)|moderation/i.test(model.id))
+    return false;
+  const modalities = object4(model.modalities) ? model.modalities : void 0;
+  return !modalities || (!Array.isArray(modalities.input) || modalities.input.includes("text")) && (!Array.isArray(modalities.output) || modalities.output.includes("text"));
+}
 var RemoteInferenceFallback = class _RemoteInferenceFallback {
   primary;
   makeBackend;
@@ -349531,6 +349563,7 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
       ...route.contextWindow || route.maxOutputTokens ? { providerDefaultOutput: void 0 } : route.keyless ? { providerDefaultOutput: true, remoteProviderDefaultOutput: true } : {},
       preferNativeOllamaChat: false,
       think: false,
+      remoteProviderDefaultModel: route.keyless?.providerDefaultModel ? true : void 0,
       ...route.keyless?.directAnswer ? { chatTemplateKwargs: { enable_thinking: false } } : {},
       timeoutMs: Math.min(request.timeoutMs, this.policy.requestTimeoutMs)
     };
@@ -349668,7 +349701,8 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
       this.fence(request);
       registryCaches.set(fetcher, { until: this.now() + 15e3, providers: [] });
     }
-    for (const provider of [...FREE_INFERENCE_SEEDS, ...discovered]) {
+    const alternatives = [];
+    for (const provider of mergeKeylessInferenceProviders(discovered)) {
       this.fence(request);
       if (this.now() >= deadline || count2 >= MAX_ROUTES2)
         return;
@@ -349684,50 +349718,88 @@ var RemoteInferenceFallback = class _RemoteInferenceFallback {
         keyless: provider,
         ...provider.anonymousAuthorization === "Bearer unused" ? { apiKey: "unused" } : {}
       };
-      if (seen.has(routeKey(route)) || !this.compatible(request, route, includeCooling))
+      if (!this.compatible(request, route, includeCooling))
+        continue;
+      if (provider.providerDefaultModel) {
+        const key = routeKey(route);
+        if (!seen.has(key)) {
+          seen.add(key);
+          count2++;
+          yield route;
+        }
+        continue;
+      }
+      const modelsUrl = provider.modelsUrl;
+      if (!modelsUrl)
         continue;
-      seen.add(routeKey(route));
       try {
         let cache3 = catalogCaches.get(fetcher);
         if (!cache3) {
           cache3 = /* @__PURE__ */ new Map();
           catalogCaches.set(fetcher, cache3);
         }
-        const cached = cache3.get(provider.modelsUrl);
-        const raw = cached && cached.until > this.now() ? cached.value : JSON.parse(await this.read(provider.modelsUrl, request, deadline, MAX_CATALOG_BYTES));
+        const cached = cache3.get(modelsUrl);
+        const raw = cached && cached.until > this.now() ? cached.value : JSON.parse(await this.read(modelsUrl, request, deadline, MAX_CATALOG_BYTES));
         if (!object4(raw) || !Array.isArray(raw.data) || raw.data.length > 512)
           continue;
         if (cache3.size >= 64)
           cache3.delete(cache3.keys().next().value);
-        cache3.set(provider.modelsUrl, { until: this.now() + 3e5, value: raw });
-        const models = raw.data.filter((model) => object4(model) && typeof model.id === "string" && /^[A-Za-z0-9_./:+@-]{1,200}$/.test(model.id) && model.max_completion_tokens !== 0 && model.model_type !== "embedding" && !/embedding|^bge-|^whisper|^flux/i.test(model.id));
-        const selected = models.find((model) => model.id === route.model) ?? (provider.selector ? void 0 : models[0]);
-        if (!selected && !provider.selector)
-          continue;
-        if (selected) {
-          route.model = String(selected.id);
-          const window2 = selected.context_length ?? selected.context_window ?? selected.max_model_len;
-          if (typeof window2 === "number" && Number.isSafeInteger(window2) && window2 > 0)
-            route.contextWindow = window2;
-          const output = selected.max_completion_tokens;
-          if (typeof output === "number" && Number.isSafeInteger(output) && output > 0)
-            route.maxOutputTokens = output;
-          if (Array.isArray(selected.supported_parameters) && request.tools.length && !selected.supported_parameters.includes("tools"))
+        cache3.set(modelsUrl, { until: this.now() + 3e5, value: raw });
+        const models = raw.data.filter(chatCatalogModel);
+        const unique4 = [...new Map(models.map((model) => [String(model.id), model])).values()];
+        const preferred = unique4.find((model) => model.id === route.model);
+        const ordered = [
+          ...preferred ? [preferred] : provider.selector ? [void 0] : [],
+          ...unique4.filter((model) => model !== preferred).sort((a, b) => String(a.id) < String(b.id) ? -1 : String(a.id) > String(b.id) ? 1 : 0)
+        ];
+        const compatible = [];
+        for (const selected of ordered) {
+          const candidate = { ...route, ...selected ? { model: String(selected.id) } : {} };
+          if (selected) {
+            const capabilities = object4(selected.capabilities) ? selected.capabilities : void 0;
+            if (request.tools.length && (selected.tools_calling === false || capabilities?.tools === false || Array.isArray(selected.supported_parameters) && !selected.supported_parameters.includes("tools")))
+              continue;
+            if ((request.responseFormat ?? request.response_format) && (selected.json_mode === false || capabilities?.json_mode === false))
+              continue;
+            const nestedWindow = object4(selected.context_window) ? selected.context_window.tokens : selected.context_window;
+            const window2 = [selected.context_length, nestedWindow, selected.max_model_len].find((value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0);
+            if (typeof window2 === "number")
+              candidate.contextWindow = window2;
+            const output = selected.max_completion_tokens;
+            if (typeof output === "number" && Number.isSafeInteger(output) && output > 0)
+              candidate.maxOutputTokens = output;
+          }
+          if (!candidate.model || seen.has(routeKey(candidate)) || !this.compatible(request, candidate, includeCooling))
             continue;
+          compatible.push(candidate);
+          if (compatible.length >= MAX_MODELS_PER_PROVIDER)
+            break;
         }
-        if (!route.model || !this.compatible(request, route, includeCooling))
+        const first = compatible.shift();
+        if (!first)
           continue;
-        const actualKey = routeKey(route);
-        if (actualKey !== `${new URL(route.baseUrl).origin}\0${provider.model}` && seen.has(actualKey))
-          continue;
-        seen.add(actualKey);
-        yield route;
+        alternatives.push(compatible);
+        seen.add(routeKey(first));
         count2++;
+        yield first;
       } catch {
         this.fence(request);
         this.cooldown(route, void 0);
       }
     }
+    while (alternatives.some((routes) => routes.length)) {
+      for (const routes of alternatives) {
+        this.fence(request);
+        if (this.now() >= deadline || count2 >= MAX_ROUTES2)
+          return;
+        const route = routes.shift();
+        if (!route || seen.has(routeKey(route)) || !this.compatible(request, route, includeCooling))
+          continue;
+        seen.add(routeKey(route));
+        count2++;
+        yield route;
+      }
+    }
   }
   read(url, request, deadline, limit2) {
     return this.attempt(request, Math.min(5e3, this.policy.requestTimeoutMs, deadline - this.now()), async (bounded3) => {
@@ -386366,6 +386438,7 @@ runtime_module_sha256=${record8.runtimeProvenance.module.sha256 ?? "unknown"}`
       maxTurns: options?.maxTurns ?? 60,
       continueOnDurableWorkProgress: options?.continueOnDurableWorkProgress ?? options?.maxTurns === void 0,
       acceptTextOnlyCompletion: options?.acceptTextOnlyCompletion ?? false,
+      admitTextOnlyCompletionCandidate: options?.admitTextOnlyCompletionCandidate,
       expectedOutcomeContract,
       taskObjectiveContract,
       taskWorkPlan: options?.taskWorkPlan,
@@ -406165,6 +406238,7 @@ ${dynamicProjectContext}`
     const sameResponseTelegramCompletionReplies = /* @__PURE__ */ new Map();
     const telegramOnlyCompletionCallIds = /* @__PURE__ */ new Set();
     let acceptedVisibleConversationResponse = false;
+    let acceptedHostTextCompletion = false;
     const currentTelegramCompletionObjectiveScope = () => {
       return this._telegramCompletionObjectiveScope();
     };
@@ -413008,7 +413082,85 @@ ${transportFailure2}` : transportFailure2;
         });
         const cleanNonStream = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
         this.emitModelAssistantText(cleanNonStream, turn);
-        const textOnlyCompletionAllowed = this.options.acceptTextOnlyCompletion && expectedOutcomeAllowsTextOnlyCompletion(this.options.expectedOutcomeContract);
+        const admitTextCandidate = this.options.admitTextOnlyCompletionCandidate;
+        const textCandidate = this._latestModelVisibleAssistantText;
+        if (this._isTelegramSurface() && admitTextCandidate && cleanNonStream && !isThinkOnly && this.options.expectedOutcomeContract?.requiredEffects.includes("visible_response") === true && textCandidate?.text === cleanNonStream && textCandidate.turn === turn && !this._pendingSteeringPreemption && !this._hasUnresolvedCurrentSteeringInputs() && !this.pendingUserMessages.length && !this.taskRequirementInterpretationPending) {
+          const runController = this._abortController, turnController = this._turnAbortController;
+          const signal = AbortSignal.any([runController.signal, turnController.signal]);
+          const assertCurrent = () => {
+            signal.throwIfAborted();
+            const interruption = this._interruptionLifecycle?.snapshot();
+            if (this.aborted || this._paused || this._abortController !== runController || this._turnAbortController !== turnController || this._latestModelVisibleAssistantText !== textCandidate || textCandidate.runId !== this.currentArtifactRunId() || textCandidate.taskEpoch !== this._taskEpoch || textCandidate.turn !== turn || textCandidate.text !== cleanNonStream || textCandidate.objectiveScope !== currentTelegramCompletionObjectiveScope() || textCandidate.objectiveFingerprint !== this._objectiveFrontier?.fingerprint || this._pendingSteeringPreemption || this._hasUnresolvedCurrentSteeringInputs() || this.pendingUserMessages.length || this.taskRequirementInterpretationPending || interruption && (interruption.phase !== "running" || interruption.pendingAcknowledgements.some((operation) => operation.status === "pending") || interruption.ambiguousEffects.some((effect) => effect.state === "unknown_after_interrupt")))
+              throw new Error("Host-reviewed assistant reply is no longer current");
+          };
+          let onAbort;
+          try {
+            assertCurrent();
+            const admission = Promise.resolve().then(() => {
+              assertCurrent();
+              return admitTextCandidate(Object.freeze({
+                text: cleanNonStream,
+                runId: textCandidate.runId,
+                taskEpoch: textCandidate.taskEpoch,
+                turn,
+                signal,
+                assertCurrent
+              }));
+            });
+            const admitted = await Promise.race([admission, new Promise((_resolve, reject) => {
+              onAbort = () => reject(signal.reason);
+              if (signal.aborted)
+                onAbort();
+              else
+                signal.addEventListener("abort", onAbort, { once: true });
+            })]);
+            assertCurrent();
+            if (admitted === true) {
+              acceptedCompletionReply = {
+                ...textCandidate,
+                text: cleanNonStream,
+                toolCallId: `host-visible-response:${crypto.randomUUID()}`,
+                source: "host_reviewed_model_visible_text"
+              };
+              acceptedHostTextCompletion = true;
+              acceptedVisibleConversationResponse = true;
+              completed = true;
+              summary = cleanNonStream;
+              this._onTypedEvent?.({
+                type: "completion_requested",
+                runId: this.currentArtifactRunId(),
+                summary: cleanNonStream.slice(0, 500),
+                sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              break;
+            }
+            if (admitted && typeof admitted === "object" && admitted.admitted === false && typeof admitted.feedback === "string") {
+              const feedback = this.scrubUserInput(admitted.feedback, "host-text-completion-review").trim().slice(0, 4e3);
+              if (feedback)
+                messages.push({ role: "system", content: feedback });
+            }
+          } catch (error) {
+            if (this.aborted || runController.signal.aborted)
+              break;
+            if (this._pendingSteeringPreemption || this._immediateSteeringWakeInputId || this._hasUnresolvedCurrentSteeringInputs() || this.pendingUserMessages.length || this.taskRequirementInterpretationPending) {
+              this.emit({
+                type: "status",
+                content: "Plain assistant reply admission interrupted by current user steering; entering the next safe boundary.",
+                turn,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              continue;
+            }
+            if (signal.aborted)
+              break;
+            throw error;
+          } finally {
+            if (onAbort)
+              signal.removeEventListener("abort", onAbort);
+          }
+        }
+        const textOnlyCompletionAllowed = !(this._isTelegramSurface() && admitTextCandidate) && this.options.acceptTextOnlyCompletion && expectedOutcomeAllowsTextOnlyCompletion(this.options.expectedOutcomeContract);
         if (this._isTelegramSurface() && textOnlyCompletionAllowed && cleanNonStream) {
           const beforeVisibleResponse = this._currentExpectedOutcomeAssessment();
           if (beforeVisibleResponse?.missingEffects.length && beforeVisibleResponse.missingEffects.every((effect) => effect === "visible_response")) {
@@ -413955,7 +414107,7 @@ ${terminalFeedback.slice(0, 4e3)}`,
       });
     }
     const completionHadIndependentVerificationFailure = Boolean(finalAuthoritativeDeficit || this._completionIncompleteVerification);
-    const taskCompleteRequiresVisibleResponse = this._isTelegramSurface() && acceptedTaskCompleteStatus !== void 0 && this.options.expectedOutcomeContract?.requiredEffects.includes("visible_response") === true;
+    const taskCompleteRequiresVisibleResponse = this._isTelegramSurface() && (acceptedTaskCompleteStatus !== void 0 || acceptedHostTextCompletion) && this.options.expectedOutcomeContract?.requiredEffects.includes("visible_response") === true;
     const taskCompleteOwnsAcceptedReply = acceptedCompletionReply?.source === "task_complete_user_reply" && acceptedCompletionReply.runId === this.currentArtifactRunId() && acceptedCompletionReply.taskEpoch === this._taskEpoch && acceptedCompletionReply.objectiveScope === currentTelegramCompletionObjectiveScope();
     const hasTelegramDeliveryReceipt = this._isTelegramSurface() && [...this._completionDeliveryReceipts.values()].some((receipt) => receipt.provider.trim().toLowerCase() === "telegram");
     if (completed && !declaredDegradedCompletion && taskCompleteRequiresVisibleResponse && !taskCompleteOwnsAcceptedReply && !hasTelegramDeliveryReceipt) {
@@ -413995,9 +414147,9 @@ ${terminalFeedback.slice(0, 4e3)}`,
       expectedOutcomeAssessment,
       override: acceptedTaskCompleteOverride
     });
-    const providerDeliveryIsOnlyRemainingEffect = Boolean(this._isTelegramSurface() && taskCompleteRequiresVisibleResponse && !hasTelegramDeliveryReceipt && (acceptedCompletionReply?.source === "task_complete_user_reply" || acceptedCompletionReply?.source === "same_response_model_visible_text" || acceptedCompletionReply?.source === "prior_response_model_visible_text") && expectedOutcomeAssessment && !expectedOutcomeAssessment.satisfied && expectedOutcomeAssessment.missingEffects.length === 1 && expectedOutcomeAssessment.missingEffects[0] === "visible_response" && expectedOutcomeAssessment.requiredEffects.every((effect) => effect === "visible_response" || expectedOutcomeAssessment.observedEffects.includes(effect)) && completionReadinessAllowsExpectedEffectReply(completionReadiness));
-    const canonicalProviderDeliveryIsPending = Boolean(this._isTelegramSurface() && !declaredDegradedCompletion && !hasTelegramDeliveryReceipt && !completionHadIndependentVerificationFailure && !this._terminalRuntimeFailure && !this.aborted && !this.taskRequirementInterpretationPending && !this._interruptionLifecycle?.snapshot().pendingAcknowledgements.some((operation) => operation.status === "pending") && !this._interruptionLifecycle?.snapshot().ambiguousEffects.some((effect) => effect.state === "unknown_after_interrupt") && acceptedCompletionReply && acceptedCompletionReply.runId === this.currentArtifactRunId() && acceptedCompletionReply.taskEpoch === this._taskEpoch && acceptedCompletionReply.objectiveScope === currentTelegramCompletionObjectiveScope() && (acceptedCompletionReply.source === "task_complete_user_reply" || acceptedCompletionReply.source === "same_response_model_visible_text" || acceptedCompletionReply.source === "prior_response_model_visible_text") && completionReadinessAllowsCanonicalProviderDelivery(completionReadiness, this.getTaskExecutionSnapshot(), acceptedCompletionReply.text));
-    const providerDeliveryEffectsArePending = canonicalProviderDeliveryIsPending || Boolean(this._telegramPendingProviderDeliveryFrontierIsCurrent() && !declaredDegradedCompletion && !hasTelegramDeliveryReceipt && !completionHadIndependentVerificationFailure && acceptedCompletionReply && acceptedCompletionReply.runId === this.currentArtifactRunId() && acceptedCompletionReply.taskEpoch === this._taskEpoch && acceptedCompletionReply.objectiveScope === currentTelegramCompletionObjectiveScope() && acceptedCompletionReply.objectiveFingerprint === this._objectiveFrontier?.fingerprint && (acceptedCompletionReply.source === "task_complete_user_reply" || acceptedCompletionReply.source === "same_response_model_visible_text" || acceptedCompletionReply.source === "prior_response_model_visible_text") && completionReadinessAllowsPendingProviderDelivery(completionReadiness));
+    const providerDeliveryIsOnlyRemainingEffect = Boolean(this._isTelegramSurface() && taskCompleteRequiresVisibleResponse && !hasTelegramDeliveryReceipt && (acceptedCompletionReply?.source === "task_complete_user_reply" || acceptedCompletionReply?.source === "same_response_model_visible_text" || acceptedCompletionReply?.source === "prior_response_model_visible_text" || acceptedCompletionReply?.source === "host_reviewed_model_visible_text") && expectedOutcomeAssessment && !expectedOutcomeAssessment.satisfied && expectedOutcomeAssessment.missingEffects.length === 1 && expectedOutcomeAssessment.missingEffects[0] === "visible_response" && expectedOutcomeAssessment.requiredEffects.every((effect) => effect === "visible_response" || expectedOutcomeAssessment.observedEffects.includes(effect)) && completionReadinessAllowsExpectedEffectReply(completionReadiness));
+    const canonicalProviderDeliveryIsPending = Boolean(this._isTelegramSurface() && !declaredDegradedCompletion && !hasTelegramDeliveryReceipt && !completionHadIndependentVerificationFailure && !this._terminalRuntimeFailure && !this.aborted && !this.taskRequirementInterpretationPending && !this._interruptionLifecycle?.snapshot().pendingAcknowledgements.some((operation) => operation.status === "pending") && !this._interruptionLifecycle?.snapshot().ambiguousEffects.some((effect) => effect.state === "unknown_after_interrupt") && acceptedCompletionReply && acceptedCompletionReply.runId === this.currentArtifactRunId() && acceptedCompletionReply.taskEpoch === this._taskEpoch && acceptedCompletionReply.objectiveScope === currentTelegramCompletionObjectiveScope() && (acceptedCompletionReply.source === "task_complete_user_reply" || acceptedCompletionReply.source === "same_response_model_visible_text" || acceptedCompletionReply.source === "prior_response_model_visible_text" || acceptedCompletionReply.source === "host_reviewed_model_visible_text") && completionReadinessAllowsCanonicalProviderDelivery(completionReadiness, this.getTaskExecutionSnapshot(), acceptedCompletionReply.text));
+    const providerDeliveryEffectsArePending = canonicalProviderDeliveryIsPending || Boolean(this._telegramPendingProviderDeliveryFrontierIsCurrent() && !declaredDegradedCompletion && !hasTelegramDeliveryReceipt && !completionHadIndependentVerificationFailure && acceptedCompletionReply && acceptedCompletionReply.runId === this.currentArtifactRunId() && acceptedCompletionReply.taskEpoch === this._taskEpoch && acceptedCompletionReply.objectiveScope === currentTelegramCompletionObjectiveScope() && acceptedCompletionReply.objectiveFingerprint === this._objectiveFrontier?.fingerprint && (acceptedCompletionReply.source === "task_complete_user_reply" || acceptedCompletionReply.source === "same_response_model_visible_text" || acceptedCompletionReply.source === "prior_response_model_visible_text" || acceptedCompletionReply.source === "host_reviewed_model_visible_text") && completionReadinessAllowsPendingProviderDelivery(completionReadiness));
     const attemptedSuccessfulTerminal = !declaredDegradedCompletion && (completed || acceptedTaskCompleteStatus === "completed" || acceptedTaskCompleteStatus === "no_changes_required");
     if (this._completionReadinessMode === "shadow") {
       const integrityKey = loadRuntimeRolloutIntegrityKey(this.omniusStateDir());
@@ -415112,7 +415264,7 @@ Result: ${summary.slice(0, 330)}`,
         runId: terminalReceipt.runId,
         terminalReceiptId: terminalReceipt.id
       } : void 0,
-      deliverableUserReply: terminalReceipt && (acceptedCompletionReply?.source === "task_complete_user_reply" || acceptedCompletionReply?.source === "same_response_model_visible_text" || acceptedCompletionReply?.source === "prior_response_model_visible_text") && acceptedCompletionReply.taskEpoch === terminalReceipt.taskEpoch && (declaredIncompleteReplyIsCurrent || !declaredDegradedCompletion && (providerDeliveryEffectsArePending || completionReadinessAllowsExpectedEffectReply(completionReadiness) && (providerDeliveryIsOnlyRemainingEffect || !completionHadIndependentVerificationFailure))) ? {
+      deliverableUserReply: terminalReceipt && (acceptedCompletionReply?.source === "task_complete_user_reply" || acceptedCompletionReply?.source === "same_response_model_visible_text" || acceptedCompletionReply?.source === "prior_response_model_visible_text" || acceptedCompletionReply?.source === "host_reviewed_model_visible_text") && (acceptedCompletionReply.source !== "host_reviewed_model_visible_text" || providerDeliveryIsOnlyRemainingEffect || providerDeliveryEffectsArePending) && acceptedCompletionReply.taskEpoch === terminalReceipt.taskEpoch && (declaredIncompleteReplyIsCurrent || !declaredDegradedCompletion && (providerDeliveryEffectsArePending || completionReadinessAllowsExpectedEffectReply(completionReadiness) && (providerDeliveryIsOnlyRemainingEffect || !completionHadIndependentVerificationFailure))) ? {
         text: acceptedCompletionReply.text,
         toolCallId: acceptedCompletionReply.toolCallId,
         taskEpoch: acceptedCompletionReply.taskEpoch,
@@ -422069,6 +422221,8 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
   }
   brokerRequestOptions(request, body, signal) {
     const nativeContext = request.numCtx ?? request.num_ctx;
+    if (request.remoteProviderDefaultModel === true && request.configuredEndpointOnly === true && this._provider.protocol === "openai-chat")
+      delete body["model"];
     const remoteDefault = request.remoteProviderDefaultOutput === true && request.configuredEndpointOnly === true && this._provider.protocol === "openai-chat";
     if (request.providerDefaultOutput === true && (remoteDefault || request.maxTokens === 16384 && request.contextAdmission !== true && !(Number.isFinite(nativeContext) && (nativeContext ?? 0) > 0)) && this._provider.protocol !== "anthropic-messages") {
       delete body["max_tokens"];

package/docs/DISCOVERY.json

@@ -37336,6 +37336,44 @@
         }
       ]
     },
+    {
+      "id": "guide.work-orders-wo-telegram-plain-answer-and-provider-catalog-20261012-uppercase",
+      "kind": "guide",
+      "title": "Preserve native Telegram answers and use compatible free inference routes",
+      "summary": "Status: implemented and verified. The user owns publication and runtime replacement.",
+      "keywords": [
+        "work",
+        "orders",
+        "WO",
+        "telegram",
+        "plain",
+        "answer",
+        "and",
+        "provider",
+        "catalog",
+        "20261012",
+        "md"
+      ],
+      "maturity": "internal",
+      "audiences": [
+        "maintainer",
+        "large-context-agent"
+      ],
+      "layer": "documentation",
+      "interfaces": [
+        {
+          "type": "file",
+          "target": "docs/work-orders/WO-telegram-plain-answer-and-provider-catalog-20261012.md"
+        }
+      ],
+      "references": [
+        {
+          "type": "documentation",
+          "target": "docs/work-orders/WO-telegram-plain-answer-and-provider-catalog-20261012.md",
+          "relation": "canonical-artifact"
+        }
+      ]
+    },
     {
       "id": "guide.work-orders-wo-telegram-unavailable-review-presentation-20261012-uppercase",
       "kind": "guide",

package/docs/DISCOVERY.md

@@ -647,6 +647,7 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `guide.work-orders-wo-native-transport-fresh-install-20261012-uppercase` | Native transport failure in the fresh npm installation gate | Status: implemented and verified. Publication remains with the user. |
 | `guide.work-orders-wo-primary-checkout-fallback-delivery-20261012-uppercase` | Primary checkout delivery and remote output capacity | Status: implementation complete and verified in the primary checkout. Publication remains with the user. |
 | `guide.work-orders-wo-telegram-fallback-20261012-uppercase` | Telegram outage fallback and user-selected approval mode | Status: implementation complete; distributable verification recorded below. Publication and runtime installation are reserved for the user. |
+| `guide.work-orders-wo-telegram-plain-answer-and-provider-catalog-20261012-uppercase` | Preserve native Telegram answers and use compatible free inference routes | Status: implemented and verified. The user owns publication and runtime replacement. |
 | `guide.work-orders-wo-telegram-unavailable-review-presentation-20261012-uppercase` | Telegram reply presentation when an auxiliary review is unavailable | Status: implemented and verified. Publication and runtime replacement remain with the user. |
 | `guide.work-orders-world-class-memory-compiler-readme-uppercase` | World-Class Memory Compiler Program | Status: active implementation program Owner: Omnius orchestration and memory packages Last updated: 2026-07-13 |
 | `guide.work-orders-world-class-memory-compiler-tracker-uppercase` | Memory Compiler Implementation Tracker | Last reconciled: 2026-07-13 Authority: This file is the granular program tracker. The work-order documents define the contract and acceptance criteria; neither test output nor a model claim may check an item without the named evidence. |

package/docs/work-orders/WO-telegram-plain-answer-and-provider-catalog-20261012.md

@@ -0,0 +1,117 @@
+# Preserve native Telegram answers and use compatible free inference routes
+
+Status: implemented and verified. The user owns publication and runtime replacement.
+
+## Anchored incident
+
+Telegram input 3363 (a backtick followed by “hey”), update activity
+`telegram:1e8af20a7e273e82`, finalization
+`telegram-64ac9937dc7647a8-1791853421483-1` ran on 1.0.846, PID 2409421,
+started 2026-10-13T00:32:14.464Z. Its bundle SHA256 matches the previous
+verified artifact:
+`f568a8a54e037eb22f21193f7f589f8769b6b94369c0e9dfa7446ca6e8a5f87b`.
+This incident is not explained by an older installed build.
+
+Turn 0 returned ordinary assistant text: “Hey! How can I assist you today?”
+The transcript and turn-1 context retain that answer. Native Telegram
+disabled text completion, so the runner demanded another generation to
+call task_complete. Turn 1 exhausted the remote routes and the usable
+answer never acquired terminal delivery authority. The Activity panel
+obscured the successful first response.
+
+The public registry at https://robit-man.github.io/inference/ also exposed
+two reproducible routing gaps: discovery lost LLM7's provider-default
+selector and chose the first catalog entry, and preferred-model
+incompatibility skipped a provider with other compatible models. The
+catalog-less ch.at chat endpoint was excluded even from tool-free requests.
+Asynchronous jobs, disabled relays, and non-chat services require distinct
+adapters; their presence in the page does not establish native tool support.
+
+## Ordered work
+
+1. Admit an exact current native assistant candidate through host semantic
+   assessment and real effect checks. Avoid a redundant task_complete
+   generation. Preserve run, epoch, turn, owner, steering, candidate and
+   physical evidence fences, terminal receipts and the actual Telegram ACK.
+   No executable completion tool call may be synthesized from prose.
+2. Continue actual work when a promise lacks required mutation, observation,
+   verification or delivery. An unavailable auxiliary assessment may permit
+   delivery of current useful text under existing unavailable-review policy;
+   it must leave the native goal unresolved and never forge fulfillment.
+3. Preserve known selector and transport hints while merging discovered
+   provider capabilities. Enumerate bounded, compatible catalog alternatives
+   deterministically, deduplicate actual routes, preserve whole-input capacity
+   checks, deadlines, manual approval, Stop and provider-specific credentials.
+4. Support catalog-less ch.at only for tool-free chat using its documented
+   omitted-model request. Do not invent a model identifier on the wire or
+   advertise tools, images, or unsupported job protocols.
+5. Test ordinary native text through the actual backend/runner/bridge path,
+   including unavailable assessment, real missing effects, stale ownership,
+   cancellation and provider ACK failure. Exercise registry selector and
+   catalog alternative regressions without live inference or Telegram sends.
+6. Rebuild the workspaces and actual CLI artifact, verify bundle markers and
+   package gates, then commit and push only task-owned changes. Preserve
+   unrelated dirty work and user-owned release versions. The user owns npm
+   publication and runtime replacement.
+
+No service restart, local model request, CUDA workload change or external
+Telegram message is part of this repair's verification.
+
+## Result and verification
+
+Native private and public replies now submit exact current plain text for
+host review and terminal delivery custody without another completion
+generation. Rejected candidates carry bounded missing-effect feedback into
+the next primary request. Stop, steering reconciliation, stale candidate
+rejection, ordinary prose-loop limits and actual provider acknowledgements
+remain enforced. The host neither executes a synthetic task_complete nor
+marks an unknown native goal fulfilled when auxiliary inference is unavailable.
+Selected/generated artifacts retain their explicit delivery boundary.
+
+The runtime merges known provider selector/auth/transport hints with page
+capabilities, tries bounded compatible catalog alternatives after giving
+providers their first attempt, and reads nested context/tool metadata.
+Explicit non-chat, moderation and paid-only catalog entries are excluded.
+ch.at's text-only route omits the model on the wire and needs no catalog;
+onboarding also supports it while retaining a synthetic readiness probe.
+
+Verification:
+
+- 136 registry, routing and existing fallback checks passed.
+- 18 host-admission/model-wire checks and 69 existing completion/steering
+  authority checks passed.
+- 12 new actual backend/runner/Telegram bridge integration cases passed with
+  mocked network responses, including public topic-bound ACK, unavailable
+  assessment, real file mutation, review feedback, Stop and stale ownership.
+- 89 existing Telegram/fallback checks, 11 header route checks and 61
+  onboarding checks passed. Total: 396 regression cases.
+- Two live synthetic requests through the production backend succeeded:
+  streaming text via ch.at in 4821 ms, and streaming native function calling
+  via Hermes in 1764 ms. Both recorded zero local dispatches and executed no
+  generated action. These probes contained only synthetic public test text.
+- Full workspace rebuild and staging audit passed. The tarball audit passed
+  with 531 files and zero warnings. Fresh isolated global npm installation
+  with lifecycle scripts enabled and compilers blocked passed, including
+  SQLite, CLI/library, companion install and PATH checks.
+- All 12 mocked transport scenarios passed against the exact installed
+  tarball bundle. Installed and staged runtime SHA256 match:
+  `f5581b26f6b472a9af893e906670aabb393bc4c63944d2daeadbec245809eb01`.
+
+Logs:
+`/tmp/omnius-keyless-routing-tests-20261012.log`,
+`/tmp/omnius-host-text-admission-focused.log`,
+`/tmp/omnius-host-text-admission-regressions.log`,
+`/tmp/omnius-native-plain-text-admission-20261012.log`,
+`/tmp/omnius-plain-answer-cli-regressions-20261012.log`,
+`/tmp/omnius-plain-answer-route-header-20261012.log`,
+`/tmp/omnius-onboarding-catalogless-tests-20261012.log`,
+`/tmp/omnius-plain-answer-live-remote-text-20261012.json`,
+`/tmp/omnius-plain-answer-live-remote-tools-20261012.json`,
+`/tmp/omnius-plain-answer-publish-build-final-20261012.log`,
+`/tmp/omnius-plain-answer-tarball-audit-20261012.log`,
+`/tmp/omnius-plain-answer-fresh-install-20261012.log` and
+`/tmp/omnius-plain-answer-installed-verification-20261012.json`.
+
+The already running 1.0.846 bot still uses the earlier f568a8a5 bundle.
+The next user-owned patch publication/update and restart must load this repair;
+the isolated package retained the user's staging version without publishing it.

package/npm-shrinkwrap.json

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

package/package.json

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