@yeaft/webchat-agent 0.1.503 → 0.1.505

package/package.json

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

package/unify/llm/anthropic.js

@@ -14,6 +14,19 @@ import {
   LLMServerError,
   LLMAbortError,
 } from './adapter.js';
+import {
+  normalizeEffort,
+  thinkingBudgetForEffort,
+  getThinkingCapability,
+} from '../models.js';
+
+/**
+ * task-327a: feature-flag accessor. thinkingV1 is OFF by default; set
+ * env UNIFY_THINKING_V1=1 to enable. Read lazily so tests can flip.
+ */
+function thinkingV1Enabled() {
+  return process.env.UNIFY_THINKING_V1 === '1';
+}
 
 const DEFAULT_BASE_URL = 'https://api.anthropic.com';
 const API_VERSION = '2023-06-01';
@@ -123,10 +136,10 @@ export class AnthropicAdapter extends LLMAdapter {
   }
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, 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', signal?: AbortSignal }} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, signal }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -137,6 +150,26 @@ export class AnthropicAdapter extends LLMAdapter {
       stream: true,
     };
 
+    // task-327a: inject extended-thinking only when feature flag on, effort is
+    // a valid value, and the model's registry entry says it supports the
+    // '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) {
+      const cap = getThinkingCapability(model);
+      if (cap.supportsThinking && cap.thinkingProtocol === 'anthropic') {
+        const budget = thinkingBudgetForEffort(model, normEffort);
+        if (budget && budget > 0) {
+          // Anthropic requires max_tokens > budget_tokens. Widen max_tokens
+          // if the caller's value is too small to fit the thinking budget
+          // plus a sane reply margin (1024 tokens).
+          const minMax = budget + 1024;
+          if (body.max_tokens < minMax) body.max_tokens = minMax;
+          body.thinking = { type: 'enabled', budget_tokens: budget };
+        }
+      }
+    }
+
     const translatedTools = this.#translateTools(tools);
     if (translatedTools) body.tools = translatedTools;
 

package/unify/llm/chat-completions.js

@@ -28,6 +28,18 @@ import {
   LLMServerError,
   LLMAbortError,
 } from './adapter.js';
+import {
+  normalizeEffort,
+  mapEffortToOpenAIReasoning,
+  getThinkingCapability,
+} from '../models.js';
+
+/**
+ * task-327a: feature-flag accessor. Read lazily so tests can flip.
+ */
+function thinkingV1Enabled() {
+  return process.env.UNIFY_THINKING_V1 === '1';
+}
 
 /**
  * Check if a model ID is an OpenAI model that supports max_completion_tokens.
@@ -184,10 +196,10 @@ export class ChatCompletionsAdapter extends LLMAdapter {
   }
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, extraBody?: object, 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', extraBody?: object, signal?: AbortSignal }} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, extraBody, signal }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, extraBody, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -198,6 +210,21 @@ export class ChatCompletionsAdapter extends LLMAdapter {
       stream_options: { include_usage: true },
     };
 
+    // task-327a: inject OpenAI reasoning.effort when feature flag on, effort is
+    // valid, and model's registry entry flags openai-reasoning protocol.
+    // 'max' downgrades to 'high' (OpenAI has no 'max' enum). Unknown / unsupported
+    // models silently drop the parameter.
+    const normEffort = normalizeEffort(effort);
+    if (thinkingV1Enabled() && normEffort) {
+      const cap = getThinkingCapability(model);
+      if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
+        const reasoningEffort = mapEffortToOpenAIReasoning(normEffort);
+        if (reasoningEffort) {
+          body.reasoning = { effort: reasoningEffort };
+        }
+      }
+    }
+
     const translatedTools = this.#translateTools(tools);
     if (translatedTools) body.tools = translatedTools;
 

package/unify/llm/router.js

@@ -13,6 +13,47 @@
  */
 
 import { LLMAdapter } from './adapter.js';
