@ax-llm/ax 10.0.46 → 10.0.48

package/index.cjs

@@ -84,6 +84,7 @@ __export(index_exports, {
   AxDefaultResultReranker: () => AxDefaultResultReranker,
   AxDockerSession: () => AxDockerSession,
   AxEmbeddingAdapter: () => AxEmbeddingAdapter,
+  AxFunctionError: () => AxFunctionError,
   AxFunctionProcessor: () => AxFunctionProcessor,
   AxGen: () => AxGen,
   AxHFDataLoader: () => AxHFDataLoader,
@@ -182,7 +183,6 @@ var AxSpanKindValues = /* @__PURE__ */ ((AxSpanKindValues2) => {
 })(AxSpanKindValues || {});
 
 // util/apicall.ts
-var import_path = __toESM(require("path"), 1);
 var import_web3 = require("stream/web");
 var import_api = require("@opentelemetry/api");
 
@@ -310,7 +310,6 @@ var defaultRetryConfig = {
   maxRetries: 3,
   initialDelayMs: 1e3,
   maxDelayMs: 6e4,
-  // Increased to 60 seconds
   backoffFactor: 2,
   retryableStatusCodes: [500, 408, 429, 502, 503, 504]
 };
@@ -321,18 +320,19 @@ var AxAIServiceError = class extends Error {
     super(message);
     this.url = url;
     this.requestBody = requestBody;
-    this.context = context;
-    this.name = "AxAIServiceError";
+    this.name = this.constructor.name;
     this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
     this.errorId = crypto.randomUUID();
+    this.context = context;
   }
   timestamp;
   errorId;
+  context;
   toString() {
     return `${this.name} [${this.errorId}]: ${this.message}
 Timestamp: ${this.timestamp}
 URL: ${this.url}${this.requestBody ? `
-Request Body: ${JSON.stringify(this.requestBody, null, 2)}` : ""}${this.context ? `
+Request Body: ${JSON.stringify(this.requestBody, null, 2)}` : ""}${Object.keys(this.context).length ? `
 Context: ${JSON.stringify(this.context, null, 2)}` : ""}`;
   }
   toJSON() {
@@ -357,7 +357,7 @@ var AxAIServiceStatusError = class extends AxAIServiceError {
     });
     this.status = status;
     this.statusText = statusText;
-    this.name = "AxAIServiceStatusError";
+    this.name = this.constructor.name;
   }
 };
 var AxAIServiceNetworkError = class extends AxAIServiceError {
@@ -368,14 +368,14 @@ var AxAIServiceNetworkError = class extends AxAIServiceError {
       ...context
     });
     this.originalError = originalError;
-    this.name = "AxAIServiceNetworkError";
+    this.name = this.constructor.name;
     this.stack = originalError.stack;
   }
 };
 var AxAIServiceResponseError = class extends AxAIServiceError {
   constructor(message, url, requestBody, context) {
     super(message, url, requestBody, context);
-    this.name = "AxAIServiceResponseError";
+    this.name = this.constructor.name;
   }
 };
 var AxAIServiceStreamTerminatedError = class extends AxAIServiceError {
@@ -385,7 +385,7 @@ var AxAIServiceStreamTerminatedError = class extends AxAIServiceError {
       ...context
     });
     this.lastChunk = lastChunk;
-    this.name = "AxAIServiceStreamTerminatedError";
+    this.name = this.constructor.name;
   }
 };
 var AxAIServiceTimeoutError = class extends AxAIServiceError {
@@ -394,13 +394,13 @@ var AxAIServiceTimeoutError = class extends AxAIServiceError {
       timeoutMs,
       ...context
     });
