openclaw-mcp 1.5.0 → 2.0.0-beta.1

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 
 // src/config/constants.ts
 var SERVER_NAME = "openclaw-mcp";
-var SERVER_VERSION = "1.5.0";
+var SERVER_VERSION = "2.0.0-beta.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==";
@@ -75,7 +75,7 @@ function parseArguments(version) {
     alias: "t",
     type: "string",
     choices: ["stdio", "http", "sse"],
-    description: 'Transport mode (stdio for local, http for remote; "sse" is a deprecated alias for "http")',
+    description: 'Transport mode (stdio for local, http for remote; "sse" was removed in v2.0 and exits with an error)',
     default: "stdio"
   }).option("port", {
     alias: "p",
@@ -208,16 +208,26 @@ var OpenClawApiError = class extends OpenClawError {
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_RESPONSE_SIZE_BYTES = 10 * 1024 * 1024;
 var MAX_DEBUG_BODY_LENGTH = 4096;
+var DEFAULT_MAX_STREAM_MS = 30 * 60 * 1e3;
+var FINISH_GRACE_MS = 2e3;
+var OpenClawCancelledError = class extends Error {
+  constructor(message = "Request was cancelled") {
+    super(message);
+    this.name = "OpenClawCancelledError";
+  }
+};
 var OpenClawClient = class {
   baseUrl;
   gatewayToken;
   timeoutMs;
   model;
-  constructor(baseUrl, gatewayToken, timeoutMs = DEFAULT_TIMEOUT_MS, model = "openclaw") {
+  maxStreamMs;
+  constructor(baseUrl, gatewayToken, timeoutMs = DEFAULT_TIMEOUT_MS, model = "openclaw", maxStreamMs = DEFAULT_MAX_STREAM_MS) {
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.gatewayToken = gatewayToken;
     this.timeoutMs = timeoutMs;
     this.model = model;
+    this.maxStreamMs = Math.max(maxStreamMs, timeoutMs);
   }
   buildHeaders() {
     const headers = {
@@ -232,6 +242,43 @@ var OpenClawClient = class {
     if (value.length <= MAX_DEBUG_BODY_LENGTH) return value;
     return value.slice(0, MAX_DEBUG_BODY_LENGTH) + `... (truncated, ${value.length} chars total)`;
   }
+  /**
+   * Wire an external AbortSignal to the internal controller so both
+   * timeout aborts and caller-initiated cancels stop the request.
+   */
+  linkSignal(controller, signal) {
+    if (!signal) return () => {
+    };
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return () => {
+      };
+    }
+    const onAbort = () => controller.abort(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => signal.removeEventListener("abort", onAbort);
+  }
+  /**
+   * Classify an aborted request. The caller's signal wins: only when the
+   * external signal is the one that fired do we report a cancellation —
+   * otherwise the abort came from our own timers.
+   */
+  toConnectionError(error, cause, callerSignal) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      if (callerSignal?.aborted && cause === void 0) {
+        return new OpenClawCancelledError();
+      }
+      if (cause === "max-duration") {
+        return new OpenClawConnectionError(
+          `Request to OpenClaw exceeded the maximum duration of ${this.maxStreamMs}ms`
+        );
+      }
+      return new OpenClawConnectionError(`Request to OpenClaw timed out after ${this.timeoutMs}ms`);
+    }
+    return new OpenClawConnectionError(
+      `Failed to connect to OpenClaw at ${this.baseUrl}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
   async request(path, options = {}) {
     const url = `${this.baseUrl}${path}`;
     logDebug(() => `Request: ${options.method ?? "GET"} ${url}`);
@@ -239,7 +286,12 @@ var OpenClawClient = class {
       logDebug(() => `Request body: ${this.truncateForLog(options.body)}`);
     }
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const unlink = this.linkSignal(controller, options.signal ?? void 0);
+    let abortCause;
+    const timeout = setTimeout(() => {
+      abortCause = "idle";
+      controller.abort();
+    }, this.timeoutMs);
     try {
       const response = await fetch(url, {
         ...options,
@@ -280,16 +332,10 @@ var OpenClawClient = class {
       if (error instanceof OpenClawApiError) {
         throw error;
       }
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new OpenClawConnectionError(
-          `Request to OpenClaw timed out after ${this.timeoutMs}ms`
-        );
-      }
-      throw new OpenClawConnectionError(
-        `Failed to connect to OpenClaw at ${this.baseUrl}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
+      throw this.toConnectionError(error, abortCause, options.signal ?? void 0);
     } finally {
       clearTimeout(timeout);
+      unlink();
     }
   }
   /**
@@ -301,7 +347,11 @@ var OpenClawClient = class {
   async health() {
     const url = `${this.baseUrl}/v1/chat/completions`;
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    let abortCause;
+    const timeout = setTimeout(() => {
+      abortCause = "idle";
+      controller.abort();
+    }, this.timeoutMs);
     try {
       const response = await fetch(url, {
         method: "POST",
@@ -318,27 +368,27 @@ var OpenClawClient = class {
       }
       return { status: "error", message: `Gateway error (HTTP ${response.status})` };
     } catch (error) {
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new OpenClawConnectionError(
-          `Request to OpenClaw timed out after ${this.timeoutMs}ms`
-        );
-      }
-      throw new OpenClawConnectionError(
-        `Failed to connect to OpenClaw at ${this.baseUrl}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
+      throw this.toConnectionError(error, abortCause);
     } finally {
       clearTimeout(timeout);
     }
   }
   /**
    * Send a chat message via the OpenAI-compatible /v1/chat/completions endpoint.
+   * With `options.onDelta` set, the request streams (SSE) and deltas are
+   * surfaced as they arrive; otherwise a single blocking JSON response is used.
    */
-  async chat(message, sessionId) {
+  async chat(message, options = {}) {
+    const { sessionId, signal, onDelta } = options;
+    const streaming = onDelta !== void 0;
     const body = {
       model: this.model,
       messages: [{ role: "user", content: message }],
       max_tokens: 4096
     };
+    if (streaming) {
+      body.stream = true;
+    }
     if (sessionId) {
       body.session_id = sessionId;
     }
@@ -346,17 +396,173 @@ var OpenClawClient = class {
     if (sessionId) {
       headers["x-openclaw-session-key"] = sessionId;
     }
-    const completion = await this.request("/v1/chat/completions", {
-      method: "POST",
-      body: JSON.stringify(body),
-      headers
-    });
-    const content = completion.choices?.[0]?.message?.content ?? "";
-    return {
-      response: content,
-      model: completion.model,
-      usage: completion.usage
+    if (streaming) {
+      headers["Accept"] = "text/event-stream";
+    }
+    if (!streaming) {
+      const completion = await this.request("/v1/chat/completions", {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers,
+        signal: signal ?? null
+      });
+      const content = completion.choices?.[0]?.message?.content ?? "";
+      return {
+        response: content,
+        model: completion.model,
+        usage: completion.usage
+      };
+    }
+    return this.chatStreaming(body, headers, signal, onDelta);
+  }
+  async chatStreaming(body, extraHeaders, signal, onDelta) {
+    const url = `${this.baseUrl}/v1/chat/completions`;
+    logDebug(() => `Request (stream): POST ${url}`);
+    const controller = new AbortController();
+    const unlink = this.linkSignal(controller, signal);
+    let abortCause;
+    let idleTimer = setTimeout(() => {
+      abortCause = "idle";
+      controller.abort();
+    }, this.timeoutMs);
+    const resetIdle = () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        abortCause = "idle";
+        controller.abort();
+      }, this.timeoutMs);
+    };
+    const maxTimer = setTimeout(() => {
+      abortCause = "max-duration";
+      controller.abort();
+    }, this.maxStreamMs);
+    const startFinishGrace = () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        abortCause = "finish-grace";
+        controller.abort();
+      }, FINISH_GRACE_MS);
     };
+    let accumulated = "";
+    let model;
+    let usage;
+    let finishReason;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        signal: controller.signal,
+        headers: { ...this.buildHeaders(), ...extraHeaders },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new OpenClawApiError(
+          `API request failed: ${response.status} ${response.statusText}`,
+          response.status
+        );
+      }
+      if (!response.body) {
+        throw new OpenClawConnectionError("Streaming response has no body");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let receivedBytes = 0;
+      let done = false;
+      const handleLine = (rawLine) => {
+        const line = rawLine.trim();
+        if (!line.startsWith("data:")) return false;
+        const payload = line.slice(5).trim();
+        if (payload === "[DONE]") return true;
+        let chunk;
+        try {
+          chunk = JSON.parse(payload);
+        } catch {
+          logDebug(() => `Skipping unparseable SSE line: ${this.truncateForLog(payload)}`);
+          return false;
+        }
+        if (chunk.error) {
+          throw new OpenClawApiError(
+            `Gateway reported an error: ${chunk.error.message ?? "unknown error"}`,
+            502
+          );
+        }
+        if (chunk.model) model = chunk.model;
+        if (chunk.usage) {
+          usage = chunk.usage;
+          if (finishReason) return true;
+        }
+        const choice = chunk.choices?.[0];
+        const delta = choice?.delta?.content;
+        if (delta) {
+          accumulated += delta;
+          onDelta(delta, accumulated);
+        }
+        if (choice?.finish_reason) {
+          finishReason = choice.finish_reason;
+          if (usage) return true;
+          startFinishGrace();
+        }
+        return false;
+      };
+      const nextBreak = (s) => {
+        const lf = s.indexOf("\n");
+        const cr = s.indexOf("\r");
+        if (lf === -1) return cr;
+        if (cr === -1) return lf;
+        return Math.min(lf, cr);
+      };
+      const reader = response.body.getReader();
+      try {
+        while (!done) {
+          const { value, done: readerDone } = await reader.read();
+          if (readerDone) break;
+          resetIdle();
+          receivedBytes += value.byteLength;
+          if (receivedBytes > MAX_RESPONSE_SIZE_BYTES) {
+            throw new OpenClawApiError("Response exceeds maximum allowed size (10MB)", 413);
+          }
+          buffer += decoder.decode(value, { stream: true });
+          let breakIndex;
+          while ((breakIndex = nextBreak(buffer)) !== -1) {
+            const line = buffer.slice(0, breakIndex);
+            buffer = buffer.slice(breakIndex + 1);
+            if (handleLine(line)) {
+              done = true;
+              break;
+            }
+          }
+        }
+        if (!done) {
+          buffer += decoder.decode();
+          if (buffer.trim()) {
+            handleLine(buffer);
+          }
+        }
+      } finally {
+        await reader.cancel().catch(() => {
+        });
+      }
+      if (!accumulated && !finishReason) {
+        throw new OpenClawApiError(
+          "Gateway returned no streamed content (not a valid SSE response)",
+          502
+        );
+      }
+      logDebug(() => `Stream complete (${accumulated.length} chars, finish=${finishReason})`);
+      return { response: accumulated, model, usage };
+    } catch (error) {
+      if (error instanceof OpenClawApiError) {
+        throw error;
+      }
+      if (abortCause === "finish-grace" && finishReason) {
+        logDebug(() => `Stream complete without trailing usage (${accumulated.length} chars)`);
+        return { response: accumulated, model, usage };
+      }
+      throw this.toConnectionError(error, abortCause, signal);
+    } finally {
+      clearTimeout(idleTimer);
+      clearTimeout(maxTimer);
+      unlink();
+    }
   }
 };
 