+import { getThinkingCapability, normalizeEffort } from '../models.js';
+
+/**
+ * task-327a: feature-flag accessor. Read lazily so tests can flip.
+ */
+function thinkingV1Enabled() {
+  return process.env.UNIFY_THINKING_V1 === '1';
+}
+
+/**
+ * task-327a: router-level effort filter.
+ *
+ * Strips `effort` from the outgoing params when:
+ *   - feature flag is off (thinkingV1 == off)
+ *   - effort value is unknown
+ *   - model capability is `thinkingProtocol: 'none'` (silently drop)
+ *
+ * Adapter-level guards also enforce these rules; this is defense in depth
+ * so a no-op path stays consistently a no-op regardless of adapter.
+ *
+ * @param {object} params
+ * @returns {object} new params object with effort possibly removed
+ */
+export function filterEffortForModel(params) {
+  if (!params || !('effort' in params)) return params;
+  if (!thinkingV1Enabled()) {
+    const { effort: _drop, ...rest } = params;
+    return rest;
+  }
+  const norm = normalizeEffort(params.effort);
+  if (!norm) {
+    const { effort: _drop, ...rest } = params;
+    return rest;
+  }
+  const cap = getThinkingCapability(params.model);
+  if (!cap.supportsThinking || cap.thinkingProtocol === 'none') {
+    const { effort: _drop, ...rest } = params;
+    return rest;
+  }
+  return { ...params, effort: norm };
+}
 
 /**
  * AdapterRouter — Implements LLMAdapter, routes by model → provider.
@@ -106,8 +147,9 @@ export class AdapterRouter extends LLMAdapter {
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
   async *stream(params) {
-    const adapter = await this.#resolveAdapter(params.model);
-    yield* adapter.stream(params);
+    const filtered = filterEffortForModel(params);
+    const adapter = await this.#resolveAdapter(filtered.model);
+    yield* adapter.stream(filtered);
   }
 
   /**
@@ -117,8 +159,9 @@ export class AdapterRouter extends LLMAdapter {
    * @returns {Promise<{ text: string, usage: { inputTokens: number, outputTokens: number } }>}
    */
   async call(params) {
-    const adapter = await this.#resolveAdapter(params.model);
-    return adapter.call(params);
+    const filtered = filterEffortForModel(params);
+    const adapter = await this.#resolveAdapter(filtered.model);
+    return adapter.call(filtered);
   }
 
   /**

package/unify/models.js

@@ -20,6 +20,16 @@
  * @property {number} contextWindow — Max context tokens
  * @property {number} maxOutputTokens — Max output tokens
  * @property {string} displayName — Human-readable model name
+ * @property {boolean} [supportsThinking] — task-327a: model supports thinking/reasoning effort.
+ * @property {'anthropic' | 'openai-reasoning' | 'none'} [thinkingProtocol] — task-327a:
+ *   'anthropic' → thinking:{type:'enabled', budget_tokens:N}
+ *   'openai-reasoning' → reasoning:{effort:'low'|'medium'|'high'}
+ *   'none' (default) → parameter silently dropped by router
+ * @property {'low' | 'medium' | 'high' | 'max' | null} [defaultEffort] — task-327a: adapter-level default
+ *   when caller doesn't specify effort (null = no default / decision-tree decides).
+ * @property {number} [maxBudgetTokens] — task-327a: for anthropic protocol, the cap used when
+ *   effort='max' (e.g. Opus 4 = 64K, Sonnet 4 = 32K). For openai-reasoning this field is unused
+ *   because the provider only exposes 3 enum levels.
  */
 
 /** @type {Map<string, ModelInfo>} */