-    this.name = "AxAIServiceTimeoutError";
+    this.name = this.constructor.name;
   }
 };
 var AxAIServiceAuthenticationError = class extends AxAIServiceError {
   constructor(url, requestBody, context) {
     super("Authentication failed", url, requestBody, context);
-    this.name = "AxAIServiceAuthenticationError";
+    this.name = this.constructor.name;
   }
 };
 function calculateRetryDelay(attempt, config) {
@@ -420,14 +420,31 @@ function updateRetryMetrics(metrics) {
   metrics.retryCount++;
   metrics.lastRetryTime = Date.now();
 }
+function shouldRetry(error, status, attempt, config) {
+  if (attempt >= config.maxRetries) return false;
+  if (status && config.retryableStatusCodes.includes(status)) return true;
+  return error instanceof AxAIServiceNetworkError && !(error instanceof AxAIServiceAuthenticationError);
+}
 var apiCall = async (api, json) => {
   const retryConfig = { ...defaultRetryConfig, ...api.retry };
   const timeoutMs = api.timeout ?? defaultTimeoutMs;
   const metrics = createRequestMetrics();
+  let timeoutId;
   const baseUrl = new URL(process.env["PROXY"] ?? api.url);
-  const apiPath = import_path.default.join(baseUrl.pathname, api.name ?? "/", baseUrl.search);
+  const apiPath = [baseUrl.pathname, api.name].filter(Boolean).join("/").replace(/\/+/g, "/");
   const apiUrl = new URL(apiPath, baseUrl);
   const requestId = crypto.randomUUID();
+  if (api.validateRequest) {
+    const isValid = await api.validateRequest(json);
+    if (!isValid) {
+      throw new AxAIServiceResponseError(
+        "Invalid request data",
+        apiUrl.href,
+        json,
+        { validation: "request" }
+      );
+    }
+  }
   if (api.span?.isRecording()) {
     api.span.setAttributes({
       "http.request.method": api.put ? "PUT" : "POST",
@@ -439,7 +456,7 @@ var apiCall = async (api, json) => {
   let attempt = 0;
   while (true) {
     const controller = new AbortController();
-    let timeoutId = setTimeout(() => {
+    timeoutId = setTimeout(() => {
       controller.abort("Request timeout");
     }, timeoutMs);
     try {
@@ -458,7 +475,7 @@ var apiCall = async (api, json) => {
       if (res.status === 401 || res.status === 403) {
         throw new AxAIServiceAuthenticationError(apiUrl.href, json, { metrics });
       }
-      if (res.status >= 400 && attempt < retryConfig.maxRetries && retryConfig.retryableStatusCodes.includes(res.status)) {
+      if (res.status >= 400 && shouldRetry(new Error(), res.status, attempt, retryConfig)) {
         const delay = calculateRetryDelay(attempt, retryConfig);
         attempt++;
         updateRetryMetrics(metrics);
@@ -472,7 +489,7 @@ var apiCall = async (api, json) => {
             "metrics.lastRetryTime": metrics.lastRetryTime
           });
         }
-        clearTimeout(timeoutId);
+        await new Promise((resolve) => setTimeout(resolve, delay));
         continue;
       }
       if (res.status >= 400) {
@@ -486,6 +503,17 @@ var apiCall = async (api, json) => {
       }
       if (!api.stream) {
         const resJson = await res.json();
+        if (api.validateResponse) {
+          const isValid = await api.validateResponse(resJson);
+          if (!isValid) {
+            throw new AxAIServiceResponseError(
+              "Invalid response data",
+              apiUrl.href,
+              json,
+              { validation: "response" }
+            );
+          }
+        }
         if (api.span?.isRecording()) {
           api.span.setAttributes({
             "response.time": Date.now() - metrics.startTime,
@@ -504,7 +532,7 @@ var apiCall = async (api, json) => {
       }
       let lastChunk;
       let chunkCount = 0;
-      const trackingStream = new TransformStream({
+      const trackingStream = new import_web3.TransformStream({
         transform(chunk, controller2) {
           lastChunk = chunk;
           chunkCount++;
@@ -512,7 +540,7 @@ var apiCall = async (api, json) => {
           metrics.lastChunkTime = Date.now();
           controller2.enqueue(chunk);
         },
-        flush(controller2) {
+        flush() {
           if (api.span?.isRecording()) {
             api.span.setAttributes({
               "stream.chunks": chunkCount,
@@ -520,10 +548,10 @@ var apiCall = async (api, json) => {
               "response.retries": metrics.retryCount
             });
           }
-          controller2.terminate();
         }
       });
-      const wrappedStream = new import_web3.ReadableStream({
+      let closed = false;
+      return new import_web3.ReadableStream({
         start(controller2) {
           const reader = res.body.pipeThrough(new textDecoderStream()).pipeThrough(new SSEParser()).pipeThrough(trackingStream).getReader();
           async function read() {
@@ -531,11 +559,14 @@ var apiCall = async (api, json) => {
               while (true) {
                 const { done, value } = await reader.read();
                 if (done) {
-                  controller2.close();
+                  if (!closed) {
+                    closed = true;
+                    controller2.close();
+                  }
                   break;
-                } else {
-                  controller2.enqueue(value);
                 }
+                if (closed) break;
+                controller2.enqueue(value);
               }
             } catch (e) {
               const error = e;
@@ -552,26 +583,42 @@ var apiCall = async (api, json) => {
                     { streamMetrics }
                   )
                 );
-              } else {
+              } else if (error instanceof TypeError && error.message.includes("cancelled")) {
                 controller2.error(
-                  new AxAIServiceResponseError(
-                    `Stream processing error: ${error.message}`,
+                  new AxAIServiceStreamTerminatedError(
                     apiUrl.href,
                     json,
-                    { streamMetrics }
+                    lastChunk,
+                    {
+                      streamMetrics,
+                      cancelReason: "Stream cancelled by client"
+                    }
                   )
                 );
+              } else {
+                controller2.error(
+                  new AxAIServiceNetworkError(error, apiUrl.href, json, {
+                    streamMetrics
+                  })
+                );
               }
+              throw error;
             } finally {
+              clearTimeout(timeoutId);
               reader.releaseLock();
+              if (api.span?.isRecording()) {
+                api.span.end();
+              }
             }
           }
           read();
+        },
+        // When the consumer cancels the stream, set our flag to stop processing further.
+        cancel() {
+          closed = true;
         }
       });
-      return wrappedStream;
     } catch (error) {
-      clearTimeout(timeoutId);
       if (error instanceof Error && error.name === "AbortError") {
         throw new AxAIServiceTimeoutError(apiUrl.href, timeoutMs, json, {
           metrics
@@ -584,7 +631,7 @@ var apiCall = async (api, json) => {
           "error.retries": metrics.retryCount
         });
       }
-      if (error instanceof AxAIServiceNetworkError && attempt < retryConfig.maxRetries) {
+      if (error instanceof AxAIServiceNetworkError && shouldRetry(error, void 0, attempt, retryConfig)) {
         const delay = calculateRetryDelay(attempt, retryConfig);
         attempt++;
         updateRetryMetrics(metrics);
@@ -598,12 +645,20 @@ var apiCall = async (api, json) => {
             "metrics.lastRetryTime": metrics.lastRetryTime
           });
         }
+        await new Promise((resolve) => setTimeout(resolve, delay));
         continue;
       }
       if (error instanceof AxAIServiceError) {
         error.context["metrics"] = metrics;
       }
       throw error;
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+      if (api.span?.isRecording()) {
+        api.span.end();
+      }
     }
   }
 };
@@ -1653,8 +1708,9 @@ function mapFinishReason(stopReason) {
 
 // ai/openai/types.ts
 var AxAIOpenAIModel = /* @__PURE__ */ ((AxAIOpenAIModel2) => {
-  AxAIOpenAIModel2["O1Preview"] = "o1-preview";
+  AxAIOpenAIModel2["O1"] = "o1";
   AxAIOpenAIModel2["O1Mini"] = "o1-mini";
+  AxAIOpenAIModel2["O3Mini"] = "o3-mini";
   AxAIOpenAIModel2["GPT4"] = "gpt-4";
   AxAIOpenAIModel2["GPT4O"] = "gpt-4o";
   AxAIOpenAIModel2["GPT4OMini"] = "gpt-4o-mini";
@@ -1677,7 +1733,7 @@ var AxAIOpenAIEmbedModel = /* @__PURE__ */ ((AxAIOpenAIEmbedModel2) => {
 // ai/openai/info.ts
 var axModelInfoOpenAI = [
   {
-    name: "o1-preview" /* O1Preview */,
+    name: "o1" /* O1 */,
     currency: "usd",
     promptTokenCostPer1M: 15,
     completionTokenCostPer1M: 60
@@ -1685,8 +1741,14 @@ var axModelInfoOpenAI = [
   {
     name: "o1-mini" /* O1Mini */,
     currency: "usd",
-    promptTokenCostPer1M: 3,
-    completionTokenCostPer1M: 12
+    promptTokenCostPer1M: 1.1,
+    completionTokenCostPer1M: 14.4
+  },
+  {
+    name: "o3-mini" /* O3Mini */,
+    currency: "usd",
+    promptTokenCostPer1M: 1.1,
+    completionTokenCostPer1M: 4.4
   },
   {
     name: "gpt-4" /* GPT4 */,
@@ -1786,16 +1848,12 @@ var AxAIOpenAIImpl = class {
         parameters: v.parameters
       }
     }));
-    if (tools && isO1Model(model)) {
-      throw new Error("Functions are not supported for O1 models");
-    }
     const toolsChoice = !req.functionCall && req.functions && req.functions.length > 0 ? "auto" : req.functionCall;
     const messages = createMessages2(req);
     const frequencyPenalty = req.modelConfig?.frequencyPenalty ?? this.config.frequencyPenalty;
     const stream = req.modelConfig?.stream ?? this.config.stream;
-    if (stream && isO1Model(model)) {
-      throw new Error("Streaming is not supported for O1 models");
-    }
+    const reasoningEffort = isReasoningModel(model) ? this.config.reasoningEffort : void 0;
+    const store = this.config.store;
     const reqValue = {
       model,
       messages,
@@ -1810,7 +1868,9 @@ var AxAIOpenAIImpl = class {
       presence_penalty: req.modelConfig?.presencePenalty ?? this.config.presencePenalty,
       logit_bias: this.config.logitBias,
       ...frequencyPenalty ? { frequency_penalty: frequencyPenalty } : {},
-      ...stream && this.streamingUsage ? { stream: true, stream_options: { include_usage: true } } : {}
+      ...stream && this.streamingUsage ? { stream: true, stream_options: { include_usage: true } } : {},
+      ...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+      ...store ? { store } : {}
     };
     return [apiConfig, reqValue];
   }
@@ -1936,12 +1996,6 @@ var mapFinishReason2 = (finishReason) => {
 };
 function createMessages2(req) {
   return req.chatPrompt.map((msg) => {
-    if (msg.role === "system" && isO1Model(req.model)) {
-      msg = {
-        role: "user",
-        content: msg.content
-      };
-    }
     switch (msg.role) {
       case "system":
         return { role: "system", content: msg.content };
@@ -2031,14 +2085,14 @@ var AxAIOpenAI = class extends AxBaseAI {
         embedModel: _config.embedModel
       },
       options,
-      supportFor: (model) => {
-        return isO1Model(model) ? { functions: false, streaming: false } : { functions: true, streaming: true };
+      supportFor: () => {
+        return { functions: true, streaming: true };
       },
       modelMap
     });
   }
 };
-var isO1Model = (model) => ["o1-mini" /* O1Mini */, "o1-preview" /* O1Preview */].includes(
+var isReasoningModel = (model) => ["o1-mini" /* O1Mini */, "o1" /* O1 */, "o3-mini" /* O3Mini */].includes(
   model
 );
 
@@ -3764,21 +3818,13 @@ var AxMemory = class {
 
 // dsp/asserts.ts
 var AxAssertionError = class extends Error {
-  values;
-  optional;
   constructor({
-    message,
-    values,
-    optional
+    message
   }) {
     super(message);
-    this.values = values;
-    this.optional = optional;
     this.name = this.constructor.name;
     this.stack = new Error().stack;
   }
-  getValue = () => this.values;
-  getOptional = () => this.optional;
   getFixingInstructions = () => {
     const extraFields = [];
     extraFields.push({
@@ -3791,13 +3837,16 @@ var AxAssertionError = class extends Error {
 };
 var assertAssertions = (asserts, values) => {
   for (const assert of asserts) {
-    const { fn, message, optional } = assert;
+    const { fn, message } = assert;
     const res = fn(values);
     if (res === void 0) {
       continue;
     }
-    if (!res && message) {
-      throw new AxAssertionError({ message, values, optional });
+    if (!res) {
+      if (!message) {
+        throw new Error(`Assertion Failed: No message provided for assertion`);
+      }
+      throw new AxAssertionError({ message });
     }
   }
 };
@@ -3813,13 +3862,13 @@ var assertStreamingAssertions = (asserts, values, xstate, content, final) => {
   }
   const currValue = content.substring(xstate.s);
   for (const assert of fieldAsserts) {
-    const { message, optional, fn } = assert;
+    const { message, fn } = assert;
     const res = fn(currValue, final);
     if (res === void 0) {
       continue;
     }
     if (!res && message) {
-      throw new AxAssertionError({ message, values, optional });
+      throw new AxAssertionError({ message });
     }
   }
 };
@@ -5073,13 +5122,11 @@ var ValidationError = class extends Error {
     super(message);
     this.fields = fields;
     this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
   }
-  getFields = () => this.fields;
   getFixingInstructions = () => {
     return this.fields.map((field) => ({
       name: "outputError",
-      title: "Error In Output",
+      title: "Errors In Output Fields",
       description: `Please fix and return the field \`${field.title}\` of type \`${toFieldType(field.type)}\`, ${this.message}.`
     }));
   };
@@ -5283,8 +5330,10 @@ function* streamValues(sig, values, xstate, content, final = false) {
       const v = content.substring(s);
       const v1 = v.replace(/[\s\n\t]+$/, "");
       const v2 = pos === 0 ? v1.trimStart() : v1;
-      yield { [fieldName]: v2 };
-      xstate.streamedIndex[fieldName] = pos + v1.length;
+      if (v2.length > 0) {
+        yield { [fieldName]: v2 };
+        xstate.streamedIndex[fieldName] = pos + v1.length;
+      }
       return;
     }
   }
@@ -5293,7 +5342,7 @@ function* streamValues(sig, values, xstate, content, final = false) {
     if (Array.isArray(value)) {
       const s = xstate.streamedIndex[key] ?? 0;
       const v = value.slice(s);
-      if (v) {
+      if (v && v.length > 0) {
         yield { [key]: v };
         xstate.streamedIndex[key] = s + 1;
       }
@@ -5389,7 +5438,7 @@ var extractBlock = (input) => {
 // dsp/jsonschema.ts
 var validateJSONSchema = (schema) => {
   const errors = [];
-  const validateSchemaObject = (schema2, path2 = "") => {
+  const validateSchemaObject = (schema2, path = "") => {
     const validTypes = [
       "array",
       "integer",
@@ -5400,31 +5449,31 @@ var validateJSONSchema = (schema) => {
       "object"
     ];
     if (!validTypes.includes(schema2.type)) {
-      errors.push(`Invalid type '${schema2.type}' at ${path2 || "root"}`);
+      errors.push(`Invalid type '${schema2.type}' at ${path || "root"}`);
       return;
     }
     if (schema2.type === "object" && schema2.properties) {
       if (typeof schema2.properties !== "object" || Array.isArray(schema2.properties)) {
-        errors.push(`Invalid properties object at ${path2 || "root"}`);
+        errors.push(`Invalid properties object at ${path || "root"}`);
       } else {
         for (const key in schema2.properties) {
           const value = schema2.properties[key];
           if (typeof value !== "object") {
-            errors.push(`Invalid schema object at ${path2}${key}`);
+            errors.push(`Invalid schema object at ${path}${key}`);
             continue;
           }
-          validateSchemaObject(value, `${path2}${key}.`);
+          validateSchemaObject(value, `${path}${key}.`);
         }
       }
       if (schema2.required && !Array.isArray(schema2.required)) {
-        errors.push(`'required' should be an array at ${path2 || "root"}`);
+        errors.push(`'required' should be an array at ${path || "root"}`);
       }
     }
     if (schema2.type === "array" && schema2.items) {
       if (typeof schema2.items !== "object") {
-        errors.push(`Invalid items schema at ${path2 || "root"}`);
+        errors.push(`Invalid items schema at ${path || "root"}`);
       } else {
-        validateSchemaObject(schema2.items, `${path2}items.`);
+        validateSchemaObject(schema2.items, `${path}items.`);
       }
     }
   };
@@ -5435,6 +5484,49 @@ var validateJSONSchema = (schema) => {
 };
 
 // dsp/functions.ts
+var AxFunctionError = class extends Error {
+  constructor(fields) {
+    super();
+    this.fields = fields;
+    this.name = this.constructor.name;
+  }
+  getFields = () => this.fields;
+};
+var FunctionError = class extends Error {
+  fields;
+  func;
+  constructor({
+    fields,
+    func
+  }) {
+    super();
+    this.fields = fields;
+    this.func = func;
+    this.name = this.constructor.name;
+  }
+  getFieldDescription(fieldName) {
+    if (!this.func.parameters?.properties?.[fieldName]) {
+      return "";
+    }
+    const fieldSchema = this.func.parameters.properties[fieldName];
+    let description = fieldSchema.description;
+    if (fieldSchema.enum?.length) {
+      description += ` Allowed values are: ${fieldSchema.enum.join(", ")}`;
+    }
+    return description;
+  }
+  getFixingInstructions = () => {
+    return this.fields.map((fieldError) => {
+      const schemaDescription = this.getFieldDescription(fieldError.field);
+      const fullDescription = schemaDescription ? `${fieldError.message}. ${schemaDescription}` : fieldError.message;
+      return {
+        name: "functionArgumentError",
+        title: `Errors in Function '${this.func.name}' Arguments`,
+        description: `Please fix the argument '${fieldError.field}' in function '${this.func.name}': ${fullDescription}`
+      };
+    });
+  };
+};
 var AxFunctionProcessor = class {
   funcList = [];
   constructor(funcList) {
@@ -5475,7 +5567,17 @@ var AxFunctionProcessor = class {
     if (!fnSpec.func) {
       throw new Error("No handler for function: " + func.name);
     }
-    return await this.executeFunction(fnSpec, func, options);
+    try {
+      return await this.executeFunction(fnSpec, func, options);
+    } catch (e) {
+      if (e instanceof AxFunctionError) {
+        throw new FunctionError({
+          fields: e.getFields(),
+          func: fnSpec
+        });
+      }
+      throw e;
+    }
   };
 };
 var parseFunctions = (newFuncs, existingFuncs) => {
@@ -5554,11 +5656,11 @@ var AxGen = class extends AxProgramWithSignature {
       this.functions = parseFunctions(options.functions);
     }
   }
-  addAssert = (fn, message, optional) => {
-    this.asserts.push({ fn, message, optional });
+  addAssert = (fn, message) => {
+    this.asserts.push({ fn, message });
   };
-  addStreamingAssert = (fieldName, fn, message, optional) => {
-    this.streamingAsserts.push({ fieldName, fn, message, optional });
+  addStreamingAssert = (fieldName, fn, message) => {
+    this.streamingAsserts.push({ fieldName, fn, message });
   };
   async forwardSendRequest({
     ai,
@@ -5808,6 +5910,10 @@ var AxGen = class extends AxProgramWithSignature {
             const e1 = e;
             errorFields = e1.getFixingInstructions();
             err = e;
+          } else if (e instanceof FunctionError) {
+            errorFields = e.getFixingInstructions();
+            err = e;
+          } else if (e instanceof AxAIServiceStreamTerminatedError) {
           } else {
             throw e;
           }
@@ -5822,9 +5928,6 @@ var AxGen = class extends AxProgramWithSignature {
           }
         }
       }
-      if (err instanceof AxAssertionError && err.getOptional()) {
-        return err.getValue();
-      }
       throw new Error(`Unable to fix validation error: ${err?.message}`);
     }
     throw new Error(`Max steps reached: ${maxSteps}`);
@@ -6071,6 +6174,7 @@ var AxBalancer = class _AxBalancer {
   services;
   currentServiceIndex = 0;
   currentService;
+  debug;
   constructor(services, options) {
     if (services.length === 0) {
       throw new Error("No AI services provided.");
@@ -6083,6 +6187,7 @@ var AxBalancer = class _AxBalancer {
       throw new Error("Error initializing the AI services.");
     }
     this.currentService = cs;
+    this.debug = options?.debug ?? true;
   }
   /**
    * Service comparator that respects the input order of services.
@@ -6157,16 +6262,20 @@ var AxBalancer = class _AxBalancer {
           default:
             throw e;
         }
-        console.warn(
-          `AxBalancer: Service ${this.currentService.getName()} failed`,
-          e
-        );
+        if (this.debug) {
+          console.warn(
+            `AxBalancer: Service ${this.currentService.getName()} failed`,
+            e
+          );
+        }
         if (!this.getNextService()) {
           throw e;
         }
-        console.warn(
-          `AxBalancer: Switching to service ${this.currentService.getName()}`
-        );
+        if (this.debug) {
+          console.warn(
+            `AxBalancer: Switching to service ${this.currentService.getName()}`
+          );
+        }
       }
     }
   }
@@ -6176,11 +6285,15 @@ var AxBalancer = class _AxBalancer {
       try {
         return await this.currentService.embed(req, options);
       } catch (e) {
-        console.warn(`Service ${this.currentService.getName()} failed`);
+        if (this.debug) {
+          console.warn(`Service ${this.currentService.getName()} failed`);
+        }
         if (!this.getNextService()) {
           throw e;
         }
-        console.warn(`Switching to service ${this.currentService.getName()}`);
+        if (this.debug) {
+          console.warn(`Switching to service ${this.currentService.getName()}`);
+        }
       }
     }
   }
@@ -7874,6 +7987,7 @@ var AxRAG = class extends AxChainOfThought {
   AxDefaultResultReranker,
   AxDockerSession,
   AxEmbeddingAdapter,
+  AxFunctionError,
   AxFunctionProcessor,
   AxGen,
   AxHFDataLoader,