@@ -474,9 +680,9 @@ var InstanceRegistry = class {
   }
 };
 
-// src/server/tools-registration.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+// src/server/mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import { z } from "zod";
 
 // src/utils/response-helpers.ts
 function successResponse(text) {
@@ -529,28 +735,6 @@ function validateId(value, fieldName) {
 }
 
 // src/mcp/tools/chat.ts
-var openclawChatTool = {
-  name: "openclaw_chat",
-  description: "Send a message to OpenClaw and get a response",
-  inputSchema: {
-    type: "object",
-    properties: {
-      message: {
-        type: "string",
-        description: "The message to send to OpenClaw"
-      },
-      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(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
@@ -577,7 +761,7 @@ async function handleOpenclawChat(registry2, input) {
   }
   try {
     const { client } = registry2.resolve(instanceName);
-    const response = await client.chat(msgResult.value, sessionId);
+    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");
@@ -585,19 +769,6 @@ async function handleOpenclawChat(registry2, input) {
 }
 
 // src/mcp/tools/status.ts
-var openclawStatusTool = {
-  name: "openclaw_status",
-  description: "Get OpenClaw gateway status and health information",
-  inputSchema: {
-    type: "object",
-    properties: {
-      instance: {
-        type: "string",
-        description: "Target OpenClaw instance name. Defaults to the default instance."
-      }
-    }
-  }
-};
 async function handleOpenclawStatus(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
@@ -625,14 +796,6 @@ async function handleOpenclawStatus(registry2, 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(),
@@ -721,26 +884,55 @@ var TaskManager = class {
     task.status = status;
     if (status === "running" && !task.startedAt) {
       task.startedAt = /* @__PURE__ */ new Date();
+      task.progressChars = 0;
+      task.lastActivityAt = task.startedAt;
     }
     if (status === "completed" || status === "failed" || status === "cancelled") {
       task.completedAt = /* @__PURE__ */ new Date();
     }
     if (result !== void 0) task.result = result;
     if (error !== void 0) task.error = error;
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      task.abortController = void 0;
+    }
     log(`Task ${id} status: ${status}`);
     return true;
   }
   /**
-   * Cancel a pending task
+   * Record streaming progress for a running task. Pass no character count to
+   * record liveness only (a heartbeat with no new content).
+   */
+  updateProgress(id, progressChars) {
+    const task = this.tasks.get(id);
+    if (!task || task.status !== "running") return false;
+    if (progressChars !== void 0) {
+      task.progressChars = progressChars;
+    }
+    task.lastActivityAt = /* @__PURE__ */ new Date();
+    return true;
+  }
+  /**
+   * Attach the abort controller of the in-flight request to a task
+   */
+  attachAbortController(id, controller) {
+    const task = this.tasks.get(id);
+    if (task) task.abortController = controller;
+  }
+  /**
+   * Cancel a pending or running task. Running tasks have their
+   * in-flight gateway request aborted.
    */
   cancel(id) {
     const task = this.tasks.get(id);
     if (!task) return false;
-    if (task.status !== "pending") {
+    if (task.status !== "pending" && task.status !== "running") {
       return false;
     }
+    const controller = task.abortController;
     task.status = "cancelled";
     task.completedAt = /* @__PURE__ */ new Date();
+    task.abortController = void 0;
+    controller?.abort();
     log(`Task cancelled: ${id}`);
     return true;
   }
@@ -797,85 +989,23 @@ var TaskManager = class {
 var taskManager = new TaskManager();
 
 // src/mcp/tools/tasks.ts
-var openclawChatAsyncTool = {
-  name: "openclaw_chat_async",
-  description: "Send a message to OpenClaw asynchronously. Returns a task_id immediately that can be polled for results. Use this for potentially long-running conversations.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      message: {
-        type: "string",
-        description: "The message to send to OpenClaw"
-      },
-      session_id: {
-        type: "string",
-        description: "Optional session ID for conversation context"
-      },
-      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"]
-  }
-};
-var openclawTaskStatusTool = {
-  name: "openclaw_task_status",
-  description: "Check the status of an async task. Returns status, and result if completed.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      task_id: {
-        type: "string",
-        description: "The task ID returned from openclaw_chat_async"
-      }
-    },
-    required: ["task_id"]
-  }
-};
-var openclawTaskListTool = {
-  name: "openclaw_task_list",
-  description: "List all tasks. Optionally filter by status, session, or instance.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      status: {
-        type: "string",
-        enum: ["pending", "running", "completed", "failed", "cancelled"],
-        description: "Filter by task status"
-      },
-      session_id: {
-        type: "string",
-        description: "Filter by session ID"
-      },
-      instance: {
-        type: "string",
-        description: "Filter by instance name"
-      }
-    },
-    required: []
-  }
-};
-var openclawTaskCancelTool = {
-  name: "openclaw_task_cancel",
-  description: "Cancel a pending task. Only works for tasks that haven't started yet.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      task_id: {
-        type: "string",
-        description: "The task ID to cancel"
-      }
-    },
-    required: ["task_id"]
-  }
-};
+var DEFAULT_TASK_CONCURRENCY = 3;
+var MAX_TASK_CONCURRENCY = 20;
 var processorRunning = false;
 var processorRegistry = null;
