openclaw-mcp 1.2.1 → 1.3.1

package/dist/index.js

@@ -4,15 +4,14 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/config/constants.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../../package.json");
 var SERVER_NAME = "openclaw-mcp";
-var SERVER_VERSION = pkg.version;
+var SERVER_VERSION = "1.3.1";
 var DEFAULT_OPENCLAW_URL = "http://127.0.0.1:18789";
+var DEFAULT_MODEL = "openclaw";
 var SERVER_ICON_SVG_BASE64 = "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjgiIGhlaWdodD0iMTI4IiB2aWV3Qm94PSIwIDAgMTI4IDEyOCIgZmlsbD0ibm9uZSI+PGRlZnM+PGxpbmVhckdyYWRpZW50IGlkPSJiZyIgeDE9IjAlIiB5MT0iMCUiIHgyPSIxMDAlIiB5Mj0iMTAwJSI+PHN0b3Agb2Zmc2V0PSIwJSIgc3RvcC1jb2xvcj0iIzFhMWEyZSIvPjxzdG9wIG9mZnNldD0iMTAwJSIgc3RvcC1jb2xvcj0iIzE2MjEzZSIvPjwvbGluZWFyR3JhZGllbnQ+PGxpbmVhckdyYWRpZW50IGlkPSJjbGF3IiB4MT0iMCUiIHkxPSIwJSIgeDI9IjEwMCUiIHkyPSIxMDAlIj48c3RvcCBvZmZzZXQ9IjAlIiBzdG9wLWNvbG9yPSIjZmYzMzMzIi8+PHN0b3Agb2Zmc2V0PSIxMDAlIiBzdG9wLWNvbG9yPSIjY2MwMDAwIi8+PC9saW5lYXJHcmFkaWVudD48L2RlZnM+PHJlY3Qgd2lkdGg9IjEyOCIgaGVpZ2h0PSIxMjgiIHJ4PSIyNCIgZmlsbD0idXJsKCNiZykiLz48ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSg2NCA2NCkiIHN0cm9rZT0idXJsKCNjbGF3KSIgc3Ryb2tlLXdpZHRoPSI3IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik0tMjggLTM4YzAgMCAtMTAgMjAgMCAzMiIvPjxwYXRoIGQ9Ik0tMTIgLTQwYzAgMCAtNiAyMiA0IDM0Ii8+PHBhdGggZD0iTTI4IC0zOGMwIDAgMTAgMjAgMCAzMiIvPjxwYXRoIGQ9Ik0xMiAtNDBjMCAwIDYgMjIgLTQgMzQiLz48Y2lyY2xlIGN4PSIwIiBjeT0iMTAiIHI9IjIwIiBzdHJva2Utd2lkdGg9IjYiLz48cGF0aCBkPSJNLTEwIDR2LTQiIHN0cm9rZS13aWR0aD0iNCIvPjxwYXRoIGQ9Ik0xMCA0di00IiBzdHJva2Utd2lkdGg9IjQiLz48cGF0aCBkPSJNLTggMjBjNCA2IDEyIDYgMTYgMCIgc3Ryb2tlLXdpZHRoPSIzIi8+PC9nPjwvc3ZnPg==";
 
 // src/utils/logger.ts
