@ax-llm/ax 11.0.55 → 11.0.57

package/index.cjs

@@ -1591,6 +1591,8 @@ var GoogleVertexAuth = class {
 
 // ai/anthropic/types.ts
 var AxAIAnthropicModel = /* @__PURE__ */ ((AxAIAnthropicModel2) => {
+  AxAIAnthropicModel2["Claude4Opus"] = "claude-opus-4-20250514";
+  AxAIAnthropicModel2["Claude4Sonnet"] = "claude-sonnet-4-20250514";
   AxAIAnthropicModel2["Claude37Sonnet"] = "claude-3-7-sonnet-latest";
   AxAIAnthropicModel2["Claude35Sonnet"] = "claude-3-5-sonnet-latest";
   AxAIAnthropicModel2["Claude35Haiku"] = "claude-3-5-haiku-latest";
@@ -1613,50 +1615,80 @@ var AxAIAnthropicVertexModel = /* @__PURE__ */ ((AxAIAnthropicVertexModel2) => {
 
 // ai/anthropic/info.ts
 var axModelInfoAnthropic = [
-  // 35
+  // 4
+  {
+    name: "claude-opus-4-20250514" /* Claude4Opus */,
+    currency: "usd",
+    promptTokenCostPer1M: 15,
+    completionTokenCostPer1M: 75,
+    maxTokens: 32e3
+  },
+  {
+    name: "claude-sonnet-4-20250514" /* Claude4Sonnet */,
+    currency: "usd",
+    promptTokenCostPer1M: 3,
+    completionTokenCostPer1M: 15,
+    maxTokens: 64e3
+  },
+  // 3.7
+  {
+    name: "claude-3-7-sonnet-latest" /* Claude37Sonnet */,
+    currency: "usd",
+    promptTokenCostPer1M: 3,
+    completionTokenCostPer1M: 15,
+    maxTokens: 64e3
+  },
+  // 3.5
   {
     name: "claude-3-5-sonnet-latest" /* Claude35Sonnet */,
     currency: "usd",
     promptTokenCostPer1M: 3,
-    completionTokenCostPer1M: 15
+    completionTokenCostPer1M: 15,
+    maxTokens: 8192
   },
   {
     name: "claude-3-5-haiku-latest" /* Claude35Haiku */,
     currency: "usd",
     promptTokenCostPer1M: 0.8,
-    completionTokenCostPer1M: 4
+    completionTokenCostPer1M: 4,
+    maxTokens: 8192
   },
   // 3
   {
     name: "claude-3-opus-latest" /* Claude3Opus */,
     currency: "usd",
     promptTokenCostPer1M: 15,
-    completionTokenCostPer1M: 75
+    completionTokenCostPer1M: 75,
+    maxTokens: 4096
   },
   {
     name: "claude-3-sonnet-20240229" /* Claude3Sonnet */,
     currency: "usd",
     promptTokenCostPer1M: 3,
-    completionTokenCostPer1M: 15
+    completionTokenCostPer1M: 15,
+    maxTokens: 4096
   },
   {
     name: "claude-3-haiku-20240307" /* Claude3Haiku */,
     currency: "usd",
     promptTokenCostPer1M: 0.25,
-    completionTokenCostPer1M: 1.25
+    completionTokenCostPer1M: 1.25,
+    maxTokens: 4096
   },
-  // 21
+  // 2.1
   {
     name: "claude-2.1" /* Claude21 */,
     currency: "usd",
     promptTokenCostPer1M: 8,
-    completionTokenCostPer1M: 25
+    completionTokenCostPer1M: 25,
+    maxTokens: 4096
   },
   {
     name: "claude-instant-1.2" /* ClaudeInstant12 */,
     currency: "usd",
     promptTokenCostPer1M: 0.8,
-    completionTokenCostPer1M: 2.24
+    completionTokenCostPer1M: 2.24,
+    maxTokens: 4096
   }
 ];
 
@@ -1681,7 +1713,7 @@ var AxAIAnthropicImpl = class {
   getModelConfig() {
     const { config } = this;
     return {
-      maxTokens: config.maxTokens,
+      maxTokens: config.maxTokens ?? 4096,
       temperature: config.temperature,
       topP: config.topP,
       topK: config.topK,
@@ -1744,13 +1776,18 @@ var AxAIAnthropicImpl = class {
         input_schema: v.parameters
       })
     );
+    const maxTokens = req.modelConfig?.maxTokens ?? this.config.maxTokens;
+    const stopSequences = req.modelConfig?.stopSequences ?? this.config.stopSequences;
+    const temperature = req.modelConfig?.temperature ?? this.config.temperature;
+    const topP = req.modelConfig?.topP ?? this.config.topP;
+    const topK = req.modelConfig?.topK ?? this.config.topK;
     const reqValue = {
       ...this.isVertex ? { anthropic_version: "vertex-2023-10-16" } : { model },
-      max_tokens: req.modelConfig?.maxTokens ?? this.config.maxTokens,
-      stop_sequences: req.modelConfig?.stopSequences ?? this.config.stopSequences,
-      temperature: req.modelConfig?.temperature ?? this.config.temperature,
-      top_p: req.modelConfig?.topP ?? this.config.topP,
-      top_k: req.modelConfig?.topK ?? this.config.topK,
+      ...maxTokens ? { max_tokens: maxTokens } : {},
+      ...stopSequences && stopSequences.length > 0 ? { stop_sequences: stopSequences } : {},
+      ...temperature ? { temperature } : {},
+      ...topP ? { top_p: topP } : {},
+      ...topK ? { top_k: topK } : {},
       ...toolsChoice,
       ...tools && tools.length > 0 ? { tools } : {},
       ...stream ? { stream: true } : {},
@@ -6892,6 +6929,9 @@ function getFieldProcessingMessage(field, resultText) {
 var validateJSONSchema = (schema) => {
   const errors = [];
   const validateSchemaObject = (schema2, path = "") => {
+    if (!schema2 || typeof schema2 !== "object") {
+      return;
+    }
     const validTypes = [
       "array",
       "integer",
@@ -6901,38 +6941,155 @@ var validateJSONSchema = (schema) => {
       "null",
       "object"
     ];
+    if (schema2.anyOf && Array.isArray(schema2.anyOf)) {
+      if (schema2.anyOf.length === 0) {
+        errors.push({
+          path: path || "root",
+          issue: "anyOf array is empty",
+          fix: "Add at least one schema to the anyOf array",
+          example: 'anyOf: [{ type: "string" }, { type: "null" }]'
+        });
+      }
+      schema2.anyOf.forEach((subSchema, index) => {
+        validateSchemaObject(subSchema, `${path}anyOf[${index}].`);
+      });
+      return;
+    }
+    if (schema2.oneOf && Array.isArray(schema2.oneOf)) {
+      if (schema2.oneOf.length === 0) {
+        errors.push({
+          path: path || "root",
+          issue: "oneOf array is empty",
+          fix: "Add at least one schema to the oneOf array",
+          example: 'oneOf: [{ type: "string" }, { type: "number" }]'
+        });
+      }
+      schema2.oneOf.forEach((subSchema, index) => {
+        validateSchemaObject(subSchema, `${path}oneOf[${index}].`);
+      });
+      return;
+    }
+    if (schema2.allOf && Array.isArray(schema2.allOf)) {
+      if (schema2.allOf.length === 0) {
+        errors.push({
+          path: path || "root",
+          issue: "allOf array is empty",
+          fix: "Add at least one schema to the allOf array",
+          example: 'allOf: [{ type: "object" }, { properties: { name: { type: "string" } } }]'
+        });
+      }
+      schema2.allOf.forEach((subSchema, index) => {
+        validateSchemaObject(subSchema, `${path}allOf[${index}].`);
+      });
+      return;
+    }
+    if (!schema2.type) {
+      return;
+    }
     if (!validTypes.includes(schema2.type)) {
-      errors.push(`Invalid type '${schema2.type}' at ${path || "root"}`);
+      errors.push({
+        path: path || "root",
+        issue: `Invalid type '${schema2.type}'`,
+        fix: `Change type to one of: ${validTypes.join(", ")}`,
+        example: `{ type: "string" } or { type: "object" }`
+      });
       return;
     }
-    if (schema2.type === "object" && schema2.properties) {
-      if (typeof schema2.properties !== "object" || Array.isArray(schema2.properties)) {
-        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 ${path}${key}`);
-            continue;
+    if (schema2.type === "object") {
+      if (schema2.properties) {
+        if (typeof schema2.properties !== "object" || Array.isArray(schema2.properties)) {
+          errors.push({
+            path: path || "root",
+            issue: "properties must be an object, not an array or primitive",
+            fix: "Change properties to be an object with property names as keys",
+            example: 'properties: { name: { type: "string" }, age: { type: "number" } }'
+          });
+        } else {
+          for (const key in schema2.properties) {
+            const value = schema2.properties[key];
+            if (value === void 0 || value === null) {
+              continue;
+            }
+            if (typeof value !== "object") {
+              errors.push({
+                path: `${path}${key}`,
+                issue: `Property schema must be an object, got ${typeof value}`,
+                fix: "Define the property as a proper schema object",
+                example: `${key}: { type: "string", description: "..." }`
+              });
+              continue;
+            }
+            validateSchemaObject(value, `${path}${key}.`);
           }
-          validateSchemaObject(value, `${path}${key}.`);
         }
       }
-      if (schema2.required && !Array.isArray(schema2.required)) {
-        errors.push(`'required' should be an array at ${path || "root"}`);
+      if (schema2.required) {
+        if (!Array.isArray(schema2.required)) {
+          errors.push({
+            path: path || "root",
+            issue: `'required' must be an array, got ${typeof schema2.required}`,
+            fix: "Change required to be an array of property names",
+            example: 'required: ["name", "email"] instead of required: "name,email"'
+          });
+        } else if (schema2.required.length === 0) {
+        } else {
+          if (schema2.properties) {
+            for (const requiredProp of schema2.required) {
+              if (typeof requiredProp !== "string") {
+                errors.push({
+                  path: `${path}required`,
+                  issue: `Required property names must be strings, got ${typeof requiredProp}`,
+                  fix: "Ensure all items in required array are strings",
+                  example: 'required: ["name", "email"] not required: [123, "email"]'
+                });
+              } else if (!(requiredProp in schema2.properties)) {
+                errors.push({
+                  path: `${path}required`,
+                  issue: `Required property '${requiredProp}' is not defined in properties`,
+                  fix: `Either add '${requiredProp}' to properties or remove it from required`,
+                  example: `properties: { ${requiredProp}: { type: "string" } }`
+                });
+              }
+            }
+          }
+        }
       }
     }
-    if (schema2.type === "array" && schema2.items) {
-      if (typeof schema2.items !== "object") {
-        errors.push(`Invalid items schema at ${path || "root"}`);
-      } else {
-        validateSchemaObject(schema2.items, `${path}items.`);
+    if (schema2.type === "array") {
+      if (schema2.items) {
+        if (typeof schema2.items !== "object") {
+          errors.push({
+            path: `${path}items`,
+            issue: `Array items schema must be an object, got ${typeof schema2.items}`,
+            fix: "Define items as a proper schema object",
+            example: 'items: { type: "string" } or items: { type: "object", properties: {...} }'
+          });
+        } else {
+          validateSchemaObject(schema2.items, `${path}items.`);
+        }
       }
     }
   };
   validateSchemaObject(schema);
   if (errors.length > 0) {
-    throw new Error(errors.join("; "));
+    const errorMessage = [
+      "JSON Schema validation failed:",
+      "",
+      ...errors.map((error, index) => {
+        const parts = [
+          `${index + 1}. Path: ${error.path}`,
+          `   Issue: ${error.issue}`,
+          `   Fix: ${error.fix}`
+        ];
+        if (error.example) {
+          parts.push(`   Example: ${error.example}`);
+        }
+        return parts.join("\n");
+      }),
+      "",
+      "Please fix these issues and try again."
+    ].join("\n");
+    throw new Error(errorMessage);
   }
 };