+var runningTasks = /* @__PURE__ */ new Set();
+function resolveConcurrency() {
+  const raw = process.env.OPENCLAW_TASK_CONCURRENCY;
+  if (!raw) return DEFAULT_TASK_CONCURRENCY;
+  const parsed = parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_TASK_CONCURRENCY) {
+    log(
+      `Invalid OPENCLAW_TASK_CONCURRENCY="${raw}" (must be 1-${MAX_TASK_CONCURRENCY}), using ${DEFAULT_TASK_CONCURRENCY}`
+    );
+    return DEFAULT_TASK_CONCURRENCY;
+  }
+  return parsed;
+}
 async function processTask(task, registry2) {
   taskManager.updateStatus(task.id, "running");
   let client;
@@ -886,24 +1016,41 @@ async function processTask(task, registry2) {
     taskManager.updateStatus(task.id, "failed", void 0, errorMsg);
     return;
   }
+  const controller = new AbortController();
+  taskManager.attachAbortController(task.id, controller);
   try {
     const input = task.input;
-    const response = await client.chat(input.message, input.session_id);
+    const response = await client.chat(input.message, {
+      sessionId: input.session_id,
+      signal: controller.signal,
+      onDelta: (_delta, accumulated) => {
+        taskManager.updateProgress(task.id, accumulated.length);
+      }
+    });
+    if (taskManager.get(task.id)?.status === "cancelled") {
+      return;
+    }
     taskManager.updateStatus(task.id, "completed", response.response);
   } catch (error) {
+    if (taskManager.get(task.id)?.status === "cancelled") {
+      return;
+    }
     const errorMsg = error instanceof Error ? error.message : "Unknown error";
     taskManager.updateStatus(task.id, "failed", void 0, errorMsg);
   }
 }
 async function taskProcessor() {
-  if (!processorRegistry) return;
+  const concurrency = resolveConcurrency();
+  log(`Task processor concurrency: ${concurrency}`);
   while (processorRunning) {
-    const task = taskManager.getNextPending();
-    if (task) {
-      await processTask(task, processorRegistry);
-    } else {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+    while (runningTasks.size < concurrency && processorRegistry) {
+      const task = taskManager.getNextPending();
+      if (!task) break;
+      runningTasks.add(task.id);
+      void processTask(task, processorRegistry).catch(() => {
+      }).finally(() => runningTasks.delete(task.id));
     }
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }
 function startTaskProcessor(registry2) {
@@ -997,6 +1144,10 @@ async function handleOpenclawTaskStatus(_registry, input) {
   if (task.startedAt) {
     response.started_at = task.startedAt.toISOString();
   }
+  if (task.status === "running" && task.progressChars !== void 0) {
+    response.progress_chars = task.progressChars;
+    response.last_activity_at = task.lastActivityAt?.toISOString();
+  }
   if (task.completedAt) {
     response.completed_at = task.completedAt.toISOString();
   }
@@ -1077,9 +1228,9 @@ async function handleOpenclawTaskCancel(_registry, input) {
   if (!task) {
     return errorResponse(`Task not found: ${task_id}`);
   }
-  if (task.status !== "pending") {
+  if (task.status !== "pending" && task.status !== "running") {
     return errorResponse(
-      `Cannot cancel task with status: ${task.status}. Only pending tasks can be cancelled.`
+      `Cannot cancel task with status: ${task.status}. Only pending or running tasks can be cancelled.`
     );
   }
   const cancelled = taskManager.cancel(task_id);
@@ -1099,99 +1250,155 @@ async function handleOpenclawTaskCancel(_registry, input) {
   );
 }
 
-// src/server/tools-registration.ts
+// src/server/mcp-server.ts
+var SERVER_ICONS = [
+  {
+    src: `data:image/svg+xml;base64,${SERVER_ICON_SVG_BASE64}`,
+    mimeType: "image/svg+xml",
+    sizes: ["128x128"]
+  }
+];
+var TASK_STATUS_VALUES = ["pending", "running", "completed", "failed", "cancelled"];
+var instanceField = z.string().optional().describe(
+  "Target OpenClaw instance name. Use openclaw_instances to list available instances. Defaults to the default instance."
+);
+function wrapHandler(name, handler) {
+  return async (args2) => {
+    log(`Executing tool: ${name}`);
+    try {
+      return await handler(args2 ?? {});
+    } catch (error) {
+      logError(`Error executing tool ${name}`, error);
+      throw error;
+    }
+  };
+}
 function createMcpServer(deps2) {
-  const server = new Server(
+  const { registry: registry2 } = deps2;
+  const server = new McpServer(
     {
       name: deps2.serverName,
       version: deps2.serverVersion,
-      icons: [
-        {
-          src: `data:image/svg+xml;base64,${SERVER_ICON_SVG_BASE64}`,
-          mimeType: "image/svg+xml",
-          sizes: ["128x128"]
-        }
-      ]
+      icons: SERVER_ICONS
     },
     { capabilities: { tools: {} } }
   );
-  registerTools(server, deps2);
+  server.registerTool(
+    "openclaw_chat",
+    {
+      description: "Send a message to OpenClaw and get a response",
+      inputSchema: z.object({
+        message: z.string().describe("The message to send to OpenClaw"),
+        session_id: z.string().optional().describe("Optional session ID for conversation context"),
+        instance: instanceField
+      })
+    },
+    wrapHandler("openclaw_chat", (input) => handleOpenclawChat(registry2, input))
+  );
+  server.registerTool(
+    "openclaw_status",
+    {
+      description: "Check OpenClaw gateway health",
+      annotations: { readOnlyHint: true },
+      inputSchema: z.object({
+        instance: instanceField
+      })
+    },
+    wrapHandler("openclaw_status", (input) => handleOpenclawStatus(registry2, input))
+  );
+  server.registerTool(
+    "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.",
+      annotations: { readOnlyHint: true },
+      inputSchema: z.object({})
+    },
+    wrapHandler("openclaw_instances", (input) => handleOpenclawInstances(registry2, input))
+  );
+  server.registerTool(
+    "openclaw_chat_async",
+    {
+      description: "Send a message to OpenClaw asynchronously. Returns a task_id immediately that can be polled for results. Use this for potentially long-running conversations.",
+      inputSchema: z.object({
+        message: z.string().describe("The message to send to OpenClaw"),
+        session_id: z.string().optional().describe("Optional session ID for conversation context"),
+        priority: z.number().int().optional().describe("Task priority (higher = processed first). Default: 0"),
+        instance: instanceField
+      })
+    },
+    wrapHandler("openclaw_chat_async", (input) => handleOpenclawChatAsync(registry2, input))
+  );
+  server.registerTool(
+    "openclaw_task_status",
+    {
+      description: "Check the status of an async task. Returns status, and result if completed.",
+      annotations: { readOnlyHint: true },
+      inputSchema: z.object({
+        task_id: z.string().describe("The task ID returned from openclaw_chat_async")
+      })
+    },
+    wrapHandler("openclaw_task_status", (input) => handleOpenclawTaskStatus(registry2, input))
+  );
+  server.registerTool(
+    "openclaw_task_list",
+    {
+      description: "List all tasks. Optionally filter by status, session, or instance.",
+      annotations: { readOnlyHint: true },
+      inputSchema: z.object({
+        status: z.enum(TASK_STATUS_VALUES).optional().describe("Filter by task status"),
+        session_id: z.string().optional().describe("Filter by session ID"),
+        instance: z.string().optional().describe("Filter by instance name")
+      })
+    },
+    wrapHandler("openclaw_task_list", (input) => handleOpenclawTaskList(registry2, input))
+  );
+  server.registerTool(
+    "openclaw_task_cancel",
+    {
+      description: "Cancel a pending or running task. Running tasks have their in-flight gateway request aborted.",
+      inputSchema: z.object({
+        task_id: z.string().describe("The task ID to cancel")
+      })
+    },
+    wrapHandler("openclaw_task_cancel", (input) => handleOpenclawTaskCancel(registry2, input))
+  );
   return server;
 }
-function registerTools(server, deps2) {
-  const { registry: registry2 } = deps2;
-  const toolHandlers = /* @__PURE__ */ new Map([
-    ["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,
-    openclawStatusTool,
-    openclawChatAsyncTool,
-    openclawTaskStatusTool,
-    openclawTaskListTool,
-    openclawTaskCancelTool,
-    openclawInstancesTool
-  ];
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools: allTools };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: toolArgs } = request.params;
-    log(`Executing tool: ${name}`);
-    const handler = toolHandlers.get(name);
-    if (!handler) {
-      throw new Error(`Unknown tool: ${name}`);
-    }
-    try {
-      return await handler(toolArgs);
-    } catch (error) {
-      logError(`Error executing tool ${name}`, error);
-      throw error;
-    }
-  });
-}
 
 // src/server/http.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import { mcpAuthRouter } from "@modelcontextprotocol/sdk/server/auth/router.js";
-import { requireBearerAuth } from "@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js";
+import express from "express";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { toNodeHandler } from "@modelcontextprotocol/node";
+import {
+  requireBearerAuth,
+  localhostHostValidation,
+  localhostOriginValidation,
+  getOAuthProtectedResourceMetadataUrl
+} from "@modelcontextprotocol/express";
 
 // src/auth/provider.ts
 import { randomUUID } from "crypto";
-import {
-  InvalidRequestError,
-  InvalidTokenError
-} from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { OAuthError, OAuthErrorCode } from "@modelcontextprotocol/server";
 var TOKEN_TTL_MS = 60 * 60 * 1e3;
 var AUTH_CODE_TTL_MS = 10 * 60 * 1e3;
 var REFRESH_TOKEN_TTL_MS = 24 * 60 * 60 * 1e3;
 var REAPER_INTERVAL_MS = 5 * 60 * 1e3;
-var ALLOW_ANY_REDIRECT = new Proxy([], {
-  get(target, prop) {
-    if (prop === "includes") return () => true;
-    if (prop === "length") return 1;
-    return Reflect.get(target, prop);
+var AllowAnyRedirectUris = class extends Array {
+  includes(_searchElement, _fromIndex) {
+    return true;
   }
-});
+  some(_predicate, _thisArg) {
+    return true;
+  }
+};
+var ALLOW_ANY_REDIRECT = new AllowAnyRedirectUris();
 var MAX_DYNAMIC_CLIENTS = 100;
 var OpenClawClientsStore = class {
   client;
   dynamicClients = /* @__PURE__ */ new Map();
-  // Assigned conditionally in the constructor. The MCP SDK probes
-  // `clientsStore.registerClient` at router-setup time and only advertises
-  // `/register` when the property is defined, so we must NOT define a no-op
-  // method on the prototype — it has to be instance-level and gated on config.
-  registerClient;
+  allowDynamicRegistration;
   constructor(config) {
+    this.allowDynamicRegistration = !!config.allowDynamicRegistration;
     if (config.clientId && config.clientSecret) {
       const redirectUris = config.redirectUris && config.redirectUris.length > 0 ? config.redirectUris : ALLOW_ANY_REDIRECT;
       this.client = {
@@ -1205,25 +1412,27 @@ var OpenClawClientsStore = class {
         client_id_issued_at: Math.floor(Date.now() / 1e3)
       };
     }
-    if (config.allowDynamicRegistration) {
-      this.registerClient = (client) => {
-        if (this.dynamicClients.size >= MAX_DYNAMIC_CLIENTS) {
-          const oldestKey = this.dynamicClients.keys().next().value;
-          if (oldestKey !== void 0) {
-            this.dynamicClients.delete(oldestKey);
-          }
-        }
-        this.dynamicClients.set(client.client_id, client);
-        return client;
-      };
-    }
   }
-  async getClient(clientId) {
+  getClient(clientId) {
     if (this.client && this.client.client_id === clientId) {
       return this.client;
     }
     return this.dynamicClients.get(clientId);
   }
+  /** RFC 7591 dynamic registration. Throws unless DCR is enabled. */
+  registerClient(client) {
+    if (!this.allowDynamicRegistration) {
+      throw new OAuthError(OAuthErrorCode.InvalidRequest, "Dynamic registration is disabled");
+    }
+    if (this.dynamicClients.size >= MAX_DYNAMIC_CLIENTS) {
+      const oldestKey = this.dynamicClients.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.dynamicClients.delete(oldestKey);
+      }
+    }
+    this.dynamicClients.set(client.client_id, client);
+    return client;
+  }
 };
 var OpenClawAuthProvider = class {
   clientsStore;
@@ -1260,52 +1469,80 @@ var OpenClawAuthProvider = class {
     }
   }
   /**
-   * Auto-approve: generate auth code and redirect immediately.
+   * Auto-approve: issue an auth code and return the redirect URL the
+   * router should send the user-agent to.
    */
-  async authorize(client, params, res) {
+  authorize(client, params) {
     const code = randomUUID();
     this.codes.set(code, { client, params, createdAt: Date.now() });
-    const searchParams = new URLSearchParams({ code });
+    const targetUrl = new URL(params.redirectUri);
+    targetUrl.searchParams.set("code", code);
     if (params.state !== void 0) {
-      searchParams.set("state", params.state);
+      targetUrl.searchParams.set("state", params.state);
     }
-    const targetUrl = new URL(params.redirectUri);
-    targetUrl.search = searchParams.toString();
-    res.redirect(targetUrl.toString());
+    return targetUrl.toString();
+  }
+  /** PKCE challenge recorded for a still-valid authorization code. */
+  challengeForAuthorizationCode(client, authorizationCode) {
+    return this.getAuthorizationGrant(client, authorizationCode).codeChallenge;
   }
-  async challengeForAuthorizationCode(_client, authorizationCode) {
+  /**
+   * The authorize-time parameters a code was issued with, for the checks the
+   * token endpoint has to make before redeeming it.
+   */
+  getAuthorizationGrant(client, authorizationCode) {
     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");
+      throw new OAuthError(OAuthErrorCode.InvalidGrant, "Invalid authorization code");
+    }
+    if (codeData.client.client_id !== client.client_id) {
+      throw new OAuthError(
+        OAuthErrorCode.InvalidGrant,
+        "Authorization code was not issued to this client"
+      );
     }
-    return codeData.params.codeChallenge;
+    return codeData.params;
+  }
+  /**
+   * Drop a code without redeeming it. Used when a redemption attempt looks
+   * like an attack (bad PKCE verifier, mismatched redirect_uri).
+   */
+  invalidateAuthorizationCode(authorizationCode) {
+    this.codes.delete(authorizationCode);
   }
-  async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, _redirectUri, resource) {
+  exchangeAuthorizationCode(client, authorizationCode, 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");
+      throw new OAuthError(OAuthErrorCode.InvalidGrant, "Invalid authorization code");
     }
     if (codeData.client.client_id !== client.client_id) {
-      throw new InvalidRequestError("Authorization code was not issued to this client");
+      throw new OAuthError(
+        OAuthErrorCode.InvalidGrant,
+        "Authorization code was not issued to this client"
+      );
     }
     this.codes.delete(authorizationCode);
     const accessToken = randomUUID();
     const refreshToken = randomUUID();
+    const grantId = randomUUID();
     const scopes = codeData.params.scopes || [];
+    const grantResource = codeData.params.resource ?? resource;
     this.tokens.set(accessToken, {
       token: accessToken,
       clientId: client.client_id,
       scopes,
       expiresAt: Date.now() + TOKEN_TTL_MS,
-      resource: resource || codeData.params.resource
+      resource: grantResource,
+      grantId
     });
     this.refreshTokens.set(refreshToken, {
       clientId: client.client_id,
       scopes,
       expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS,
-      resource: resource || codeData.params.resource
+      resource: grantResource,
+      grantId
     });
     return {
       access_token: accessToken,
@@ -1315,31 +1552,47 @@ var OpenClawAuthProvider = class {
       scope: scopes.join(" ")
     };
   }
-  async exchangeRefreshToken(client, refreshToken, scopes, resource) {
+  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");
+      throw new OAuthError(OAuthErrorCode.InvalidGrant, "Invalid refresh token");
     }
     if (data.clientId !== client.client_id) {
-      throw new InvalidRequestError("Refresh token was not issued to this client");
+      throw new OAuthError(
+        OAuthErrorCode.InvalidGrant,
+        "Refresh token was not issued to this client"
+      );
+    }
+    let tokenScopes = data.scopes;
+    if (scopes && scopes.length > 0) {
+      const escalated = scopes.filter((scope) => !data.scopes.includes(scope));
+      if (escalated.length > 0) {
+        throw new OAuthError(
+          OAuthErrorCode.InvalidScope,
+          `Requested scope exceeds the original grant: ${escalated.join(" ")}`
+        );
+      }
+      tokenScopes = scopes;
     }
     this.refreshTokens.delete(refreshToken);
     const accessToken = randomUUID();
     const newRefreshToken = randomUUID();
-    const tokenScopes = scopes || data.scopes;
+    const grantResource = data.resource ?? resource;
     this.tokens.set(accessToken, {
       token: accessToken,
       clientId: client.client_id,
       scopes: tokenScopes,
       expiresAt: Date.now() + TOKEN_TTL_MS,
-      resource: resource || data.resource
+      resource: grantResource,
+      grantId: data.grantId
     });
     this.refreshTokens.set(newRefreshToken, {
       clientId: client.client_id,
       scopes: tokenScopes,
       expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS,
-      resource: resource || data.resource
+      resource: grantResource,
+      grantId: data.grantId
     });
     return {
       access_token: accessToken,
@@ -1349,10 +1602,11 @@ var OpenClawAuthProvider = class {
       scope: tokenScopes.join(" ")
     };
   }
+  /** SDK v2 `OAuthTokenVerifier` contract — plugs into `requireBearerAuth`. */
   async verifyAccessToken(token) {
     const tokenData = this.tokens.get(token);
     if (!tokenData || tokenData.expiresAt < Date.now()) {
-      throw new InvalidTokenError("Invalid or expired token");
+      throw new OAuthError(OAuthErrorCode.InvalidToken, "Invalid or expired token");
     }
     return {
       token,
@@ -1362,19 +1616,374 @@ var OpenClawAuthProvider = class {
       resource: tokenData.resource
     };
   }
-  async revokeToken(client, request) {
+  revokeToken(client, request) {
     const tokenData = this.tokens.get(request.token);
-    if (tokenData && tokenData.clientId === client.client_id) {
-      this.tokens.delete(request.token);
-    }
     const refreshData = this.refreshTokens.get(request.token);
-    if (refreshData && refreshData.clientId === client.client_id) {
-      this.refreshTokens.delete(request.token);
+    const grantId = tokenData && tokenData.clientId === client.client_id ? tokenData.grantId : refreshData && refreshData.clientId === client.client_id ? refreshData.grantId : void 0;
+    if (grantId === void 0) return;
+    this.revokeGrant(grantId);
+  }
+  /** Drop every access and refresh token minted from one authorization. */
+  revokeGrant(grantId) {
+    for (const [token, data] of this.tokens) {
+      if (data.grantId === grantId) this.tokens.delete(token);
+    }
+    for (const [token, data] of this.refreshTokens) {
+      if (data.grantId === grantId) this.refreshTokens.delete(token);
     }
   }
 };
 
+// src/auth/router.ts
+import { createHash, randomUUID as randomUUID2, timingSafeEqual } from "crypto";
+import { Router, json, urlencoded } from "express";
+import { rateLimit } from "express-rate-limit";
+import { OAuthError as OAuthError2, OAuthErrorCode as OAuthErrorCode2 } from "@modelcontextprotocol/server";
+var ERROR_STATUS = {
+  [OAuthErrorCode2.InvalidClient]: 401,
+  [OAuthErrorCode2.InvalidToken]: 401,
+  [OAuthErrorCode2.InsufficientScope]: 403,
+  [OAuthErrorCode2.MethodNotAllowed]: 405,
+  [OAuthErrorCode2.ServerError]: 500,
+  [OAuthErrorCode2.TemporarilyUnavailable]: 503
+};
+function sendOAuthError(res, error) {
+  if (error instanceof OAuthError2) {
+    const status = ERROR_STATUS[error.code] ?? 400;
+    res.status(status).json(error.toResponseObject());
+    return;
+  }
+  logError("OAuth endpoint error", error);
+  res.status(500).json(new OAuthError2(OAuthErrorCode2.ServerError, "Internal Server Error").toResponseObject());
+}
+function timingSafeStringEqual(a, b) {
+  const hashA = createHash("sha256").update(a).digest();
+  const hashB = createHash("sha256").update(b).digest();
+  return timingSafeEqual(hashA, hashB);
+}
+function verifyPkce(codeVerifier, codeChallenge) {
+  const computed = createHash("sha256").update(codeVerifier).digest("base64url");
+  return timingSafeStringEqual(computed, codeChallenge);
+}
+function isValidPkceValue(value) {
+  return /^[A-Za-z0-9\-._~]{43,128}$/.test(value);
+}
+function firstString(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && typeof value[0] === "string") return value[0];
+  return void 0;
+}
+function parseResource(value) {
+  if (!value) return void 0;
+  try {
+    return new URL(value);
+  } catch {
+    throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Invalid resource parameter");
+  }
+}
+function authenticateClient(provider, req) {
+  const body = req.body ?? {};
+  let clientId = firstString(body.client_id);
+  let clientSecret = firstString(body.client_secret);
+  const authHeader = req.headers.authorization;
+  if (authHeader?.startsWith("Basic ")) {
+    const formDecode = (value) => decodeURIComponent(value.replace(/\+/g, " "));
+    let decoded;
+    try {
+      decoded = Buffer.from(authHeader.slice(6), "base64").toString("utf8");
+    } catch {
+      throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Malformed Basic authorization header");
+    }
+    const separator = decoded.indexOf(":");
+    if (separator === -1) {
+      throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Malformed Basic authorization header");
+    }
+    try {
+      clientId = formDecode(decoded.slice(0, separator));
+      clientSecret = formDecode(decoded.slice(separator + 1));
+    } catch {
+      throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Malformed Basic authorization header");
+    }
+  }
+  if (!clientId) {
+    throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Missing client_id");
+  }
+  const client = provider.clientsStore.getClient(clientId);
+  if (!client) {
+    throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Unknown client");
+  }
+  if (client.client_secret) {
+    if (!clientSecret || !timingSafeStringEqual(client.client_secret, clientSecret)) {
+      throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Invalid client credentials");
+    }
+  }
+  return client;
+}
+function isLoopbackHost(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+}
+function isSafeRedirectScheme(url) {
+  if (url.protocol === "https:") return true;
+  if (url.protocol === "http:") return isLoopbackHost(url.hostname);
+  return false;
+}
+function isRedirectUriAllowed(client, redirectUri) {
+  const uris = client.redirect_uris;
+  if (!uris) return false;
+  if (uris.some((registered) => registered === redirectUri)) return true;
+  let requested;
+  try {
+    requested = new URL(redirectUri);
+  } catch {
+    return false;
+  }
+  if (!isLoopbackHost(requested.hostname)) return false;
+  return uris.some((registered) => {
+    try {
+      const candidate = new URL(registered);
+      return isLoopbackHost(candidate.hostname) && candidate.protocol === requested.protocol && candidate.hostname === requested.hostname && candidate.pathname === requested.pathname;
+    } catch {
+      return false;
+    }
+  });
+}
+function createAuthRouter(options) {
+  const { provider, issuerUrl } = options;
+  const scopesSupported = options.scopesSupported ?? ["mcp:tools"];
+  const issuer = issuerUrl.toString().replace(/\/$/, "");
+  const router = Router();
+  const makeLimiter = (limit) => rateLimit({
+    windowMs: 60 * 60 * 1e3,
+    limit,
+    standardHeaders: true,
+    legacyHeaders: false
+  });
+  const authorizeLimiter = makeLimiter(100);
+  const tokenLimiter = makeLimiter(100);
+  const revokeLimiter = makeLimiter(100);
+  const registerLimiter = makeLimiter(20);
+  router.get("/.well-known/oauth-authorization-server", (_req, res) => {
+    const metadata = {
+      issuer,
+      authorization_endpoint: `${issuer}/authorize`,
+      token_endpoint: `${issuer}/token`,
+      revocation_endpoint: `${issuer}/revoke`,
+      response_types_supported: ["code"],
+      grant_types_supported: ["authorization_code", "refresh_token"],
+      code_challenge_methods_supported: ["S256"],
+      token_endpoint_auth_methods_supported: ["client_secret_post", "client_secret_basic", "none"],
+      scopes_supported: scopesSupported
+    };
+    if (provider.clientsStore.allowDynamicRegistration) {
+      metadata.registration_endpoint = `${issuer}/register`;
+    }
+    res.json(metadata);
+  });
+  router.get("/authorize", authorizeLimiter, (req, res) => {
+    try {
+      const clientId = firstString(req.query.client_id);
+      if (!clientId) {
+        throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Missing client_id");
+      }
+      const client = provider.clientsStore.getClient(clientId);
+      if (!client) {
+        throw new OAuthError2(OAuthErrorCode2.InvalidClient, "Unknown client");
+      }
+      const redirectUri = firstString(req.query.redirect_uri);
+      if (!redirectUri) {
+        throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Missing redirect_uri");
+      }
+      let parsedRedirect;
+      try {
+        parsedRedirect = new URL(redirectUri);
+      } catch {
+        throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Invalid redirect_uri");
+      }
+      if (!isSafeRedirectScheme(parsedRedirect)) {
+        throw new OAuthError2(
+          OAuthErrorCode2.InvalidRequest,
+          "redirect_uri must use https, or http on loopback"
+        );
+      }
+      if (!isRedirectUriAllowed(client, redirectUri)) {
+        throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Unregistered redirect_uri");
+      }
+      const redirectError = (code, description) => {
+        const url = new URL(redirectUri);
+        url.searchParams.set("error", code);
+        url.searchParams.set("error_description", description);
+        const state = firstString(req.query.state);
+        if (state !== void 0) url.searchParams.set("state", state);
+        res.redirect(url.toString());
+      };
+      const responseType = firstString(req.query.response_type);
+      if (responseType !== "code") {
+        redirectError(OAuthErrorCode2.UnsupportedResponseType, 'response_type must be "code"');
+        return;
+      }
+      const codeChallenge = firstString(req.query.code_challenge);
+      if (!codeChallenge) {
+        redirectError(OAuthErrorCode2.InvalidRequest, "code_challenge is required (PKCE)");
+        return;
+      }
+      if (!isValidPkceValue(codeChallenge)) {
+        redirectError(
+          OAuthErrorCode2.InvalidRequest,
+          "code_challenge must be 43-128 characters (RFC 7636)"
+        );
+        return;
+      }
+      const challengeMethod = firstString(req.query.code_challenge_method) ?? "S256";
+      if (challengeMethod !== "S256") {
+        redirectError(OAuthErrorCode2.InvalidRequest, "code_challenge_method must be S256");
+        return;
+      }
+      let resource;
+      try {
+        resource = parseResource(firstString(req.query.resource));
+      } catch {
+        redirectError(OAuthErrorCode2.InvalidRequest, "Invalid resource parameter");
+        return;
+      }
+      const parsedScopes = firstString(req.query.scope)?.split(" ").filter(Boolean);
+      const requestedScopes = parsedScopes && parsedScopes.length > 0 ? parsedScopes : void 0;
+      if (requestedScopes) {
+        const unknown = requestedScopes.filter((scope) => !scopesSupported.includes(scope));
+        if (unknown.length > 0) {
+          redirectError(OAuthErrorCode2.InvalidScope, `Unsupported scope: ${unknown.join(" ")}`);
+          return;
+        }
+      }
+      const params = {
+        redirectUri,
+        codeChallenge,
+        state: firstString(req.query.state),
+        // Clients that omit `scope` get the full supported set, so the
+        // resource server can require a scope without breaking them.
+        scopes: requestedScopes ?? [...scopesSupported],
+        resource
+      };
+      res.redirect(provider.authorize(client, params));
+    } catch (error) {
+      sendOAuthError(res, error);
+    }
+  });
+  router.post("/token", tokenLimiter, urlencoded({ extended: false }), (req, res) => {
+    try {
+      const client = authenticateClient(provider, req);
+      const body = req.body ?? {};
+      const grantType = firstString(body.grant_type);
+      const resource = parseResource(firstString(body.resource));
+      if (grantType === "authorization_code") {
+        const code = firstString(body.code);
+        if (!code) {
+          throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Missing code");
+        }
+        const codeVerifier = firstString(body.code_verifier);
+        if (!codeVerifier) {
+          throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Missing code_verifier (PKCE)");
+        }
+        if (!isValidPkceValue(codeVerifier)) {
+          provider.invalidateAuthorizationCode(code);
+          throw new OAuthError2(
+            OAuthErrorCode2.InvalidGrant,
+            "code_verifier must be 43-128 characters (RFC 7636)"
+          );
+        }
+        const grant = provider.getAuthorizationGrant(client, code);
+        const presentedRedirectUri = firstString(body.redirect_uri);
+        if (presentedRedirectUri !== grant.redirectUri) {
+          provider.invalidateAuthorizationCode(code);
+          throw new OAuthError2(
+            OAuthErrorCode2.InvalidGrant,
+            "redirect_uri does not match the authorization request"
+          );
+        }
+        if (!verifyPkce(codeVerifier, grant.codeChallenge)) {
+          provider.invalidateAuthorizationCode(code);
+          throw new OAuthError2(OAuthErrorCode2.InvalidGrant, "PKCE verification failed");
+        }
+        res.json(provider.exchangeAuthorizationCode(client, code, resource));
+        return;
+      }
+      if (grantType === "refresh_token") {
+        const refreshToken = firstString(body.refresh_token);
+        if (!refreshToken) {
+          throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Missing refresh_token");
+        }
+        const scopes = firstString(body.scope)?.split(" ").filter(Boolean);
+        res.json(provider.exchangeRefreshToken(client, refreshToken, scopes, resource));
+        return;
+      }
+      throw new OAuthError2(OAuthErrorCode2.UnsupportedGrantType, "Unsupported grant_type");
+    } catch (error) {
+      sendOAuthError(res, error);
+    }
+  });
+  router.post("/revoke", revokeLimiter, urlencoded({ extended: false }), (req, res) => {
+    try {
+      const client = authenticateClient(provider, req);
+      const token = firstString(req.body?.token);
+      if (!token) {
+        throw new OAuthError2(OAuthErrorCode2.InvalidRequest, "Missing token");
+      }
+      provider.revokeToken(client, { token });
+      res.status(200).json({});
+    } catch (error) {
+      sendOAuthError(res, error);
+    }
+  });
+  if (provider.clientsStore.allowDynamicRegistration) {
+    router.post("/register", registerLimiter, json(), (req, res) => {
+      try {
+        const body = req.body ?? {};
+        const redirectUris = body.redirect_uris;
+        if (!Array.isArray(redirectUris) || redirectUris.length === 0 || !redirectUris.every((uri) => typeof uri === "string")) {
+          throw new OAuthError2(
+            OAuthErrorCode2.InvalidRequest,
+            "redirect_uris must be a non-empty array of strings"
+          );
+        }
+        for (const uri of redirectUris) {
+          let parsed;
+          try {
+            parsed = new URL(uri);
+          } catch {
+            throw new OAuthError2(OAuthErrorCode2.InvalidRequest, `Invalid redirect_uri: ${uri}`);
+          }
+          if (!isSafeRedirectScheme(parsed)) {
+            throw new OAuthError2(
+              OAuthErrorCode2.InvalidRequest,
+              `redirect_uri must use https, or http on loopback: ${uri}`
+            );
+          }
+        }
+        const authMethod = firstString(body.token_endpoint_auth_method) ?? "client_secret_post";
+        const isPublic = authMethod === "none";
+        const client = {
+          client_id: randomUUID2(),
+          redirect_uris: redirectUris,
+          token_endpoint_auth_method: authMethod,
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          client_name: firstString(body.client_name) ?? "Dynamically Registered Client",
+          client_id_issued_at: Math.floor(Date.now() / 1e3)
+        };
+        if (!isPublic) {
+          client.client_secret = randomUUID2() + randomUUID2();
+        }
+        res.status(201).json(provider.clientsStore.registerClient(client));
+      } catch (error) {
+        sendOAuthError(res, error);
+      }
+    });
+  }
+  return router;
+}
+
 // src/server/http.ts
+var MCP_MAX_BODY_SIZE = "4mb";
+var DRAIN_GRACE_MS = 3e3;
 function parseTrustProxy(value) {
   if (value === void 0 || value === "") {
     return void 0;
@@ -1423,12 +2032,31 @@ function isOriginAllowed(origin, allowedOrigins) {
 async function createHttpServer(config, deps2) {
   const authEnabled = !!config.authConfig?.clientId;
   const corsConfig = loadCorsConfig();
-  const legacySseSessions = /* @__PURE__ */ new Map();
-  const streamableSessions = /* @__PURE__ */ new Map();
-  const app = createMcpExpressApp({ host: config.host });
+  const app = express();
+  app.set("query parser", "simple");
+  const isLoopbackBind = config.host === "127.0.0.1" || config.host === "localhost" || config.host === "::1";
+  if (isLoopbackBind) {
+    app.use(localhostHostValidation());
+    app.use(localhostOriginValidation());
+    log("DNS-rebinding protection: enabled (loopback bind)");
+  } else {
+    log(
+      `DNS-rebinding protection: disabled (HOST=${config.host} is not loopback) \u2014 rely on your reverse proxy and CORS_ORIGINS to restrict access`
+    );
+  }
   if (config.trustProxy !== void 0) {
+    if (config.trustProxy === true && authEnabled) {
+      logError(
+        "TRUST_PROXY=true is unsafe with authentication enabled: the client-controlled X-Forwarded-For entry becomes the rate-limit key, disabling rate limiting on the OAuth endpoints. Set TRUST_PROXY to the number of proxy hops instead (TRUST_PROXY=1 for a single reverse proxy). Refusing to start."
+      );
+      process.exit(1);
+    }
     app.set("trust proxy", config.trustProxy);
     log(`Trust proxy: ${JSON.stringify(config.trustProxy)}`);
+  } else if (authEnabled) {
+    log(
+      "WARNING: TRUST_PROXY is not set. Behind a reverse proxy every request appears to come from the proxy's IP, so the OAuth rate limits apply to all clients as one shared budget. Set TRUST_PROXY=1 when running behind a proxy."
+    );
   }
   app.use((req, res, next) => {
     if (!corsConfig.enabled) {
@@ -1442,7 +2070,9 @@ async function createHttpServer(config, deps2) {
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
       res.setHeader(
         "Access-Control-Allow-Headers",
-        "Content-Type, Authorization, Mcp-Session-Id, mcp-protocol-version"
+        // Mcp-Method / Mcp-Name are required request headers in the
+        // 2026-07-28 Streamable HTTP transport; Mcp-Session-Id is 2025-era.
+        "Content-Type, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Mcp-Method, Mcp-Name"
       );
       res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
     }
@@ -1456,130 +2086,65 @@ async function createHttpServer(config, deps2) {
   if (authEnabled) {
     const provider = new OpenClawAuthProvider(config.authConfig);
     const issuerUrl = config.issuerUrl ? new URL(config.issuerUrl) : new URL(`http://${config.host === "0.0.0.0" ? "localhost" : config.host}:${config.port}`);
-    app.use(
-      mcpAuthRouter({
-        provider,
-        issuerUrl,
-        scopesSupported: ["mcp:tools"]
-      })
-    );
+    app.use(createAuthRouter({ provider, issuerUrl, scopesSupported: ["mcp:tools"] }));
+    const protectedResourceMetadata = (resourcePath) => ({
+      resource: `${issuerUrl.toString().replace(/\/$/, "")}${resourcePath}`,
+      authorization_servers: [issuerUrl.toString().replace(/\/$/, "")],
+      scopes_supported: ["mcp:tools"]
+    });
     app.get("/.well-known/oauth-protected-resource/:path", (req, res) => {
-      res.json({
-        resource: `${issuerUrl.toString()}${req.params.path}`,
-        authorization_servers: [issuerUrl.toString().replace(/\/$/, "")],
-        scopes_supported: ["mcp:tools"]
-      });
+      res.json(protectedResourceMetadata(`/${req.params.path}`));
+    });
+    app.get("/.well-known/oauth-protected-resource", (_req, res) => {
+      res.json(protectedResourceMetadata("/mcp"));
+    });
+    authMiddleware = requireBearerAuth({
+      verifier: provider,
+      // Actually enforce the scope the metadata advertises; without this any
+      // non-expired token authorizes every tool call regardless of its grant.
+      requiredScopes: ["mcp:tools"],
+      resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(new URL("/mcp", issuerUrl))
     });
-    authMiddleware = requireBearerAuth({ verifier: provider });
   }
   app.get("/health", (_req, res) => {
     res.json({
       status: "ok",
       transport: "streamable-http",
-      legacySseSupported: true,
+      legacySseSupported: false,
       auth: authEnabled
     });
   });
-  const withAuth = (handler) => {
-    if (authMiddleware) {
-      return [authMiddleware, async (req, res) => handler(req, res)];
-    }
-    return [async (req, res) => handler(req, res)];
+  const mcpHandler = createMcpHandler(() => createMcpServer(deps2), {
+    legacy: "stateless",
+    onerror: (error) => logError("MCP handler error", error)
+  });
+  const nodeHandler = toNodeHandler(mcpHandler, {
+    onerror: (error) => logError("MCP transport error", error)
+  });
+  const mcpRoute = (req, res) => {
+    void nodeHandler(req, res, req.body);
   };
-  app.get(
-    "/sse",
-    ...withAuth(async (req, res) => {
-      log("Legacy SSE transport is deprecated; prefer Streamable HTTP at /mcp");
-      const transport = new SSEServerTransport("/messages", res);
-      const server = createMcpServer(deps2);
-      const sessionId = transport.sessionId;
-      legacySseSessions.set(sessionId, { transport, server });
-      log(`SSE session connected: ${sessionId}`);
-      transport.onclose = () => {
-        legacySseSessions.delete(sessionId);
-        log(`SSE session disconnected: ${sessionId}`);
-      };
-      try {
-        await server.connect(transport);
-      } catch (error) {
-        legacySseSessions.delete(sessionId);
-        logError(`Failed to connect SSE session ${sessionId}`, error);
-      }
-    })
-  );
-  app.post(
-    "/messages",
-    ...withAuth(async (req, res) => {
-      const sessionId = req.query.sessionId;
-      const session = legacySseSessions.get(sessionId);
-      if (!session) {
-        res.status(404).json({ error: "Session not found" });
-        return;
-      }
-      try {
-        await session.transport.handlePostMessage(
-          req,
-          res,
-          req.body
-        );
-      } catch (error) {
-        logError(`Error handling message for session ${sessionId}`, error);
-        if (!res.headersSent) {
-          res.status(500).json({ error: "Internal server error" });
-        }
-      }
-    })
-  );
-  const handleStreamableRequest = async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    if (sessionId && streamableSessions.has(sessionId)) {
-      const session = streamableSessions.get(sessionId);
-      try {
-        await session.transport.handleRequest(
-          req,
-          res,
-          req.body
-        );
-      } catch (error) {
-        logError(`Error in streamable session ${sessionId}`, error);
-        if (!res.headersSent) {
-          res.status(500).json({ error: "Internal server error" });
-        }
-      }
-      return;
-    }
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID2(),
-      onsessioninitialized: (newSessionId) => {
-        streamableSessions.set(newSessionId, { transport, server });
-        log(`Streamable session initialized: ${newSessionId}`);
-      }
+  const mcpBodyParser = express.json({ limit: MCP_MAX_BODY_SIZE });
+  if (authMiddleware) {
+    app.all("/mcp", authMiddleware, mcpBodyParser, mcpRoute);
+  } else {
+    app.all("/mcp", mcpBodyParser, mcpRoute);
+  }
+  const legacyGone = (_req, res) => {
+    res.status(410).json({
+      error: "The HTTP+SSE transport was removed in openclaw-mcp 2.0. Connect via /mcp (Streamable HTTP)."
     });
-    transport.onclose = () => {
-      const sid = transport.sessionId;
-      if (sid) {
-        streamableSessions.delete(sid);
-        log(`Streamable session closed: ${sid}`);
-      }
-    };
-    const server = createMcpServer(deps2);
-    try {
-      await server.connect(transport);
-      await transport.handleRequest(
-        req,
-        res,
-        req.body
-      );
-    } catch (error) {
-      logError("Failed to initialize streamable session", error);
-      if (!res.headersSent) {
-        res.status(500).json({ error: "Internal server error" });
-      }
-    }
   };
-  app.get("/mcp", ...withAuth(handleStreamableRequest));
-  app.post("/mcp", ...withAuth(handleStreamableRequest));
-  app.delete("/mcp", ...withAuth(handleStreamableRequest));
+  app.get("/sse", legacyGone);
+  app.post("/messages", legacyGone);
+  app.use(
+    (err, _req, res, _next) => {
+      logError("Request error", err);
+      if (res.headersSent) return;
+      const status = err.status ?? err.statusCode ?? 400;
+      res.status(status).json({ error: status === 413 ? "Payload too large" : "Bad Request" });
+    }
+  );
   const httpServer = app.listen(config.port, config.host, () => {
     log(`HTTP server listening on ${config.host}:${config.port}`);
     log(`Auth enabled: ${authEnabled}`);
@@ -1589,43 +2154,41 @@ async function createHttpServer(config, deps2) {
       log("Endpoints:");
       log("  GET  /.well-known/oauth-authorization-server          - OAuth metadata");
       log("  GET  /.well-known/oauth-protected-resource/mcp        - Protected resource metadata");
-      log("  POST /authorize                                       - Authorization");
+      log("  GET  /authorize                                       - Authorization");
       log("  POST /token                                           - Token exchange");
     } else {
       log("WARNING: Auth is DISABLED - server is open to anyone!");
     }
     log("MCP Endpoints:");
     log("  GET  /health   - Health check (no auth)");
-    log("  ALL  /mcp      - Streamable HTTP (primary)");
-    log("  GET  /sse      - Legacy SSE stream (deprecated)");
-    log("  POST /messages - Legacy SSE messages (deprecated)");
+    log("  ALL  /mcp      - Streamable HTTP (stateless)");
   });
+  let shuttingDown = false;
   const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
     log("Shutting down HTTP server...");
-    for (const [id, session] of legacySseSessions) {
-      try {
-        await session.server.close();
-      } catch (error) {
-        logError(`Error closing SSE session ${id}`, error);
-      }
-    }
-    legacySseSessions.clear();
-    for (const [id, session] of streamableSessions) {
-      try {
-        await session.server.close();
-      } catch (error) {
-        logError(`Error closing streamable session ${id}`, error);
-      }
-    }
-    streamableSessions.clear();
-    httpServer.close(() => {
-      log("HTTP server stopped");
-      process.exit(0);
-    });
-    setTimeout(() => {
+    const forceExit = setTimeout(() => {
       logError("Forced shutdown after timeout");
       process.exit(1);
     }, 5e3);
+    forceExit.unref?.();
+    const drained = new Promise((resolve) => httpServer.close(() => resolve()));
+    try {
+      await mcpHandler.close();
+    } catch (error) {
+      logError("Error closing MCP handler", error);
+    }
+    const cutConnections = setTimeout(() => {
+      log("Draining timed out; closing remaining connections");
+      httpServer.closeAllConnections?.();
+    }, DRAIN_GRACE_MS);
+    cutConnections.unref?.();
+    await drained;
+    clearTimeout(cutConnections);
+    clearTimeout(forceExit);
+    log("HTTP server stopped");
+    process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
@@ -1658,10 +2221,13 @@ async function main() {
     const defaultLabel = instance.isDefault ? " (default)" : "";
     log(`Instance "${instance.name}": ${instance.url}${defaultLabel}`);
   }
-  if (args.transport === "sse" || args.transport === "http") {
-    if (args.transport === "sse") {
-      log("WARNING: --transport sse is deprecated; use --transport http instead");
-    }
+  if (args.transport === "sse") {
+    logError(
+      "The legacy SSE transport was removed in v2.0. Use --transport http (Streamable HTTP)."
+    );
+    process.exit(1);
+  }
+  if (args.transport === "http") {
     const httpConfig = {
       port: args.port,
       host: args.host,
@@ -1718,9 +2284,14 @@ async function main() {
     }
     await createHttpServer(httpConfig, deps);
   } else {
-    const server = createMcpServer(deps);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+    const handle = serveStdio(() => createMcpServer(deps), {
+      onerror: (error) => logError("stdio transport error", error)
+    });
+    const shutdownStdio = () => {
+      void Promise.resolve(handle.close?.()).finally(() => process.exit(0));
+    };
+    process.on("SIGTERM", shutdownStdio);
+    process.on("SIGINT", shutdownStdio);
     log("OpenClaw MCP server running on stdio");
   }
 }