@yeaft/webchat-agent 0.1.1033 → 0.1.1034

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.1033",
+  "version": "0.1.1034",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/config.js

@@ -23,6 +23,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { getModelEffortOptions, getThinkingCapability, modelSupportsEffort, resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
+import { inferProtocolFromModelId } from './llm/router.js';
 import { normalizeKnownProviderForRuntime } from './llm/known-providers.js';
 
 /** Default configuration values. */
@@ -456,10 +457,18 @@ export function loadConfig(overrides = {}) {
           };
           if (m.contextWindow !== undefined) entry.contextWindow = m.contextWindow;
           if (m.maxOutput !== undefined) entry.maxOutput = m.maxOutput;
-          const effortOptions = getModelEffortOptions(m.id);
+          const protocol = m.protocol || p.protocol || inferProtocolFromModelId(m.id) || 'openai-responses';
+          const effortContext = {
+            protocol,
+            supportsEffort: m.supportsEffort,
+            effortOptions: m.effortOptions,
+            thinkingProtocol: m.thinkingProtocol,
+            maxBudgetTokens: m.maxBudgetTokens,
+          };
+          const effortOptions = getModelEffortOptions(m.id, effortContext);
           if (effortOptions.length > 0) {
-            const cap = getThinkingCapability(m.id);
-            entry.supportsEffort = modelSupportsEffort(m.id);
+            const cap = getThinkingCapability(m.id, effortContext);
+            entry.supportsEffort = modelSupportsEffort(m.id, effortContext);
             entry.effortOptions = effortOptions;
             entry.effortProtocol = cap.thinkingProtocol;
           }

package/yeaft/llm/router.js

@@ -22,7 +22,7 @@
  */
 
 import { LLMAdapter } from './adapter.js';
-import { getModelEffortOptions, getThinkingCapability, normalizeEffort, parseModelRef } from '../models.js';
+import { getModelEffortOptions, getThinkingCapability, normalizeEffort, normalizeEffortOptions, parseModelRef } from '../models.js';
 import {
   GITHUB_COPILOT_BASE_URL,
   GITHUB_COPILOT_CREDENTIAL_PROVIDER,
@@ -48,6 +48,15 @@ export function normalizeModelEntry(entry) {
     if (typeof entry.protocol === 'string' && entry.protocol) {
       out.protocol = entry.protocol;
     }
+    if (entry.supportsEffort === true) out.supportsEffort = true;
+    if (typeof entry.thinkingProtocol === 'string' && entry.thinkingProtocol) {
+      out.thinkingProtocol = entry.thinkingProtocol;
+    }
+    const effortOptions = normalizeEffortOptions(entry.effortOptions);
+    if (effortOptions) out.effortOptions = effortOptions;
+    if (Number.isFinite(entry.maxBudgetTokens) && entry.maxBudgetTokens > 0) {
+      out.maxBudgetTokens = entry.maxBudgetTokens;
+    }
     return out;
   }
   return null;
@@ -101,7 +110,7 @@ function thinkingV1Enabled() {
  * @param {object} params
  * @returns {object} new params object with effort possibly removed
  */
-export function filterEffortForModel(params) {
+export function filterEffortForModel(params, context = {}) {
   if (!params || !('effort' in params)) return params;
   if (!thinkingV1Enabled()) {
     if (params.effortSource !== 'user') {
@@ -115,12 +124,19 @@ export function filterEffortForModel(params) {
     return rest;
   }
   const modelId = parseModelRef(params.model).modelId;
-  const cap = getThinkingCapability(modelId);
+  const effortContext = {
+    protocol: context.protocol,
+    supportsEffort: context.entry?.supportsEffort,
+    effortOptions: context.entry?.effortOptions,
+    thinkingProtocol: context.entry?.thinkingProtocol,
+    maxBudgetTokens: context.entry?.maxBudgetTokens,
+  };
+  const cap = getThinkingCapability(modelId, effortContext);
   if (!cap.supportsThinking || cap.thinkingProtocol === 'none') {
     const { effort: _drop, effortSource: _source, ...rest } = params;
     return rest;
   }
-  if (!getModelEffortOptions(modelId).includes(norm)) {
+  if (!getModelEffortOptions(modelId, effortContext).includes(norm)) {
     const { effort: _drop, effortSource: _source, ...rest } = params;
     return rest;
   }
@@ -429,7 +445,7 @@ export class AdapterRouter extends LLMAdapter {
     const authModeKey = anthropicAuthHeaderMode || 'default';
     const cacheKey = `${provider.name}::${protocol}::${authModeKey}::${apiKeyFp}`;
     const cached = this.#adapterCache.get(cacheKey);
-    if (cached) return { adapter: cached, modelId: entry.id };
+    if (cached) return { adapter: cached, modelId: entry.id, protocol, entry };
 
     // Token rotation eviction: when a credential provider hands us a NEW
     // fingerprint for the same (provider, protocol) pair, drop the stale
@@ -467,7 +483,7 @@ export class AdapterRouter extends LLMAdapter {
     }
 
     this.#adapterCache.set(cacheKey, adapter);
-    return { adapter, modelId: entry.id };
+    return { adapter, modelId: entry.id, protocol, entry };
   }
 
   /**
@@ -527,10 +543,10 @@ export class AdapterRouter extends LLMAdapter {
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
   async *stream(params) {
-    const filtered = filterEffortForModel(params);
+    const resolved = await this.#resolveAdapter(params.model);
+    const filtered = filterEffortForModel({ ...params, model: resolved.modelId }, resolved);
     const sanitized = sanitizeMessagesForWire(filtered);
-    const { adapter, modelId } = await this.#resolveAdapter(sanitized.model);
-    yield* adapter.stream({ ...sanitized, model: modelId });
+    yield* resolved.adapter.stream({ ...sanitized, model: resolved.modelId });
   }
 
   /**
@@ -540,10 +556,10 @@ export class AdapterRouter extends LLMAdapter {
    * @returns {Promise<{ text: string, usage: { inputTokens: number, outputTokens: number } }>}
    */
   async call(params) {
-    const filtered = filterEffortForModel(params);
+    const resolved = await this.#resolveAdapter(params.model);
+    const filtered = filterEffortForModel({ ...params, model: resolved.modelId }, resolved);
     const sanitized = sanitizeMessagesForWire(filtered);
-    const { adapter, modelId } = await this.#resolveAdapter(sanitized.model);
-    return adapter.call({ ...sanitized, model: modelId });
+    return resolved.adapter.call({ ...sanitized, model: resolved.modelId });
   }
 
   /**

package/yeaft/models.js

@@ -436,6 +436,20 @@ export const ANTHROPIC_ADAPTIVE_MAX_EFFORT_OPTIONS = ['low', 'medium', 'high', '
 // keep the user-facing scale to the three levels the user expects.
 export const DEEPSEEK_REASONING_EFFORT_OPTIONS = ['low', 'medium', 'high'];
 
+const VALID_EFFORT_OPTIONS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+
+export function normalizeEffortOptions(options) {
+  if (!Array.isArray(options)) return null;
+  const out = [];
+  for (const raw of options) {
+    const effort = normalizeEffort(raw);
+    if (effort && VALID_EFFORT_OPTIONS.has(effort) && !out.includes(effort)) {
+      out.push(effort);
+    }
+  }
+  return out.length ? out : null;
+}
+
 function inferThinkingCapability(model) {
   const id = parseModelRef(model).modelId.toLowerCase();
   if (!id) return null;
@@ -475,11 +489,10 @@ function inferThinkingCapability(model) {
     return { supportsThinking: true, thinkingProtocol: 'anthropic', defaultEffort: null, maxBudgetTokens };
   }
 
-  // DeepSeek reasoning models expose a thinking effort hint. Only the reasoner
-  // family (deepseek-reasoner / deepseek-r1*) is a reasoning model — plain
-  // deepseek-chat stays effort-less. Effort travels over the openai-reasoning
-  // `reasoning.effort` path; user-facing scale is low/medium/high.
-  if (/^deepseek-(reasoner|r1)/.test(id)) {
+  // DeepSeek providers/proxies commonly expose reasoning controls through an
+  // OpenAI-Responses-compatible surface. The router/config layer still gates
+  // this by effective protocol; direct adapter calls use this family fallback.
+  if (/^deepseek/.test(id)) {
     return {
       supportsThinking: true,
       thinkingProtocol: 'openai-reasoning',
@@ -522,10 +535,33 @@ export function thinkingBudgetForEffort(model, effort) {
  * @param {string} model
  * @returns {{ supportsThinking: boolean, thinkingProtocol: 'anthropic' | 'anthropic-adaptive' | 'openai-reasoning' | 'none', defaultEffort: Effort | null, maxBudgetTokens: number | null, effortOptions: Effort[] }}
  */
-export function getThinkingCapability(model) {
+export function getThinkingCapability(model, context = {}) {
   const info = MODEL_REGISTRY.get(model);
+  const overrideOptions = normalizeEffortOptions(context.effortOptions);
+  const overrideProtocol = context.thinkingProtocol || (context.protocol === 'anthropic' ? 'anthropic' : context.protocol === 'openai-responses' ? 'openai-reasoning' : null);
+  if (context.supportsEffort === true || overrideOptions) {
+    return {
+      supportsThinking: true,
+      thinkingProtocol: overrideProtocol || 'openai-reasoning',
+      defaultEffort: context.defaultEffort ?? null,
+      maxBudgetTokens: context.maxBudgetTokens ?? null,
+      effortOptions: overrideOptions,
+    };
+  }
   const hasExplicitThinking = info && Object.prototype.hasOwnProperty.call(info, 'supportsThinking');
-  const inferred = hasExplicitThinking ? null : inferThinkingCapability(model);
+  let inferred = hasExplicitThinking ? null : inferThinkingCapability(model);
+  if (context.protocol === 'openai-responses' && !inferred && /^deepseek/i.test(parseModelRef(model).modelId)) {
+    inferred = {
+      supportsThinking: true,
+      thinkingProtocol: 'openai-reasoning',
+      defaultEffort: null,
+      maxBudgetTokens: null,
+      effortOptions: DEEPSEEK_REASONING_EFFORT_OPTIONS,
+    };
+  }
+  if (context.protocol === 'anthropic' && inferred?.thinkingProtocol === 'openai-reasoning') {
+    inferred = null;
+  }
   if ((!info || !info.supportsThinking) && !inferred) {
     return {
       supportsThinking: false,
@@ -544,8 +580,8 @@ export function getThinkingCapability(model) {
   };
 }
 
-export function getModelEffortOptions(model) {
-  const cap = getThinkingCapability(model);
+export function getModelEffortOptions(model, context = {}) {
+  const cap = getThinkingCapability(model, context);
   if (!cap.supportsThinking || cap.thinkingProtocol === 'none') return [];
   if (Array.isArray(cap.effortOptions)) return cap.effortOptions.slice();
   if (cap.thinkingProtocol === 'openai-reasoning') return OPENAI_REASONING_EFFORT_OPTIONS.slice();
@@ -554,8 +590,8 @@ export function getModelEffortOptions(model) {
   return [];
 }
 
-export function modelSupportsEffort(model) {
-  return getModelEffortOptions(model).length > 0;
+export function modelSupportsEffort(model, context = {}) {
+  return getModelEffortOptions(model, context).length > 0;
 }
 
 /**
@@ -613,6 +649,14 @@ export function normalizeProviderModels(provider) {
       if (typeof entry.protocol === 'string' && entry.protocol.trim()) {
         norm.protocol = entry.protocol.trim();
       }
+      if (entry.supportsEffort === true) norm.supportsEffort = true;
+      if (typeof entry.thinkingProtocol === 'string' && entry.thinkingProtocol.trim()) {
+        norm.thinkingProtocol = entry.thinkingProtocol.trim();
+      }
+      const effortOptions = normalizeEffortOptions(entry.effortOptions);
+      if (effortOptions) norm.effortOptions = effortOptions;
+      const maxBudget = coercePositiveInt(entry.maxBudgetTokens);
+      if (maxBudget !== undefined) norm.maxBudgetTokens = maxBudget;
       out.push(norm);
     }
     // silently skip anything else (null / missing id / numbers)