+var debugEnabled = false;
 var SENSITIVE_PATTERNS = [
   /Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi,
   /api[_-]?key["\s:=]+[A-Za-z0-9\-._~+/]{8,}/gi,
@@ -30,6 +29,19 @@ function sanitizeLogMessage(message) {
 function log(message) {
   console.error(`[openclaw-mcp] ${sanitizeLogMessage(message)}`);
 }
+function setDebugEnabled(enabled) {
+  debugEnabled = enabled;
+}
+function isDebugEnabled() {
+  return debugEnabled;
+}
+function logDebug(messageOrFactory) {
+  if (!debugEnabled) {
+    return;
+  }
+  const message = typeof messageOrFactory === "function" ? messageOrFactory() : messageOrFactory;
+  console.error(`[openclaw-mcp] DEBUG: ${sanitizeLogMessage(message)}`);
+}
 function logError(message, error) {
   console.error(`[openclaw-mcp] ERROR: ${sanitizeLogMessage(message)}`);
   if (error) {
@@ -54,6 +66,11 @@ function parseArguments(version) {
     type: "string",
     description: "Bearer token for OpenClaw gateway authentication",
     default: process.env.OPENCLAW_GATEWAY_TOKEN || void 0
+  }).option("model", {
+    alias: "m",
+    type: "string",
+    description: "Model name for chat completions",
+    default: process.env.OPENCLAW_MODEL || DEFAULT_MODEL
   }).option("transport", {
     alias: "t",
     type: "string",
@@ -73,6 +90,10 @@ function parseArguments(version) {
     type: "number",
     description: "Request timeout in milliseconds",
     default: parseInt(process.env.OPENCLAW_TIMEOUT_MS || "120000", 10)
+  }).option("debug", {
+    type: "boolean",
+    description: "Enable debug logging",
+    default: process.env.DEBUG === "true" || process.env.NODE_ENV === "development"
   }).option("auth", {
     type: "boolean",
     description: "Enable OAuth authentication (SSE mode)",
@@ -94,18 +115,60 @@ function parseArguments(version) {
     description: "Allowed OAuth redirect URIs (comma-separated)",
     default: process.env.MCP_REDIRECT_URIS || void 0
   }).help().parseSync();
+  let instances;
+  const instancesEnv = process.env.OPENCLAW_INSTANCES;
+  if (instancesEnv) {
+    try {
+      const parsed = JSON.parse(instancesEnv);
+      if (!Array.isArray(parsed) || parsed.length === 0) {
+        throw new Error("OPENCLAW_INSTANCES must be a non-empty JSON array");
+      }
+      for (const item of parsed) {
+        if (!item || typeof item.name !== "string" || !item.name.trim()) {
+          throw new Error(
+            'Each instance in OPENCLAW_INSTANCES must have a non-empty string "name"'
+          );
+        }
+        if (typeof item.url !== "string" || !item.url.trim()) {
+          throw new Error(`Instance "${item.name}": must have a non-empty string "url"`);
+        }
+      }
+      instances = parsed.map((cfg) => ({
+        ...cfg,
+        timeout: cfg.timeout ?? argv.timeout
+      }));
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`OPENCLAW_INSTANCES contains invalid JSON: ${error.message}`);
+      }
+      throw error;
+    }
+  } else {
+    instances = [
+      {
+        name: "default",
+        url: argv["openclaw-url"],
+        token: argv["gateway-token"],
+        timeout: argv.timeout,
+        default: true
+      }
+    ];
+  }
   return {
     openclawUrl: argv["openclaw-url"],
     gatewayToken: argv["gateway-token"],
+    model: argv.model,
     transport: argv.transport,
     port: argv.port,
     host: argv.host,
     timeout: argv.timeout,
+    debug: argv.debug,
     authEnabled: argv.auth,
     clientId: argv["client-id"],
     clientSecret: argv["client-secret"],
     issuerUrl: argv["issuer-url"],
-    redirectUris: argv["redirect-uris"] ? argv["redirect-uris"].split(",").map((s) => s.trim()).filter(Boolean) : void 0
+    redirectUris: argv["redirect-uris"] ? argv["redirect-uris"].split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+    instances
   };
 }
 
@@ -134,14 +197,17 @@ var OpenClawApiError = class extends OpenClawError {
 // src/openclaw/client.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_RESPONSE_SIZE_BYTES = 10 * 1024 * 1024;
+var MAX_DEBUG_BODY_LENGTH = 4096;
 var OpenClawClient = class {
   baseUrl;
   gatewayToken;
   timeoutMs;
-  constructor(baseUrl, gatewayToken, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  model;
+  constructor(baseUrl, gatewayToken, timeoutMs = DEFAULT_TIMEOUT_MS, model = "openclaw") {
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.gatewayToken = gatewayToken;
     this.timeoutMs = timeoutMs;
+    this.model = model;
   }
   buildHeaders() {
     const headers = {
@@ -152,8 +218,16 @@ var OpenClawClient = class {
     }
     return headers;
   }
+  truncateForLog(value) {
+    if (value.length <= MAX_DEBUG_BODY_LENGTH) return value;
+    return value.slice(0, MAX_DEBUG_BODY_LENGTH) + `... (truncated, ${value.length} chars total)`;
+  }
   async request(path, options = {}) {
     const url = `${this.baseUrl}${path}`;
+    logDebug(() => `Request: ${options.method ?? "GET"} ${url}`);
+    if (options.body) {
+      logDebug(() => `Request body: ${this.truncateForLog(options.body)}`);
+    }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
     try {
@@ -166,11 +240,23 @@ var OpenClawClient = class {
         }
       });
       if (!response.ok) {
+        if (isDebugEnabled()) {
+          const contentLength2 = response.headers.get("content-length");
+          if (!contentLength2 || parseInt(contentLength2, 10) <= MAX_RESPONSE_SIZE_BYTES) {
+            const errorBody = await response.text();
+            if (errorBody.length <= MAX_RESPONSE_SIZE_BYTES) {
+              logDebug(
+                () => `Response error (${response.status}): ${this.truncateForLog(errorBody)}`
+              );
+            }
+          }
+        }
         throw new OpenClawApiError(
           `API request failed: ${response.status} ${response.statusText}`,
           response.status
         );
       }
+      logDebug(() => `Response: ${response.status} ${response.statusText}`);
       const contentLength = response.headers.get("content-length");
       if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE_BYTES) {
         throw new OpenClawApiError("Response exceeds maximum allowed size (10MB)", 413);
@@ -239,7 +325,7 @@ var OpenClawClient = class {
    */
   async chat(message, sessionId) {
     const body = {
-      model: "claude-opus-4-5",
+      model: this.model,
       messages: [{ role: "user", content: message }],
       max_tokens: 4096
     };
@@ -264,6 +350,120 @@ var OpenClawClient = class {
   }
 };
 
+// src/openclaw/registry.ts
+var INSTANCE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var InstanceRegistry = class {
+  instances = /* @__PURE__ */ new Map();
+  defaultName;
+  constructor(configs, model) {
+    if (configs.length === 0) {
+      throw new Error("At least one OpenClaw instance must be configured");
+    }
+    const names = /* @__PURE__ */ new Set();
+    let explicitDefault;
+    for (const config of configs) {
+      if (!INSTANCE_NAME_RE.test(config.name)) {
+        throw new Error(
+          `Invalid instance name "${config.name}": must be 1-64 chars, alphanumeric/dashes/underscores, start with alphanumeric`
+        );
+      }
+      try {
+        const parsed = new URL(config.url);
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+          throw new Error(
+            `Instance "${config.name}": URL must use http or https (got ${parsed.protocol})`
+          );
+        }
+      } catch (error) {
+        if (error instanceof TypeError) {
+          throw new Error(`Instance "${config.name}": invalid URL "${config.url}"`);
+        }
+        throw error;
+      }
+      if (names.has(config.name)) {
+        throw new Error(`Duplicate instance name: "${config.name}"`);
+      }
+      names.add(config.name);
+      if (config.default) {
+        if (explicitDefault) {
+          throw new Error(
+            `Multiple default instances: "${explicitDefault}" and "${config.name}". Only one default is allowed.`
+          );
+        }
+        explicitDefault = config.name;
+      }
+      const client = new OpenClawClient(config.url, config.token, config.timeout, model);
+      this.instances.set(config.name, { config, client });
+    }
+    this.defaultName = explicitDefault ?? configs[0].name;
+  }
+  /**
+   * Get client by instance name. Returns undefined if not found.
+   */
+  get(name) {
+    return this.instances.get(name)?.client;
+  }
+  /**
+   * Get the default client.
+   */
+  getDefault() {
+    const entry = this.instances.get(this.defaultName);
+    if (!entry) {
+      throw new Error(`Default instance "${this.defaultName}" not found`);
+    }
+    return entry.client;
+  }
+  /**
+   * Get the default instance name.
+   */
+  getDefaultName() {
+    return this.defaultName;
+  }
+  /**
+   * Resolve an optional instance name to a concrete client.
+   * Falls back to default when name is undefined.
+   */
+  resolve(name) {
+    if (!name) {
+      return { name: this.defaultName, client: this.getDefault() };
+    }
+    const client = this.get(name);
+    if (!client) {
+      const available = this.listNames().join(", ");
+      throw new Error(`Unknown instance "${name}". Available: ${available}`);
+    }
+    return { name, client };
+  }
+  /**
+   * List instance names.
+   */
+  listNames() {
+    return Array.from(this.instances.keys());
+  }
+  /**
+   * List instances with safe metadata (never exposes tokens).
+   */
+  list() {
+    return Array.from(this.instances.entries()).map(([name, { config }]) => ({
+      name,
+      url: config.url,
+      isDefault: name === this.defaultName
+    }));
+  }
+  /**
+   * Number of registered instances.
+   */
+  get size() {
+    return this.instances.size;
+  }
+  /**
+   * Check if this is a single-instance (backward-compat) setup.
+   */
+  get isSingleInstance() {
+    return this.instances.size === 1;
+  }
+};
+
 // src/server/tools-registration.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -332,12 +532,16 @@ var openclawChatTool = {
       session_id: {
         type: "string",
         description: "Optional session ID for conversation context"
+      },
+      instance: {
+        type: "string",
+        description: "Target OpenClaw instance name. Use openclaw_instances to list available instances. Defaults to the default instance."
       }
     },
     required: ["message"]
   }
 };
-async function handleOpenclawChat(client2, input) {
+async function handleOpenclawChat(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -353,8 +557,17 @@ async function handleOpenclawChat(client2, input) {
     }
     sessionId = sidResult.value;
   }
+  let instanceName;
+  if (input.instance !== void 0) {
+    const instResult = validateId(input.instance, "instance");
+    if (instResult.valid === false) {
+      return errorResponse(instResult.error);
+    }
+    instanceName = instResult.value;
+  }
   try {
-    const response = await client2.chat(msgResult.value, sessionId);
+    const { client } = registry2.resolve(instanceName);
+    const response = await client.chat(msgResult.value, sessionId);
     return successResponse(response.response);
   } catch (error) {
     return errorResponse(error instanceof Error ? error.message : "Failed to chat with OpenClaw");
@@ -367,16 +580,33 @@ var openclawStatusTool = {
   description: "Get OpenClaw gateway status and health information",
   inputSchema: {
     type: "object",
-    properties: {}
+    properties: {
+      instance: {
+        type: "string",
+        description: "Target OpenClaw instance name. Defaults to the default instance."
+      }
+    }
   }
 };
-async function handleOpenclawStatus(client2, input) {
+async function handleOpenclawStatus(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
+  let instanceName;
+  if (input.instance !== void 0) {
+    const instResult = validateId(input.instance, "instance");
+    if (instResult.valid === false) {
+      return errorResponse(instResult.error);
+    }
+    instanceName = instResult.value;
+  }
   try {
-    const response = await client2.health();
-    return jsonResponse(response);
+    const resolved = registry2.resolve(instanceName);
+    const response = await resolved.client.health();
+    return jsonResponse({
+      ...response,
+      instance: resolved.name
+    });
   } catch (error) {
     return errorResponse(
       error instanceof Error ? error.message : "Failed to get status from OpenClaw"
@@ -384,6 +614,22 @@ async function handleOpenclawStatus(client2, input) {
   }
 }
 
+// src/mcp/tools/instances.ts
+var openclawInstancesTool = {
+  name: "openclaw_instances",
+  description: "List all configured OpenClaw instances. Shows instance names, URLs, and which is the default. Use instance names in other tools to target a specific OpenClaw gateway.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleOpenclawInstances(registry2, _input) {
+  return jsonResponse({
+    instances: registry2.list(),
+    total: registry2.size
+  });
+}
+
 // src/mcp/tasks/manager.ts
 var MAX_TASKS = 1e3;
 var CLEANUP_INTERVAL_MS = 10 * 60 * 1e3;
@@ -424,6 +670,7 @@ var TaskManager = class {
       input: options.input,
       createdAt: /* @__PURE__ */ new Date(),
       sessionId: options.sessionId,
+      instanceId: options.instanceId,
       priority: options.priority ?? 0
     };
     this.tasks.set(id, task);
@@ -447,6 +694,9 @@ var TaskManager = class {
     if (filter?.sessionId) {
       tasks = tasks.filter((t) => t.sessionId === filter.sessionId);
     }
+    if (filter?.instanceId) {
+      tasks = tasks.filter((t) => t.instanceId === filter.instanceId);
+    }
     return tasks.sort((a, b) => {
       if (b.priority !== a.priority) return b.priority - a.priority;
       return a.createdAt.getTime() - b.createdAt.getTime();
@@ -554,6 +804,10 @@ var openclawChatAsyncTool = {
       priority: {
         type: "number",
         description: "Task priority (higher = processed first). Default: 0"
+      },
+      instance: {
+        type: "string",
+        description: "Target OpenClaw instance name. Defaults to the default instance."
       }
     },
     required: ["message"]
@@ -575,7 +829,7 @@ var openclawTaskStatusTool = {
 };
 var openclawTaskListTool = {
   name: "openclaw_task_list",
-  description: "List all tasks. Optionally filter by status or session.",
+  description: "List all tasks. Optionally filter by status, session, or instance.",
   inputSchema: {
     type: "object",
     properties: {
@@ -587,6 +841,10 @@ var openclawTaskListTool = {
       session_id: {
         type: "string",
         description: "Filter by session ID"
+      },
+      instance: {
+        type: "string",
+        description: "Filter by instance name"
       }
     },
     required: []
@@ -607,12 +865,20 @@ var openclawTaskCancelTool = {
   }
 };
 var processorRunning = false;
-var processorClient = null;
-async function processTask(task, client2) {
+var processorRegistry = null;
+async function processTask(task, registry2) {
   taskManager.updateStatus(task.id, "running");
+  let client;
+  try {
+    client = registry2.resolve(task.instanceId).client;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Instance not available";
+    taskManager.updateStatus(task.id, "failed", void 0, errorMsg);
+    return;
+  }
   try {
     const input = task.input;
-    const response = await client2.chat(input.message, input.session_id);
+    const response = await client.chat(input.message, input.session_id);
     taskManager.updateStatus(task.id, "completed", response.response);
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : "Unknown error";
@@ -620,26 +886,26 @@ async function processTask(task, client2) {
   }
 }
 async function taskProcessor() {
-  if (!processorClient) return;
+  if (!processorRegistry) return;
   while (processorRunning) {
     const task = taskManager.getNextPending();
     if (task) {
-      await processTask(task, processorClient);
+      await processTask(task, processorRegistry);
     } else {
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
   }
 }
-function startTaskProcessor(client2) {
+function startTaskProcessor(registry2) {
   if (processorRunning) return;
-  processorClient = client2;
+  processorRegistry = registry2;
   processorRunning = true;
   taskProcessor().catch(() => {
     processorRunning = false;
   });
   log("Task processor started");
 }
-async function handleOpenclawChatAsync(client2, input) {
+async function handleOpenclawChatAsync(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -662,18 +928,35 @@ async function handleOpenclawChatAsync(client2, input) {
     }
     priority = input.priority;
   }
-  startTaskProcessor(client2);
+  let instanceId;
+  try {
+    let instanceName;
+    if (input.instance !== void 0) {
+      const instResult = validateId(input.instance, "instance");
+      if (instResult.valid === false) {
+        return errorResponse(instResult.error);
+      }
+      instanceName = instResult.value;
+    }
+    const resolved = registry2.resolve(instanceName);
+    instanceId = resolved.name;
+  } catch (error) {
+    return errorResponse(error instanceof Error ? error.message : "Invalid instance");
+  }
+  startTaskProcessor(registry2);
   const task = taskManager.create({
     type: "chat",
     input: { message: msgResult.value, session_id: sessionId },
     sessionId,
-    priority
+    priority,
+    instanceId
   });
   return successResponse(
     JSON.stringify(
       {
         task_id: task.id,
         status: task.status,
+        instance: instanceId,
         message: "Task queued. Use openclaw_task_status to check progress."
       },
       null,
@@ -681,7 +964,7 @@ async function handleOpenclawChatAsync(client2, input) {
     )
   );
 }
-async function handleOpenclawTaskStatus(_client, input) {
+async function handleOpenclawTaskStatus(_registry, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -698,6 +981,7 @@ async function handleOpenclawTaskStatus(_client, input) {
     task_id: task.id,
     type: task.type,
     status: task.status,
+    instance: task.instanceId,
     created_at: task.createdAt.toISOString()
   };
   if (task.startedAt) {
@@ -721,7 +1005,7 @@ var VALID_TASK_STATUSES = [
   "failed",
   "cancelled"
 ];
-async function handleOpenclawTaskList(_client, input) {
+async function handleOpenclawTaskList(_registry, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -740,12 +1024,21 @@ async function handleOpenclawTaskList(_client, input) {
     }
     session_id = sidResult.value;
   }
-  const tasks = taskManager.list({ status, sessionId: session_id });
+  let instanceFilter;
+  if (input.instance !== void 0) {
+    const instResult = validateId(input.instance, "instance");
+    if (instResult.valid === false) {
+      return errorResponse(instResult.error);
+    }
+    instanceFilter = instResult.value;
+  }
+  const tasks = taskManager.list({ status, sessionId: session_id, instanceId: instanceFilter });
   const stats = taskManager.stats();
   const taskList = tasks.map((t) => ({
     task_id: t.id,
     type: t.type,
     status: t.status,
+    instance: t.instanceId,
     priority: t.priority,
     created_at: t.createdAt.toISOString(),
     has_result: t.status === "completed" && !!t.result
@@ -761,7 +1054,7 @@ async function handleOpenclawTaskList(_client, input) {
     )
   );
 }
-async function handleOpenclawTaskCancel(_client, input) {
+async function handleOpenclawTaskCancel(_registry, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -816,14 +1109,15 @@ function createMcpServer(deps2) {
   return server;
 }
 function registerTools(server, deps2) {
-  const { client: client2 } = deps2;
+  const { registry: registry2 } = deps2;
   const toolHandlers = /* @__PURE__ */ new Map([
-    ["openclaw_chat", (input) => handleOpenclawChat(client2, input)],
-    ["openclaw_status", (input) => handleOpenclawStatus(client2, input)],
-    ["openclaw_chat_async", (input) => handleOpenclawChatAsync(client2, input)],
-    ["openclaw_task_status", (input) => handleOpenclawTaskStatus(client2, input)],
-    ["openclaw_task_list", (input) => handleOpenclawTaskList(client2, input)],
-    ["openclaw_task_cancel", (input) => handleOpenclawTaskCancel(client2, input)]
+    ["openclaw_chat", (input) => handleOpenclawChat(registry2, input)],
+    ["openclaw_status", (input) => handleOpenclawStatus(registry2, input)],
+    ["openclaw_chat_async", (input) => handleOpenclawChatAsync(registry2, input)],
+    ["openclaw_task_status", (input) => handleOpenclawTaskStatus(registry2, input)],
+    ["openclaw_task_list", (input) => handleOpenclawTaskList(registry2, input)],
+    ["openclaw_task_cancel", (input) => handleOpenclawTaskCancel(registry2, input)],
+    ["openclaw_instances", (input) => handleOpenclawInstances(registry2, input)]
   ]);
   const allTools = [
     openclawChatTool,
@@ -831,7 +1125,8 @@ function registerTools(server, deps2) {
     openclawChatAsyncTool,
     openclawTaskStatusTool,
     openclawTaskListTool,
-    openclawTaskCancelTool
+    openclawTaskCancelTool,
+    openclawInstancesTool
   ];
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: allTools };
@@ -941,9 +1236,9 @@ var OpenClawAuthProvider = class {
   /**
    * Auto-approve: generate auth code and redirect immediately.
    */
-  async authorize(client2, params, res) {
+  async authorize(client, params, res) {
     const code = randomUUID();
-    this.codes.set(code, { client: client2, params, createdAt: Date.now() });
+    this.codes.set(code, { client, params, createdAt: Date.now() });
     const searchParams = new URLSearchParams({ code });
     if (params.state !== void 0) {
       searchParams.set("state", params.state);
@@ -960,13 +1255,13 @@ var OpenClawAuthProvider = class {
     }
     return codeData.params.codeChallenge;
   }
-  async exchangeAuthorizationCode(client2, authorizationCode, _codeVerifier, _redirectUri, resource) {
+  async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, _redirectUri, resource) {
     const codeData = this.codes.get(authorizationCode);
     if (!codeData || Date.now() - codeData.createdAt > AUTH_CODE_TTL_MS) {
       if (codeData) this.codes.delete(authorizationCode);
       throw new InvalidRequestError("Invalid authorization code");
     }
-    if (codeData.client.client_id !== client2.client_id) {
+    if (codeData.client.client_id !== client.client_id) {
       throw new InvalidRequestError("Authorization code was not issued to this client");
     }
     this.codes.delete(authorizationCode);
@@ -975,13 +1270,13 @@ var OpenClawAuthProvider = class {
     const scopes = codeData.params.scopes || [];
     this.tokens.set(accessToken, {
       token: accessToken,
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes,
       expiresAt: Date.now() + TOKEN_TTL_MS,
       resource: resource || codeData.params.resource
     });
     this.refreshTokens.set(refreshToken, {
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes,
       expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS,
       resource: resource || codeData.params.resource
@@ -994,13 +1289,13 @@ var OpenClawAuthProvider = class {
       scope: scopes.join(" ")
     };
   }
-  async exchangeRefreshToken(client2, refreshToken, scopes, resource) {
+  async exchangeRefreshToken(client, refreshToken, scopes, resource) {
     const data = this.refreshTokens.get(refreshToken);
     if (!data || data.expiresAt < Date.now()) {
       if (data) this.refreshTokens.delete(refreshToken);
       throw new InvalidRequestError("Invalid refresh token");
     }
-    if (data.clientId !== client2.client_id) {
+    if (data.clientId !== client.client_id) {
       throw new InvalidRequestError("Refresh token was not issued to this client");
     }
     this.refreshTokens.delete(refreshToken);
@@ -1009,13 +1304,13 @@ var OpenClawAuthProvider = class {
     const tokenScopes = scopes || data.scopes;
     this.tokens.set(accessToken, {
       token: accessToken,
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes: tokenScopes,
       expiresAt: Date.now() + TOKEN_TTL_MS,
       resource: resource || data.resource
     });
     this.refreshTokens.set(newRefreshToken, {
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes: tokenScopes,
       expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS,
       resource: resource || data.resource
@@ -1284,18 +1579,31 @@ async function createSSEServer(config, deps2) {
 
 // src/index.ts
 var args = parseArguments(SERVER_VERSION);
-var client = new OpenClawClient(args.openclawUrl, args.gatewayToken, args.timeout);
+setDebugEnabled(args.debug);
+var trimmedModel = args.model.trim();
+if (!trimmedModel) {
+  logError('OPENCLAW_MODEL / --model must be a non-empty string. Default is "openclaw".');
+  process.exit(1);
+}
+args.model = trimmedModel;
+var registry = new InstanceRegistry(args.instances, args.model);
 var deps = {
-  client,
+  registry,
   serverName: SERVER_NAME,
   serverVersion: SERVER_VERSION
 };
 async function main() {
   log(`Starting ${SERVER_NAME} v${SERVER_VERSION}`);
-  log(`OpenClaw URL: ${args.openclawUrl}`);
+  log(`Model: ${args.model}`);
   log(`Transport: ${args.transport}`);
-  log(`Gateway token: ${args.gatewayToken ? "configured" : "not set"}`);
   log(`Request timeout: ${args.timeout}ms`);
+  if (args.debug) {
+    log("Debug logging: enabled");
+  }
+  for (const instance of registry.list()) {
+    const defaultLabel = instance.isDefault ? " (default)" : "";
+    log(`Instance "${instance.name}": ${instance.url}${defaultLabel}`);
+  }
   if (args.transport === "sse") {
     const sseConfig = {
       port: args.port,