@yeaft/webchat-agent 0.1.417 → 0.1.419

package/conversation.js

@@ -6,6 +6,7 @@ import { query } from './sdk/index.js';
 import { loadSessionHistory } from './history.js';
 import { startClaudeQuery } from './claude.js';
 import { crewSessions, loadCrewIndex } from './crew.js';
+import { handleUnifyInput } from './unify/web-bridge.js';
 
 // 不支持的斜杠命令（真正需要交互式 CLI 的命令）
 const UNSUPPORTED_SLASH_COMMANDS = ['/help', '/bug', '/login', '/logout', '/terminal-setup', '/vim', '/config'];
@@ -293,7 +294,8 @@ export async function sendConversationList() {
       createdAt: state.createdAt,
       processing: !!state.turnActive,
       userId: state.userId,
-      username: state.username
+      username: state.username,
+      mode: state.mode || null
     };
     list.push(entry);
   }
@@ -354,7 +356,7 @@ export function sendError(conversationId, message) {
 
 // 创建新的 conversation (延迟启动 Claude，等待用户发送第一条消息)
 export async function createConversation(msg) {
-  const { conversationId, workDir, userId, username, disallowedTools } = msg;
+  const { conversationId, workDir, userId, username, disallowedTools, mode } = msg;
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
 
   console.log(`Creating conversation: ${conversationId} in ${effectiveWorkDir} (lazy start)`);
@@ -375,6 +377,7 @@ export async function createConversation(msg) {
     userId,
     username,
     disallowedTools: disallowedTools || null,  // null = 使用全局默认
+    mode: mode || 'claude',  // 'claude' (default) or 'unify'
     usage: {
       inputTokens: 0,
       outputTokens: 0,
@@ -390,7 +393,8 @@ export async function createConversation(msg) {
     workDir: effectiveWorkDir,
     userId,
     username,
-    disallowedTools: disallowedTools || null
+    disallowedTools: disallowedTools || null,
+    mode: mode || 'claude'
   });
 
   // 立即发送 agent 级别的 MCP servers 列表（从 ~/.claude.json 读取的）
@@ -413,8 +417,11 @@ export async function createConversation(msg) {
   sendConversationList();
 
   // ★ Prestart Claude CLI in background to eagerly fetch skills/tools/model
-  // Fire-and-forget: failure just degrades to lazy-start behavior
-  prestartClaude(conversationId, effectiveWorkDir, null);
+  // Skip prestart for unify mode — it doesn't use Claude CLI
+  if (mode !== 'unify') {
+    // Fire-and-forget: failure just degrades to lazy-start behavior
+    prestartClaude(conversationId, effectiveWorkDir, null);
+  }
 }
 
 // Resume 历史 conversation (延迟启动 Claude，等待用户发送第一条消息)
@@ -662,6 +669,12 @@ export async function handleCancelExecution(msg) {
 export async function handleUserInput(msg) {
   const { conversationId, prompt, workDir, claudeSessionId } = msg;
 
+  // ★ Unify mode: route to Unify Engine instead of Claude CLI
+  const state = ctx.conversations.get(conversationId);
+  if (state?.mode === 'unify') {
+    return handleUnifyInput(msg);
+  }
+
   // 解析斜杠命令
   const slashCommand = parseSlashCommand(prompt);
 

package/package.json

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

package/unify/llm/chat-completions.js

@@ -12,6 +12,12 @@
  *   Response: delta.tool_calls[i].function.arguments (JSON string) → accumulate → JSON.parse → UnifiedToolCall
  *   Result:   UnifiedToolResult → { role: "tool", tool_call_id, content }
  *   Finish:   "tool_calls" → "tool_use", "stop" → "end_turn", "length" → "max_tokens"
+ *
+ * max_tokens strategy (based on model ID):
+ *   OpenAI models (gpt-*, o1*, o3*, o4*) use "max_completion_tokens" (new standard).
+ *   All other models (DeepSeek, Gemini, etc.) use "max_tokens" (legacy/compat).
+ *   CopilotProxy transparently forwards whatever the client sends.
+ *   Callers can override via extraBody to pass any parameter directly.
  */
 
 import {
@@ -23,6 +29,26 @@ import {
   LLMAbortError,
 } from './adapter.js';
 
+/**
+ * Check if a model ID is an OpenAI model that supports max_completion_tokens.
+ * OpenAI introduced max_completion_tokens with o1 and made it standard for
+ * GPT-4.1+, o-series, and GPT-5+. Other OpenAI-compatible APIs (DeepSeek,
+ * Gemini, Ollama) still only understand max_tokens.
+ *
+ * @param {string} model — The model ID (e.g. "gpt-5", "deepseek-chat", "o3")
+ * @returns {boolean} true = use max_completion_tokens
+ */
+export function useNewMaxTokensParam(model) {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  // GPT-4.1+ and GPT-5+
+  if (m.startsWith('gpt-')) return true;
+  // o-series reasoning models (o1, o3, o4-mini, etc.)
+  if (/^o\d/.test(m)) return true;
+  // Everything else (deepseek-*, gemini-*, claude-*, custom models): legacy
+  return false;
+}
+
 /**
  * ChatCompletionsAdapter — Talks to OpenAI Chat Completions API and compatibles.
  */
@@ -39,6 +65,24 @@ export class ChatCompletionsAdapter extends LLMAdapter {
     this.#baseUrl = baseUrl.replace(/\/+$/, ''); // strip trailing slash
   }
 
+  /** Expose baseUrl for testing. */
+  get baseUrl() { return this.#baseUrl; }
+
+  /**
+   * Build the max-tokens portion of the request body.
+   * Uses max_completion_tokens for OpenAI models, max_tokens for others.
+   *
+   * @param {string} model
+   * @param {number} maxTokens
+   * @returns {object}
+   */
+  #maxTokensBody(model, maxTokens) {
+    if (useNewMaxTokensParam(model)) {
+      return { max_completion_tokens: maxTokens };
+    }
+    return { max_tokens: maxTokens };
+  }
+
   /**
    * Translate UnifiedToolDef[] → Chat Completions tool format.
    * @param {import('./adapter.js').UnifiedToolDef[]} tools
@@ -140,16 +184,16 @@ export class ChatCompletionsAdapter 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, extraBody?: object, 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, extraBody, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
       model,
       messages: this.#translateMessages(system, messages),
-      max_tokens: maxTokens,
+      ...this.#maxTokensBody(model, maxTokens),
       stream: true,
       stream_options: { include_usage: true },
     };
@@ -157,6 +201,9 @@ export class ChatCompletionsAdapter extends LLMAdapter {
     const translatedTools = this.#translateTools(tools);
     if (translatedTools) body.tools = translatedTools;
 
+    // extraBody allows callers to pass through any additional/override parameters
+    if (extraBody) Object.assign(body, extraBody);
+
     const response = await fetch(`${this.#baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
@@ -277,15 +324,18 @@ export class ChatCompletionsAdapter extends LLMAdapter {
   /**
    * Non-streaming call for side queries.
    */
-  async call({ model, system, messages, maxTokens = 4096, signal }) {
+  async call({ model, system, messages, maxTokens = 4096, extraBody, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
       model,
       messages: this.#translateMessages(system, messages),
-      max_tokens: maxTokens,
+      ...this.#maxTokensBody(model, maxTokens),
     };
 
+    // extraBody allows callers to pass through any additional/override parameters
+    if (extraBody) Object.assign(body, extraBody);
+
     const response = await fetch(`${this.#baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {

package/unify/web-bridge.js

@@ -0,0 +1,204 @@
+/**
+ * web-bridge.js — Bridge between Yeaft Unify Engine and the Web UI
+ *
+ * Translates Unify Engine streaming events into the sendOutput wire format
+ * that the existing web client already understands. This means the UI needs
+ * zero rendering changes — Unify conversations look identical to Claude ones.
+ *
+ * Architecture: Agent-side only. UI and Server are transparent relays.
+ *
+ * Lifecycle per conversation:
+ *   1. First user message → lazy-load a Unify Session (loadSession)
+ *   2. Each user message → engine.query({ prompt }) → stream events → sendOutput
+ *   3. On turn complete → send turn_completed so UI exits processing state
+ */
+
+import ctx from '../context.js';
+import { sendOutput, sendConversationList } from '../conversation.js';
+import { loadSession } from './session.js';
+
+/**
+ * Handle a user message for a Unify-mode conversation.
+ *
+ * Called from conversation.js handleUserInput() when state.mode === 'unify'.
+ * Reuses the same sendOutput() wire format as Claude conversations so the
+ * web client renders messages identically.
+ *
+ * @param {{ conversationId: string, prompt: string }} msg
+ */
+export async function handleUnifyInput(msg) {
+  const { conversationId, prompt } = msg;
+  const state = ctx.conversations.get(conversationId);
+
+  if (!state) {
+    console.error(`[Unify] No conversation state for ${conversationId}`);
+    return;
+  }
+
+  // ─── Lazy-init Unify Session ──────────────────────────────
+  if (!state._unifySession) {
+    try {
+      console.log(`[Unify] Loading session for ${conversationId}...`);
+      state._unifySession = await loadSession({
+        skipMCP: true,
+        skipSkills: true,
+      });
+      state._unifyMessages = [];
+      console.log(`[Unify] Session loaded for ${conversationId} (model: ${state._unifySession.config.model})`);
+    } catch (err) {
+      console.error(`[Unify] Failed to load session for ${conversationId}:`, err);
+      sendOutput(conversationId, {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'text',
+            text: `Unify session initialization failed: ${err.message}`
+          }]
+        }
+      });
+      ctx.sendToServer({
+        type: 'turn_completed',
+        conversationId,
+        workDir: state.workDir
+      });
+      return;
+    }
+  }
+
+  const session = state._unifySession;
+
+  // ─── Send user message to UI ──────────────────────────────
+  sendOutput(conversationId, {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: prompt
+    }
+  });
+
+  // Track messages for multi-turn context
+  state._unifyMessages.push({ role: 'user', content: prompt });
+
+  // ─── Run Engine query and stream back ─────────────────────
+  let fullText = '';
+  let hasError = false;
+
+  try {
+    for await (const event of session.engine.query({
+      prompt,
+      messages: state._unifyMessages.slice(0, -1), // pass history (excluding current prompt which engine adds)
+    })) {
+      switch (event.type) {
+        case 'text_delta':
+          fullText += event.text;
+          sendOutput(conversationId, {
+            type: 'assistant',
+            message: {
+              role: 'assistant',
+              content: [{
+                type: 'text',
+                text: event.text
+              }]
+            },
+            subtype: 'text_delta'
+          });
+          break;
+
+        case 'tool_call':
+          sendOutput(conversationId, {
+            type: 'assistant',
+            message: {
+              role: 'assistant',
+              content: [{
+                type: 'tool_use',
+                id: event.id,
+                name: event.name,
+                input: event.input
+              }]
+            }
+          });
+          break;
+
+        case 'tool_result':
+          sendOutput(conversationId, {
+            type: 'assistant',
+            message: {
+              role: 'tool',
+              tool_use_id: event.toolCallId,
+              content: typeof event.result === 'string'
+                ? event.result
+                : JSON.stringify(event.result)
+            }
+          });
+          break;
+
+        case 'usage':
+          // Update conversation usage tracking
+          if (state.usage) {
+            state.usage.inputTokens += event.inputTokens || 0;
+            state.usage.outputTokens += event.outputTokens || 0;
+          }
+          break;
+
+        case 'error':
+          hasError = true;
+          sendOutput(conversationId, {
+            type: 'assistant',
+            message: {
+              role: 'assistant',
+              content: [{
+                type: 'text',
+                text: `Error: ${event.error?.message || 'Unknown error'}`
+              }]
+            }
+          });
+          break;
+
+        case 'stop':
+        case 'turn_start':
+        case 'turn_end':
+        case 'recall':
+        case 'consolidate':
+        case 'fallback':
+        case 'thinking_delta':
+          // These are engine-internal events; no UI action needed
+          break;
+      }
+    }
+  } catch (err) {
+    hasError = true;
+    console.error(`[Unify] Query error for ${conversationId}:`, err);
+    sendOutput(conversationId, {
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        content: [{
+          type: 'text',
+          text: `Unify query error: ${err.message}`
+        }]
+      }
+    });
+  }
+
+  // ─── Track assistant response for multi-turn ──────────────
+  if (fullText) {
+    state._unifyMessages.push({ role: 'assistant', content: fullText });
+  }
+
+  // ─── Send result + turn_completed ─────────────────────────
+  // Emit a result message to match Claude's wire format (UI uses this for state management)
+  sendOutput(conversationId, {
+    type: 'result',
+    subtype: hasError ? 'error' : 'success',
+    result_text: fullText
+  });
+
+  ctx.sendToServer({
+    type: 'turn_completed',
+    conversationId,
+    workDir: state.workDir
+  });
+
+  sendConversationList();
+}