@ax-llm/ax 11.0.25 → 11.0.26

package/index.cjs

@@ -8625,6 +8625,53 @@ var AxEmbeddingAdapter = class {
   }
 };
 
+// ../../node_modules/uuid/dist/esm-node/rng.js
+var import_crypto2 = __toESM(require("crypto"));
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto2.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// ../../node_modules/uuid/dist/esm-node/native.js
+var import_crypto3 = __toESM(require("crypto"));
+var native_default = {
+  randomUUID: import_crypto3.default.randomUUID
+};
+
+// ../../node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
 // mcp/client.ts
 var colorLog7 = new ColorLog();
 var AxMCPClient = class {
@@ -8633,13 +8680,13 @@ var AxMCPClient = class {
     this.options = options;
   }
   functions = [];
-  requestId = 0;
+  activeRequests = /* @__PURE__ */ new Map();
   capabilities = {};
   async init() {
     if ("connect" in this.transport) {
       await this.transport.connect?.();
     }
-    const res = await this.sendRequest("initialize", {
+    const { result: res } = await this.sendRequest("initialize", {
       protocolVersion: "2024-11-05",
       capabilities: {
         roots: { listChanged: true },
@@ -8650,6 +8697,12 @@ var AxMCPClient = class {
         version: "1.0.0"
       }
     });
+    const expectedProtocolVersion = "2024-11-05";
+    if (res.protocolVersion !== expectedProtocolVersion) {
+      throw new Error(
+        `Protocol version mismatch. Expected ${expectedProtocolVersion} but got ${res.protocolVersion}`
+      );
+    }
     if (res.capabilities.tools) {
       this.capabilities.tools = true;
     }
@@ -8659,67 +8712,121 @@ var AxMCPClient = class {
     if (res.capabilities.prompts) {
       this.capabilities.prompts = true;
     }
-    await this.sendNotification("initialized");
+    await this.sendNotification("notifications/initialized");
     await this.discoverFunctions();
   }
   async discoverFunctions() {
     if (!this.capabilities.tools) {
       throw new Error("Tools are not supported");
     }
-    const res = await this.sendRequest(
-      "tools/list"
-    );
-    this.functions = res.tools.map(
-      (fn) => ({
-        name: fn.name,
-        description: fn.description,
-        parameters: fn.inputSchema,
+    const { result: res } = await this.sendRequest("tools/list");
+    this.functions = res.tools.map((fn) => {
+      const override = this.options.functionOverrides?.find(
+        (o) => o.name === fn.name
+      );
+      const parameters = fn.inputSchema.properties ? {
+        properties: fn.inputSchema.properties,
+        required: fn.inputSchema.required ?? [],
+        type: fn.inputSchema.type
+      } : void 0;
+      return {
+        name: override?.updates.name ?? fn.name,
+        description: override?.updates.description ?? fn.description,
+        parameters,
         func: async (args) => {
-          const result = await this.sendRequest("tools/call", { name: fn.name, arguments: args });
+          const { result } = await this.sendRequest("tools/call", { name: fn.name, arguments: args });
           return result;
         }
-      })
-    );
+      };
+    });
+    if (this.options.debug) {
+      console.log(
+        colorLog7.yellow(`> Discovered ${this.functions.length} functions:`)
+      );
+      for (const fn of this.functions) {
+        console.log(colorLog7.yellow(`  - ${fn.name}: ${fn.description}`));
+      }
+    }
   }
-  async ping() {
-    await this.sendRequest("ping");
+  async ping(timeout = 3e3) {
+    const pingPromise = this.sendRequest("ping");
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error("Ping response timeout exceeded")),
+        timeout
+      )
+    );
+    const response = await Promise.race([pingPromise, timeoutPromise]);
+    const { result } = response;
+    if (typeof result !== "object" || result === null || Object.keys(result).length !== 0) {
+      throw new Error(`Unexpected ping response: ${JSON.stringify(result)}`);
+    }
   }
   toFunction() {
     return this.functions;
   }
-  async sendRequest(method, params) {
+  cancelRequest(id) {
+    if (this.activeRequests.has(id)) {
+      this.sendNotification("notifications/cancelled", {
+        requestId: id,
+        reason: "Client cancelled request"
+      });
+      const entry = this.activeRequests.get(id);
+      if (entry) {
+        entry.reject(new Error(`Request ${id} cancelled`));
+      }
+      this.activeRequests.delete(id);
+    }
+  }
+  async sendRequest(method, params = {}) {
+    const requestId = v4_default();
     const request = {
       jsonrpc: "2.0",
-      id: ++this.requestId,
+      id: requestId,
       method,
       params
     };
     if (this.options.debug) {
       console.log(
         colorLog7.blueBright(
-          `> Sending request:
+          `> Sending request ${requestId}:
 ${JSON.stringify(request, null, 2)}`
         )
       );
     }
-    const res = await this.transport.send(request);
-    if (this.options.debug) {
-      console.log(
-        colorLog7.greenBright(
-          `> Received response:
+    const responsePromise = new Promise((resolve, reject) => {
+      this.activeRequests.set(requestId, { reject });
+      this.transport.send(request).then((res) => {
+        this.activeRequests.delete(requestId);
+        if (this.options.debug) {
+          console.log(
+            colorLog7.greenBright(
+              `> Received response for request ${requestId}:
 ${JSON.stringify(res, null, 2)}`
-        )
-      );
-    }
-    if ("error" in res) {
-      throw new Error(`RPC Error ${res.error.code}: ${res.error.message}`);
-    }
-    if ("result" in res) {
-      return res.result;
-    }
-    throw new Error("Invalid response no result or error");
+            )
+          );
+        }
+        if (res !== null && typeof res === "object" && "error" in res) {
+          const errorObj = res;
+          reject(
+            new Error(
+              `RPC Error ${errorObj.error.code}: ${errorObj.error.message}`
+            )
+          );
+        } else if (res !== null && typeof res === "object" && "result" in res) {
+          resolve({ result: res.result });
+        } else {
+          reject(new Error("Invalid response no result or error"));
+        }
+      }).catch((err) => {
+        this.activeRequests.delete(requestId);
+        reject(err);
+      });
+    });
+    const { result } = await responsePromise;
+    return { id: requestId, result };
   }
-  async sendNotification(method, params) {
+  async sendNotification(method, params = {}) {
     const notification = {
       jsonrpc: "2.0",
       method,