clawmatrix 0.1.23 → 0.2.1

package/src/model-proxy.ts

@@ -11,7 +11,7 @@ import type {
 import { debug } from "./debug.ts";
 import { readBody } from "./http-utils.ts";
 
-const MODEL_TIMEOUT = 120_000; // 2 minutes
+const DEFAULT_MODEL_TIMEOUT = 120_000; // 2 minutes
 
 /** Normalize usage from OpenAI-compatible APIs (supports both field naming conventions). */
 function parseUsage(usage: Record<string, number> | undefined): { inputTokens: number; outputTokens: number } | undefined {
@@ -62,17 +62,54 @@ export class ModelProxy {
   private httpServer: Server | null = null;
   private gatewayInfo: GatewayInfo;
   private openclawConfig: OpenClawConfig;
+  private readonly modelTimeout: number;
+
+  /** Dynamically discovered proxy models from peer capabilities (auto-discovery). */
+  private discoveredModels: import("./config.ts").ProxyModel[] = [];
 
   /** Cache of models that need a different API format than configured (detected at runtime).
    *  Entries expire after 10 minutes so upstream upgrades are eventually detected. */
   private modelApiCache = new Map<string, { api: string; ts: number }>();
   private static readonly MODEL_API_CACHE_TTL = 600_000; // 10 minutes
+  private cacheCleanupTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, gatewayInfo: GatewayInfo, openclawConfig: OpenClawConfig) {
     this.config = config;
     this.peerManager = peerManager;
     this.gatewayInfo = gatewayInfo;
     this.openclawConfig = openclawConfig;
+    this.modelTimeout = config.modelTimeout ?? DEFAULT_MODEL_TIMEOUT;
+  }
+
+  /** All proxy models: static config + dynamically discovered from peers. */
+  get allProxyModels(): import("./config.ts").ProxyModel[] {
+    if (this.discoveredModels.length === 0) return this.config.proxyModels;
+    return [...this.config.proxyModels, ...this.discoveredModels];
+  }
+
+  /** Rebuild discovered models from current peer capabilities.
+   *  Skips models already present in static config.proxyModels. */
+  updateDiscoveredModels(peers: import("./router.ts").RouteEntry[]) {
+    const staticKeys = new Set(this.config.proxyModels.map((m) => `${m.nodeId}/${m.id}`));
+    const next: import("./config.ts").ProxyModel[] = [];
+    for (const peer of peers) {
+      for (const m of peer.models) {
+        const key = `${peer.nodeId}/${m.id}`;
+        if (staticKeys.has(key)) continue;
+        next.push({
+          id: m.id,
+          nodeId: peer.nodeId,
+          provider: m.provider,
+          description: m.description,
+          input: m.input,
+          compat: m.compat as import("./config.ts").ProxyModel["compat"],
+        });
+      }
+    }
+    this.discoveredModels = next;
+    if (next.length > 0) {
+      debug("proxy", `Auto-discovered ${next.length} model(s) from peers: ${next.map((m) => `${m.nodeId}/${m.id}`).join(", ")}`);
+    }
   }
 
   /**
@@ -226,8 +263,18 @@ export class ModelProxy {
     return items;
   }
 
-  /** Resolve API endpoint for a model: explicit config > OpenClaw provider > gateway fallback */
-  private resolveModelEndpoint(model: { id: string; provider: string; baseUrl?: string; apiKey?: string; api?: string }): { baseUrl: string; apiKey?: string; direct: boolean; api: string } {
+  /**
+   * Resolve API endpoint for a model: explicit config > OpenClaw provider > null.
+   *
+   * ⚠️ 重要：绝对不能 fallback 到 OpenClaw gateway 的 /v1/chat/completions！
+   * OpenClaw gateway 的 /v1/chat/completions 会走 Agent 系统，每次请求都会创建
+   * 一个新的 Agent session（带记忆、system prompt 等）。这会导致：
+   * - 远程节点（如 iPhone）的每次 model_req 都在本地产生一个多余的 OpenClaw 会话
+   * - 模型响应被 OpenClaw Agent 的 system prompt 和记忆污染，结果不正确
+   *
+   * 如果找不到直连 API 端点，必须返回 null 让调用方报错，而不是静默 fallback。
+   */
+  private resolveModelEndpoint(model: { id: string; provider: string; baseUrl?: string; apiKey?: string; api?: string }): { baseUrl: string; apiKey?: string; direct: boolean; api: string } | null {
     const defaultApi = "openai-completions";
 
     // 1. Explicit baseUrl in ClawMatrix model config
@@ -255,18 +302,20 @@ export class ModelProxy {
       };
     }
 
-    // 3. Fallback: OpenClaw gateway
-    const { port } = this.gatewayInfo;
-    return {
-      baseUrl: `http://127.0.0.1:${port}/v1`,
-      apiKey: undefined,
-      direct: false,
-      api: model.api ?? defaultApi,
-    };
+    // 找不到直连端点 → 返回 null（见上方注释，不能 fallback 到 gateway）
+    return null;
   }
 
   /** Start the local HTTP proxy server for OpenAI-compatible requests. */
   start() {
+    // Periodically prune expired model API cache entries
+    this.cacheCleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, entry] of this.modelApiCache) {
+        if (now - entry.ts > ModelProxy.MODEL_API_CACHE_TTL) this.modelApiCache.delete(id);
+      }
+    }, ModelProxy.MODEL_API_CACHE_TTL);
+
     this.httpServer = createServer(async (req, res) => {
       try {
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -308,6 +357,10 @@ export class ModelProxy {
   }
 
   stop() {
+    if (this.cacheCleanupTimer) {
+      clearInterval(this.cacheCleanupTimer);
+      this.cacheCleanupTimer = null;
+    }
     if (this.httpServer) {
       this.httpServer.close();
       this.httpServer = null;
@@ -338,11 +391,22 @@ export class ModelProxy {
     } else {
       // Stream response
       const reader = response.body.getReader();
+      let finished = false;
+
+      // Clean up stream when client disconnects mid-stream
+      res.on("close", () => {
+        if (!finished) {
+          finished = true;
+          reader.cancel().catch(() => {});
+        }
+      });
+
       const pump = (): void => {
         reader.read().then(({ done, value }) => {
-          if (done) {
+          if (done || finished) {
+            finished = true;
             reader.releaseLock();
-            res.end();
+            if (!res.writableEnded) res.end();
             return;
           }
           const ok = res.write(value);
@@ -352,8 +416,9 @@ export class ModelProxy {
             res.once("drain", pump);
           }
         }).catch(() => {
+          finished = true;
           reader.releaseLock();
-          res.end();
+          if (!res.writableEnded) res.end();
         });
       };
       pump();
@@ -369,16 +434,17 @@ export class ModelProxy {
   } | { error: { status: number; message: string } } {
     const slashIdx = rawModelId.indexOf("/");
     let modelId: string;
-    let matchingModels: (typeof this.config.proxyModels)[number][];
+    const proxyModels = this.allProxyModels;
+    let matchingModels: (typeof proxyModels)[number][];
 
     if (slashIdx > 0) {
       const nodeId = rawModelId.slice(0, slashIdx);
       modelId = rawModelId.slice(slashIdx + 1);
       // Explicit node/model — only target that specific node, no failover to others
-      matchingModels = this.config.proxyModels.filter((m) => m.id === modelId && m.nodeId === nodeId);
+      matchingModels = proxyModels.filter((m) => m.id === modelId && m.nodeId === nodeId);
     } else {
       modelId = rawModelId;
-      matchingModels = this.config.proxyModels.filter((m) => m.id === modelId);
+      matchingModels = proxyModels.filter((m) => m.id === modelId);
     }
 
     if (matchingModels.length === 0) {
@@ -397,6 +463,16 @@ export class ModelProxy {
       }
     }
 
+    // Sort candidates by latency (lowest first) for optimal first-try and failover order
+    candidates.sort((a, b) => {
+      const routeA = this.peerManager.router.getRoute(a.routeNodeId);
+      const routeB = this.peerManager.router.getRoute(b.routeNodeId);
+      const aDirect = routeA?.connection ? 0 : 1;
+      const bDirect = routeB?.connection ? 0 : 1;
+      if (aDirect !== bDirect) return aDirect - bDirect;
+      return (routeA?.latencyMs ?? 0) - (routeB?.latencyMs ?? 0);
+    });
+
     debug("proxy", `model raw="${rawModelId}" modelId="${modelId}" candidates=${candidates.map((c) => c.routeNodeId).join(",") || "none"}`);
     if (candidates.length === 0) {
       return { error: { status: 502, message: `No reachable node for model "${rawModelId}"` } };
@@ -519,10 +595,21 @@ export class ModelProxy {
     const encoder = new TextEncoder();
     const model = frame.payload.model;
 
+    let streamController: ReadableStreamDefaultController;
     const readable = new ReadableStream({
       start: (controller) => {
+        streamController = controller;
         this.startStreamAttempt(requestId, targetNodeId, frame, responseFormat, controller, encoder, model, failoverCandidates, buildFrame);
       },
+      cancel: () => {
+        // Client disconnected — find and clean up the pending request using this controller
+        for (const [id, p] of this.pending) {
+          if (p.controller === streamController) {
+            this.cleanupRequest(id, p.stableStreamId);
+            break;
+          }
+        }
+      },
     });
 
     // Emit setup events for responses API (once, before any attempts)
@@ -556,7 +643,7 @@ export class ModelProxy {
       this.cleanupRequest(requestId);
       this.peerManager.router.markFailed(requestId);
       this.tryStreamFailover(stableId, responseFormat, controller, encoder, model, failoverCandidates, buildFrame, `model request to "${targetNodeId}" timed out`);
-    }, MODEL_TIMEOUT);
+    }, this.modelTimeout);
 
     this.pending.set(requestId, {
       resolve: () => {}, reject: () => {},
@@ -730,7 +817,7 @@ export class ModelProxy {
         this.pending.delete(requestId);
         this.peerManager.router.markFailed(requestId);
         reject(new Error(`Model request to "${targetNodeId}" timed out`));
-      }, MODEL_TIMEOUT);
+      }, this.modelTimeout);
 
       this.pending.set(requestId, {
         resolve: resolve as (v: unknown) => void,
@@ -814,7 +901,7 @@ export class ModelProxy {
         .map((p) => p.nodeId),
     );
 
-    const models = this.config.proxyModels.map((m) => {
+    const models = this.allProxyModels.map((m) => {
       const entry: Record<string, unknown> = {
         id: m.id,
         object: "model",
@@ -901,6 +988,7 @@ export class ModelProxy {
       }
     } catch {
       this.cleanupRequest(frame.id, pending.stableStreamId);
+      try { pending.controller?.close(); } catch { /* already closed */ }
     }
   }
 
@@ -920,7 +1008,10 @@ export class ModelProxy {
       this.cleanupRequest(frame.id, stableId);
     } else {
       // Use full deltaObj when available (carries tool_calls etc.), otherwise simple text delta
-      const delta = frame.payload.deltaObj ?? { content: frame.payload.delta };
+      const delta = frame.payload.deltaObj ?? {
+        content: frame.payload.delta,
+        ...(frame.payload.reasoningDelta && { reasoning_content: frame.payload.reasoningDelta }),
+      };
       const chunkStableId = pending.stableStreamId ?? frame.id;
       const chunk = { id: `chatcmpl-${chunkStableId}`, object: "chat.completion.chunk", choices: [{ index: 0, delta, finish_reason: null }] };
       pending.controller!.enqueue(pending.encoder!.encode(`data: ${JSON.stringify(chunk)}\n\n`));
@@ -962,14 +1053,19 @@ export class ModelProxy {
     }
   }
 
-  private sendStreamDelta(to: string, id: string, delta: string, deltaObj?: unknown) {
+  private sendStreamDelta(to: string, id: string, delta: string, deltaObj?: unknown, reasoningDelta?: string) {
     this.peerManager.sendTo(to, {
       type: "model_stream",
       id,
       from: this.config.nodeId,
       to,
       timestamp: Date.now(),
-      payload: { delta, ...(deltaObj !== undefined && { deltaObj }), done: false },
+      payload: {
+        delta,
+        ...(reasoningDelta && { reasoningDelta }),
+        ...(deltaObj !== undefined && { deltaObj }),
+        done: false,
+      },
     } satisfies ModelStreamChunk);
   }
 
@@ -1007,6 +1103,13 @@ export class ModelProxy {
 
     try {
       const endpoint = this.resolveModelEndpoint(model);
+      if (!endpoint) {
+        this.peerManager.sendTo(from, {
+          type: "model_res", id, from: this.config.nodeId, to: from, timestamp: Date.now(),
+          payload: { success: false, error: `No direct API endpoint configured for model "${payload.model}" (provider: ${model.provider}). Configure baseUrl/apiKey in ClawMatrix model config or OpenClaw provider config.` },
+        } satisfies ModelResponse);
+        return;
+      }
       // Use payload.api override from requesting side, or cached API from previous auto-detection
       const cached = this.modelApiCache.get(model.id);
       const cachedApi = (cached && Date.now() - cached.ts < ModelProxy.MODEL_API_CACHE_TTL) ? cached.api : undefined;
@@ -1017,16 +1120,10 @@ export class ModelProxy {
       const url = `${endpoint.baseUrl}${path}`;
       const headers: Record<string, string> = { "Content-Type": "application/json" };
 
-      if (endpoint.direct) {
-        if (endpoint.apiKey) headers["Authorization"] = `Bearer ${endpoint.apiKey}`;
-        debug("model_req", `direct API call to ${url} (api=${endpoint.api})`);
-      } else {
-        const { authHeader } = this.gatewayInfo;
-        if (authHeader) headers["Authorization"] = authHeader;
-        debug("model_req", `gateway fallback to ${url}`);
-      }
+      if (endpoint.apiKey) headers["Authorization"] = `Bearer ${endpoint.apiKey}`;
+      debug("model_req", `direct API call to ${url} (api=${endpoint.api})`);
 
-      const modelField = endpoint.direct ? model.id : `${model.provider}/${model.id}`;
+      const modelField = model.id;
       const srcFormat = payload.inputFormat ?? "chat";
 
       // Convert messages between formats if source and target API differ
@@ -1142,11 +1239,12 @@ export class ModelProxy {
                   // Chat completions format
                   lastUsage = parseUsage(parsed.usage) ?? lastUsage;
                   const d = parsed.choices?.[0]?.delta;
-                  const delta = d?.content || d?.reasoning_content || "";
+                  const delta = d?.content || "";
+                  const reasoningDelta = d?.reasoning_content || "";
                   // Pass full delta object when it contains tool_calls or other structured data
                   const hasStructured = d?.tool_calls || d?.refusal != null;
-                  if (delta || hasStructured) {
-                    this.sendStreamDelta(from, id, delta, hasStructured ? d : undefined);
+                  if (delta || reasoningDelta || hasStructured) {
+                    this.sendStreamDelta(from, id, delta, hasStructured ? d : undefined, reasoningDelta || undefined);
                     contentSent = true;
                   }
                 }
@@ -1206,11 +1304,13 @@ export class ModelProxy {
           result = {}; // unused — chatFallbackResult takes precedence
         }
         let content: string;
+        let reasoning = "";
         let message: unknown | undefined;
         let usage: { inputTokens: number; outputTokens: number } | undefined;
 
         if (chatFallbackResult) {
           ({ content, message, usage } = chatFallbackResult);
+          reasoning = chatFallbackResult.reasoning ?? "";
         } else if (isResponsesApi) {
           // Responses API: extract text from output[].content[].text
           content = "";
@@ -1249,12 +1349,15 @@ export class ModelProxy {
         } else {
           // Chat completions format
           const msg = result.choices?.[0]?.message;
-          content = msg?.content || msg?.reasoning_content || "";
+          content = msg?.content || "";
+          reasoning = msg?.reasoning_content || "";
           // Carry full message object when it has tool_calls or other structured data
           if (msg?.tool_calls || msg?.refusal != null || msg?.function_call) {
             message = msg;
           }
           usage = parseUsage(result.usage);
+          // If no content but has reasoning, use reasoning as content fallback
+          if (!content && reasoning) content = reasoning;
         }
 
         this.peerManager.sendTo(from, {
@@ -1266,6 +1369,7 @@ export class ModelProxy {
           payload: {
             success: true,
             content,
+            ...(reasoning && { reasoning }),
             ...(message !== undefined && { message }),
             usage,
           },
@@ -1292,7 +1396,7 @@ export class ModelProxy {
     modelField: string,
     payload: ModelRequest["payload"],
     headers: Record<string, string>,
-  ): Promise<{ content: string; message?: unknown; usage?: { inputTokens: number; outputTokens: number } } | null> {
+  ): Promise<{ content: string; reasoning?: string; message?: unknown; usage?: { inputTokens: number; outputTokens: number } } | null> {
     try {
       const srcFormat = payload.inputFormat ?? "chat";
       const messages = srcFormat === "chat"
@@ -1316,10 +1420,11 @@ export class ModelProxy {
       if (!chatResp.ok) return null;
       const chatResult = await chatResp.json();
       const msg = chatResult.choices?.[0]?.message;
-      const content = msg?.content || msg?.reasoning_content || "";
+      const content = msg?.content || "";
+      const reasoningContent = msg?.reasoning_content || "";
       const message = (msg?.tool_calls || msg?.refusal != null || msg?.function_call) ? msg : undefined;
       const usage = parseUsage(chatResult.usage);
-      return { content, message, usage };
+      return { content: content || reasoningContent, reasoning: reasoningContent || undefined, message, usage };
     } catch (err) {
       debug("model_req", `retryWithChatCompletions failed for "${modelField}": ${err instanceof Error ? err.message : String(err)}`);
       return null;