@ax-llm/ax 11.0.23 → 11.0.26

package/index.js

@@ -649,7 +649,8 @@ ${hideContent ? "" : colorLog.whiteBright(msg.content ?? "<empty>")}`;
   }
 };
 var logChatRequestMessage = (msg) => {
-  process.stdout.write(formatChatMessage(msg) + "\n");
+  process.stdout.write(`${formatChatMessage(msg)}
+`);
   process.stdout.write(colorLog.blueBright("\nAssistant:\n"));
 };
 var logChatRequest = (chatPrompt) => {
@@ -967,7 +968,7 @@ var AxBaseAI = class {
       return res2;
     };
     if (options?.debug ?? this.debug) {
-      logChatRequest(req["chatPrompt"]);
+      logChatRequest(req.chatPrompt);
     }
     const rt = options?.rateLimiter ?? this.rt;
     const rv = rt ? await rt(fn, { modelUsage: this.modelUsage }) : await fn();
@@ -1633,6 +1634,7 @@ var AxAIOpenAIModel = /* @__PURE__ */ ((AxAIOpenAIModel2) => {
   AxAIOpenAIModel2["O1Mini"] = "o1-mini";
   AxAIOpenAIModel2["O3Mini"] = "o3-mini";
   AxAIOpenAIModel2["GPT4"] = "gpt-4";
+  AxAIOpenAIModel2["GPT45"] = "gpt-4.5-preview";
   AxAIOpenAIModel2["GPT4O"] = "gpt-4o";
   AxAIOpenAIModel2["GPT4OMini"] = "gpt-4o-mini";
   AxAIOpenAIModel2["GPT4ChatGPT4O"] = "chatgpt-4o-latest";
@@ -1653,6 +1655,12 @@ var AxAIOpenAIEmbedModel = /* @__PURE__ */ ((AxAIOpenAIEmbedModel2) => {
 
 // ai/openai/info.ts
 var axModelInfoOpenAI = [
+  {
+    name: "gpt-4.5-preview" /* GPT45 */,
+    currency: "usd",
+    promptTokenCostPer1M: 75,
+    completionTokenCostPer1M: 150
+  },
   {
     name: "o1" /* O1 */,
     currency: "usd",
@@ -3660,7 +3668,7 @@ var AxAI = class {
 };
 
 // dsp/generate.ts
-import { ReadableStream as ReadableStream2 } from "stream/web";
+import { ReadableStream as ReadableStream2 } from "node:stream/web";
 import { SpanKind as SpanKind2 } from "@opentelemetry/api";
 
 // ai/util.ts
@@ -3754,7 +3762,7 @@ var MemoryImpl = class {
       }
     }
     if (this.debug) {
-      if (delta) {
+      if (delta && typeof delta === "string") {
         debugResponseDelta(delta);
       } else if (lastItem) {
         debugResponse({ content, name, functionCalls });
@@ -3887,10 +3895,10 @@ var AxAssertionError = class extends Error {
     return extraFields;
   };
 };
-var assertAssertions = (asserts, values) => {
+var assertAssertions = async (asserts, values) => {
   for (const assert of asserts) {
     const { fn, message } = assert;
-    const res = fn(values);
+    const res = await fn(values);
     if (res === void 0) {
       continue;
     }
@@ -3902,7 +3910,7 @@ var assertAssertions = (asserts, values) => {
     }
   }
 };
-var assertStreamingAssertions = (asserts, xstate, content, final = false) => {
+var assertStreamingAssertions = async (asserts, xstate, content, final = false) => {
   if (!xstate.currField || xstate.s === -1 || !asserts || asserts.length === 0) {
     return;
   }
@@ -3915,7 +3923,7 @@ var assertStreamingAssertions = (asserts, xstate, content, final = false) => {
   const currValue = content.substring(xstate.s);
   for (const assert of fieldAsserts) {
     const { message, fn } = assert;
-    const res = fn(currValue, final);
+    const res = await fn(currValue, final);
     if (res === void 0) {
       continue;
     }
@@ -3928,9 +3936,6 @@ var assertStreamingAssertions = (asserts, xstate, content, final = false) => {
 // dsp/datetime.ts
 import moment from "moment-timezone";
 
-// dsp/program.ts
-import "@opentelemetry/api";
-
 // dsp/registry.ts
 var AxInstanceRegistry = class {
   reg;
@@ -4461,7 +4466,7 @@ function validateField(field) {
 
 // dsp/util.ts
 var colorLog3 = new ColorLog();
-var updateProgressBar = (current, total, success, elapsedTime, progressBarWidth = 20, msg) => {
+var updateProgressBar = (current, total, success, elapsedTime, msg, progressBarWidth = 20) => {
   const percentage = (current / total * 100).toFixed(1);
   const filledBarLength = Math.round(progressBarWidth * current / total);
   const emptyBarLength = progressBarWidth - filledBarLength;
@@ -4708,6 +4713,7 @@ var AxProgramWithSignature = class {
   async forward(_ai, _values, _options) {
     throw new Error("forward() not implemented");
   }
+  // biome-ignore lint/correctness/useYield: just a placeholder
   async *streamingForward(_ai, _values, _options) {
     throw new Error("streamingForward() not implemented");
   }
@@ -4805,6 +4811,7 @@ var AxProgram = class {
   async forward(_ai, _values, _options) {
     throw new Error("forward() not implemented");
   }
+  // biome-ignore lint/correctness/useYield: just a placeholder
   async *streamingForward(_ai, _values, _options) {
     throw new Error("streamingForward() not implemented");
   }
@@ -4884,9 +4891,7 @@ var AxPromptTemplate = class {
     task.push(
       `You will be provided with the following fields: ${inArgs}. Your task is to generate new fields: ${outArgs}.`
     );
-    const funcs = functions?.map(
-      (f) => "toFunction" in f ? f.toFunction() : f
-    );
+    const funcs = functions?.map((f) => "toFunction" in f ? f.toFunction() : f)?.flat();
     const funcList = funcs?.map((fn) => `- \`${fn.name}\`: ${formatDescription(fn.description)}`).join("\n");
     if (funcList && funcList.length > 0) {
       task.push(`## Available Functions
@@ -5785,10 +5790,10 @@ var AxFunctionProcessor = class {
       (v) => v.name.localeCompare(func.name) === 0
     );
     if (!fnSpec) {
-      throw new Error(`Function not found: ` + func.name);
+      throw new Error(`Function not found: ${func.name}`);
     }
     if (!fnSpec.func) {
-      throw new Error("No handler for function: " + func.name);
+      throw new Error(`No handler for function: ${func.name}`);
     }
     try {
       return await this.executeFunction(fnSpec, func, options);
@@ -5809,9 +5814,11 @@ var parseFunctions = (newFuncs, existingFuncs) => {
       return f.toFunction();
     }
     return f;
-  });
+  }).flat();
   for (const fn of functions.filter((v) => v.parameters)) {
-    validateJSONSchema(fn.parameters);
+    if (fn.parameters) {
+      validateJSONSchema(fn.parameters);
+    }
   }
   return [...existingFuncs ?? [], ...functions];
 };
@@ -5857,11 +5864,11 @@ ${result}
     return promise;
   });
   const results = await Promise.all(promises);
-  results.forEach((result) => {
+  for (const result of results) {
     if (result) {
       mem.add(result, sessionId);
     }
-  });
+  }
   return functionsExecuted;
 };
 function parseFunctionCalls(ai, functionCalls, values, model) {
@@ -5945,13 +5952,14 @@ var AxGen = class extends AxProgramWithSignature {
       model,
       rateLimiter,
       stream,
-      functions,
+      functions: _functions,
       functionCall: _functionCall
     } = options ?? {};
     const chatPrompt = mem?.history(sessionId) ?? [];
     if (chatPrompt.length === 0) {
       throw new Error("No chat prompt found");
     }
+    const functions = _functions?.map((f) => "toFunction" in f ? f.toFunction() : f)?.flat();
     const functionCall = _functionCall ?? this.options?.functionCall;
     const res = await ai.chat(
       {
@@ -5976,13 +5984,14 @@ var AxGen = class extends AxProgramWithSignature {
     mem,
     options
   }) {
-    const { sessionId, traceId, model, functions } = options ?? {};
+    const { sessionId, traceId, model, functions: _functions } = options ?? {};
     const fastFail = options?.fastFail ?? this.options?.fastFail;
     const modelName = model ?? ai.getDefaultModels().model;
     const usageInfo = {
       ai: ai.getName(),
       model: modelName
     };
+    const functions = _functions?.map((f) => "toFunction" in f ? f.toFunction() : f)?.flat();
     const res = await this.forwardSendRequest({
       ai,
       mem,
@@ -6066,7 +6075,11 @@ var AxGen = class extends AxProgramWithSignature {
           streamingValidation
         );
         if (this.streamingAsserts.length !== 0) {
-          assertStreamingAssertions(this.streamingAsserts, xstate, content);
+          await assertStreamingAssertions(
+            this.streamingAsserts,
+            xstate,
+            content
+          );
         }
         if (this.streamingFieldProcessors.length !== 0) {
           await processStreamingFieldProcessors(
@@ -6082,7 +6095,7 @@ var AxGen = class extends AxProgramWithSignature {
         if (skip) {
           continue;
         }
-        assertAssertions(this.asserts, values);
+        await assertAssertions(this.asserts, values);
       }
       if (result.finishReason === "length") {
         throw new Error("Max tokens reached before completion");
@@ -6104,8 +6117,13 @@ var AxGen = class extends AxProgramWithSignature {
       this.functionsExecuted = /* @__PURE__ */ new Set([...this.functionsExecuted, ...fx]);
     } else {
       streamingExtractFinalValue(this.signature, values, xstate, content);
-      assertStreamingAssertions(this.streamingAsserts, xstate, content, true);
-      assertAssertions(this.asserts, values);
+      await assertStreamingAssertions(
+        this.streamingAsserts,
+        xstate,
+        content,
+        true
+      );
+      await assertAssertions(this.asserts, values);
       if (this.fieldProcessors.length) {
         await processFieldProcessors(
           this.fieldProcessors,
@@ -6165,7 +6183,7 @@ var AxGen = class extends AxProgramWithSignature {
         }
       } else if (result.content) {
         extractValues(this.signature, values, result.content);
-        assertAssertions(this.asserts, values);
+        await assertAssertions(this.asserts, values);
         if (this.fieldProcessors.length) {
           await processFieldProcessors(
             this.fieldProcessors,
@@ -6283,8 +6301,8 @@ var AxGen = class extends AxProgramWithSignature {
     }
     const funcNames = functions?.map((f) => f.name).join(",");
     const attributes = {
-      ["generate.signature"]: this.signature.toString(),
-      ["generate.functions"]: funcNames ?? ""
+      "generate.signature": this.signature.toString(),
+      "generate.functions": funcNames ?? ""
     };
     const span = tracer.startSpan("Generate", {
       kind: SpanKind2.SERVER,
@@ -6330,7 +6348,7 @@ var AxGen = class extends AxProgramWithSignature {
 
 // prompts/agent.ts
 function processChildAgentFunction(childFunction, parentValues, parentInputKeys, modelList, options) {
-  let processedFunction = { ...childFunction };
+  const processedFunction = { ...childFunction };
   if (processedFunction.parameters) {
     const childKeys = processedFunction.parameters.properties ? Object.keys(processedFunction.parameters.properties) : [];
     const commonKeys = parentInputKeys.filter((key) => childKeys.includes(key)).filter((key) => key !== "model");
@@ -6402,7 +6420,7 @@ var AxAgent = class {
     this.debug = debug;
     if (!name || name.length < 5) {
       throw new Error(
-        `Agent name must be at least 10 characters (more descriptive)`
+        "Agent name must be at least 10 characters (more descriptive)"
       );
     }
     if (!description || description.length < 20) {
@@ -6964,8 +6982,8 @@ var AxBootstrapFewShot = class {
         total,
         this.traces.length,
         et,
-        30,
-        "Tuning Prompt"
+        "Tuning Prompt",
+        30
       );
       if (this.traces.length > maxDemos) {
         return;
@@ -8058,13 +8076,13 @@ var AxHFDataLoader = class {
 };
 
 // funcs/code.ts
-import * as _crypto from "crypto";
-import * as _http from "http";
-import * as _https from "https";
+import * as _crypto from "node:crypto";
 import * as _fs from "node:fs";
-import * as _os from "os";
-import * as _process from "process";
-import { runInNewContext } from "vm";
+import * as _http from "node:http";
+import * as _https from "node:https";
+import * as _os from "node:os";
+import * as _process from "node:process";
+import { runInNewContext } from "node:vm";
 var AxJSInterpreterPermission = /* @__PURE__ */ ((AxJSInterpreterPermission2) => {
   AxJSInterpreterPermission2["FS"] = "node:fs";
   AxJSInterpreterPermission2["NET"] = "net";
@@ -8335,7 +8353,7 @@ var AxTestPrompt = class {
         successCount++;
       }
       const et = (/* @__PURE__ */ new Date()).getTime() - st;
-      updateProgressBar(i, total, successCount, et, 30, "Testing Prompt");
+      updateProgressBar(i, total, successCount, et, "Testing Prompt", 30);
     }
     console.log(
       "\nPerformance: ",
@@ -8501,6 +8519,320 @@ var AxEmbeddingAdapter = class {
   }
 };
 
+// ../../node_modules/uuid/dist/esm-node/rng.js
+import crypto2 from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto2.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
+import crypto3 from "crypto";
+var native_default = {
+  randomUUID: crypto3.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 {
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.options = options;
+  }
+  functions = [];
+  activeRequests = /* @__PURE__ */ new Map();
+  capabilities = {};
+  async init() {
+    if ("connect" in this.transport) {
+      await this.transport.connect?.();
+    }
+    const { result: res } = await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        roots: { listChanged: true },
+        sampling: {}
+      },
+      clientInfo: {
+        name: "AxMCPClient",
+        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;
+    }
+    if (res.capabilities.resources) {
+      this.capabilities.resources = true;
+    }
+    if (res.capabilities.prompts) {
+      this.capabilities.prompts = true;
+    }
+    await this.sendNotification("notifications/initialized");
+    await this.discoverFunctions();
+  }
+  async discoverFunctions() {
+    if (!this.capabilities.tools) {
+      throw new Error("Tools are not supported");
+    }
+    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 });
+          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(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;
+  }
+  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: requestId,
+      method,
+      params
+    };
+    if (this.options.debug) {
+      console.log(
+        colorLog7.blueBright(
+          `> Sending request ${requestId}:
+${JSON.stringify(request, null, 2)}`
+        )
+      );
+    }
+    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 (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 = {}) {
+    const notification = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    if (this.options.debug) {
+      console.log(
+        "\u27A1\uFE0F Sending notification:",
+        JSON.stringify(notification, null, 2)
+      );
+    }
+    await this.transport.sendNotification(notification);
+  }
+};
+
+// mcp/httpTransport.ts
+var AxMCPHTTPTransport = class {
+  endpoint = null;
+  sseUrl;
+  eventSource;
+  constructor(sseUrl) {
+    this.sseUrl = sseUrl;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.eventSource = new EventSource(this.sseUrl);
+      this.eventSource.addEventListener("endpoint", (event) => {
+        try {
+          const messageEvent = event;
+          const data = JSON.parse(messageEvent.data);
+          if (!data.uri) {
+            throw new Error("Endpoint URI missing in SSE event data");
+          }
+          this.endpoint = data.uri;
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+      this.eventSource.onerror = () => {
+        reject(new Error("Failed to establish SSE connection"));
+      };
+    });
+  }
+  async send(message) {
+    if (!this.endpoint) {
+      throw new Error(
+        "HTTPTransport endpoint is not initialized. Call connect() first."
+      );
+    }
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP error ${res.status}: ${res.statusText}`);
+    }
+    return res.json();
+  }
+  async sendNotification(message) {
+    if (!this.endpoint) {
+      throw new Error(
+        "HTTPTransport endpoint is not initialized. Call connect() first."
+      );
+    }
+    await fetch(this.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+  }
+};
+
+// mcp/stdioTransport.ts
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+var AxMCPStdioTransport = class {
+  process;
+  rl;
+  pendingResponses = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.process = spawn(config.command, config.args ?? [], {
+      env: config.env ? { ...process.env, ...config.env } : process.env
+    });
+    this.rl = readline.createInterface({ input: this.process.stdout });
+    this.rl.on("line", (line) => {
+      const response = JSON.parse(line);
+      const resolver = this.pendingResponses.get(response.id);
+      if (resolver) {
+        resolver(response);
+        this.pendingResponses.delete(response.id);
+      }
+    });
+  }
+  async send(message) {
+    return new Promise((resolve) => {
+      this.pendingResponses.set(message.id, (res) => {
+        resolve(res);
+      });
+      this.process.stdin.write(`${JSON.stringify(message)}
+`);
+    });
+  }
+  async sendNotification(message) {
+    this.process.stdin.write(`${JSON.stringify(message)}
+`);
+  }
+  async connect() {
+  }
+};
+
 // ai/multiservice.ts
 var AxMultiServiceRouter = class {
   services = /* @__PURE__ */ new Map();
@@ -8752,6 +9084,9 @@ export {
   AxJSInterpreter,
   AxJSInterpreterPermission,
   AxLLMRequestTypeValues,
+  AxMCPClient,
+  AxMCPHTTPTransport,
+  AxMCPStdioTransport,
   AxMemory,
   AxMockAIService,
   AxMultiServiceRouter,