@ax-llm/ax 10.0.46 → 10.0.47

package/index.cjs

@@ -182,7 +182,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 +309,6 @@ var defaultRetryConfig = {
   maxRetries: 3,
   initialDelayMs: 1e3,
   maxDelayMs: 6e4,
-  // Increased to 60 seconds
   backoffFactor: 2,
   retryableStatusCodes: [500, 408, 429, 502, 503, 504]
 };
@@ -321,18 +319,19 @@ var AxAIServiceError = class extends Error {
     super(message);
     this.url = url;
     this.requestBody = requestBody;
-    this.context = context;
     this.name = "AxAIServiceError";
     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() {
@@ -420,14 +419,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 +455,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 +474,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 +488,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 +502,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 +531,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 +539,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 +547,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 +558,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 +582,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 +630,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 +644,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 +1707,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 +1732,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 +1740,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 +1847,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 +1867,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 +1995,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 +2084,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
 );
 
@@ -5283,8 +5336,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 +5348,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 +5444,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 +5455,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.`);
       }
     }
   };
@@ -5808,6 +5863,7 @@ var AxGen = class extends AxProgramWithSignature {
             const e1 = e;
             errorFields = e1.getFixingInstructions();
             err = e;
+          } else if (e instanceof AxAIServiceStreamTerminatedError) {
           } else {
             throw e;
           }
@@ -6071,6 +6127,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 +6140,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 +6215,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 +6238,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()}`);
+        }
       }
     }
   }