@ax-llm/ax 11.0.25 → 11.0.27

package/index.cjs

@@ -85,6 +85,7 @@ __export(index_exports, {
   AxDefaultResultReranker: () => AxDefaultResultReranker,
   AxDockerSession: () => AxDockerSession,
   AxEmbeddingAdapter: () => AxEmbeddingAdapter,
+  AxEvalUtil: () => AxEvalUtil,
   AxFunctionError: () => AxFunctionError,
   AxFunctionProcessor: () => AxFunctionProcessor,
   AxGen: () => AxGen,
@@ -108,7 +109,48 @@ __export(index_exports, {
   AxSimpleClassifier: () => AxSimpleClassifier,
   AxSimpleClassifierClass: () => AxSimpleClassifierClass,
   AxSpanKindValues: () => AxSpanKindValues,
-  AxTestPrompt: () => AxTestPrompt
+  AxStringUtil: () => AxStringUtil,
+  AxTestPrompt: () => AxTestPrompt,
+  axAIAnthropicDefaultConfig: () => axAIAnthropicDefaultConfig,
+  axAIAzureOpenAIBestConfig: () => axAIAzureOpenAIBestConfig,
+  axAIAzureOpenAICreativeConfig: () => axAIAzureOpenAICreativeConfig,
+  axAIAzureOpenAIDefaultConfig: () => axAIAzureOpenAIDefaultConfig,
+  axAIAzureOpenAIFastConfig: () => axAIAzureOpenAIFastConfig,
+  axAICohereCreativeConfig: () => axAICohereCreativeConfig,
+  axAICohereDefaultConfig: () => axAICohereDefaultConfig,
+  axAIDeepSeekCodeConfig: () => axAIDeepSeekCodeConfig,
+  axAIDeepSeekDefaultConfig: () => axAIDeepSeekDefaultConfig,
+  axAIGoogleGeminiDefaultConfig: () => axAIGoogleGeminiDefaultConfig,
+  axAIGoogleGeminiDefaultCreativeConfig: () => axAIGoogleGeminiDefaultCreativeConfig,
+  axAIHuggingFaceCreativeConfig: () => axAIHuggingFaceCreativeConfig,
+  axAIHuggingFaceDefaultConfig: () => axAIHuggingFaceDefaultConfig,
+  axAIMistralBestConfig: () => axAIMistralBestConfig,
+  axAIMistralDefaultConfig: () => axAIMistralDefaultConfig,
+  axAIOllamaDefaultConfig: () => axAIOllamaDefaultConfig,
+  axAIOllamaDefaultCreativeConfig: () => axAIOllamaDefaultCreativeConfig,
+  axAIOpenAIBestConfig: () => axAIOpenAIBestConfig,
+  axAIOpenAICreativeConfig: () => axAIOpenAICreativeConfig,
+  axAIOpenAIDefaultConfig: () => axAIOpenAIDefaultConfig,
+  axAIOpenAIFastConfig: () => axAIOpenAIFastConfig,
+  axAIRekaBestConfig: () => axAIRekaBestConfig,
+  axAIRekaCreativeConfig: () => axAIRekaCreativeConfig,
+  axAIRekaDefaultConfig: () => axAIRekaDefaultConfig,
+  axAIRekaFastConfig: () => axAIRekaFastConfig,
+  axAITogetherDefaultConfig: () => axAITogetherDefaultConfig,
+  axBaseAIDefaultConfig: () => axBaseAIDefaultConfig,
+  axBaseAIDefaultCreativeConfig: () => axBaseAIDefaultCreativeConfig,
+  axModelInfoAnthropic: () => axModelInfoAnthropic,
+  axModelInfoCohere: () => axModelInfoCohere,
+  axModelInfoDeepSeek: () => axModelInfoDeepSeek,
+  axModelInfoGoogleGemini: () => axModelInfoGoogleGemini,
+  axModelInfoGroq: () => axModelInfoGroq,
+  axModelInfoHuggingFace: () => axModelInfoHuggingFace,
+  axModelInfoMistral: () => axModelInfoMistral,
+  axModelInfoOpenAI: () => axModelInfoOpenAI,
+  axModelInfoReka: () => axModelInfoReka,
+  axModelInfoTogether: () => axModelInfoTogether,
+  axSpanAttributes: () => axSpanAttributes,
+  axSpanEvents: () => axSpanEvents
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -151,6 +193,9 @@ var axSpanAttributes = {
   DB_QUERY_RESULT_VECTOR: "db.query.result.vector",
   DB_QUERY_RESULT_DOCUMENT: "db.query.result.document"
 };
+var axSpanEvents = {
+  LLM_PROMPT: "gen_ai.prompt"
+};
 var AxLLMRequestTypeValues = /* @__PURE__ */ ((AxLLMRequestTypeValues2) => {
   AxLLMRequestTypeValues2["COMPLETION"] = "completion";
   AxLLMRequestTypeValues2["CHAT"] = "chat";
@@ -806,6 +851,12 @@ var axBaseAIDefaultConfig = () => structuredClone({
   topK: 40,
   topP: 0.9
 });
+var axBaseAIDefaultCreativeConfig = () => structuredClone({
+  maxTokens: 2e3,
+  temperature: 0.4,
+  topP: 0.7,
+  frequencyPenalty: 0.2
+});
 var AxBaseAI = class {
   constructor(aiImpl, {
     name,
@@ -1847,6 +1898,19 @@ var axAIOpenAIDefaultConfig = () => structuredClone({
   embedModel: "text-embedding-3-small" /* TextEmbedding3Small */,
   ...axBaseAIDefaultConfig()
 });
+var axAIOpenAIBestConfig = () => structuredClone({
+  ...axAIOpenAIDefaultConfig(),
+  model: "gpt-4o" /* GPT4O */
+});
+var axAIOpenAICreativeConfig = () => structuredClone({
+  model: "gpt-4o" /* GPT4O */,
+  embedModel: "text-embedding-3-small" /* TextEmbedding3Small */,
+  ...axBaseAIDefaultCreativeConfig()
+});
+var axAIOpenAIFastConfig = () => ({
+  ...axAIOpenAIDefaultConfig(),
+  model: "gpt-4o-mini" /* GPT4OMini */
+});
 var AxAIOpenAIImpl = class {
   constructor(config, streamingUsage, dimensions) {
     this.config = config;
@@ -2152,6 +2216,9 @@ var AxAIOpenAI = class extends AxAIOpenAIBase {
 
 // ai/azure-openai/api.ts
 var axAIAzureOpenAIDefaultConfig = axAIOpenAIDefaultConfig;
+var axAIAzureOpenAICreativeConfig = axAIOpenAICreativeConfig;
+var axAIAzureOpenAIFastConfig = axAIOpenAIFastConfig;
+var axAIAzureOpenAIBestConfig = axAIOpenAIBestConfig;
 var AxAIAzureOpenAI = class extends AxAIOpenAIBase {
   constructor({
     apiKey,
@@ -2268,6 +2335,11 @@ var axAICohereDefaultConfig = () => structuredClone({
   embedModel: "embed-english-v3.0" /* EmbedEnglishV30 */,
   ...axBaseAIDefaultConfig()
 });
+var axAICohereCreativeConfig = () => structuredClone({
+  model: "command-r" /* CommandR */,
+  embedModel: "embed-english-v3.0" /* EmbedEnglishV30 */,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAICohereImpl = class {
   constructor(config) {
     this.config = config;
@@ -2544,6 +2616,10 @@ var axAIDeepSeekDefaultConfig = () => structuredClone({
   model: "deepseek-chat" /* DeepSeekChat */,
   ...axBaseAIDefaultConfig()
 });
+var axAIDeepSeekCodeConfig = () => structuredClone({
+  model: "deepseek-coder" /* DeepSeekCoder */,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAIDeepSeek = class extends AxAIOpenAIBase {
   constructor({
     apiKey,
@@ -2691,6 +2767,12 @@ var axAIGoogleGeminiDefaultConfig = () => structuredClone({
   safetySettings,
   ...axBaseAIDefaultConfig()
 });
+var axAIGoogleGeminiDefaultCreativeConfig = () => structuredClone({
+  model: "gemini-2.0-flash" /* Gemini20Flash */,
+  embedModel: "text-embedding-004" /* TextEmbedding004 */,
+  safetySettings,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAIGoogleGeminiImpl = class {
   constructor(config, isVertex, endpointId, apiKey, options) {
     this.config = config;
@@ -3202,6 +3284,10 @@ var axAIHuggingFaceDefaultConfig = () => structuredClone({
   model: "meta-llama/Llama-2-70b-chat-hf" /* MetaLlama270BChatHF */,
   ...axBaseAIDefaultConfig()
 });
+var axAIHuggingFaceCreativeConfig = () => structuredClone({
+  model: "meta-llama/Llama-2-70b-chat-hf" /* MetaLlama270BChatHF */,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAIHuggingFaceImpl = class {
   constructor(config) {
     this.config = config;
@@ -3383,6 +3469,10 @@ var axAIMistralDefaultConfig = () => structuredClone({
   model: "mistral-small-latest" /* MistralSmall */,
   ...axBaseAIDefaultConfig()
 });
+var axAIMistralBestConfig = () => structuredClone({
+  ...axAIMistralDefaultConfig(),
+  model: "mistral-large-latest" /* MistralLarge */
+});
 var AxAIMistral = class extends AxAIOpenAIBase {
   constructor({
     apiKey,
@@ -3415,6 +3505,11 @@ var axAIOllamaDefaultConfig = () => structuredClone({
   model: "nous-hermes2",
   embedModel: "all-minilm"
 });
+var axAIOllamaDefaultCreativeConfig = () => structuredClone({
+  ...axBaseAIDefaultCreativeConfig(),
+  model: "nous-hermes2",
+  embedModel: "all-minilm"
+});
 var AxAIOllama = class extends AxAIOpenAIBase {
   constructor({
     apiKey = "not-set",
@@ -3474,6 +3569,18 @@ var axAIRekaDefaultConfig = () => structuredClone({
   model: "reka-core" /* RekaCore */,
   ...axBaseAIDefaultConfig()
 });
+var axAIRekaBestConfig = () => structuredClone({
+  ...axAIRekaDefaultConfig(),
+  model: "reka-core" /* RekaCore */
+});
+var axAIRekaCreativeConfig = () => structuredClone({
+  model: "reka-core" /* RekaCore */,
+  ...axBaseAIDefaultCreativeConfig()
+});
+var axAIRekaFastConfig = () => ({
+  ...axAIRekaDefaultConfig(),
+  model: "reka-flash" /* RekaFlash */
+});
 var AxAIRekaImpl = class {
   constructor(config) {
     this.config = config;
@@ -8551,7 +8658,7 @@ var batchArray = (arr, size) => {
   }
   return chunkedArr;
 };
-var axStringUtil = {
+var AxStringUtil = {
   trimNonAlphaNum,
   splitIntoTwo,
   dedup,
@@ -8570,7 +8677,7 @@ var AxDefaultResultReranker = class extends AxGen {
   forward = async (ai, input, options) => {
     const { rankedItems } = await super.forward(ai, input, options);
     const sortedIndexes = rankedItems.map((item) => {
-      const { id: index } = axStringUtil.extractIdAndText(item);
+      const { id: index } = AxStringUtil.extractIdAndText(item);
       return index;
     });
     const sortedItems = input.items.map((_, index) => {
@@ -8625,6 +8732,1277 @@ var AxEmbeddingAdapter = class {
   }
 };
 
+// dsp/stopwords.ts
+var stopwords = /* @__PURE__ */ new Set([
+  "0o",
+  "0s",
+  "3a",
+  "3b",
+  "3d",
+  "6b",
+  "6o",
+  "a",
+  "a1",
+  "a2",
+  "a3",
+  "a4",
+  "ab",
+  "able",
+  "about",
+  "above",
+  "abst",
+  "ac",
+  "accordance",
+  "according",
+  "accordingly",
+  "across",
+  "act",
+  "actually",
+  "ad",
+  "added",
+  "adj",
+  "ae",
+  "af",
+  "affected",
+  "affecting",
+  "affects",
+  "after",
+  "afterwards",
+  "ag",
+  "again",
+  "against",
+  "ah",
+  "ain",
+  "ain't",
+  "aj",
+  "al",
+  "all",
+  "allow",
+  "allows",
+  "almost",
+  "alone",
+  "along",
+  "already",
+  "also",
+  "although",
+  "always",
+  "am",
+  "among",
+  "amongst",
+  "amoungst",
+  "amount",
+  "an",
+  "and",
+  "announce",
+  "another",
+  "any",
+  "anybody",
+  "anyhow",
+  "anymore",
+  "anyone",
+  "anything",
+  "anyway",
+  "anyways",
+  "anywhere",
+  "ao",
+  "ap",
+  "apart",
+  "apparently",
+  "appear",
+  "appreciate",
+  "appropriate",
+  "approximately",
+  "ar",
+  "are",
+  "aren",
+  "arent",
+  "aren't",
+  "arise",
+  "around",
+  "as",
+  "a's",
+  "aside",
+  "ask",
+  "asking",
+  "associated",
+  "at",
+  "au",
+  "auth",
+  "av",
+  "available",
+  "aw",
+  "away",
+  "awfully",
+  "ax",
+  "ay",
+  "az",
+  "b",
+  "b1",
+  "b2",
+  "b3",
+  "ba",
+  "back",
+  "bc",
+  "bd",
+  "be",
+  "became",
+  "because",
+  "become",
+  "becomes",
+  "becoming",
+  "been",
+  "before",
+  "beforehand",
+  "begin",
+  "beginning",
+  "beginnings",
+  "begins",
+  "behind",
+  "being",
+  "believe",
+  "below",
+  "beside",
+  "besides",
+  "best",
+  "better",
+  "between",
+  "beyond",
+  "bi",
+  "bill",
+  "biol",
+  "bj",
+  "bk",
+  "bl",
+  "bn",
+  "both",
+  "bottom",
+  "bp",
+  "br",
+  "brief",
+  "briefly",
+  "bs",
+  "bt",
+  "bu",
+  "but",
+  "bx",
+  "by",
+  "c",
+  "c1",
+  "c2",
+  "c3",
+  "ca",
+  "call",
+  "came",
+  "can",
+  "cannot",
+  "cant",
+  "can't",
+  "cause",
+  "causes",
+  "cc",
+  "cd",
+  "ce",
+  "certain",
+  "certainly",
+  "cf",
+  "cg",
+  "ch",
+  "changes",
+  "ci",
+  "cit",
+  "cj",
+  "cl",
+  "clearly",
+  "cm",
+  "c'mon",
+  "cn",
+  "co",
+  "com",
+  "come",
+  "comes",
+  "con",
+  "concerning",
+  "consequently",
+  "consider",
+  "considering",
+  "contain",
+  "containing",
+  "contains",
+  "corresponding",
+  "could",
+  "couldn",
+  "couldnt",
+  "couldn't",
+  "course",
+  "cp",
+  "cq",
+  "cr",
+  "cry",
+  "cs",
+  "c's",
+  "ct",
+  "cu",
+  "currently",
+  "cv",
+  "cx",
+  "cy",
+  "cz",
+  "d",
+  "d2",
+  "da",
+  "date",
+  "dc",
+  "dd",
+  "de",
+  "definitely",
+  "describe",
+  "described",
+  "despite",
+  "detail",
+  "df",
+  "di",
+  "did",
+  "didn",
+  "didn't",
+  "different",
+  "dj",
+  "dk",
+  "dl",
+  "do",
+  "does",
+  "doesn",
+  "doesn't",
+  "doing",
+  "don",
+  "done",
+  "don't",
+  "down",
+  "downwards",
+  "dp",
+  "dr",
+  "ds",
+  "dt",
+  "du",
+  "due",
+  "during",
+  "dx",
+  "dy",
+  "e",
+  "e2",
+  "e3",
+  "ea",
+  "each",
+  "ec",
+  "ed",
+  "edu",
+  "ee",
+  "ef",
+  "effect",
+  "eg",
+  "ei",
+  "eight",
+  "eighty",
+  "either",
+  "ej",
+  "el",
+  "eleven",
+  "else",
+  "elsewhere",
+  "em",
+  "empty",
+  "en",
+  "end",
+  "ending",
+  "enough",
+  "entirely",
+  "eo",
+  "ep",
+  "eq",
+  "er",
+  "es",
+  "especially",
+  "est",
+  "et",
+  "et-al",
+  "etc",
+  "eu",
+  "ev",
+  "even",
+  "ever",
+  "every",
+  "everybody",
+  "everyone",
+  "everything",
+  "everywhere",
+  "ex",
+  "exactly",
+  "example",
+  "except",
+  "ey",
+  "f",
+  "f2",
+  "fa",
+  "far",
+  "fc",
+  "few",
+  "ff",
+  "fi",
+  "fifteen",
+  "fifth",
+  "fify",
+  "fill",
+  "find",
+  "fire",
+  "first",
+  "five",
+  "fix",
+  "fj",
+  "fl",
+  "fn",
+  "fo",
+  "followed",
+  "following",
+  "follows",
+  "for",
+  "former",
+  "formerly",
+  "forth",
+  "forty",
+  "found",
+  "four",
+  "fr",
+  "from",
+  "front",
+  "node:fs",
+  "ft",
+  "fu",
+  "full",
+  "further",
+  "furthermore",
+  "fy",
+  "g",
+  "ga",
+  "gave",
+  "ge",
+  "get",
+  "gets",
+  "getting",
+  "gi",
+  "give",
+  "given",
+  "gives",
+  "giving",
+  "gj",
+  "gl",
+  "go",
+  "goes",
+  "going",
+  "gone",
+  "got",
+  "gotten",
+  "gr",
+  "greetings",
+  "gs",
+  "gy",
+  "h",
+  "h2",
+  "h3",
+  "had",
+  "hadn",
+  "hadn't",
+  "happens",
+  "hardly",
+  "has",
+  "hasn",
+  "hasnt",
+  "hasn't",
+  "have",
+  "haven",
+  "haven't",
+  "having",
+  "he",
+  "hed",
+  "he'd",
+  "he'll",
+  "hello",
+  "help",
+  "hence",
+  "her",
+  "here",
+  "hereafter",
+  "hereby",
+  "herein",
+  "heres",
+  "here's",
+  "hereupon",
+  "hers",
+  "herself",
+  "hes",
+  "he's",
+  "hh",
+  "hi",
+  "hid",
+  "him",
+  "himself",
+  "his",
+  "hither",
+  "hj",
+  "ho",
+  "home",
+  "hopefully",
+  "how",
+  "howbeit",
+  "however",
+  "how's",
+  "hr",
+  "hs",
+  "http",
+  "hu",
+  "hundred",
+  "hy",
+  "i",
+  "i2",
+  "i3",
+  "i4",
+  "i6",
+  "i7",
+  "i8",
+  "ia",
+  "ib",
+  "ibid",
+  "ic",
+  "id",
+  "i'd",
+  "ie",
+  "if",
+  "ig",
+  "ignored",
+  "ih",
+  "ii",
+  "ij",
+  "il",
+  "i'll",
+  "im",
+  "i'm",
+  "immediate",
+  "immediately",
+  "importance",
+  "important",
+  "in",
+  "inasmuch",
+  "inc",
+  "indeed",
+  "index",
+  "indicate",
+  "indicated",
+  "indicates",
+  "information",
+  "inner",
+  "insofar",
+  "instead",
+  "interest",
+  "into",
+  "invention",
+  "inward",
+  "io",
+  "ip",
+  "iq",
+  "ir",
+  "is",
+  "isn",
+  "isn't",
+  "it",
+  "itd",
+  "it'd",
+  "it'll",
+  "its",
+  "it's",
+  "itself",
+  "iv",
+  "i've",
+  "ix",
+  "iy",
+  "iz",
+  "j",
+  "jj",
+  "jr",
+  "js",
+  "jt",
+  "ju",
+  "just",
+  "k",
+  "ke",
+  "keep",
+  "keeps",
+  "kept",
+  "kg",
+  "kj",
+  "km",
+  "know",
+  "known",
+  "knows",
+  "ko",
+  "l",
+  "l2",
+  "la",
+  "largely",
+  "last",
+  "lately",
+  "later",
+  "latter",
+  "latterly",
+  "lb",
+  "lc",
+  "le",
+  "least",
+  "les",
+  "less",
+  "lest",
+  "let",
+  "lets",
+  "let's",
+  "lf",
+  "like",
+  "liked",
+  "likely",
+  "line",
+  "little",
+  "lj",
+  "ll",
+  "ll",
+  "ln",
+  "lo",
+  "look",
+  "looking",
+  "looks",
+  "los",
+  "lr",
+  "ls",
+  "lt",
+  "ltd",
+  "m",
+  "m2",
+  "ma",
+  "made",
+  "mainly",
+  "make",
+  "makes",
+  "many",
+  "may",
+  "maybe",
+  "me",
+  "mean",
+  "means",
+  "meantime",
+  "meanwhile",
+  "merely",
+  "mg",
+  "might",
+  "mightn",
+  "mightn't",
+  "mill",
+  "million",
+  "mine",
+  "miss",
+  "ml",
+  "mn",
+  "mo",
+  "more",
+  "moreover",
+  "most",
+  "mostly",
+  "move",
+  "mr",
+  "mrs",
+  "ms",
+  "mt",
+  "mu",
+  "much",
+  "mug",
+  "must",
+  "mustn",
+  "mustn't",
+  "my",
+  "myself",
+  "model",
+  "n",
+  "n2",
+  "na",
+  "name",
+  "namely",
+  "nay",
+  "nc",
+  "nd",
+  "ne",
+  "near",
+  "nearly",
+  "necessarily",
+  "necessary",
+  "need",
+  "needn",
+  "needn't",
+  "needs",
+  "neither",
+  "never",
+  "nevertheless",
+  "new",
+  "next",
+  "ng",
+  "ni",
+  "nine",
+  "ninety",
+  "nj",
+  "nl",
+  "nn",
+  "no",
+  "nobody",
+  "non",
+  "none",
+  "nonetheless",
+  "noone",
+  "nor",
+  "normally",
+  "nos",
+  "not",
+  "noted",
+  "nothing",
+  "novel",
+  "now",
+  "nowhere",
+  "nr",
+  "ns",
+  "nt",
+  "ny",
+  "o",
+  "oa",
+  "ob",
+  "obtain",
+  "obtained",
+  "obviously",
+  "oc",
+  "od",
+  "of",
+  "off",
+  "often",
+  "og",
+  "oh",
+  "oi",
+  "oj",
+  "ok",
+  "okay",
+  "ol",
+  "old",
+  "om",
+  "omitted",
+  "on",
+  "once",
+  "one",
+  "ones",
+  "only",
+  "onto",
+  "oo",
+  "op",
+  "oq",
+  "or",
+  "ord",
+  "os",
+  "ot",
+  "other",
+  "others",
+  "otherwise",
+  "ou",
+  "ought",
+  "our",
+  "ours",
+  "ourselves",
+  "out",
+  "outside",
+  "over",
+  "overall",
+  "ow",
+  "owing",
+  "own",
+  "ox",
+  "oz",
+  "p",
+  "p1",
+  "p2",
+  "p3",
+  "page",
+  "pagecount",
+  "pages",
+  "par",
+  "part",
+  "particular",
+  "particularly",
+  "pas",
+  "past",
+  "pc",
+  "pd",
+  "pe",
+  "per",
+  "perhaps",
+  "pf",
+  "ph",
+  "pi",
+  "pj",
+  "pk",
+  "pl",
+  "placed",
+  "please",
+  "plus",
+  "pm",
+  "pn",
+  "po",
+  "poorly",
+  "possible",
+  "possibly",
+  "potentially",
+  "pp",
+  "pq",
+  "pr",
+  "predominantly",
+  "present",
+  "presumably",
+  "previously",
+  "primarily",
+  "probably",
+  "promptly",
+  "proud",
+  "provides",
+  "ps",
+  "pt",
+  "pu",
+  "put",
+  "py",
+  "q",
+  "qj",
+  "qu",
+  "que",
+  "quickly",
+  "quite",
+  "qv",
+  "r",
+  "r2",
+  "ra",
+  "ran",
+  "rather",
+  "rc",
+  "rd",
+  "re",
+  "readily",
+  "really",
+  "reasonably",
+  "recent",
+  "recently",
+  "ref",
+  "refs",
+  "regarding",
+  "regardless",
+  "regards",
+  "related",
+  "relatively",
+  "research",
+  "research-articl",
+  "respectively",
+  "resulted",
+  "resulting",
+  "results",
+  "rf",
+  "rh",
+  "ri",
+  "right",
+  "rj",
+  "rl",
+  "rm",
+  "rn",
+  "ro",
+  "rq",
+  "rr",
+  "rs",
+  "rt",
+  "ru",
+  "run",
+  "rv",
+  "ry",
+  "s",
+  "s2",
+  "sa",
+  "said",
+  "same",
+  "saw",
+  "say",
+  "saying",
+  "says",
+  "sc",
+  "sd",
+  "se",
+  "sec",
+  "second",
+  "secondly",
+  "section",
+  "see",
+  "seeing",
+  "seem",
+  "seemed",
+  "seeming",
+  "seems",
+  "seen",
+  "self",
+  "selves",
+  "sensible",
+  "sent",
+  "serious",
+  "seriously",
+  "seven",
+  "several",
+  "sf",
+  "shall",
+  "shan",
+  "shan't",
+  "she",
+  "shed",
+  "she'd",
+  "she'll",
+  "shes",
+  "she's",
+  "should",
+  "shouldn",
+  "shouldn't",
+  "should've",
+  "show",
+  "showed",
+  "shown",
+  "showns",
+  "shows",
+  "si",
+  "side",
+  "significant",
+  "significantly",
+  "similar",
+  "similarly",
+  "since",
+  "sincere",
+  "six",
+  "sixty",
+  "sj",
+  "sl",
+  "slightly",
+  "sm",
+  "sn",
+  "so",
+  "some",
+  "somebody",
+  "somehow",
+  "someone",
+  "somethan",
+  "something",
+  "sometime",
+  "sometimes",
+  "somewhat",
+  "somewhere",
+  "soon",
+  "sorry",
+  "sp",
+  "specifically",
+  "specified",
+  "specify",
+  "specifying",
+  "sq",
+  "sr",
+  "ss",
+  "st",
+  "still",
+  "stop",
+  "strongly",
+  "sub",
+  "substantially",
+  "successfully",
+  "such",
+  "sufficiently",
+  "suggest",
+  "sup",
+  "sure",
+  "sy",
+  "system",
+  "sz",
+  "t",
+  "t1",
+  "t2",
+  "t3",
+  "take",
+  "taken",
+  "taking",
+  "tb",
+  "tc",
+  "td",
+  "te",
+  "tell",
+  "ten",
+  "tends",
+  "tf",
+  "th",
+  "than",
+  "thank",
+  "thanks",
+  "thanx",
+  "that",
+  "that'll",
+  "thats",
+  "that's",
+  "that've",
+  "the",
+  "their",
+  "theirs",
+  "them",
+  "themselves",
+  "then",
+  "thence",
+  "there",
+  "thereafter",
+  "thereby",
+  "thered",
+  "therefore",
+  "therein",
+  "there'll",
+  "thereof",
+  "therere",
+  "theres",
+  "there's",
+  "thereto",
+  "thereupon",
+  "there've",
+  "these",
+  "they",
+  "theyd",
+  "they'd",
+  "they'll",
+  "theyre",
+  "they're",
+  "they've",
+  "thickv",
+  "thin",
+  "think",
+  "third",
+  "this",
+  "thorough",
+  "thoroughly",
+  "those",
+  "thou",
+  "though",
+  "thoughh",
+  "thousand",
+  "three",
+  "throug",
+  "through",
+  "throughout",
+  "thru",
+  "thus",
+  "ti",
+  "til",
+  "tip",
+  "tj",
+  "tl",
+  "tm",
+  "tn",
+  "to",
+  "together",
+  "too",
+  "took",
+  "top",
+  "toward",
+  "towards",
+  "tp",
+  "tq",
+  "tr",
+  "tried",
+  "tries",
+  "truly",
+  "try",
+  "trying",
+  "ts",
+  "t's",
+  "tt",
+  "tv",
+  "twelve",
+  "twenty",
+  "twice",
+  "two",
+  "tx",
+  "u",
+  "u201d",
+  "ue",
+  "ui",
+  "uj",
+  "uk",
+  "um",
+  "un",
+  "under",
+  "unfortunately",
+  "unless",
+  "unlike",
+  "unlikely",
+  "until",
+  "unto",
+  "uo",
+  "up",
+  "upon",
+  "ups",
+  "ur",
+  "us",
+  "use",
+  "used",
+  "useful",
+  "usefully",
+  "usefulness",
+  "uses",
+  "using",
+  "usually",
+  "ut",
+  "v",
+  "va",
+  "value",
+  "various",
+  "vd",
+  "ve",
+  "ve",
+  "very",
+  "via",
+  "viz",
+  "vj",
+  "vo",
+  "vol",
+  "vols",
+  "volumtype",
+  "vq",
+  "vs",
+  "vt",
+  "vu",
+  "w",
+  "wa",
+  "want",
+  "wants",
+  "was",
+  "wasn",
+  "wasnt",
+  "wasn't",
+  "way",
+  "we",
+  "wed",
+  "we'd",
+  "welcome",
+  "well",
+  "we'll",
+  "well-b",
+  "went",
+  "were",
+  "we're",
+  "weren",
+  "werent",
+  "weren't",
+  "we've",
+  "what",
+  "whatever",
+  "what'll",
+  "whats",
+  "what's",
+  "when",
+  "whence",
+  "whenever",
+  "when's",
+  "where",
+  "whereafter",
+  "whereas",
+  "whereby",
+  "wherein",
+  "wheres",
+  "where's",
+  "whereupon",
+  "wherever",
+  "whether",
+  "which",
+  "while",
+  "whim",
+  "whither",
+  "who",
+  "whod",
+  "whoever",
+  "whole",
+  "who'll",
+  "whom",
+  "whomever",
+  "whos",
+  "who's",
+  "whose",
+  "why",
+  "why's",
+  "wi",
+  "widely",
+  "will",
+  "willing",
+  "wish",
+  "with",
+  "within",
+  "without",
+  "wo",
+  "won",
+  "wonder",
+  "wont",
+  "won't",
+  "words",
+  "world",
+  "would",
+  "wouldn",
+  "wouldnt",
+  "wouldn't",
+  "www",
+  "x",
+  "x1",
+  "x2",
+  "x3",
+  "xf",
+  "xi",
+  "xj",
+  "xk",
+  "xl",
+  "xn",
+  "xo",
+  "xs",
+  "xt",
+  "xv",
+  "xx",
+  "y",
+  "y2",
+  "yes",
+  "yet",
+  "yj",
+  "yl",
+  "you",
+  "youd",
+  "you'd",
+  "you'll",
+  "your",
+  "youre",
+  "you're",
+  "yours",
+  "yourself",
+  "yourselves",
+  "you've",
+  "yr",
+  "ys",
+  "yt",
+  "z",
+  "zero",
+  "zi",
+  "zz",
+  "task"
+]);
+
+// dsp/eval.ts
+function filterTokens(tokens, exclusions) {
+  return tokens.filter((token) => !exclusions.has(token));
+}
+function countTokens(tokens) {
+  const counter = {};
+  for (const token of tokens) {
+    counter[token] = (counter[token] || 0) + 1;
+  }
+  return counter;
+}
+function normalizeText(s) {
+  s = s.normalize("NFD");
+  s = s.replace(/\b(a|an|the)\b/g, " ");
+  s = s.split(/\s+/).join(" ");
+  s = s.replace(/[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]/g, "");
+  return s.toLowerCase();
+}
+function emScore(prediction, groundTruth) {
+  return normalizeText(prediction) === normalizeText(groundTruth);
+}
+function f1Score(prediction, groundTruth) {
+  const predictionTokens = normalizeText(prediction).split(" ");
+  const groundTruthTokens = normalizeText(groundTruth).split(" ");
+  const predictionCounts = countTokens(predictionTokens);
+  const groundTruthCounts = countTokens(groundTruthTokens);
+  let numSame = 0;
+  for (const token in predictionCounts) {
+    const v1 = predictionCounts[token] ?? 0;
+    const v2 = groundTruthCounts[token] ?? 0;
+    numSame += Math.min(v1, v2);
+  }
+  if (numSame === 0) {
+    return 0;
+  }
+  const precision = numSame / predictionTokens.length;
+  const recall = numSame / groundTruthTokens.length;
+  return 2 * precision * recall / (precision + recall);
+}
+function novelF1ScoreOptimized(history, prediction, groundTruth, returnRecall = false) {
+  const historyTokens = normalizeText(history).split(" ");
+  let predictionTokens = normalizeText(prediction).split(" ");
+  let groundTruthTokens = normalizeText(groundTruth).split(" ");
+  const exclusions = /* @__PURE__ */ new Set([...stopwords, ...historyTokens]);
+  predictionTokens = filterTokens(predictionTokens, exclusions);
+  groundTruthTokens = filterTokens(groundTruthTokens, exclusions);
+  const numSame = 0;
+  const precision = numSame / predictionTokens.length;
+  const recall = numSame / groundTruthTokens.length;
+  const f1 = 2 * precision * recall / (precision + recall);
+  return returnRecall ? recall : f1;
+}
+var AxEvalUtil = {
+  emScore,
+  f1Score,
+  novelF1ScoreOptimized
+};
+
+// ../../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 +10011,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 +10028,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 +10043,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,
@@ -9014,7 +10452,7 @@ var AxRAG = class extends AxChainOfThought {
         options
       );
       const val = await this.queryFn(query);
-      context = axStringUtil.dedup([...context, val]);
+      context = AxStringUtil.dedup([...context, val]);
     }
     return super.forward(ai, { context, question }, options);
   }
@@ -9076,6 +10514,7 @@ var AxRAG = class extends AxChainOfThought {
   AxDefaultResultReranker,
   AxDockerSession,
   AxEmbeddingAdapter,
+  AxEvalUtil,
   AxFunctionError,
   AxFunctionProcessor,
   AxGen,
@@ -9099,6 +10538,47 @@ var AxRAG = class extends AxChainOfThought {
   AxSimpleClassifier,
   AxSimpleClassifierClass,
   AxSpanKindValues,
-  AxTestPrompt
+  AxStringUtil,
+  AxTestPrompt,
+  axAIAnthropicDefaultConfig,
+  axAIAzureOpenAIBestConfig,
+  axAIAzureOpenAICreativeConfig,
+  axAIAzureOpenAIDefaultConfig,
+  axAIAzureOpenAIFastConfig,
+  axAICohereCreativeConfig,
+  axAICohereDefaultConfig,
+  axAIDeepSeekCodeConfig,
+  axAIDeepSeekDefaultConfig,
+  axAIGoogleGeminiDefaultConfig,
+  axAIGoogleGeminiDefaultCreativeConfig,
+  axAIHuggingFaceCreativeConfig,
+  axAIHuggingFaceDefaultConfig,
+  axAIMistralBestConfig,
+  axAIMistralDefaultConfig,
+  axAIOllamaDefaultConfig,
+  axAIOllamaDefaultCreativeConfig,
+  axAIOpenAIBestConfig,
+  axAIOpenAICreativeConfig,
+  axAIOpenAIDefaultConfig,
+  axAIOpenAIFastConfig,
+  axAIRekaBestConfig,
+  axAIRekaCreativeConfig,
+  axAIRekaDefaultConfig,
+  axAIRekaFastConfig,
+  axAITogetherDefaultConfig,
+  axBaseAIDefaultConfig,
+  axBaseAIDefaultCreativeConfig,
+  axModelInfoAnthropic,
+  axModelInfoCohere,
+  axModelInfoDeepSeek,
+  axModelInfoGoogleGemini,
+  axModelInfoGroq,
+  axModelInfoHuggingFace,
+  axModelInfoMistral,
+  axModelInfoOpenAI,
+  axModelInfoReka,
+  axModelInfoTogether,
+  axSpanAttributes,
+  axSpanEvents
 });
 //# sourceMappingURL=index.cjs.map