clawmatrix 0.1.20 → 0.1.22

package/src/router.ts

@@ -299,6 +299,16 @@ export class Router {
   }
 
   // ── Accessors ──────────────────────────────────────────────────
+  /** Get the connectivity status of a peer: "direct", "relay", or "unreachable". */
+  getPeerStatus(entry: RouteEntry): "direct" | "relay" | "unreachable" {
+    if (entry.connection?.isOpen) return "direct";
+    if (entry.reachableVia) {
+      const relay = this.connections.get(entry.reachableVia);
+      if (relay?.isOpen) return "relay";
+    }
+    return "unreachable";
+  }
+
   getAllPeers(): RouteEntry[] {
     return [...this.routes.values()];
   }

package/src/tool-proxy.ts

@@ -1,6 +1,7 @@
 import type { PeerManager } from "./peer-manager.ts";
 import type { ClawMatrixConfig, ToolProxyConfig } from "./config.ts";
 import type { ToolProxyRequest, ToolProxyResponse } from "./types.ts";
+import type { PluginLogger } from "openclaw/plugin-sdk";
 import { isLocalTool, executeLocally } from "./local-tools.ts";
 
 const TOOL_TIMEOUT = 30_000;
@@ -27,12 +28,14 @@ export class ToolProxy {
   private peerManager: PeerManager;
   private pending = new Map<string, PendingToolReq>();
   private gatewayInfo: GatewayInfo;
+  private logger: PluginLogger;
   private satelliteHandler: SatelliteToolHandler | null = null;
 
-  constructor(config: ClawMatrixConfig, peerManager: PeerManager, gatewayInfo: GatewayInfo) {
+  constructor(config: ClawMatrixConfig, peerManager: PeerManager, gatewayInfo: GatewayInfo, logger: PluginLogger) {
     this.config = config;
     this.peerManager = peerManager;
     this.gatewayInfo = gatewayInfo;
+    this.logger = logger;
   }
 
   /** Set the satellite tool handler (called by ClusterRuntime after WebHandler is created). */
@@ -62,12 +65,14 @@ export class ToolProxy {
     if (!route) {
       if (this.satelliteHandler?.isSatelliteNode(node)) {
         const id = crypto.randomUUID();
+        this.logger.info(`[clawmatrix] Tool invoke: "${tool}" -> satellite node "${node}" (id=${id})`);
         return this.satelliteHandler.queueToolForSatellite(node, id, tool, params, timeout);
       }
       throw new Error(`Node "${node}" not reachable`);
     }
 
     const id = crypto.randomUUID();
+    this.logger.info(`[clawmatrix] Tool invoke: "${tool}" -> node "${node}" (id=${id})`);
     const frame: ToolProxyRequest = {
       type: "tool_req",
       id,
@@ -106,8 +111,10 @@ export class ToolProxy {
     this.pending.delete(frame.id);
 
     if (frame.payload.success && frame.payload.result) {
+      this.logger.info(`[clawmatrix] Tool response: id=${frame.id} from="${frame.from}" success`);
       pending.resolve(frame.payload.result);
     } else {
+      this.logger.warn(`[clawmatrix] Tool response: id=${frame.id} from="${frame.from}" failed: ${frame.payload.error}`);
       pending.reject(new Error(frame.payload.error ?? "Remote tool execution failed"));
     }
   }
@@ -126,6 +133,7 @@ export class ToolProxy {
     }
 
     if (!this.isToolAllowed(payload.tool, toolProxyConfig)) {
+      this.logger.warn(`[clawmatrix] Tool request denied: "${payload.tool}" from="${from}" (not allowed)`);
       this.sendResponse(id, from, {
         success: false,
         error: `Tool "${payload.tool}" not allowed on this node`,
@@ -133,13 +141,17 @@ export class ToolProxy {
       return;
     }
 
+    this.logger.info(`[clawmatrix] Tool request: "${payload.tool}" from="${from}" (id=${id})`);
+
     try {
       const result = isLocalTool(payload.tool)
         ? await executeLocally(payload.tool, payload.params)
         : await this.executeViaGateway(payload.tool, payload.params);
 
+      this.logger.info(`[clawmatrix] Tool executed: "${payload.tool}" id=${id} success`);
       this.sendResponse(id, from, { success: true, result });
     } catch (err) {
+      this.logger.error(`[clawmatrix] Tool executed: "${payload.tool}" id=${id} failed: ${err}`);
       this.sendResponse(id, from, {
         success: false,
         error: err instanceof Error ? err.message : String(err),

package/src/tools/cluster-peers.ts

@@ -24,7 +24,7 @@ export function createClusterPeersTool(): AnyAgentTool {
           models: entry.models.map((m) => m.id),
           tags: entry.tags,
           tools: entry.toolProxy?.enabled ? (entry.toolProxy.allow ?? []) : [],
-          status: entry.connection?.isOpen ? "connected" : "unreachable",
+          status: runtime.peerManager.router.getPeerStatus(entry),
           latencyMs: entry.latencyMs,
         }));
 

package/src/types.ts

@@ -98,6 +98,9 @@ export interface ModelRequest extends ClusterFrame {
     provider?: string;
     api?: string;
     messages: unknown[];
+    /** Format of `messages`: "chat" = OpenAI chat completions, "responses" = OpenAI Responses API input items.
+     *  Defaults to "chat" for backward compatibility. */
+    inputFormat?: "chat" | "responses";
     temperature?: number;
     maxTokens?: number;
     stream: boolean;