@mcp-ts/sdk 1.0.0 → 1.0.1

package/dist/adapters/agui-middleware.mjs

@@ -3,410 +3,335 @@ import { Middleware, EventType } from '@ag-ui/client';
 export { EventType, Middleware } from '@ag-ui/client';
 
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/adapters/agui-adapter.ts
-var agui_adapter_exports = {};
-__export(agui_adapter_exports, {
-  AguiAdapter: () => AguiAdapter
-});
-var AguiAdapter;
-var init_agui_adapter = __esm({
-  "src/adapters/agui-adapter.ts"() {
-    AguiAdapter = class {
-      constructor(client, options = {}) {
-        this.client = client;
-        this.options = options;
-      }
-      /**
-       * Get tools with handlers for MCP tool execution.
-       *
-       * Each tool includes a handler function that:
-       * 1. Calls the MCP tool via the client
-       * 2. Extracts text content from the result
-       * 3. Returns the result as a string or JSON
-       *
-       * @returns Array of AguiTool objects
-       */
-      async getTools() {
-        const isMultiSession = typeof this.client.getClients === "function";
-        if (isMultiSession) {
-          const clients = this.client.getClients();
-          const allTools = [];
-          for (const client of clients) {
-            const tools = await this.transformTools(client);
-            allTools.push(...tools);
-          }
-          return allTools;
-        }
-        return this.transformTools(this.client);
-      }
-      async transformTools(client) {
-        if (!client.isConnected()) {
-          return [];
-        }
-        const result = await client.listTools();
-        const prefix = this.options.prefix ?? client.getServerId() ?? "mcp";
-        const tools = [];
-        for (const tool of result.tools) {
-          const toolName = `${prefix}_${tool.name}`;
-          tools.push({
-            name: toolName,
-            description: tool.description || `Execute ${tool.name}`,
-            parameters: tool.inputSchema || { type: "object", properties: {} },
-            handler: async (args) => {
-              console.log(`[AguiAdapter] Executing MCP tool: ${tool.name}`, args);
-              const result2 = await client.callTool(tool.name, args);
-              if (result2.content && Array.isArray(result2.content)) {
-                const textContent = result2.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-                return textContent || result2;
-              }
-              return result2;
-            }
-          });
-        }
-        return tools;
-      }
-      /**
-       * Get tools as a function (for dynamic loading).
-       *
-       * @returns Function that returns a Promise of tools
-       */
-      getToolsFunction() {
-        return async () => this.getTools();
-      }
-      /**
-       * Get tool definitions in JSON Schema format for passing to remote agents.
-       *
-       * This format is compatible with:
-       * - OpenAI's function calling API
-       * - AG-UI input.tools format
-       * - Most LLM tool/function calling implementations
-       *
-       * @returns Array of AguiToolDefinition objects
-       */
-      async getToolDefinitions() {
-        const isMultiSession = typeof this.client.getClients === "function";
-        if (isMultiSession) {
-          const clients = this.client.getClients();
-          const allTools = [];
-          for (const client of clients) {
-            const tools = await this.transformToolDefinitions(client);
-            allTools.push(...tools);
-          }
-          return allTools;
-        }
-        return this.transformToolDefinitions(this.client);
-      }
-      async transformToolDefinitions(client) {
-        if (!client.isConnected()) {
-          return [];
-        }
-        const result = await client.listTools();
-        const prefix = this.options.prefix ?? client.getServerId() ?? "mcp";
-        const tools = [];
-        for (const tool of result.tools) {
-          tools.push({
-            name: `${prefix}_${tool.name}`,
-            description: tool.description || `Execute ${tool.name}`,
-            parameters: tool.inputSchema || { type: "object", properties: {} }
-          });
-        }
-        return tools;
+function cleanSchema(schema) {
+  if (!schema) {
+    return { type: "object", properties: {} };
+  }
+  const cleaned = { ...schema };
+  delete cleaned.$schema;
+  delete cleaned.$id;
+  delete cleaned.$comment;
+  delete cleaned.$defs;
+  delete cleaned.definitions;
+  if (cleaned.properties && typeof cleaned.properties === "object") {
+    const cleanedProps = {};
+    for (const [key, value] of Object.entries(cleaned.properties)) {
+      if (typeof value === "object" && value !== null) {
+        cleanedProps[key] = cleanSchema(value);
+      } else {
+        cleanedProps[key] = value;
       }
-    };
+    }
+    cleaned.properties = cleanedProps;
+  }
+  if (cleaned.items && typeof cleaned.items === "object") {
+    cleaned.items = cleanSchema(cleaned.items);
   }
-});
+  if (cleaned.additionalProperties && typeof cleaned.additionalProperties === "object") {
+    cleaned.additionalProperties = cleanSchema(cleaned.additionalProperties);
+  }
+  return cleaned;
+}
+
+// src/adapters/agui-middleware.ts
 var McpMiddleware = class extends Middleware {
   constructor(config) {
     super();
-    __publicField(this, "client");
-    __publicField(this, "toolPrefix");
-    __publicField(this, "actions");
     __publicField(this, "tools");
-    __publicField(this, "actionsLoaded", false);
-    this.client = config.client;
-    this.toolPrefix = config.toolPrefix ?? "server-";
-    this.actions = config.tools ?? null;
-    this.tools = null;
-    if (this.actions) {
-      this.actionsLoaded = true;
-      this.tools = this.actionsToTools(this.actions);
-    }
-  }
-  /**
-   * Convert actions to AG-UI tool format
-   */
-  actionsToTools(actions) {
-    return actions.map((action) => ({
-      name: action.name,
-      description: action.description,
-      parameters: action.parameters || { type: "object", properties: {} }
+    __publicField(this, "toolSchemas");
+    __publicField(this, "maxResultLength");
+    this.tools = config.tools;
+    this.maxResultLength = config.maxResultLength ?? 5e4;
+    this.toolSchemas = this.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: cleanSchema(t.parameters)
     }));
   }
-  /**
-   * Check if a tool name is an MCP tool (matches the configured prefix)
-   */
   isMcpTool(toolName) {
-    return toolName.startsWith(this.toolPrefix);
+    return this.tools.some((t) => t.name === toolName);
   }
-  /**
-   * Load actions from the MCP client if not already loaded
-   */
-  async ensureActionsLoaded() {
-    if (this.actionsLoaded) return;
-    const { AguiAdapter: AguiAdapter2 } = await Promise.resolve().then(() => (init_agui_adapter(), agui_adapter_exports));
-    const adapter = new AguiAdapter2(this.client);
-    this.actions = await adapter.getTools();
-    this.actionsLoaded = true;
+  parseArgs(argsString) {
+    if (!argsString?.trim()) return {};
+    try {
+      return JSON.parse(argsString);
+    } catch {
+      const trimmed = argsString.trim();
+      if (trimmed.includes("}{")) {
+        const firstObject = trimmed.slice(0, trimmed.indexOf("}{") + 1);
+        try {
+          return JSON.parse(firstObject);
+        } catch {
+          console.error(`[McpMiddleware] Failed to parse JSON:`, firstObject);
+        }
+      }
+      console.error(`[McpMiddleware] Failed to parse args:`, argsString);
+      return {};
+    }
   }
-  /**
-   * Execute an MCP tool and return the result as a string
-   */
   async executeTool(toolName, args) {
-    await this.ensureActionsLoaded();
-    const action = this.actions?.find((a) => a.name === toolName);
-    if (!action) {
-      return `Error: Tool not found: ${toolName}`;
-    }
-    if (!action.handler) {
-      return `Error: Tool has no handler: ${toolName}`;
+    const tool = this.tools.find((t) => t.name === toolName);
+    if (!tool?.handler) {
+      return `Error: Tool ${tool ? "has no handler" : "not found"}: ${toolName}`;
     }
     try {
       console.log(`[McpMiddleware] Executing tool: ${toolName}`, args);
-      const result = await action.handler(args);
-      console.log(`[McpMiddleware] Tool result:`, typeof result === "string" ? result.slice(0, 200) : result);
-      return typeof result === "string" ? result : JSON.stringify(result);
+      const result = await tool.handler(args);
+      let resultStr = typeof result === "string" ? result : JSON.stringify(result);
+      if (resultStr.length > this.maxResultLength) {
+        const original = resultStr.length;
+        resultStr = resultStr.slice(0, this.maxResultLength) + `
+
+[... Truncated from ${original} to ${this.maxResultLength} chars]`;
+        console.log(`[McpMiddleware] Tool result truncated from ${original} to ${this.maxResultLength} chars`);
+      }
+      console.log(`[McpMiddleware] Tool result:`, resultStr.slice(0, 200));
+      return resultStr;
     } catch (error) {
       console.error(`[McpMiddleware] Error executing tool:`, error);
-      return `Error executing tool: ${error.message || String(error)}`;
+      return `Error: ${error.message || String(error)}`;
     }
   }
-  /**
-   * Generate a unique message ID for tool results
-   */
-  generateMessageId() {
-    return `mcp_result_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  generateId(prefix) {
+    return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  }
+  ensureIds(input) {
+    const anyInput = input;
+    if (!anyInput.threadId) anyInput.threadId = this.generateId("mcp_thread");
+    if (!anyInput.runId) anyInput.runId = this.generateId("mcp_run");
+  }
+  /** Process tool call events and update state */
+  handleToolCallEvent(event, state) {
+    const { toolCallArgsBuffer, toolCallNames, pendingMcpCalls } = state;
+    if (event.type === EventType.TEXT_MESSAGE_CHUNK) {
+      const e = event;
+      if (e.delta) {
+        state.textContent = (state.textContent || "") + e.delta;
+      }
+    }
+    if (event.type === EventType.TOOL_CALL_START) {
+      const e = event;
+      if (e.toolCallId && e.toolCallName) {
+        toolCallNames.set(e.toolCallId, e.toolCallName);
+        if (this.isMcpTool(e.toolCallName)) {
+          pendingMcpCalls.add(e.toolCallId);
+        }
+        console.log(`[McpMiddleware] TOOL_CALL_START: ${e.toolCallName} (id: ${e.toolCallId}, isMCP: ${this.isMcpTool(e.toolCallName)})`);
+      }
+    }
+    if (event.type === EventType.TOOL_CALL_ARGS) {
+      const e = event;
+      if (e.toolCallId && e.delta) {
+        const existing = toolCallArgsBuffer.get(e.toolCallId) || "";
+        toolCallArgsBuffer.set(e.toolCallId, existing + e.delta);
+      }
+    }
+    if (event.type === EventType.TOOL_CALL_END) {
+      const e = event;
+      console.log(`[McpMiddleware] TOOL_CALL_END: ${toolCallNames.get(e.toolCallId) ?? "unknown"} (id: ${e.toolCallId})`);
+    }
+    if (event.type === EventType.MESSAGES_SNAPSHOT) {
+      const messages = event.messages || [];
+      if (messages.length > 0) {
+        const lastMsg = messages[messages.length - 1];
+        if (lastMsg.role === "assistant" && lastMsg.content) {
+          state.textContent = lastMsg.content;
+        }
+        for (let i = messages.length - 1; i >= 0; i--) {
+          const msg = messages[i];
+          const tools = Array.isArray(msg.toolCalls) ? msg.toolCalls : Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+          if (msg.role === "assistant" && tools.length > 0) {
+            for (const tc of tools) {
+              if (tc.id && tc.function?.name && !toolCallNames.has(tc.id)) {
+                toolCallNames.set(tc.id, tc.function.name);
+                toolCallArgsBuffer.set(tc.id, tc.function.arguments || "{}");
+                if (this.isMcpTool(tc.function.name)) {
+                  pendingMcpCalls.add(tc.id);
+                  console.log(`[McpMiddleware] MESSAGES_SNAPSHOT: Discovered ${tc.function.name} (id: ${tc.id})`);
+                }
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  /** Execute pending MCP tools and return results */
+  async executeTools(state) {
+    const { toolCallArgsBuffer, toolCallNames, pendingMcpCalls } = state;
+    const results = [];
+    const promises = [...pendingMcpCalls].map(async (toolCallId) => {
+      const toolName = toolCallNames.get(toolCallId);
+      if (!toolName) return;
+      const args = this.parseArgs(toolCallArgsBuffer.get(toolCallId) || "{}");
+      console.log(`[McpMiddleware] Executing pending tool: ${toolName}`);
+      const result = await this.executeTool(toolName, args);
+      results.push({
+        toolCallId,
+        toolName,
+        result,
+        messageId: this.generateId("mcp_result")
+      });
+      pendingMcpCalls.delete(toolCallId);
+    });
+    await Promise.all(promises);
+    return results;
+  }
+  /** Emit tool results (without RUN_FINISHED - that's emitted when truly done) */
+  emitToolResults(observer, results) {
+    for (const { toolCallId, toolName, result, messageId } of results) {
+      observer.next({
+        type: EventType.TOOL_CALL_RESULT,
+        toolCallId,
+        messageId,
+        content: result,
+        role: "tool",
+        timestamp: Date.now()
+      });
+      console.log(`[McpMiddleware] Emitting TOOL_CALL_RESULT for: ${toolName}`);
+    }
   }
-  /**
-   * Run the middleware, intercepting and executing MCP tool calls
-   */
   run(input, next) {
     return new Observable((observer) => {
-      const toolCallArgsBuffer = /* @__PURE__ */ new Map();
-      const toolCallNames = /* @__PURE__ */ new Map();
-      const pendingMcpCalls = /* @__PURE__ */ new Set();
-      console.log(`[McpMiddleware] Starting run with ${this.actions?.length ?? 0} registered actions`);
-      console.log(`[McpMiddleware] Tool prefix: "${this.toolPrefix}"`);
-      if (this.tools && this.tools.length > 0) {
-        const existingTools = input.tools || [];
-        input.tools = [...existingTools, ...this.tools];
-        console.log(`[McpMiddleware] Injected ${this.tools.length} MCP tools into input.tools`);
-        console.log(`[McpMiddleware] Total tools: ${input.tools.length}`);
-        console.log(`[McpMiddleware] Tool names:`, this.tools.map((t) => t.name));
+      const state = {
+        toolCallArgsBuffer: /* @__PURE__ */ new Map(),
+        toolCallNames: /* @__PURE__ */ new Map(),
+        pendingMcpCalls: /* @__PURE__ */ new Set(),
+        textContent: "",
+        error: false
+      };
+      this.ensureIds(input);
+      const anyInput = input;
+      console.log(`[McpMiddleware] === NEW RUN ===`);
+      console.log(`[McpMiddleware] threadId: ${anyInput.threadId}, runId: ${anyInput.runId}`);
+      console.log(`[McpMiddleware] messages: ${input.messages?.length ?? 0}, tools: ${this.tools?.length ?? 0}`);
+      if (this.toolSchemas?.length) {
+        input.tools = [...input.tools || [], ...this.toolSchemas];
+        console.log(`[McpMiddleware] Injected ${this.toolSchemas.length} tools:`, this.toolSchemas.map((t) => t.name));
       }
-      const handleRunFinished = async (event) => {
-        if (pendingMcpCalls.size === 0) {
-          observer.next(event);
+      const handleRunFinished = async () => {
+        if (state.error) return;
+        if (state.pendingMcpCalls.size === 0) {
+          observer.next({
+            type: EventType.RUN_FINISHED,
+            threadId: anyInput.threadId,
+            runId: anyInput.runId,
+            timestamp: Date.now()
+          });
           observer.complete();
           return;
         }
-        console.log(`[McpMiddleware] RUN_FINISHED received with ${pendingMcpCalls.size} pending MCP calls`);
-        const callPromises = [...pendingMcpCalls].map(async (toolCallId) => {
-          const toolName = toolCallNames.get(toolCallId);
-          if (!toolName) return;
-          const argsString = toolCallArgsBuffer.get(toolCallId) || "{}";
-          let args = {};
-          try {
-            args = JSON.parse(argsString);
-          } catch (e) {
-            console.error(`[McpMiddleware] Failed to parse args:`, argsString);
+        console.log(`[McpMiddleware] RUN_FINISHED with ${state.pendingMcpCalls.size} pending calls`);
+        const toolCalls = [];
+        for (const toolCallId of state.pendingMcpCalls) {
+          const name = state.toolCallNames.get(toolCallId);
+          const args = state.toolCallArgsBuffer.get(toolCallId) || "{}";
+          if (name) {
+            toolCalls.push({
+              id: toolCallId,
+              type: "function",
+              function: { name, arguments: args }
+            });
           }
-          console.log(`[McpMiddleware] Executing pending tool: ${toolName}`);
-          const result = await this.executeTool(toolName, args);
-          const messageId = this.generateMessageId();
-          const resultEvent = {
-            type: EventType.TOOL_CALL_RESULT,
-            toolCallId,
-            messageId,
-            content: result,
-            role: "tool",
-            timestamp: Date.now()
+        }
+        if (toolCalls.length > 0 || state.textContent) {
+          const assistantMsg = {
+            id: this.generateId("msg_ast"),
+            role: "assistant",
+            content: state.textContent || null,
+            // Ensure null if empty string for strict LLMs
+            tool_calls: toolCalls.length > 0 ? toolCalls : void 0
           };
-          console.log(`[McpMiddleware] Emitting TOOL_CALL_RESULT for: ${toolName}`);
-          observer.next(resultEvent);
+          input.messages.push(assistantMsg);
+          console.log(`[McpMiddleware] Added assistant message to history before tools: ${state.textContent?.slice(0, 50)}... [${toolCalls.length} tools]`);
+        }
+        const results = await this.executeTools(state);
+        this.emitToolResults(observer, results);
+        console.log(`[McpMiddleware] Triggering continuation with ${results.length} results`);
+        for (const { toolCallId, result, messageId } of results) {
           input.messages.push({
             id: messageId,
             role: "tool",
-            toolCallId,
+            tool_call_id: toolCallId,
             content: result
           });
-          pendingMcpCalls.delete(toolCallId);
-        });
-        await Promise.all(callPromises);
-        console.log(`[McpMiddleware] All MCP tools executed, emitting RUN_FINISHED`);
-        observer.next({
-          type: EventType.RUN_FINISHED,
-          threadId: input.threadId,
-          runId: input.runId,
-          timestamp: Date.now()
+        }
+        state.toolCallArgsBuffer.clear();
+        state.toolCallNames.clear();
+        state.textContent = "";
+        anyInput.runId = this.generateId("mcp_run");
+        console.log(`[McpMiddleware] === CONTINUATION RUN === messages: ${input.messages.length}`);
+        next.run(input).subscribe({
+          next: (event) => {
+            if (state.error) return;
+            this.handleToolCallEvent(event, state);
+            if (event.type === EventType.RUN_ERROR) {
+              console.log(`[McpMiddleware] RUN_ERROR received in continuation`);
+              state.error = true;
+              observer.next(event);
+              observer.complete();
+              return;
+            }
+            if (event.type === EventType.RUN_STARTED) {
+              console.log(`[McpMiddleware] Filtering RUN_STARTED from continuation`);
+              return;
+            }
+            if (event.type === EventType.RUN_FINISHED) {
+              if (state.pendingMcpCalls.size > 0) {
+                handleRunFinished();
+              } else {
+                observer.next(event);
+                observer.complete();
+              }
+              return;
+            }
+            observer.next(event);
+          },
+          error: (err) => {
+            state.error = true;
+            observer.error(err);
+          },
+          complete: () => {
+            if (!state.error && state.pendingMcpCalls.size === 0) observer.complete();
+          }
         });
-        console.log(`[McpMiddleware] Triggering new run`);
-        this.triggerNewRun(observer, input, next, toolCallArgsBuffer, toolCallNames, pendingMcpCalls);
       };
       const subscription = next.run(input).subscribe({
         next: (event) => {
-          if (event.type === EventType.TOOL_CALL_START) {
-            const startEvent = event;
-            if (startEvent.toolCallId && startEvent.toolCallName) {
-              toolCallNames.set(startEvent.toolCallId, startEvent.toolCallName);
-              const isMcp = this.isMcpTool(startEvent.toolCallName);
-              console.log(`[McpMiddleware] TOOL_CALL_START: ${startEvent.toolCallName} (id: ${startEvent.toolCallId}, isMCP: ${isMcp})`);
-              if (isMcp) {
-                pendingMcpCalls.add(startEvent.toolCallId);
-              }
-            }
-          }
-          if (event.type === EventType.TOOL_CALL_ARGS) {
-            const argsEvent = event;
-            if (argsEvent.toolCallId && argsEvent.delta) {
-              const existing = toolCallArgsBuffer.get(argsEvent.toolCallId) || "";
-              toolCallArgsBuffer.set(argsEvent.toolCallId, existing + argsEvent.delta);
-            }
-          }
-          if (event.type === EventType.TOOL_CALL_END) {
-            const endEvent = event;
-            const toolName = toolCallNames.get(endEvent.toolCallId);
-            console.log(`[McpMiddleware] TOOL_CALL_END: ${toolName ?? "unknown"} (id: ${endEvent.toolCallId})`);
+          if (state.error) return;
+          this.handleToolCallEvent(event, state);
+          if (event.type === EventType.RUN_ERROR) {
+            console.log(`[McpMiddleware] RUN_ERROR received`);
+            state.error = true;
+            observer.next(event);
+            observer.complete();
+            return;
           }
           if (event.type === EventType.RUN_FINISHED) {
-            handleRunFinished(event);
+            handleRunFinished();
             return;
           }
           observer.next(event);
         },
-        error: (error) => {
-          observer.error(error);
+        error: (err) => {
+          state.error = true;
+          observer.error(err);
         },
         complete: () => {
-          if (pendingMcpCalls.size === 0) {
-            observer.complete();
-          }
-        }
-      });
-      return () => {
-        subscription.unsubscribe();
-      };
-    });
-  }
-  triggerNewRun(observer, input, next, toolCallArgsBuffer, toolCallNames, pendingMcpCalls) {
-    toolCallArgsBuffer.clear();
-    toolCallNames.clear();
-    pendingMcpCalls.clear();
-    console.log(`[McpMiddleware] Starting new run with updated messages`);
-    next.run(input).subscribe({
-      next: (event) => {
-        if (event.type === EventType.TOOL_CALL_START) {
-          const startEvent = event;
-          if (startEvent.toolCallId && startEvent.toolCallName) {
-            toolCallNames.set(startEvent.toolCallId, startEvent.toolCallName);
-            const isMcp = this.isMcpTool(startEvent.toolCallName);
-            console.log(`[McpMiddleware] TOOL_CALL_START: ${startEvent.toolCallName} (id: ${startEvent.toolCallId}, isMCP: ${isMcp})`);
-            if (isMcp) {
-              pendingMcpCalls.add(startEvent.toolCallId);
-            }
-          }
-        }
-        if (event.type === EventType.TOOL_CALL_ARGS) {
-          const argsEvent = event;
-          if (argsEvent.toolCallId && argsEvent.delta) {
-            const existing = toolCallArgsBuffer.get(argsEvent.toolCallId) || "";
-            toolCallArgsBuffer.set(argsEvent.toolCallId, existing + argsEvent.delta);
-          }
+          if (!state.error && state.pendingMcpCalls.size === 0) observer.complete();
         }
-        if (event.type === EventType.TOOL_CALL_END) {
-          const endEvent = event;
-          const toolName = toolCallNames.get(endEvent.toolCallId);
-          console.log(`[McpMiddleware] TOOL_CALL_END: ${toolName ?? "unknown"} (id: ${endEvent.toolCallId})`);
-        }
-        if (event.type === EventType.RUN_FINISHED) {
-          if (pendingMcpCalls.size > 0) {
-            console.log(`[McpMiddleware] RUN_FINISHED with ${pendingMcpCalls.size} pending calls, executing...`);
-            this.handlePendingCalls(observer, input, next, toolCallArgsBuffer, toolCallNames, pendingMcpCalls);
-          } else {
-            observer.next(event);
-            observer.complete();
-          }
-          return;
-        }
-        observer.next(event);
-      },
-      error: (error) => observer.error(error),
-      complete: () => {
-        if (pendingMcpCalls.size === 0) {
-          observer.complete();
-        }
-      }
-    });
-  }
-  async handlePendingCalls(observer, input, next, toolCallArgsBuffer, toolCallNames, pendingMcpCalls) {
-    const callPromises = [...pendingMcpCalls].map(async (toolCallId) => {
-      const toolName = toolCallNames.get(toolCallId);
-      if (!toolName) return;
-      const argsString = toolCallArgsBuffer.get(toolCallId) || "{}";
-      let args = {};
-      try {
-        args = JSON.parse(argsString);
-      } catch (e) {
-        console.error(`[McpMiddleware] Failed to parse args:`, argsString);
-      }
-      console.log(`[McpMiddleware] Executing pending tool: ${toolName}`);
-      const result = await this.executeTool(toolName, args);
-      const messageId = this.generateMessageId();
-      const resultEvent = {
-        type: EventType.TOOL_CALL_RESULT,
-        toolCallId,
-        messageId,
-        content: result,
-        role: "tool",
-        timestamp: Date.now()
-      };
-      console.log(`[McpMiddleware] Emitting TOOL_CALL_RESULT for: ${toolName}`);
-      observer.next(resultEvent);
-      input.messages.push({
-        id: messageId,
-        role: "tool",
-        toolCallId,
-        content: result
       });
-      pendingMcpCalls.delete(toolCallId);
-    });
-    await Promise.all(callPromises);
-    console.log(`[McpMiddleware] Pending tools executed, emitting RUN_FINISHED`);
-    observer.next({
-      type: EventType.RUN_FINISHED,
-      threadId: input.threadId,
-      runId: input.runId,
-      timestamp: Date.now()
+      return () => subscription.unsubscribe();
     });
-    console.log(`[McpMiddleware] Triggering new run`);
-    this.triggerNewRun(observer, input, next, toolCallArgsBuffer, toolCallNames, pendingMcpCalls);
   }
 };
-function createMcpMiddleware(client, options = {}) {
-  const middleware = new McpMiddleware({
-    client,
-    ...options
-  });
+function createMcpMiddleware(options) {
+  const middleware = new McpMiddleware(options);
   return (input, next) => {
     return middleware.run(input, next);
   };