@@ -32,6 +42,11 @@ export const MODEL_REGISTRY = new Map([
     contextWindow: 200000,
     maxOutputTokens: 16384,
     displayName: 'Claude Sonnet 4',
+    // task-327a: extended thinking supported; budget caps at 32K on Sonnet.
+    supportsThinking: true,
+    thinkingProtocol: 'anthropic',
+    defaultEffort: null,
+    maxBudgetTokens: 32000,
   }],
   ['claude-opus-4-20250514', {
     provider: 'anthropic',
@@ -40,6 +55,11 @@ export const MODEL_REGISTRY = new Map([
     contextWindow: 200000,
     maxOutputTokens: 16384,
     displayName: 'Claude Opus 4',
+    // task-327a: PM decision — Opus max budget = 64K.
+    supportsThinking: true,
+    thinkingProtocol: 'anthropic',
+    defaultEffort: null,
+    maxBudgetTokens: 64000,
   }],
   ['claude-haiku-3-20250414', {
     provider: 'anthropic',
@@ -48,6 +68,9 @@ export const MODEL_REGISTRY = new Map([
     contextWindow: 200000,
     maxOutputTokens: 8192,
     displayName: 'Claude Haiku 3',
+    // task-327a: Haiku 3 does not support extended thinking — effort is dropped.
+    supportsThinking: false,
+    thinkingProtocol: 'none',
   }],
 
   // ── OpenAI ─────────────────────────────────────────────────────
@@ -58,6 +81,10 @@ export const MODEL_REGISTRY = new Map([
     contextWindow: 256000,
     maxOutputTokens: 16384,
     displayName: 'GPT-5',
+    // task-327a: GPT-5 supports reasoning.effort (low/medium/high). No 'max'.
+    supportsThinking: true,
+    thinkingProtocol: 'openai-reasoning',
+    defaultEffort: null,
   }],
   // gpt-5-mini/-nano/-pro: keep id + family/protocol metadata so they appear
   // as known models, but do NOT hardcode context/maxOutput — the real limits
@@ -119,6 +146,10 @@ export const MODEL_REGISTRY = new Map([
     contextWindow: 200000,
     maxOutputTokens: 100000,
     displayName: 'o3',
+    // task-327a: o-series reasoning models use reasoning.effort.
+    supportsThinking: true,
+    thinkingProtocol: 'openai-reasoning',
+    defaultEffort: null,
   }],
   ['o4-mini', {
     provider: 'openai',
@@ -127,6 +158,9 @@ export const MODEL_REGISTRY = new Map([
     contextWindow: 200000,
     maxOutputTokens: 100000,
     displayName: 'o4-mini',
+    supportsThinking: true,
+    thinkingProtocol: 'openai-reasoning',
+    defaultEffort: null,
   }],
 
   // ── DeepSeek ───────────────────────────────────────────────────
@@ -231,7 +265,110 @@ export function parseModelRef(ref) {
   };
 }
 
-// ─── task-284: config-driven context / maxOutput ────────────────
+// ─── task-327a: thinking / reasoning capability ─────────────────
+
+/**
+ * Valid effort levels accepted by Unify adapters.
+ * @typedef {'low' | 'medium' | 'high' | 'max'} Effort
+ */
+
+/**
+ * Budget-token map for the Anthropic extended-thinking protocol.
+ * 'max' is model-specific (override via ModelInfo.maxBudgetTokens).
+ *
+ * These numbers are adapter defaults — `thinkingBudgetForEffort()` below
+ * consults the registry entry first before falling back to this table.
+ */
+export const ANTHROPIC_THINKING_BUDGETS = {
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  // 'max' resolves per-model; default fallback if model has no maxBudgetTokens.
+  max: 32000,
+};
+
+/**
+ * Map a Unify effort level to the OpenAI reasoning.effort enum. OpenAI does
+ * not expose a 'max' level — callers that pass 'max' get 'high' (the highest
+ * available on that protocol). The router/engine should log this downgrade
+ * but the adapter MUST NOT error.
+ *
+ * @param {Effort} effort
+ * @returns {'low' | 'medium' | 'high' | null}
+ */
+export function mapEffortToOpenAIReasoning(effort) {
+  if (!effort) return null;
+  switch (effort) {
+    case 'low': return 'low';
+    case 'medium': return 'medium';
+    case 'high': return 'high';
+    // OpenAI doesn't support 'max'; degrade to 'high'. Engine may emit a
+    // debug line noting the downgrade — adapter level stays silent.
+    case 'max': return 'high';
+    default: return null;
+  }
+}
+
+/**
+ * Resolve the Anthropic thinking budget_tokens value for a given (model, effort).
+ *
+ * Priority:
+ *   1. Registry ModelInfo.maxBudgetTokens when effort === 'max'
+ *   2. ANTHROPIC_THINKING_BUDGETS[effort]
+ *
+ * @param {string} model
+ * @param {Effort} effort
+ * @returns {number | null} Null when effort is unknown/falsy.
+ */
+export function thinkingBudgetForEffort(model, effort) {
+  if (!effort) return null;
+  if (effort === 'max') {
+    const info = MODEL_REGISTRY.get(model);
+    if (info?.maxBudgetTokens) return info.maxBudgetTokens;
+    return ANTHROPIC_THINKING_BUDGETS.max;
+  }
+  return ANTHROPIC_THINKING_BUDGETS[effort] ?? null;
+}
+
+/**
+ * Get the thinking capability for a model. Models not in the registry or
+ * explicitly marked supportsThinking:false return a noop capability — the
+ * router uses this to silently drop the `effort` parameter for unsupported
+ * models (red line: never error on unsupported).
+ *
+ * @param {string} model
+ * @returns {{ supportsThinking: boolean, thinkingProtocol: 'anthropic' | 'openai-reasoning' | 'none', defaultEffort: Effort | null, maxBudgetTokens: number | null }}
+ */
+export function getThinkingCapability(model) {
+  const info = MODEL_REGISTRY.get(model);
+  if (!info || !info.supportsThinking) {
+    return {
+      supportsThinking: false,
+      thinkingProtocol: 'none',
+      defaultEffort: null,
+      maxBudgetTokens: null,
+    };
+  }
+  return {
+    supportsThinking: true,
+    thinkingProtocol: info.thinkingProtocol || 'none',
+    defaultEffort: info.defaultEffort ?? null,
+    maxBudgetTokens: info.maxBudgetTokens ?? null,
+  };
+}
+
+/**
+ * Valid-effort guard. Unknown values → null (caller should treat as "no effort").
+ *
+ * @param {unknown} effort
+ * @returns {Effort | null}
+ */
+export function normalizeEffort(effort) {
+  if (effort === 'low' || effort === 'medium' || effort === 'high' || effort === 'max') {
+    return effort;
+  }
+  return null;
+}
 
 /**
  * Coerce a possibly-stringy numeric value to a positive integer, or

package/unify/web-bridge.js

@@ -243,6 +243,109 @@ const THREAD_MUTATING_TOOLS = new Set([
   'AttachThreadToTask',
 ]);
 
+/**
+ * task-325b — Working Status event stream.
+ *
+ * Surfaces Engine lifecycle events (emitted by 325a) as a single
+ * `thread_status` event for the frontend Working Status panel, plus
+ * `thread_list_snapshot` for cold-start / reconnect.
+ *
+ * Contract (aligned with designer spec):
+ *   thread_status   → { type: 'thread_status', threadId, state,
+ *                       startedAt?, completedAt?, toolName?, reason? }
+ *     state ∈ 'running' | 'idle' | 'aborted' | 'error'
+ *   thread_list_snapshot → { type: 'thread_list_snapshot', threads[],
+ *                            currentThreadId, serverTime }
+ *
+ * Red lines (per PM): do NOT mutate engine state; this layer is a pure
+ * observer + translator. Event names match designer doc verbatim.
+ */
+
+/** Map Engine event name → Working Status state string. */
+function engineEventToState(engineEventType) {
+  switch (engineEventType) {
+    case 'thread_started':   return 'running';
+    case 'thread_completed': return 'idle';
+    case 'thread_aborted':   return 'aborted';
+    case 'thread_error':     return 'error';
+    default:                 return null;
+  }
+}
+
+/**
+ * Build and broadcast a `thread_status` payload translated from a raw
+ * engine lifecycle event. The engine event shape (325a) is:
+ *   { type, threadId, startedAt?, completedAt?, toolName?, reason? }
+ * Unknown fields pass through untouched so future engine additions
+ * (e.g. `attempt`) flow to the UI without another bridge change.
+ *
+ * @param {object} ev — engine event
+ * @returns {boolean} true if a thread_status was emitted
+ */
+function emitThreadStatusFromEngineEvent(ev) {
+  if (!ev || typeof ev !== 'object') return false;
+  const state = engineEventToState(ev.type);
+  if (!state) return false;
+  const payload = { type: 'thread_status', threadId: ev.threadId, state };
+  if (ev.startedAt != null)   payload.startedAt   = ev.startedAt;
+  if (ev.completedAt != null) payload.completedAt = ev.completedAt;
+  if (ev.toolName)            payload.toolName    = ev.toolName;
+  if (ev.reason)              payload.reason      = ev.reason;
+  if (ev.error?.message)      payload.error       = ev.error.message;
+  sendUnifyEvent(payload);
+  return true;
+}
+
+/**
+ * task-325b: full-snapshot push distinct from `thread_list_updated`.
+ * Emits `thread_list_snapshot` — a complete state dump the client uses
+ * on page load / WebSocket reconnect to rebuild the Working Status panel
+ * without missing any in-flight thread.
+ *
+ * Snapshot includes per-thread `state` (idle / running / aborted) resolved
+ * from the engine registry's live inflight set. Threads the registry has
+ * no entry for default to 'idle'.
+ */
+function sendThreadListSnapshot() {
+  try {
+    const store = getThreadStore();
+    const registry = session?.engineRegistry || null;
+    const inflight = new Set(
+      typeof registry?.inflightThreadIds === 'function'
+        ? registry.inflightThreadIds()
+        : [],
+    );
+    const threads = store.list().map(t => ({
+      id: t.id,
+      name: t.name,
+      goal: t.goal || '',
+      parentThreadId: t.parentThreadId || null,
+      status: t.status,
+      archived: !!t.archived,
+      messageCount: t.messageCount || 0,
+      lastMessageAt: t.lastMessageAt || null,
+      lastActivityAt: t.lastActivityAt || t.lastMessageAt || t.updatedAt || null,
+      unread: t.unread || 0,
+      preview: t.preview || '',
+      createdAt: t.createdAt,
+      updatedAt: t.updatedAt,
+      taskId: (typeof store.attachedTask === 'function')
+        ? (store.attachedTask(t.id) || null)
+        : null,
+      running: t.id === store.currentId,
+      state: inflight.has(t.id) ? 'running' : 'idle',
+    }));
+    sendUnifyEvent({
+      type: 'thread_list_snapshot',
+      threads,
+      currentThreadId: store.currentId,
+      serverTime: Date.now(),
+    });
+  } catch (err) {
+    console.warn('[Unify] sendThreadListSnapshot failed:', err?.message || err);
+  }
+}
+
 /**
  * task-310: parse a leading `@thread-<id>` or `@thread-<name>` marker on
  * the user's input and return it as a dispatcher override. The marker
@@ -331,6 +434,23 @@ function forwardPipelineEvent(ev, ctx) {
  */
 function handleEngineEvent(event, threadId, hctx) {
   hctx.resetQueryTimer();
+
+  // task-325b: translate Engine lifecycle events into a single
+  // `thread_status` event for the frontend Working Status panel. These
+  // events are observer-only — they never mutate bridge state. The raw
+  // engine event is NOT forwarded further; the switch below handles
+  // anything the UI still needs.
+  if (event && (
+    event.type === 'thread_started' ||
+    event.type === 'thread_completed' ||
+    event.type === 'thread_aborted' ||
+    event.type === 'thread_error'
+  )) {
+    // Engine events carry their own threadId; fall back to envelope id.
+    emitThreadStatusFromEngineEvent({ ...event, threadId: event.threadId || threadId });
+    return;
+  }
+
   switch (event.type) {
     case 'text_delta':
       hctx.assistantTextParts.push(event.text);
@@ -562,6 +682,10 @@ export async function handleUnifyChat(msg) {
       // task-301 Part 2: initial thread snapshot so sidebar V2 renders
       // the real 'main' thread (and any restored threads) right away.
       sendThreadListUpdate();
+      // task-325b: full Working Status snapshot (superset with state +
+      // serverTime) so a freshly-connected client can restore inflight
+      // status without waiting for the next engine event.
+      sendThreadListSnapshot();
     }
 
     // ─── Per-call AbortController (task-320) ──
@@ -945,6 +1069,12 @@ export async function handleUnifyLoadHistory(msg) {
     tools: session.status.tools,
   });
   sendThreadListUpdate();
+  // task-325b: after a page refresh / reconnect the frontend needs the
+  // full Working Status snapshot to rebuild the panel (which thread is
+  // running, idle, aborted). `thread_list_updated` is intentionally a
+  // mutation-delta stream; `thread_list_snapshot` is the single
+  // authoritative "everything right now" payload.
+  sendThreadListSnapshot();
 
   const limit = msg.limit || 50;
   const messages = session.conversationStore.loadRecent(limit);
@@ -1030,6 +1160,9 @@ export async function resetUnifySession() {
     });
     // task-301 Part 2: re-push thread snapshot after session reset.
     sendThreadListUpdate();
+    // task-325b: also push the full Working Status snapshot so the UI
+    // doesn't retain stale "running" badges from the prior session.
+    sendThreadListSnapshot();
   } catch (err) {
     console.error('[Unify] Failed to re-initialize session after reset:', err.message);
   }