@yeaft/webchat-agent 0.1.998 → 0.1.1000

package/package.json

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

package/yeaft/config.js

@@ -22,7 +22,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
+import { getModelEffortOptions, modelSupportsEffort, resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 import { normalizeKnownProviderForRuntime } from './llm/known-providers.js';
 
 /** Default configuration values. */
@@ -394,11 +394,17 @@ export function loadConfig(overrides = {}) {
         if (!config.availableModels.some(am => am.id === m.id)) {
           const entry = {
             id: m.id,
+            ref: p.name ? `${p.name}/${m.id}` : m.id,
             provider: p.name,
             label: m.id,
           };
           if (m.contextWindow !== undefined) entry.contextWindow = m.contextWindow;
           if (m.maxOutput !== undefined) entry.maxOutput = m.maxOutput;
+          const effortOptions = getModelEffortOptions(m.id);
+          if (effortOptions.length > 0) {
+            entry.supportsEffort = modelSupportsEffort(m.id);
+            entry.effortOptions = effortOptions;
+          }
           config.availableModels.push(entry);
         }
       }

package/yeaft/engine.js

@@ -1372,7 +1372,8 @@ export class Engine {
     // valid prompt prefix.
     const parsed = parseEffortPrefix(prompt);
     const effectivePrompt = parsed.cleanedPrompt;
-    const effectiveUserEffort = normalizeEffort(userEffort) || parsed.effort || null;
+    const configuredEffort = normalizeEffort(this.#config?.modelEffort);
+    const effectiveUserEffort = normalizeEffort(userEffort) || parsed.effort || configuredEffort || null;
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
       ? collabToolPolicy
       : null;
@@ -1957,6 +1958,7 @@ export class Engine {
           tools: toolDefs.length > 0 ? toolDefs : undefined,
           maxTokens: this.#config.maxOutputTokens || 16384,
           effort: resolvedEffort,
+          effortSource: userEffort ? 'user' : 'auto',
           signal,
           onRawExchange: captureRawExchange,
         })) {

package/yeaft/llm/anthropic.js

@@ -156,10 +156,10 @@ export class AnthropicAdapter extends LLMAdapter {
   }
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', signal?: AbortSignal }} params
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', effortSource?: 'user'|'auto', signal?: AbortSignal }} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, signal, onRawExchange }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, signal, onRawExchange }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -175,7 +175,7 @@ export class AnthropicAdapter extends LLMAdapter {
     // 'anthropic' thinking protocol. Unknown models or non-thinking models
     // silently drop the parameter — red line: never error on unsupported.
     const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
+    if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
       const cap = getThinkingCapability(model);
       if (cap.supportsThinking && cap.thinkingProtocol === 'anthropic') {
         const budget = thinkingBudgetForEffort(model, normEffort);
@@ -427,7 +427,7 @@ export class AnthropicAdapter extends LLMAdapter {
    * models silently drop the param. max_tokens auto-widens to budget+1024
    * when needed.
    */
-  async call({ model, system, messages, maxTokens = 4096, effort, signal }) {
+  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -439,7 +439,7 @@ export class AnthropicAdapter extends LLMAdapter {
 
     // task-327c: mirror stream()'s thinking injection for side queries.
     const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
+    if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
       const cap = getThinkingCapability(model);
       if (cap.supportsThinking && cap.thinkingProtocol === 'anthropic') {
         const budget = thinkingBudgetForEffort(model, normEffort);

package/yeaft/llm/openai-responses.js

@@ -230,7 +230,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
   // ─── Streaming ──────────────────────────────────────────
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', extraBody?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', effortSource?: 'user'|'auto', extraBody?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
    *
    * NOTE on `extraBody`: any keys you spread here are merged verbatim into
    * the wire body and — because the verbatim debug feature is intentionally
@@ -239,7 +239,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
    * `api-key` headers are auto-redacted (see `redactRawRequest` in
    * `adapter.js`); request-body fields are caller-controlled.
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, extraBody, signal, onRawExchange }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, extraBody, signal, onRawExchange }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -257,7 +257,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     // registry entry must declare thinkingProtocol === 'openai-reasoning'.
     // Unknown / unsupported models silently drop the field.
     const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
+    if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
       const cap = getThinkingCapability(model);
       if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
         const wireEffort = effortForResponses(normEffort);
@@ -478,7 +478,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
    * expose them, mirror the stream() instrumentation. Parity with
    * anthropic.js's `call()`.
    */
-  async call({ model, system, messages, maxTokens = 4096, effort, extraBody, signal }) {
+  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, extraBody, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -490,7 +490,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
     // Mirror stream()'s thinking injection for non-streaming side queries.
     const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
+    if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
       const cap = getThinkingCapability(model);
       if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
         const wireEffort = effortForResponses(normEffort);

package/yeaft/llm/router.js

@@ -99,20 +99,22 @@ function thinkingV1Enabled() {
 export function filterEffortForModel(params) {
   if (!params || !('effort' in params)) return params;
   if (!thinkingV1Enabled()) {
-    const { effort: _drop, ...rest } = params;
-    return rest;
+    if (params.effortSource !== 'user') {
+      const { effort: _drop, effortSource: _source, ...rest } = params;
+      return rest;
+    }
   }
   const norm = normalizeEffort(params.effort);
   if (!norm) {
-    const { effort: _drop, ...rest } = params;
+    const { effort: _drop, effortSource: _source, ...rest } = params;
     return rest;
   }
   const cap = getThinkingCapability(parseModelRef(params.model).modelId);
   if (!cap.supportsThinking || cap.thinkingProtocol === 'none') {
-    const { effort: _drop, ...rest } = params;
+    const { effort: _drop, effortSource: _source, ...rest } = params;
     return rest;
   }
-  return { ...params, effort: norm };
+  return { ...params, effort: norm, effortSource: params.effortSource };
 }
 
 /**

package/yeaft/models.js

@@ -411,6 +411,27 @@ export function mapEffortToOpenAIReasoning(effort) {
   }
 }
 
+export const MODEL_EFFORT_OPTIONS = ['low', 'medium', 'high'];
+
+function inferThinkingCapability(model) {
+  const id = parseModelRef(model).modelId.toLowerCase();
+  if (!id) return null;
+
+  if (/^(gpt-5|o1|o3|o4|chatgpt-|codex-)/.test(id)) {
+    return { supportsThinking: true, thinkingProtocol: 'openai-reasoning', defaultEffort: null, maxBudgetTokens: null };
+  }
+
+  // Anthropic extended thinking is available on Claude 3.7+ and Claude 4.x.
+  // Be conservative: older Claude 3/3.5/Haiku entries stay unsupported unless
+  // explicitly listed in the registry.
+  if (/^claude-/.test(id) && (/(^|-)3-7($|-|\.)/.test(id) || /(^|-)4($|-|\.)/.test(id))) {
+    const maxBudgetTokens = id.includes('opus') ? 64000 : 32000;
+    return { supportsThinking: true, thinkingProtocol: 'anthropic', defaultEffort: null, maxBudgetTokens };
+  }
+
+  return null;
+}
+
 /**
  * Resolve the Anthropic thinking budget_tokens value for a given (model, effort).
  *
@@ -443,7 +464,9 @@ export function thinkingBudgetForEffort(model, effort) {
  */
 export function getThinkingCapability(model) {
   const info = MODEL_REGISTRY.get(model);
-  if (!info || !info.supportsThinking) {
+  const hasExplicitThinking = info && Object.prototype.hasOwnProperty.call(info, 'supportsThinking');
+  const inferred = hasExplicitThinking ? null : inferThinkingCapability(model);
+  if ((!info || !info.supportsThinking) && !inferred) {
     return {
       supportsThinking: false,
       thinkingProtocol: 'none',
@@ -452,13 +475,23 @@ export function getThinkingCapability(model) {
     };
   }
   return {
-    supportsThinking: true,
-    thinkingProtocol: info.thinkingProtocol || 'none',
-    defaultEffort: info.defaultEffort ?? null,
-    maxBudgetTokens: info.maxBudgetTokens ?? null,
+    supportsThinking: Boolean(info?.supportsThinking ?? inferred?.supportsThinking),
+    thinkingProtocol: info?.thinkingProtocol || inferred?.thinkingProtocol || 'none',
+    defaultEffort: info?.defaultEffort ?? inferred?.defaultEffort ?? null,
+    maxBudgetTokens: info?.maxBudgetTokens ?? inferred?.maxBudgetTokens ?? null,
   };
 }
 
+export function getModelEffortOptions(model) {
+  const cap = getThinkingCapability(model);
+  if (!cap.supportsThinking || cap.thinkingProtocol === 'none') return [];
+  return MODEL_EFFORT_OPTIONS.slice();
+}
+
+export function modelSupportsEffort(model) {
+  return getModelEffortOptions(model).length > 0;
+}
+
 /**
  * Valid-effort guard. Unknown values → null (caller should treat as "no effort").
  *

package/yeaft/sessions/session-config.js

@@ -6,7 +6,8 @@
  *
  * v1 schema (intentionally tiny — extend via additive keys only):
  *   {
- *     "model": "my-proxy/claude-sonnet-4-20250514"   // optional
+ *     "model": "my-proxy/claude-sonnet-4-20250514",  // optional
+ *     "modelEffort": "high"                          // optional
  *   }
  *
  * Missing file or `{}` → no session-level override. Missing field → fall back to user-level
@@ -26,7 +27,8 @@ import { sessionsRoot, resolveSessionYeaftDir } from './session-crud.js';
 const CONFIG_FILE = 'config.json';
 
 /** Whitelist of persisted session model-override fields. Reject everything else. */
-const ALLOWED_KEYS = new Set(['model']);
+const ALLOWED_KEYS = new Set(['model', 'modelEffort']);
+const ALLOWED_EFFORTS = new Set(['low', 'medium', 'high']);
 
 export class SessionConfigError extends Error {
   constructor(code, message) {
@@ -97,6 +99,11 @@ export function validateSessionConfig(cfg) {
       throw new SessionConfigError('invalid_model', 'model must be a non-empty string');
     }
   }
+  if ('modelEffort' in cfg && cfg.modelEffort !== null && cfg.modelEffort !== undefined && cfg.modelEffort !== '') {
+    if (typeof cfg.modelEffort !== 'string' || !ALLOWED_EFFORTS.has(cfg.modelEffort.trim())) {
+      throw new SessionConfigError('invalid_model_effort', 'modelEffort must be low, medium, or high');
+    }
+  }
 }
 
 /**
@@ -163,5 +170,10 @@ export function resolveSessionConfig(userConfig, sessionConfig) {
     base.model = model;
     base.primaryModel = model;
   }
+  if (overrides.modelEffort && typeof overrides.modelEffort === 'string' && ALLOWED_EFFORTS.has(overrides.modelEffort)) {
+    base.modelEffort = overrides.modelEffort;
+  } else {
+    delete base.modelEffort;
+  }
   return base;
 }

package/yeaft/web-bridge.js

@@ -1494,15 +1494,54 @@ export function handleYeaftVpRead(msg) {
 /**
  * Session CRUD wired to WS events.
  */
+function decorateSessionsWithRuntimeState(sessions) {
+  const rows = Array.isArray(sessions) ? sessions : [];
+  if (rows.length === 0) return rows;
+  let statuses = [];
+  try {
+    statuses = getVpStatusBroker().snapshot();
+  } catch {
+    statuses = [];
+  }
+  const bySession = new Map();
+  for (const status of statuses) {
+    const sessionId = status?.sessionId || status?.groupId || null;
+    if (!sessionId) continue;
+    const state = status.state || 'idle';
+    const running = !['idle', 'offline', 'completed', 'failed', 'aborted'].includes(state);
+    const updatedAt = status.updatedAt || status.since || Date.now();
+    const prev = bySession.get(sessionId) || { running: false, runningVpCount: 0, latestActivityAt: 0 };
+    if (running) prev.runningVpCount += 1;
+    prev.running = prev.running || running;
+    prev.latestActivityAt = Math.max(prev.latestActivityAt || 0, updatedAt || 0);
+    bySession.set(sessionId, prev);
+  }
+  return rows.map(session => {
+    if (!session || !session.id) return session;
+    const runtime = bySession.get(session.id);
+    if (!runtime) return { ...session, running: false, active: false };
+    return {
+      ...session,
+      running: !!runtime.running,
+      active: !!runtime.running,
+      runningVpCount: runtime.runningVpCount || 0,
+      latestActivityAt: runtime.latestActivityAt || null,
+    };
+  });
+}
+
 function sendSessionCrudResult(payload) {
-  sendSessionEvent({ type: 'session_crud_result', ...payload });
+  const next = payload && payload.ok && Array.isArray(payload.sessions)
+    ? { ...payload, sessions: decorateSessionsWithRuntimeState(payload.sessions) }
+    : payload;
+  sendSessionEvent({ type: 'session_crud_result', ...next });
 }
 
 function sendSessionSnapshotBroadcast() {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     if (!yeaftDir) return;
-    const sessions = snapshotSessions(yeaftDir);
+    const sessions = decorateSessionsWithRuntimeState(snapshotSessions(yeaftDir));
     sendSessionEvent({ type: 'session_list_updated', sessions });
   } catch (err) {
     console.warn('[Yeaft] sendSessionSnapshotBroadcast failed:', err?.message || err);
@@ -2796,6 +2835,7 @@ async function ensureSessionLoaded() {
     type: 'session_ready',
     conversationId: yeaftConversationId,
     model: session.config.model,
+    modelEffort: session.config.modelEffort || null,
     availableModels: session.config.availableModels || [],
     skills: session.status.skills,
     mcpServers: session.status.mcpServers,
@@ -3920,23 +3960,34 @@ export function handleYeaftModeSwitch(_msg) {
 }
 
 
+
+export function modelRefMatchesAvailable(model, requested) {
+  if (!model || !requested) return false;
+  return model.id === requested
+    || model.ref === requested
+    || (model.provider && model.id && `${model.provider}/${model.id}` === requested);
+}
+
 /** Handle model switch from the web UI. */
 export function handleYeaftModelSwitch(msg) {
   if (!session || !msg.model) return;
   refreshLiveSessionConfig();
 
   const available = session.config.availableModels || [];
-  const found = available.some(m => m.id === msg.model);
+  const found = available.some(m => modelRefMatchesAvailable(m, msg.model));
   if (!found) {
     console.warn(`[Yeaft] model switch rejected — "${msg.model}" not in availableModels`);
     return;
   }
 
   session.config.model = msg.model;
+  session.config.primaryModel = msg.model;
+  session.config.modelEffort = msg.modelEffort || null;
 
   sendSessionEvent({
     type: 'model_switched',
     model: msg.model,
+    modelEffort: session.config.modelEffort || null,
   });
 }
 
@@ -3996,6 +4047,7 @@ export async function handleYeaftLoadHistory(msg) {
     type: 'session_ready',
     conversationId: yeaftConversationId,
     model: session.config.model,
+    modelEffort: session.config.modelEffort || null,
     availableModels: session.config.availableModels || [],
     skills: session.status.skills,
     mcpServers: session.status.mcpServers,