@ax-llm/ax 12.0.8 → 12.0.12

package/index.js

@@ -320,6 +320,17 @@ var AxAIServiceAuthenticationError = class extends AxAIServiceError {
     this.name = this.constructor.name;
   }
 };
+async function safeReadResponseBody(response) {
+  try {
+    if (response.headers.get("content-type")?.includes("application/json")) {
+      return await response.json();
+    }
+    const clonedResponse = response.clone();
+    return await clonedResponse.text();
+  } catch (e) {
+    return `[ReadableStream - read failed: ${e.message}]`;
+  }
+}
 function calculateRetryDelay(attempt, config) {
   const delay = Math.min(
     config.maxDelayMs,
@@ -413,9 +424,15 @@ var apiCall = async (api, json) => {
       });
       clearTimeout(timeoutId);
       if (res.status === 401 || res.status === 403) {
-        throw new AxAIServiceAuthenticationError(apiUrl.href, json, res.body, {
-          metrics
-        });
+        const responseBody = await safeReadResponseBody(res);
+        throw new AxAIServiceAuthenticationError(
+          apiUrl.href,
+          json,
+          responseBody,
+          {
+            metrics
+          }
+        );
       }
       if (res.status >= 400 && shouldRetry(new Error(), res.status, attempt, retryConfig)) {
         const delay = calculateRetryDelay(attempt, retryConfig);
@@ -433,12 +450,13 @@ var apiCall = async (api, json) => {
         continue;
       }
       if (res.status >= 400) {
+        const responseBody = await safeReadResponseBody(res);
         throw new AxAIServiceStatusError(
           res.status,
           res.statusText,
           apiUrl.href,
           json,
-          res.body,
+          responseBody,
           { metrics }
         );
       }
@@ -536,7 +554,7 @@ var apiCall = async (api, json) => {
                     error,
                     apiUrl.href,
                     json,
-                    res.body,
+                    "[ReadableStream - consumed during streaming]",
                     {
                       streamMetrics
                     }
@@ -667,12 +685,12 @@ var ColorLog = class {
   }
 };
 
-// ai/debug.ts
+// dsp/loggers.ts
 var colorLog = new ColorLog();
 var defaultOutput = (message) => {
   process.stdout.write(message);
 };
-var createDefaultLogger = (output = defaultOutput) => {
+var axCreateDefaultLogger = (output = defaultOutput) => {
   return (message, options) => {
     const tags = options?.tags ?? [];
     let formattedMessage = message;
@@ -681,12 +699,44 @@ var createDefaultLogger = (output = defaultOutput) => {
     } else if (tags.includes("success") || tags.includes("responseContent")) {
       formattedMessage = colorLog.greenBright(formattedMessage);
     } else if (tags.includes("functionName")) {
-      formattedMessage = colorLog.whiteBright(formattedMessage);
-    } else if (tags.includes("functionArg") || tags.includes("systemContent") || tags.includes("assistantContent")) {
+      if (tags.includes("firstFunction")) {
+        formattedMessage = `
+${colorLog.whiteBright(formattedMessage)}`;
+      } else {
+        formattedMessage = `${colorLog.whiteBright(formattedMessage)}`;
+      }
+    } else if (tags.includes("systemContent") || tags.includes("assistantContent")) {
       formattedMessage = colorLog.blueBright(formattedMessage);
     } else if (tags.includes("warning") || tags.includes("discovery")) {
       formattedMessage = colorLog.yellow(formattedMessage);
+    } else if (tags.includes("functionArg")) {
+      formattedMessage = "";
+    }
+    if (tags.includes("responseStart") || tags.includes("systemStart") || tags.includes("userStart")) {
+      formattedMessage = `
+${formattedMessage}`;
+    } else if (tags.includes("responseEnd") || tags.includes("systemEnd") || tags.includes("userEnd")) {
+      formattedMessage = `${formattedMessage}
+`;
+    } else if (tags.includes("assistantStart")) {
+      formattedMessage = `
+${formattedMessage}
+`;
+    } else if (tags.includes("error")) {
+      formattedMessage = `
+${formattedMessage}
+`;
+    } else if (tags.includes("functionEnd")) {
+      formattedMessage = `
+`;
     }
+    output(formattedMessage);
+  };
+};
+var axCreateDefaultTextLogger = (output = defaultOutput) => {
+  return (message, options) => {
+    const tags = options?.tags ?? [];
+    let formattedMessage = message;
     if (tags.includes("responseStart") || tags.includes("systemStart") || tags.includes("userStart")) {
       formattedMessage = `
 ${formattedMessage}`;
@@ -708,7 +758,137 @@ ${formattedMessage}
     output(formattedMessage);
   };
 };
-var defaultLogger = createDefaultLogger();
+var axCreateOptimizerLogger = (output = (msg) => process.stdout.write(msg)) => {
+  const baseLogger = axCreateDefaultLogger(output);
+  let isFirstPhase = true;
+  return (message, options) => {
+    const tags = options?.tags ?? [];
+    let formattedMessage = message;
+    if (tags.includes("optimizer")) {
+      if (tags.includes("start")) {
+        const trialsMatch = message.match(/with (\d+) trials?/) || message.match(/(\d+) trials?/);
+        const optimizerMatch = message.match(
+          /(MIPROv2|BootstrapFewshot|[A-Z][a-zA-Z]+)/
+        );
+        const optimizerName = optimizerMatch ? optimizerMatch[1] : "Optimizer";
+        if (trialsMatch && trialsMatch[1]) {
+          formattedMessage = `
+\u250C\u2500 ${optimizerName} optimization (${trialsMatch[1]} trials)
+`;
+        } else {
+          formattedMessage = `
+\u250C\u2500 ${optimizerName} optimization
+`;
+        }
+        isFirstPhase = true;
+      } else if (tags.includes("config")) {
+        if (message.includes("examples") && message.includes("training")) {
+          const match = message.match(
+            /(\d+) examples for training and (\d+) for validation/
+          ) || message.match(/(\d+) training.*?(\d+) validation/);
+          if (match && match[1] && match[2]) {
+            formattedMessage = `\u2502  Dataset: ${match[1]} training, ${match[2]} validation
+`;
+          } else {
+            const simpleMatch = message.match(/(\d+) examples/);
+            if (simpleMatch && simpleMatch[1]) {
+              formattedMessage = `\u2502  Dataset: ${simpleMatch[1]} examples
+`;
+            }
+          }
+        } else if (message.includes("teacher")) {
+          formattedMessage = `\u2502  Using teacher model
+`;
+        } else {
+          formattedMessage = `\u2502  ${message}
+`;
+        }
+      } else if (tags.includes("phase")) {
+        if (isFirstPhase) {
+          formattedMessage = `\u251C\u2500 ${message}
+`;
+          isFirstPhase = false;
+        } else {
+          formattedMessage = `\u251C\u2500 ${message}
+`;
+        }
+      } else if (tags.includes("result")) {
+        if (message.includes("Generated") || message.includes("Selected")) {
+          const match = message.match(/(\d+)/);
+          if (match && match[1]) {
+            formattedMessage = `\u2502  \u2713 ${message}
+`;
+          } else {
+            formattedMessage = `\u2502  \u2713 ${message}
+`;
+          }
+        } else if (message.includes("configuration")) {
+          formattedMessage = `\u2502  Applied best configuration
+`;
+        } else {
+          formattedMessage = `\u2502  ${message}
+`;
+        }
+      } else if (tags.includes("progress")) {
+        formattedMessage = `\u2502  ${message}
+`;
+      } else if (tags.includes("complete")) {
+        const scoreMatch = message.match(/(score|performance):\s*([\d.]+)/);
+        if (scoreMatch && scoreMatch[2]) {
+          const score = parseFloat(scoreMatch[2]);
+          const percentage = score <= 1 ? (score * 100).toFixed(1) + "%" : score.toFixed(3);
+          formattedMessage = `\u251C\u2500 Complete! Best: ${percentage}
+`;
+        } else if (message.includes("Bootstrap")) {
+          formattedMessage = `\u251C\u2500 ${message}
+`;
+        } else {
+          formattedMessage = `\u251C\u2500 Optimization complete
+`;
+        }
+      } else if (tags.includes("checkpoint")) {
+        if (message.includes("Resuming")) {
+          formattedMessage = `\u2502  ${message}
+`;
+        } else {
+          const match = message.match(/checkpoint:\s*(.+)/) || message.match(/Saved\s+(.+)/);
+          if (match && match[1]) {
+            formattedMessage = `\u2514\u2500 Saved: ${match[1]}
+`;
+          } else {
+            formattedMessage = `\u2514\u2500 Checkpoint saved
+`;
+          }
+        }
+      }
+    } else if (tags.includes("discovery")) {
+      if (message.includes("Found") && message.includes("examples")) {
+        const match = message.match(/Found (\d+)/);
+        if (match && match[1]) {
+          formattedMessage = `\u2502  Found ${match[1]} examples
+`;
+        }
+      }
+    }
+    if (tags.includes("error")) {
+      formattedMessage = `
+\u2717 ${message}
+`;
+    } else if (tags.includes("warning")) {
+      formattedMessage = `
+\u26A0 ${message}
+`;
+    } else if (tags.includes("success") && !tags.includes("optimizer")) {
+      formattedMessage = `\u2713 ${message}
+`;
+    }
+    baseLogger(formattedMessage, options);
+  };
+};
+var axDefaultOptimizerLogger = axCreateOptimizerLogger();
+
+// ai/debug.ts
+var defaultLogger = axCreateDefaultLogger();
 var formatChatMessage = (msg, hideContent, hideSystemPrompt) => {
   switch (msg.role) {
     case "system":
@@ -785,9 +965,14 @@ var logResponseResult = (r, logger = defaultLogger) => {
   if (r.functionCalls && r.functionCalls.length > 0) {
     for (const [i, f2] of r.functionCalls.entries()) {
       if (f2.function.name) {
-        logger(`[${i + 1}] ${f2.function.name}`, {
-          tags: ["functionName"]
-        });
+        const tags = ["functionName"];
+        if (i === 0) {
+          tags.push("firstFunction");
+        }
+        if (r.functionCalls.length > 1) {
+          tags.push("multipleFunctions");
+        }
+        logger(`[${i + 1}] ${f2.function.name}`, { tags });
       }
       if (f2.function.params) {
         const params = typeof f2.function.params === "string" ? f2.function.params : JSON.stringify(f2.function.params, null, 2);
@@ -1027,6 +1212,9 @@ var AxBaseAI = class {
   }
   async _chat1(req, options) {
     const model = this.getModel(req.model) ?? req.model ?? this.defaults.model;
+    if (req.chatPrompt && Array.isArray(req.chatPrompt)) {
+      validateAxMessageArray(req.chatPrompt);
+    }
     const modelConfig = {
       ...this.aiImpl.getModelConfig(),
       ...req.modelConfig
@@ -1098,7 +1286,6 @@ var AxBaseAI = class {
     if (chatReq.functions && chatReq.functions.length > 0) {
       functions = chatReq.functions.map((fn2) => this.cleanupFunctionSchema(fn2));
     }
-    validateChatPrompt(chatReq.chatPrompt);
     const req = {
       ...chatReq,
       model,
@@ -1149,11 +1336,14 @@ var AxBaseAI = class {
         const res2 = respFn(resp, state);
         res2.sessionId = options?.sessionId;
         if (!res2.modelUsage) {
-          res2.modelUsage = {
-            ai: this.name,
-            model,
-            tokens: this.aiImpl.getTokenUsage()
-          };
+          const tokenUsage = this.aiImpl.getTokenUsage();
+          if (tokenUsage) {
+            res2.modelUsage = {
+              ai: this.name,
+              model,
+              tokens: tokenUsage
+            };
+          }
         }
         this.modelUsage = res2.modelUsage;
         if (span?.isRecording()) {
@@ -1287,11 +1477,14 @@ var AxBaseAI = class {
     const res = this.aiImpl.createEmbedResp(resValue);
     res.sessionId = options?.sessionId;
     if (!res.modelUsage) {
-      res.modelUsage = {
-        ai: this.name,
-        model: embedModel,
-        tokens: this.aiImpl.getTokenUsage()
-      };
+      const tokenUsage = this.aiImpl.getTokenUsage();
+      if (tokenUsage) {
+        res.modelUsage = {
+          ai: this.name,
+          model: embedModel,
+          tokens: tokenUsage
+        };
+      }
     }
     this.embedModelUsage = res.modelUsage;
     if (span?.isRecording() && res.modelUsage?.tokens) {
@@ -1455,16 +1648,6 @@ function validateAxMessageArray(values) {
     }
   }
 }
-function validateChatPrompt(chatPrompt) {
-  for (let i = 0; i < chatPrompt.length; i++) {
-    const message = chatPrompt[i];
-    if (message && "content" in message && typeof message.content === "string" && message.content.trim() === "") {
-      throw new Error(
-        `Chat prompt validation failed: Message at index ${i} has empty content`
-      );
-    }
-  }
-}
 function validateModels(models) {
   const keys = /* @__PURE__ */ new Set();
   for (const model of models) {
@@ -1536,14 +1719,18 @@ var axModelInfoAnthropic = [
     currency: "usd",
     promptTokenCostPer1M: 15,
     completionTokenCostPer1M: 75,
-    maxTokens: 32e3
+    maxTokens: 32e3,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
   },
   {
     name: "claude-sonnet-4-20250514" /* Claude4Sonnet */,
     currency: "usd",
     promptTokenCostPer1M: 3,
     completionTokenCostPer1M: 15,
-    maxTokens: 64e3
+    maxTokens: 64e3,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
   },
   // 3.7
   {
@@ -1551,7 +1738,9 @@ var axModelInfoAnthropic = [
     currency: "usd",
     promptTokenCostPer1M: 3,
     completionTokenCostPer1M: 15,
-    maxTokens: 64e3
+    maxTokens: 64e3,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
   },
   // 3.5
   {
@@ -1607,13 +1796,47 @@ var axModelInfoAnthropic = [
   }
 ];
 
+// dsp/modelinfo.ts
+function getModelInfo({
+  model,
+  modelInfo,
+  models
+}) {
+  const modelEntry = models?.find((v) => v.key === model);
+  const mappedModel = modelEntry && "model" in modelEntry ? modelEntry.model : model;
+  const exactMatch = modelInfo.find((v) => v.name === model);
+  if (exactMatch) return exactMatch;
+  const normalizedName = mappedModel.replace(/^(anthropic\.|openai\.)/, "").replace(/-latest$/, "").replace(/-\d{8}$/, "").replace(/-v\d+:\d+$/, "").replace(/@\d{8}$/, "").replace(/-\d{2,}(-[a-zA-Z0-9-]+)?$/, "").replace(/-v\d+@\d{8}$/, "").replace(/-v\d+$/, "");
+  const normalizedMatch = modelInfo.find((v) => v.name === normalizedName);
+  if (normalizedMatch) return normalizedMatch;
+  return null;
+}
+
 // ai/anthropic/api.ts
 var axAIAnthropicDefaultConfig = () => structuredClone({
   model: "claude-3-7-sonnet-latest" /* Claude37Sonnet */,
+  maxTokens: 4e4,
+  // Ensure maxTokens is higher than highest thinking budget
+  thinkingTokenBudgetLevels: {
+    minimal: 1024,
+    low: 5e3,
+    medium: 1e4,
+    high: 2e4,
+    highest: 32e3
+  },
   ...axBaseAIDefaultConfig()
 });
 var axAIAnthropicVertexDefaultConfig = () => structuredClone({
   model: "claude-3-7-sonnet" /* Claude37Sonnet */,
+  maxTokens: 4e4,
+  // Ensure maxTokens is higher than highest thinking budget
+  thinkingTokenBudgetLevels: {
+    minimal: 1024,
+    low: 5e3,
+    medium: 1e4,
+    high: 2e4,
+    highest: 32e3
+  },
   ...axBaseAIDefaultConfig()
 });
 var AxAIAnthropicImpl = class {
@@ -1622,6 +1845,7 @@ var AxAIAnthropicImpl = class {
     this.isVertex = isVertex;
   }
   tokensUsed;
+  currentPromptConfig;
   getTokenUsage() {
     return this.tokensUsed;
   }
@@ -1640,7 +1864,8 @@ var AxAIAnthropicImpl = class {
       n: config.n
     };
   }
-  createChatReq = (req) => {
+  createChatReq = (req, config) => {
+    this.currentPromptConfig = config;
     const model = req.model;
     const stream = req.modelConfig?.stream ?? this.config.stream;
     let apiConfig;
@@ -1696,17 +1921,67 @@ var AxAIAnthropicImpl = class {
     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 n = req.modelConfig?.n ?? this.config.n;
+    if (n && n > 1) {
+      throw new Error("Anthropic does not support sampling (n > 1)");
+    }
+    let thinkingConfig;
+    if (this.config.thinking?.budget_tokens) {
+      thinkingConfig = this.config.thinking;
+    }
+    if (config?.thinkingTokenBudget) {
+      const levels = this.config.thinkingTokenBudgetLevels;
+      switch (config.thinkingTokenBudget) {
+        case "none":
+          thinkingConfig = void 0;
+          break;
+        case "minimal":
+          thinkingConfig = {
+            type: "enabled",
+            budget_tokens: levels?.minimal ?? 1024
+          };
+          break;
+        case "low":
+          thinkingConfig = {
+            type: "enabled",
+            budget_tokens: levels?.low ?? 5e3
+          };
+          break;
+        case "medium":
+          thinkingConfig = {
+            type: "enabled",
+            budget_tokens: levels?.medium ?? 1e4
+          };
+          break;
+        case "high":
+          thinkingConfig = {
+            type: "enabled",
+            budget_tokens: levels?.high ?? 2e4
+          };
+          break;
+        case "highest":
+          thinkingConfig = {
+            type: "enabled",
+            budget_tokens: levels?.highest ?? 32e3
+          };
+          break;
+      }
+    }
     const reqValue = {
       ...this.isVertex ? { anthropic_version: "vertex-2023-10-16" } : { model },
       ...maxTokens ? { max_tokens: maxTokens } : {},
       ...stopSequences && stopSequences.length > 0 ? { stop_sequences: stopSequences } : {},
-      ...temperature ? { temperature } : {},
-      ...topP ? { top_p: topP } : {},
-      ...topK ? { top_k: topK } : {},
+      // Only include temperature when thinking is not enabled
+      ...temperature && !thinkingConfig ? { temperature } : {},
+      // Only include top_p when thinking is not enabled, or when it's >= 0.95
+      ...topP && (!thinkingConfig || topP >= 0.95) ? { top_p: topP } : {},
+      // Only include top_k when thinking is not enabled
+      ...topK && !thinkingConfig ? { top_k: topK } : {},
       ...toolsChoice,
       ...tools && tools.length > 0 ? { tools } : {},
       ...stream ? { stream: true } : {},
       ...system ? { system } : {},
+      ...thinkingConfig ? { thinking: thinkingConfig } : {},
       messages
     };
     return [apiConfig, reqValue];
@@ -1716,9 +1991,11 @@ var AxAIAnthropicImpl = class {
       throw new Error(`Anthropic Chat API Error: ${resp.error.message}`);
     }
     const finishReason = mapFinishReason(resp.stop_reason);
-    const results = resp.content.map((msg) => {
+    const showThoughts = this.currentPromptConfig?.thinkingTokenBudget !== "none" && this.currentPromptConfig?.showThoughts !== false;
+    const results = resp.content.map((msg, index) => {
       if (msg.type === "tool_use") {
         return {
+          index,
           id: msg.id,
           functionCalls: [
             {
@@ -1733,12 +2010,23 @@ var AxAIAnthropicImpl = class {
           finishReason
         };
       }
+      if ((msg.type === "thinking" || msg.type === "redacted_thinking") && showThoughts) {
+        return {
+          index,
+          thought: msg.thinking,
+          id: resp.id,
+          finishReason
+        };
+      }
       return {
+        index,
         content: msg.type === "text" ? msg.text : "",
         id: resp.id,
         finishReason
       };
-    });
+    }).filter(
+      (result) => result.content !== "" || result.thought !== void 0 || result.functionCalls !== void 0
+    );
     this.tokensUsed = {
       promptTokens: resp.usage.input_tokens,
       completionTokens: resp.usage.output_tokens,
@@ -1758,9 +2046,10 @@ var AxAIAnthropicImpl = class {
       const { error } = resp;
       throw new Error(error.message);
     }
+    const index = 0;
     if (resp.type === "message_start") {
       const { message } = resp;
-      const results = [{ content: "", id: message.id }];
+      const results = [{ index, content: "", id: message.id }];
       this.tokensUsed = {
         promptTokens: message.usage?.input_tokens ?? 0,
         completionTokens: message.usage?.output_tokens ?? 0,
@@ -1772,7 +2061,18 @@ var AxAIAnthropicImpl = class {
       const { content_block: contentBlock } = resp;
       if (contentBlock.type === "text") {
         return {
-          results: [{ content: contentBlock.text }]
+          results: [{ index, content: contentBlock.text }]
+        };
+      }
+      if (contentBlock.type === "thinking") {
+        const showThoughts = this.currentPromptConfig?.thinkingTokenBudget !== "none" && this.currentPromptConfig?.showThoughts !== false;
+        if (showThoughts) {
+          return {
+            results: [{ index, thought: contentBlock.thinking }]
+          };
+        }
+        return {
+          results: [{ index, content: "" }]
         };
       }
       if (contentBlock.type === "tool_use") {
@@ -1789,7 +2089,7 @@ var AxAIAnthropicImpl = class {
             }
           ];
           return {
-            results: [{ functionCalls }]
+            results: [{ index, functionCalls }]
           };
         }
       }
@@ -1798,7 +2098,23 @@ var AxAIAnthropicImpl = class {
       const { delta } = resp;
       if (delta.type === "text_delta") {
         return {
-          results: [{ content: delta.text }]
+          results: [{ index, content: delta.text }]
+        };
+      }
+      if (delta.type === "thinking_delta") {
+        const showThoughts = this.currentPromptConfig?.thinkingTokenBudget !== "none" && this.currentPromptConfig?.showThoughts !== false;
+        if (showThoughts) {
+          return {
+            results: [{ index, thought: delta.thinking }]
+          };
+        }
+        return {
+          results: [{ index, content: "" }]
+        };
+      }
+      if (delta.type === "signature_delta") {
+        return {
+          results: [{ index, content: "" }]
         };
       }
       if (delta.type === "input_json_delta") {
@@ -1817,7 +2133,7 @@ var AxAIAnthropicImpl = class {
           }
         ];
         return {
-          results: [{ functionCalls }]
+          results: [{ index, functionCalls }]
         };
       }
     }
@@ -1829,12 +2145,16 @@ var AxAIAnthropicImpl = class {
         totalTokens: usage.output_tokens
       };
       const results = [
-        { content: "", finishReason: mapFinishReason(delta.stop_reason) }
+        {
+          index,
+          content: "",
+          finishReason: mapFinishReason(delta.stop_reason)
+        }
       ];
       return { results };
     }
     return {
-      results: [{ content: "" }]
+      results: [{ index, content: "" }]
     };
   };
 };
@@ -1876,6 +2196,20 @@ var AxAIAnthropic = class extends AxBaseAI {
       ...config
     };
     const aiImpl = new AxAIAnthropicImpl(_config, isVertex);
+    const supportFor = (model) => {
+      const mi = getModelInfo({
+        model,
+        modelInfo: axModelInfoAnthropic,
+        models
+      });
+      return {
+        functions: true,
+        streaming: true,
+        hasThinkingBudget: mi?.hasThinkingBudget ?? false,
+        hasShowThoughts: mi?.hasShowThoughts ?? false,
+        functionCot: true
+      };
+    };
     super(aiImpl, {
       name: "Anthropic",
       apiURL,
@@ -1883,7 +2217,7 @@ var AxAIAnthropic = class extends AxBaseAI {
       modelInfo: axModelInfoAnthropic,
       defaults: { model: _config.model },
       options,
-      supportFor: { functions: true, streaming: true, functionCot: true },
+      supportFor,
       models
     });
   }
@@ -2013,22 +2347,6 @@ function mapFinishReason(stopReason) {
   }
 }
 
-// dsp/modelinfo.ts
-function getModelInfo({
-  model,
-  modelInfo,
-  models
-}) {
-  const modelEntry = models?.find((v) => v.key === model);
-  const mappedModel = modelEntry && "model" in modelEntry ? modelEntry.model : model;
-  const exactMatch = modelInfo.find((v) => v.name === model);
-  if (exactMatch) return exactMatch;
-  const normalizedName = mappedModel.replace(/^(anthropic\.|openai\.)/, "").replace(/-latest$/, "").replace(/-\d{8}$/, "").replace(/-v\d+:\d+$/, "").replace(/@\d{8}$/, "").replace(/-\d{2,}(-[a-zA-Z0-9-]+)?$/, "").replace(/-v\d+@\d{8}$/, "").replace(/-v\d+$/, "");
-  const normalizedMatch = modelInfo.find((v) => v.name === normalizedName);
-  if (normalizedMatch) return normalizedMatch;
-  return null;
-}
-
 // ai/openai/chat_types.ts
 var AxAIOpenAIModel = /* @__PURE__ */ ((AxAIOpenAIModel2) => {
   AxAIOpenAIModel2["O1"] = "o1";
@@ -2363,6 +2681,7 @@ var AxAIOpenAIImpl = class {
         })
       );
       return {
+        index: choice.index,
         id: `${choice.index}`,
         content: choice.message.content,
         thought: choice.message.reasoning_content,
@@ -2388,6 +2707,7 @@ var AxAIOpenAIImpl = class {
     }
     const results = choices.map(
       ({
+        index,
         delta: {
           content,
           role,
@@ -2397,11 +2717,11 @@ var AxAIOpenAIImpl = class {
         finish_reason: oaiFinishReason
       }) => {
         const finishReason = mapFinishReason2(oaiFinishReason);
-        const functionCalls = toolCalls?.map(({ id: _id, index, function: { name, arguments: params } }) => {
-          if (typeof _id === "string" && typeof index === "number" && !sstate.indexIdMap[index]) {
-            sstate.indexIdMap[index] = _id;
+        const functionCalls = toolCalls?.map(({ id: _id, index: index2, function: { name, arguments: params } }) => {
+          if (typeof _id === "string" && typeof index2 === "number" && !sstate.indexIdMap[index2]) {
+            sstate.indexIdMap[index2] = _id;
           }
-          const id2 = sstate.indexIdMap[index];
+          const id2 = sstate.indexIdMap[index2];
           if (!id2) {
             return null;
           }
@@ -2412,6 +2732,7 @@ var AxAIOpenAIImpl = class {
           };
         }).filter((v) => v !== null);
         return {
+          index,
           content,
           role,
           thought,
@@ -2446,7 +2767,7 @@ var mapFinishReason2 = (finishReason) => {
   }
 };
 function createMessages2(req) {
-  return req.chatPrompt.map((msg) => {
+  const openaiReq = req.chatPrompt.map((msg) => {
     switch (msg.role) {
       case "system":
         return { role: "system", content: msg.content };
@@ -2495,7 +2816,7 @@ function createMessages2(req) {
             tool_calls: toolCalls
           };
         }
-        if (!msg.content) {
+        if (msg.content === void 0) {
           throw new Error(
             "Assistant content is required when no tool calls are provided"
           );
@@ -2515,6 +2836,7 @@ function createMessages2(req) {
         throw new Error("Invalid role");
     }
   });
+  return openaiReq;
 }
 var AxAIOpenAIBase = class extends AxBaseAI {
   constructor({
@@ -2868,6 +3190,7 @@ var AxAICohereImpl = class {
     }
     const results = [
       {
+        index: 0,
         id: resp.generation_id,
         content: resp.text,
         functionCalls,
@@ -3500,7 +3823,7 @@ var AxAIGoogleGeminiImpl = class {
   createChatResp = (resp) => {
     const results = resp.candidates?.map(
       (candidate) => {
-        const result = {};
+        const result = { index: 0 };
         switch (candidate.finishReason) {
           case "MAX_TOKENS":
             result.finishReason = "length";
@@ -3897,6 +4220,7 @@ ${fc}`;
     return {
       results: [
         {
+          index: 0,
           content: resp.generated_text
         }
       ]
@@ -4538,7 +4862,7 @@ var AxAIOpenAIResponsesImpl = class {
       }
     }
     return {
-      results: [currentResult],
+      results: [{ ...currentResult, index: 0 }],
       remoteId: id
     };
   }
@@ -4546,6 +4870,7 @@ var AxAIOpenAIResponsesImpl = class {
   createChatStreamResp(streamEvent) {
     const event = streamEvent;
     const baseResult = {
+      index: 0,
       id: "",
       content: "",
       finishReason: "stop"
@@ -5113,7 +5438,7 @@ var AxAIRekaImpl = class {
       completionTokens: usage.output_tokens,
       totalTokens: usage.input_tokens + usage.output_tokens
     } : void 0;
-    const results = responses.map((res) => {
+    const results = responses.map((res, index) => {
       const finishReason = mapFinishReason3(res.finish_reason);
       let content;
       if (typeof res.message.content === "string") {
@@ -5122,6 +5447,7 @@ var AxAIRekaImpl = class {
         content = res.message.content.text;
       }
       return {
+        index,
         id: `${id}`,
         content,
         finishReason
@@ -5136,7 +5462,7 @@ var AxAIRekaImpl = class {
       completionTokens: usage.output_tokens,
       totalTokens: usage.input_tokens + usage.output_tokens
     } : void 0;
-    const results = responses.map((res) => {
+    const results = responses.map((res, index) => {
       const finishReason = mapFinishReason3(res.finish_reason);
       let content;
       if (typeof res.chunk.content === "string") {
@@ -5145,6 +5471,7 @@ var AxAIRekaImpl = class {
         content = res.chunk.content.text;
       }
       return {
+        index,
         id: `${id}`,
         content,
         finishReason
@@ -5498,111 +5825,325 @@ var AxAIGrok = class extends AxAIOpenAIBase {
 };
 
 // dsp/generate.ts
-import { ReadableStream as ReadableStream2 } from "stream/web";
+import { ReadableStream as ReadableStream3 } from "stream/web";
 import {
   context as context2,
   SpanKind as SpanKind2,
   trace
 } from "@opentelemetry/api";
 
-// ai/util.ts
-function mergeFunctionCalls(functionCalls, functionCallDeltas) {
-  for (const _fc of functionCallDeltas) {
-    const fc = functionCalls.find((fc2) => fc2.id === _fc.id);
-    if (fc) {
-      if (typeof _fc.function.name == "string" && _fc.function.name.length > 0) {
-        fc.function.name += _fc.function.name;
-      }
-      if (typeof _fc.function.params == "string" && _fc.function.params.length > 0) {
-        fc.function.params += _fc.function.params;
-      }
-      if (typeof _fc.function.params == "object") {
-        fc.function.params = _fc.function.params;
-      }
-    } else {
-      functionCalls.push(_fc);
-    }
-  }
-}
-
-// mem/memory.ts
-var defaultLimit = 1e4;
-var MemoryImpl = class {
-  constructor(limit = defaultLimit, options) {
-    this.limit = limit;
-    this.options = options;
-    if (limit <= 0) {
-      throw Error("argument 'limit' must be greater than 0");
-    }
-  }
-  data = [];
-  addMemory(value) {
-    if (Array.isArray(value)) {
-      this.data.push(...value.map((chat) => ({ chat: structuredClone(chat) })));
-    } else {
-      this.data.push({
-        chat: structuredClone(value)
-      });
-    }
-    if (this.data.length > this.limit) {
-      const removeCount = this.data.length - this.limit;
-      this.data.splice(0, removeCount);
-    }
+// ai/validate.ts
+function axValidateChatRequestMessage(item) {
+  if (!item) {
+    throw new Error("Chat request message item cannot be null or undefined");
   }
-  add(value) {
-    this.addMemory(value);
-    if (this.options?.debug) {
-      debugRequest(value, this.options?.debugHideSystemPrompt);
-    }
+  if (!item.role) {
+    throw new Error("Chat request message must have a role");
   }
-  addResultMessage({
-    content,
-    name,
-    functionCalls
-  }) {
-    const isContentEmpty = typeof content === "string" && content.trim() === "";
-    if (isContentEmpty) {
-      this.addMemory({ name, role: "assistant", functionCalls });
-    } else {
-      this.addMemory({ content, name, role: "assistant", functionCalls });
+  switch (item.role) {
+    case "system":
+      if (!item.content || item.content.trim() === "") {
+        throw new Error(
+          "System message content cannot be empty or whitespace-only"
+        );
+      }
+      break;
+    case "user":
+      if (!item.content) {
+        throw new Error("User message content cannot be undefined");
+      }
+      if (typeof item.content === "string") {
+        if (item.content.trim() === "") {
+          throw new Error(
+            "User message content cannot be empty or whitespace-only"
+          );
+        }
+      } else if (Array.isArray(item.content)) {
+        if (item.content.length === 0) {
+          throw new Error("User message content array cannot be empty");
+        }
+        for (let index = 0; index < item.content.length; index++) {
+          const contentItem = item.content[index];
+          if (!contentItem || typeof contentItem !== "object") {
+            throw new Error(
+              `User message content item at index ${index} must be an object`
+            );
+          }
+          if (!contentItem.type) {
+            throw new Error(
+              `User message content item at index ${index} must have a type`
+            );
+          }
+          switch (contentItem.type) {
+            case "text":
+              if (!contentItem.text || contentItem.text.trim() === "") {
+                throw new Error(
+                  `User message text content at index ${index} cannot be empty or whitespace-only`
+                );
+              }
+              break;
+            case "image":
+              if (!contentItem.image || contentItem.image.trim() === "") {
+                throw new Error(
+                  `User message image content at index ${index} cannot be empty`
+                );
+              }
+              if (!contentItem.mimeType || contentItem.mimeType.trim() === "") {
+                throw new Error(
+                  `User message image content at index ${index} must have a mimeType`
+                );
+              }
+              break;
+            case "audio":
+              if (!contentItem.data || contentItem.data.trim() === "") {
+                throw new Error(
+                  `User message audio content at index ${index} cannot be empty`
+                );
+              }
+              break;
+            default:
+              throw new Error(
+                `User message content item at index ${index} has unsupported type: ${contentItem.type}`
+              );
+          }
+        }
+      } else {
+        throw new Error(
+          "User message content must be a string or array of content objects"
+        );
+      }
+      break;
+    case "assistant":
+      if (!item.content && !item.functionCalls) {
+        throw new Error(
+          "Assistant message must have either content or function calls"
+        );
+      }
+      if (item.content && typeof item.content !== "string") {
+        throw new Error("Assistant message content must be a string");
+      }
+      if (item.functionCalls && !Array.isArray(item.functionCalls)) {
+        throw new Error("Assistant message function calls must be an array");
+      }
+      break;
+    case "function":
+      if (!item.functionId || item.functionId.trim() === "") {
+        throw new Error("Function message must have a non-empty functionId");
+      }
+      if (item.result === void 0 || item.result === null) {
+        throw new Error("Function message must have a result");
+      }
+      if (typeof item.result !== "string") {
+        throw new Error("Function message result must be a string");
+      }
+      break;
+    default:
+      throw new Error(
+        `Unsupported message role: ${item.role}`
+      );
+  }
+}
+function axValidateChatResponseResult(results) {
+  const resultsArray = Array.isArray(results) ? results : [results];
+  if (resultsArray.length === 0) {
+    throw new Error("Chat response results cannot be empty");
+  }
+  for (let arrayIndex = 0; arrayIndex < resultsArray.length; arrayIndex++) {
+    const result = resultsArray[arrayIndex];
+    if (!result) {
+      throw new Error(
+        `Chat response result at index ${arrayIndex} cannot be null or undefined`
+      );
+    }
+    if (typeof result.index !== "number") {
+      throw new Error(
+        `Chat response result at index ${arrayIndex} must have a numeric index`
+      );
+    }
+    if (result.index < 0) {
+      throw new Error(
+        `Chat response result at index ${arrayIndex} must have a non-negative index`
+      );
+    }
+    if (!result.content && !result.thought && !result.functionCalls && !result.finishReason) {
+      throw new Error(
+        `Chat response result at index ${arrayIndex} must have at least one of: content, thought, functionCalls, or finishReason`
+      );
+    }
+    if (result.content !== void 0 && typeof result.content !== "string") {
+      throw new Error(
+        `Chat response result content at index ${arrayIndex} must be a string`
+      );
+    }
+    if (result.thought !== void 0 && typeof result.thought !== "string") {
+      throw new Error(
+        `Chat response result thought at index ${arrayIndex} must be a string`
+      );
+    }
+    if (result.name !== void 0) {
+      if (typeof result.name !== "string") {
+        throw new Error(
+          `Chat response result name at index ${arrayIndex} must be a string`
+        );
+      }
+      if (result.name.trim() === "") {
+        throw new Error(
+          `Chat response result name at index ${arrayIndex} cannot be empty or whitespace-only`
+        );
+      }
+    }
+    if (result.id !== void 0) {
+      if (typeof result.id !== "string") {
+        throw new Error(
+          `Chat response result id at index ${arrayIndex} must be a string`
+        );
+      }
+      if (result.id.trim() === "") {
+        throw new Error(
+          `Chat response result id at index ${arrayIndex} cannot be empty or whitespace-only`
+        );
+      }
+    }
+    if (result.functionCalls !== void 0) {
+      if (!Array.isArray(result.functionCalls)) {
+        throw new Error(
+          `Chat response result functionCalls at index ${arrayIndex} must be an array`
+        );
+      }
+      for (let callIndex = 0; callIndex < result.functionCalls.length; callIndex++) {
+        const functionCall = result.functionCalls[callIndex];
+        if (!functionCall) {
+          throw new Error(
+            `Function call at index ${callIndex} in result ${arrayIndex} cannot be null or undefined`
+          );
+        }
+        if (!functionCall.id || typeof functionCall.id !== "string" || functionCall.id.trim() === "") {
+          throw new Error(
+            `Function call at index ${callIndex} in result ${arrayIndex} must have a non-empty string id`
+          );
+        }
+        if (functionCall.type !== "function") {
+          throw new Error(
+            `Function call at index ${callIndex} in result ${arrayIndex} must have type 'function'`
+          );
+        }
+        if (!functionCall.function) {
+          throw new Error(
+            `Function call at index ${callIndex} in result ${arrayIndex} must have a function object`
+          );
+        }
+        if (!functionCall.function.name || typeof functionCall.function.name !== "string" || functionCall.function.name.trim() === "") {
+          throw new Error(
+            `Function call at index ${callIndex} in result ${arrayIndex} must have a non-empty function name`
+          );
+        }
+        if (functionCall.function.params !== void 0) {
+          if (typeof functionCall.function.params !== "string" && typeof functionCall.function.params !== "object") {
+            throw new Error(
+              `Function call params at index ${callIndex} in result ${arrayIndex} must be a string or object`
+            );
+          }
+        }
+      }
+    }
+    if (result.finishReason !== void 0) {
+      const validFinishReasons = [
+        "stop",
+        "length",
+        "function_call",
+        "content_filter",
+        "error"
+      ];
+      if (!validFinishReasons.includes(result.finishReason)) {
+        throw new Error(
+          `Chat response result finishReason at index ${arrayIndex} must be one of: ${validFinishReasons.join(", ")}`
+        );
+      }
     }
   }
-  addResult({
-    content,
-    name,
-    functionCalls
-  }) {
-    this.addResultMessage({ content, name, functionCalls });
+}
+
+// mem/memory.ts
+var MemoryImpl = class {
+  constructor(options) {
+    this.options = options;
+  }
+  data = [];
+  addRequest(items, index) {
+    this.data.push(
+      ...items.map((item) => {
+        const value = structuredClone(item);
+        return {
+          role: item.role,
+          chat: [{ index, value }]
+        };
+      })
+    );
+    if (this.options?.debug) {
+      debugRequest(items, this.options?.debugHideSystemPrompt);
+    }
+  }
+  addResponse(results) {
+    const chat = results.map((result) => ({
+      index: result.index,
+      value: structuredClone(result)
+    }));
+    this.data.push({
+      role: "assistant",
+      chat
+    });
     if (this.options?.debug) {
-      debugResponse({ content, name, functionCalls });
+      for (const result of results) {
+        debugResponse(result);
+      }
     }
   }
   updateResult({
     content,
     name,
     functionCalls,
-    delta
+    delta,
+    index
   }) {
     const lastItem = this.data.at(-1);
-    if (!lastItem || lastItem.chat.role !== "assistant") {
-      throw new Error("No assistant message to update");
+    const log = () => {
+      if (this.options?.debug) {
+        if (delta && typeof delta === "string") {
+          debugResponseDelta(delta);
+        } else if (!delta && (content || functionCalls)) {
+          debugResponse({ content, name, functionCalls, index });
+        }
+      }
+    };
+    if (!lastItem || lastItem.role !== "assistant") {
+      this.data.push({
+        role: "assistant",
+        chat: [
+          { index, value: structuredClone({ content, name, functionCalls }) }
+        ]
+      });
+      log();
+      return;
     }
-    if (typeof content === "string" && content.trim() !== "") {
-      lastItem.chat.content = content;
+    const chat = lastItem.chat.find((v) => v.index === index);
+    if (!chat) {
+      lastItem.chat.push({
+        index,
+        value: structuredClone({ content, name, functionCalls })
+      });
+      log();
+      return;
     }
-    if (name && name.trim() !== "") {
-      lastItem.chat.name = name;
+    if ("content" in chat.value && typeof content === "string" && content.trim() !== "") {
+      chat.value.content = content;
     }
-    if (functionCalls && functionCalls.length > 0) {
-      lastItem.chat.functionCalls = functionCalls;
+    if ("name" in chat.value && name && name.trim() !== "") {
+      chat.value.name = name;
     }
-    if (this.options?.debug) {
-      if (delta && typeof delta === "string") {
-        debugResponseDelta(delta);
-      } else if (!delta && (content || functionCalls)) {
-        debugResponse({ content, name, functionCalls });
-      }
+    if ("functionCalls" in chat.value && functionCalls && functionCalls.length > 0) {
+      chat.value.functionCalls = functionCalls;
     }
+    log();
   }
   addTag(name) {
     const lastItem = this.data.at(-1);
@@ -5621,8 +6162,7 @@ var MemoryImpl = class {
     if (tagIndex === -1) {
       throw new Error(`Tag "${name}" not found`);
     }
-    const removedItems = this.data.splice(tagIndex);
-    return removedItems.map((item) => item.chat);
+    return this.data.splice(tagIndex);
   }
   removeByTag(name) {
     const indices = this.data.reduce((acc, item, index) => {
@@ -5634,28 +6174,29 @@ var MemoryImpl = class {
     if (indices.length === 0) {
       throw new Error(`No items found with tag "${name}"`);
     }
-    return indices.reverse().map((index) => this.data.splice(index, 1).at(0)?.chat).filter(Boolean).reverse();
+    return indices.reverse().map((index) => this.data.splice(index, 1).at(0)).filter((item) => item !== void 0).reverse();
   }
-  history() {
-    return this.data.map((item) => item.chat);
+  history(index) {
+    const result = [];
+    for (const { role, chat } of this.data) {
+      const value = chat.find((v) => v.index === index)?.value;
+      if (value) {
+        result.push({ role, ...value });
+      }
+    }
+    return result;
   }
   getLast() {
-    const lastItem = this.data.at(-1);
-    if (!lastItem) return void 0;
-    return {
-      chat: lastItem.chat,
-      tags: lastItem.tags
-    };
+    return this.data.at(-1);
   }
   reset() {
     this.data = [];
   }
 };
 var AxMemory = class {
-  constructor(limit = defaultLimit, options) {
-    this.limit = limit;
+  constructor(options) {
     this.options = options;
-    this.defaultMemory = new MemoryImpl(limit, options);
+    this.defaultMemory = new MemoryImpl(options);
   }
   memories = /* @__PURE__ */ new Map();
   defaultMemory;
@@ -5664,15 +6205,34 @@ var AxMemory = class {
       return this.defaultMemory;
     }
     if (!this.memories.has(sessionId)) {
-      this.memories.set(sessionId, new MemoryImpl(this.limit, this.options));
+      this.memories.set(sessionId, new MemoryImpl(this.options));
     }
     return this.memories.get(sessionId);
   }
-  add(value, sessionId) {
-    this.getMemory(sessionId).add(value);
-  }
-  addResult(result, sessionId) {
-    this.getMemory(sessionId).addResult(result);
+  addRequest(value, sessionId) {
+    for (const item of value) {
+      axValidateChatRequestMessage(item);
+    }
+    this.getMemory(sessionId).addRequest(value, 0);
+  }
+  addResponse(results, sessionId) {
+    axValidateChatResponseResult(results);
+    this.getMemory(sessionId).addResponse(results);
+  }
+  addFunctionResult({
+    functionId,
+    isError,
+    index,
+    result
+  }, sessionId) {
+    const functionMessage = {
+      role: "function",
+      functionId,
+      isError,
+      result
+    };
+    axValidateChatRequestMessage(functionMessage);
+    this.getMemory(sessionId).addRequest([functionMessage], index);
   }
   updateResult(result, sessionId) {
     this.getMemory(sessionId).updateResult(result);
@@ -5683,8 +6243,8 @@ var AxMemory = class {
   rewindToTag(name, sessionId) {
     return this.getMemory(sessionId).rewindToTag(name);
   }
-  history(sessionId) {
-    return this.getMemory(sessionId).history();
+  history(index, sessionId) {
+    return this.getMemory(sessionId).history(index);
   }
   getLast(sessionId) {
     return this.getMemory(sessionId).getLast();
@@ -5693,7 +6253,7 @@ var AxMemory = class {
     if (!sessionId) {
       this.defaultMemory.reset();
     } else {
-      this.memories.set(sessionId, new MemoryImpl(this.limit, this.options));
+      this.memories.set(sessionId, new MemoryImpl(this.options));
     }
   }
 };
@@ -5774,86 +6334,236 @@ var assertStreamingAssertions = async (asserts, xstate, content, final = false)
   }
 };
 
-// dsp/datetime.ts
-import moment from "moment-timezone";
-
-// dsp/util.ts
-var colorLog3 = new ColorLog();
-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;
-  const filledBar = colorLog3.blueBright("\u2588".repeat(filledBarLength));
-  const emptyBar = " ".repeat(emptyBarLength);
-  const itemsPerSecond = elapsedTime > 0 ? (current / elapsedTime).toFixed(2) : "0.00";
-  process.stdout.write(
-    `\r${msg}: ${current} / ${total} (${colorLog3.yellow(percentage)}%): 100%|${filledBar}${emptyBar}| Success: ${success}/${total} [${colorLog3.red(elapsedTime.toFixed(2))}, ${itemsPerSecond}it/s]`
-  );
-};
-var validateValue = (field, value) => {
-  const ft = field.type ?? { name: "string", isArray: false };
-  const validateSingleValue = (expectedType, val) => {
-    switch (expectedType) {
-      case "class":
-        return typeof val === "string";
-      case "code":
-        return typeof val === "string";
-      case "string":
-        return typeof val === "string";
-      case "number":
-        return typeof val === "number";
-      case "boolean":
-        return typeof val === "boolean";
-      case "date":
-        return val instanceof Date || typeof val === "string";
-      case "datetime":
-        return val instanceof Date || typeof val === "string";
-      case "json":
-        return typeof val === "object" || typeof val === "string";
-      default:
-        return false;
-    }
-  };
-  const validImage = (val) => {
-    if (!val || typeof val !== "object" || !("mimeType" in val) || !("data" in val)) {
-      return false;
-    }
-    return true;
-  };
-  if (field.type?.name === "image") {
-    let msg;
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (!validImage(item)) {
-          msg = "object ({ mimeType: string; data: string })";
-          break;
-        }
-      }
-    } else if (!validImage(value)) {
-      msg = "object ({ mimeType: string; data: string })";
-    }
-    if (msg) {
-      throw new Error(
-        `Validation failed: Expected '${field.name}' to be type '${msg}' instead got '${value}'`
-      );
-    }
-    return;
+// dsp/errors.ts
+var ValidationError = class extends Error {
+  fields;
+  constructor({
+    message,
+    fields
+  }) {
+    super(message);
+    this.fields = fields;
+    this.name = this.constructor.name;
   }
-  const validAudio = (val) => {
-    if (!val || typeof val !== "object" || !("data" in val)) {
-      return false;
-    }
-    return true;
+  getFixingInstructions = () => {
+    const toFieldType2 = (type) => {
+      const baseType = (() => {
+        switch (type?.name) {
+          case "string":
+            return "string";
+          case "number":
+            return "number";
+          case "boolean":
+            return "boolean";
+          case "date":
+            return 'date ("YYYY-MM-DD" format)';
+          case "datetime":
+            return 'date time ("YYYY-MM-DD HH:mm Timezone" format)';
+          case "json":
+            return "JSON object";
+          case "class":
+            return "classification class";
+          case "code":
+            return "code";
+          default:
+            return "string";
+        }
+      })();
+      return type?.isArray ? `json array of ${baseType} items` : baseType;
+    };
+    return this.fields.map((field) => ({
+      name: "outputError",
+      title: "Output Correction Required",
+      description: `The section labeled '${field.title}' does not match the expected format of '${toFieldType2(field.type)}'. ${this.message} Please revise your response to ensure it conforms to the specified format.`
+    }));
   };
-  if (field.type?.name === "audio") {
-    let msg;
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (!validAudio(item)) {
-          msg = "object ({ data: string; format?: string })";
-          break;
+  toString() {
+    const toFieldType2 = (type) => {
+      const baseType = (() => {
+        switch (type?.name) {
+          case "string":
+            return "string";
+          case "number":
+            return "number";
+          case "boolean":
+            return "boolean";
+          case "date":
+            return 'date ("YYYY-MM-DD" format)';
+          case "datetime":
+            return 'date time ("YYYY-MM-DD HH:mm Timezone" format)';
+          case "json":
+            return "JSON object";
+          case "class":
+            return "classification class";
+          case "code":
+            return "code";
+          default:
+            return "string";
         }
-      }
+      })();
+      return type?.isArray ? `json array of ${baseType} items` : baseType;
+    };
+    return [
+      `${this.name}: ${this.message}`,
+      ...this.fields.map(
+        (field) => `  - ${field.title}: Expected format '${toFieldType2(field.type)}'`
+      )
+    ].join("\n");
+  }
+  [Symbol.for("nodejs.util.inspect.custom")](_depth, _options) {
+    return this.toString();
+  }
+};
+
+// dsp/datetime.ts
+import moment from "moment-timezone";
+function parseLLMFriendlyDate(field, dateStr, required = false) {
+  try {
+    return _parseLLMFriendlyDate(dateStr);
+  } catch (err) {
+    if (field.isOptional && !required) {
+      return;
+    }
+    const message = err.message;
+    throw new ValidationError({ fields: [field], message, value: dateStr });
+  }
+}
+function _parseLLMFriendlyDate(dateStr) {
+  if (!moment(dateStr, "YYYY-MM-DD", true).isValid()) {
+    throw new Error(
+      'Invalid date format. Please provide the date in "YYYY-MM-DD" format.'
+    );
+  }
+  const date = moment.utc(dateStr, "YYYY-MM-DD").startOf("day");
+  return date.toDate();
+}
+function parseLLMFriendlyDateTime(field, dateStr, required = false) {
+  try {
+    return _parseLLMFriendlyDateTime(dateStr);
+  } catch (err) {
+    if (field.isOptional && !required) {
+      return;
+    }
+    const message = err.message;
+    throw new ValidationError({ fields: [field], message, value: dateStr });
+  }
+}
+function _parseLLMFriendlyDateTime(dateTimeStr) {
+  const dateTimeRegex = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?) (.+)$/;
+  const match = dateTimeStr.match(dateTimeRegex);
+  if (!match) {
+    throw new Error(
+      'Invalid date and time format. Please provide the date and time in "YYYY-MM-DD HH:mm" or "YYYY-MM-DD HH:mm:ss" format, followed by the timezone.'
+    );
+  }
+  const [, dateTime, timeZone] = match;
+  if (!dateTime || !timeZone) {
+    throw new Error(
+      'Invalid date and time format. Please provide the date and time in "YYYY-MM-DD HH:mm" or "YYYY-MM-DD HH:mm:ss" format, followed by the timezone.'
+    );
+  }
+  const zone = moment.tz.zone(timeZone);
+  if (!zone) {
+    throw new Error(
+      `Unrecognized time zone ${timeZone}. Please provide a valid time zone name, abbreviation, or offset. For example, "America/New_York", or "EST".`
+    );
+  }
+  const date = moment.tz(
+    dateTime,
+    ["YYYY-MM-DD HH:mm", "YYYY-MM-DD HH:mm:ss"],
+    zone.name
+  );
+  if (!date.isValid()) {
+    throw new Error(
+      "Invalid date and time values. Please ensure all components are correct."
+    );
+  }
+  return date.utc().toDate();
+}
+var formatDateWithTimezone = (date) => {
+  const momentDate = moment(date).utc();
+  return momentDate.format(`YYYY-MM-DD HH:mm:ss UTC`);
+};
+
+// dsp/util.ts
+var colorLog3 = new ColorLog();
+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;
+  const filledBar = colorLog3.blueBright("\u2588".repeat(filledBarLength));
+  const emptyBar = " ".repeat(emptyBarLength);
+  const successRate = total > 0 ? (success / total * 100).toFixed(1) : "0.0";
+  const friendlyMsg = msg.includes("Running MIPROv2 optimization") ? "Testing prompt variations" : msg.includes("Tuning Prompt") ? "Generating training examples" : msg;
+  process.stdout.write(
+    `\u2502  ${friendlyMsg}: ${current}/${total} (${colorLog3.yellow(percentage)}%) |${filledBar}${emptyBar}| Success rate: ${colorLog3.greenBright(successRate)}%
+`
+  );
+};
+var validateValue = (field, value) => {
+  const ft = field.type ?? { name: "string", isArray: false };
+  const validateSingleValue = (expectedType, val) => {
+    switch (expectedType) {
+      case "class":
+        return typeof val === "string";
+      case "code":
+        return typeof val === "string";
+      case "string":
+        return typeof val === "string";
+      case "number":
+        return typeof val === "number";
+      case "boolean":
+        return typeof val === "boolean";
+      case "date":
+        return val instanceof Date || typeof val === "string";
+      case "datetime":
+        return val instanceof Date || typeof val === "string";
+      case "json":
+        return typeof val === "object" || typeof val === "string";
+      default:
+        return false;
+    }
+  };
+  const validImage = (val) => {
+    if (!val || typeof val !== "object" || !("mimeType" in val) || !("data" in val)) {
+      return false;
+    }
+    return true;
+  };
+  if (field.type?.name === "image") {
+    let msg;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (!validImage(item)) {
+          msg = "object ({ mimeType: string; data: string })";
+          break;
+        }
+      }
+    } else if (!validImage(value)) {
+      msg = "object ({ mimeType: string; data: string })";
+    }
+    if (msg) {
+      throw new Error(
+        `Validation failed: Expected '${field.name}' to be type '${msg}' instead got '${value}'`
+      );
+    }
+    return;
+  }
+  const validAudio = (val) => {
+    if (!val || typeof val !== "object" || !("data" in val)) {
+      return false;
+    }
+    return true;
+  };
+  if (field.type?.name === "audio") {
+    let msg;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (!validAudio(item)) {
+          msg = "object ({ data: string; format?: string })";
+          break;
+        }
+      }
     } else if (!validAudio(value)) {
       msg = "object ({ data: string; format?: string })";
     }
@@ -5936,18 +6646,24 @@ var parseMarkdownList = (input) => {
   }
   return list;
 };
-function mergeDeltas(base, delta) {
+function mergeDeltas(base, currentDelta) {
+  const { index, delta, version } = currentDelta;
+  const target = base.find((b) => b.index === index)?.delta;
+  if (!target) {
+    base.push({ index, delta, version });
+    return base;
+  }
   for (const key of Object.keys(delta)) {
-    const baseValue = base[key];
+    const baseValue = target[key];
     const deltaValue = delta[key];
     if (baseValue === void 0 && Array.isArray(deltaValue)) {
-      base[key] = [...deltaValue];
+      target[key] = [...deltaValue];
     } else if (Array.isArray(baseValue) && Array.isArray(deltaValue)) {
-      base[key] = [...baseValue ?? [], ...deltaValue];
+      target[key] = [...baseValue, ...deltaValue];
     } else if ((baseValue === void 0 || typeof baseValue === "string") && typeof deltaValue === "string") {
-      base[key] = (baseValue ?? "") + deltaValue;
+      target[key] = `${baseValue ?? ""}${deltaValue}`;
     } else {
-      base[key] = deltaValue;
+      target[key] = deltaValue;
     }
   }
   return base;
@@ -5994,19 +6710,15 @@ function matchesContent(content, prefix, startIndex = 0, prefixCache = globalPre
   if (!prefixCache.get(prefix)) {
     prefixCache.set(prefix, prefixes);
   }
-  const contentEnd = content.slice(
-    Math.max(startIndex, content.length - prefix.length)
-  );
-  for (let i = 0; i < prefixes.length - 1; i++) {
+  let longestPartialMatch = -1;
+  for (let i = prefixes.length - 1; i >= 0; i--) {
     const partialPrefix = prefixes[i];
-    if (partialPrefix === "\n" || partialPrefix === ":") {
-      continue;
-    }
-    if (partialPrefix && contentEnd.endsWith(partialPrefix)) {
-      return -2;
+    if (content.endsWith(partialPrefix)) {
+      longestPartialMatch = i;
+      break;
     }
   }
-  return -1;
+  return longestPartialMatch >= 0 ? -2 : -1;
 }
 var formatTime = (ms) => {
   const seconds = Math.floor(ms / 1e3);
@@ -6029,11 +6741,10 @@ var updateDetailedProgress = (roundIndex, current, total, elapsedTime, example,
   process.stdout.write("\r\x1B[K");
   const percentage = (current / total * 100).toFixed(1);
   const formattedTime = formatTime(elapsedTime);
-  const itemsPerSecond = elapsedTime > 0 ? (current / elapsedTime * 1e3).toFixed(2) : "0.00";
   const eta = calculateETA(current, total, elapsedTime);
-  let output = `Round ${roundIndex + 1}/${configInfo.maxRounds}: ${current}/${total} (${percentage}%) [${formattedTime}, ${itemsPerSecond} it/s, ETA: ${eta}]`;
+  let output = `Training round ${roundIndex + 1}/${configInfo.maxRounds}: ${current}/${total} (${percentage}%) [${formattedTime}, ETA: ${eta}]`;
   const successRate = stats.totalCalls > 0 ? stats.successfulDemos / stats.totalCalls * 100 : 0;
-  output += ` | Success: ${stats.successfulDemos}/${stats.totalCalls} (${successRate.toFixed(1)}%)`;
+  output += ` | Success rate: ${successRate.toFixed(1)}% (${stats.successfulDemos}/${stats.totalCalls})`;
   if (configInfo.verboseMode || configInfo.debugMode) {
     if (configInfo.costMonitoring) {
       output += `
@@ -6069,913 +6780,365 @@ var updateDetailedProgress = (roundIndex, current, total, elapsedTime, example,
   console.log(output);
 };
 
-// dsp/prompt.ts
-var functionCallInstructions = `
-## Function Call Instructions
-- Complete the task, using the functions defined earlier in this prompt. 
-- Call functions step-by-step, using the output of one function as input to the next.
-- Use the function results to generate the output fields.`;
-var formattingRules = `
-## Strict Output Formatting Rules
-- Output must strictly follow the defined plain-text \`field name: value\` field format.
-- Output field, values must strictly adhere to the specified output field formatting rules.
-- Do not add any text before or after the output fields, just the field name and value.
-- Do not use code blocks.`;
-var AxPromptTemplate = class {
-  sig;
-  fieldTemplates;
-  task;
-  thoughtFieldName;
-  functions;
-  constructor(sig, options, fieldTemplates) {
-    this.sig = sig;
-    this.fieldTemplates = fieldTemplates;
-    this.thoughtFieldName = options?.thoughtFieldName ?? "thought";
-    this.functions = options?.functions;
-    const task = [];
-    const inArgs = renderDescFields(this.sig.getInputFields());
-    const outArgs = renderDescFields(this.sig.getOutputFields());
-    task.push(
-      `You will be provided with the following fields: ${inArgs}. Your task is to generate new fields: ${outArgs}.`
-    );
-    const funcs = this.functions?.map((f2) => "toFunction" in f2 ? f2.toFunction() : f2)?.flat();
-    const funcList = funcs?.map((fn) => `- \`${fn.name}\`: ${formatDescription(fn.description)}`).join("\n");
-    if (funcList && funcList.length > 0) {
-      task.push(`## Available Functions
-${funcList}`);
-    }
-    const inputFields = renderInputFields(this.sig.getInputFields());
-    task.push(`## Input Fields
-${inputFields}`);
-    const outputFields = renderOutputFields(this.sig.getOutputFields());
-    task.push(`## Output Fields
-${outputFields}`);
-    if (funcList && funcList.length > 0) {
-      task.push(functionCallInstructions.trim());
-    }
-    task.push(formattingRules.trim());
-    const desc = this.sig.getDescription();
-    if (desc) {
-      const text = formatDescription(desc);
-      task.push(text);
+// dsp/extract.ts
+var extractValues = (sig, values, content, strictMode = false) => {
+  const xstate = { extractedFields: [], streamedIndex: {}, s: -1 };
+  streamingExtractValues(sig, values, xstate, content, { strictMode });
+  streamingExtractFinalValue(sig, values, xstate, content);
+  for (const field of sig.getOutputFields()) {
+    if (field.isInternal) {
+      delete values[field.name];
     }
-    this.task = {
-      type: "text",
-      text: task.join("\n\n")
-    };
   }
-  renderSingleValueUserContent = (values, renderedExamples, renderedDemos, examplesInSystemPrompt) => {
-    const completion = this.renderInputFields(values);
-    const promptList = examplesInSystemPrompt ? completion : [...renderedExamples, ...renderedDemos, ...completion];
-    const prompt = promptList.filter((v) => v !== void 0);
-    return prompt.every((v) => v.type === "text") ? prompt.map((v) => v.text).join("\n") : prompt.reduce(combineConsecutiveStrings("\n"), []);
-  };
-  render = (values, {
-    examples,
-    demos
-  }) => {
-    const renderedExamples = examples ? [
-      { type: "text", text: "\n\n## Examples\n" },
-      ...this.renderExamples(examples)
-    ] : [];
-    const renderedDemos = demos ? this.renderDemos(demos) : [];
-    const allTextExamples = renderedExamples.every((v) => v.type === "text");
-    const allTextDemos = renderedDemos.every((v) => v.type === "text");
-    const examplesInSystemPrompt = allTextExamples && allTextDemos;
-    let systemContent = this.task.text;
-    if (examplesInSystemPrompt) {
-      const combinedItems = [
-        { type: "text", text: systemContent },
-        ...renderedExamples,
-        ...renderedDemos
-      ];
-      combinedItems.reduce(combineConsecutiveStrings(""), []);
-      if (combinedItems && combinedItems[0]) {
-        systemContent = combinedItems[0].text;
-      }
+};
+var checkMissingRequiredFields = (xstate, values, outputFields) => {
+  const missingFields = [];
+  for (const field of outputFields) {
+    if (field && !field.isOptional && values[field.name] === void 0) {
+      missingFields.push(field);
     }
-    const systemPrompt = {
-      role: "system",
-      content: systemContent
-    };
-    if (Array.isArray(values)) {
-      let userMessages = [];
-      const history = values;
-      for (const [index, message] of history.entries()) {
-        let content;
-        if (index === 0) {
-          content = this.renderSingleValueUserContent(
-            message.values,
-            renderedExamples,
-            renderedDemos,
-            examplesInSystemPrompt
-          );
-        } else {
-          content = this.renderSingleValueUserContent(
-            message.values,
-            [],
-            [],
-            false
-          );
-        }
-        if (message.role === "user") {
-          userMessages.push({ role: "user", content });
+  }
+  if (missingFields.length > 0) {
+    throw new ValidationError({
+      message: `Required ${missingFields.length === 1 ? "field" : "fields"} not found`,
+      fields: missingFields
+    });
+  }
+};
+var streamingExtractValues = (sig, values, xstate, content, { strictMode, skipEarlyFail } = {}) => {
+  const fields = sig.getOutputFields();
+  let expectedField;
+  for (const [index, field] of fields.entries()) {
+    if (index === xstate.currFieldIndex && !xstate.inAssumedField) {
+      continue;
+    }
+    if (field.name in values && !(index === xstate.currFieldIndex && xstate.inAssumedField)) {
+      continue;
+    }
+    const isFirst = xstate.extractedFields.length === 0;
+    const prefix = (isFirst ? "" : "\n") + field.title + ":";
+    let e = matchesContent(content, prefix, xstate.s);
+    let prefixLen = prefix.length;
+    switch (e) {
+      case -1:
+        if (skipEarlyFail) {
           continue;
         }
-        if (message.role !== "assistant") {
-          throw new Error("Invalid message role");
+        if (!strictMode && fields.length === 1 && xstate.currField === void 0) {
+          xstate.inAssumedField = true;
+          expectedField = field;
+          prefixLen = 0;
+          e = 0;
+          break;
         }
-        if (typeof content !== "string") {
-          throw new Error(
-            "Assistant message cannot contain non-text content like images, files,etc"
-          );
+        if (xstate.currField === void 0 && !field.isOptional) {
+          throw new ValidationError({
+            message: "Expected (Required) field not found",
+            fields: [field]
+          });
         }
-        userMessages.push({ role: "assistant", content });
-      }
-      return [systemPrompt, ...userMessages];
+        expectedField = field.isOptional ? void 0 : field;
+        continue;
+      // Field is not found, continue to the next field
+      case -2:
+        return true;
+      // Partial match at end, skip and gather more content
+      case -3:
+        return true;
+      // String is only whitespace, skip and gather more content
+      case -4:
+        xstate.inBlock = true;
+        return true;
     }
-    const userContent = this.renderSingleValueUserContent(
-      values,
-      renderedExamples,
-      renderedDemos,
-      examplesInSystemPrompt
-    );
-    return [systemPrompt, { role: "user", content: userContent }];
-  };
-  renderExtraFields = (extraFields) => {
-    const prompt = [];
-    if (!extraFields || extraFields.length === 0) {
-      return prompt;
+    if (expectedField && expectedField.name !== field.name) {
+      throw new ValidationError({
+        message: "Expected (Required) field not found",
+        fields: [expectedField]
+      });
     }
-    const groupedFields = extraFields.reduce(
-      (acc, field) => {
-        const title = field.title;
-        if (!acc[title]) {
-          acc[title] = [];
-        }
-        acc[title].push(field);
-        return acc;
-      },
-      {}
-    );
-    const formattedGroupedFields = Object.entries(groupedFields).map(([title, fields]) => {
-      if (fields.length === 1) {
-        const field = fields[0];
-        return {
-          title,
-          name: field.name,
-          description: field.description
-        };
-      } else if (fields.length > 1) {
-        const valuesList = fields.map((field) => `- ${field.description}`).join("\n");
-        return {
-          title,
-          name: fields[0].name,
-          description: valuesList
-        };
+    if (xstate.currField !== void 0 && xstate.inAssumedField) {
+      xstate.inAssumedField = false;
+      xstate.streamedIndex[xstate.currField.name] = 0;
+      xstate.currField = void 0;
+    }
+    if (xstate.currField) {
+      const val = content.substring(xstate.s, e).trim();
+      const parsedValue = validateAndParseFieldValue(xstate.currField, val);
+      if (parsedValue !== void 0) {
+        values[xstate.currField.name] = parsedValue;
       }
-    }).filter(Boolean);
-    formattedGroupedFields.forEach((field) => {
-      const fn = this.fieldTemplates?.[field.name] ?? this.defaultRenderInField;
-      prompt.push(...fn(field, field.description));
-    });
-    return prompt;
-  };
-  renderExamples = (data) => {
-    const list = [];
-    const exampleContext = {
-      isExample: true
-    };
-    for (const [index, item] of data.entries()) {
-      const renderedInputItem = this.sig.getInputFields().map(
-        (field) => this.renderInField(field, item, {
-          ...exampleContext,
-          isInputField: true
-        })
-      ).filter((v) => v !== void 0).flat();
-      const renderedOutputItem = this.sig.getOutputFields().map(
-        (field) => this.renderInField(field, item, {
-          ...exampleContext,
-          isInputField: false
-        })
-      ).filter((v) => v !== void 0).flat();
-      const renderedItem = [...renderedInputItem, ...renderedOutputItem];
-      if (index > 0 && renderedItem.length > 0 && renderedItem[0]?.type === "text") {
-        list.push({ type: "text", text: "---\n\n" });
+      if (xstate.prevFields) {
+        xstate.prevFields?.push({ field: xstate.currField, s: xstate.s, e });
+      } else {
+        xstate.prevFields = [{ field: xstate.currField, s: xstate.s, e }];
       }
-      renderedItem.forEach((v) => {
-        if ("text" in v) {
-          v.text = v.text + "\n";
-        }
-        list.push(v);
-      });
     }
-    return list;
-  };
-  renderDemos = (data) => {
-    const list = [];
-    const inputFields = this.sig.getInputFields();
-    const outputFields = this.sig.getOutputFields();
-    const demoContext = {
-      isExample: true
-    };
-    for (const item of data) {
-      const inputRenderedItems = inputFields.map(
-        (field) => this.renderInField(field, item, {
-          ...demoContext,
-          isInputField: true
-        })
-      ).filter((v) => v !== void 0).flat();
-      const outputRenderedItems = outputFields.map(
-        (field) => this.renderInField(field, item, {
-          ...demoContext,
-          isInputField: false
-        })
-      ).filter((v) => v !== void 0).flat();
-      const renderedItem = [...inputRenderedItems, ...outputRenderedItems];
-      renderedItem.slice(0, -1).forEach((v) => {
-        if ("text" in v) {
-          v.text = v.text + "\n";
-        }
-        list.push(v);
-      });
+    xstate.s = e + prefixLen;
+    xstate.currField = field;
+    xstate.currFieldIndex = index;
+    if (!xstate.extractedFields.includes(field)) {
+      xstate.extractedFields.push(field);
     }
-    return list;
-  };
-  renderInputFields = (values) => {
-    const renderedItems = this.sig.getInputFields().map((field) => this.renderInField(field, values, void 0)).filter((v) => v !== void 0).flat();
-    renderedItems.filter((v) => v.type === "text").forEach((v) => {
-      v.text = v.text + "\n";
-    });
-    return renderedItems;
-  };
-  renderInField = (field, values, context3) => {
-    const value = values[field.name];
-    if (isEmptyValue(field, value, context3)) {
-      return;
+    if (xstate.streamedIndex[field.name] === void 0) {
+      xstate.streamedIndex[field.name] = 0;
     }
-    if (field.type) {
-      validateValue(field, value);
+  }
+};
+var streamingExtractFinalValue = (sig, values, xstate, content) => {
+  if (xstate.currField) {
+    let val = content.substring(xstate.s).trim();
+    const parsedValue = validateAndParseFieldValue(xstate.currField, val);
+    if (parsedValue !== void 0) {
+      values[xstate.currField.name] = parsedValue;
     }
-    const processedValue = processValue(field, value);
-    const textFieldFn = this.fieldTemplates?.[field.name] ?? this.defaultRenderInField;
-    return textFieldFn(field, processedValue);
-  };
-  defaultRenderInField = (field, value) => {
-    if (field.type?.name === "image") {
-      const validateImage = (value2) => {
-        if (!value2) {
-          throw new Error("Image field value is required.");
-        }
-        if (typeof value2 !== "object") {
-          throw new Error("Image field value must be an object.");
-        }
-        if (!("mimeType" in value2)) {
-          throw new Error("Image field must have mimeType");
+  }
+  checkMissingRequiredFields(xstate, values, sig.getOutputFields());
+};
+var convertValueToType = (field, val, required = false) => {
+  switch (field.type?.name) {
+    case "code":
+      return extractBlock(val);
+    case "string":
+      return val;
+    case "number": {
+      const v = Number(val);
+      if (Number.isNaN(v)) {
+        if (field.isOptional && !required) {
+          return;
         }
-        if (!("data" in value2)) {
-          throw new Error("Image field must have data");
+        throw new Error("Invalid number");
+      }
+      return v;
+    }
+    case "boolean": {
+      if (typeof val === "boolean") {
+        return val;
+      }
+      const v = val.toLowerCase();
+      if (v === "true") {
+        return true;
+      } else if (v === "false") {
+        return false;
+      } else {
+        if (field.isOptional && !required) {
+          return;
         }
-        return value2;
-      };
-      let result = [
-        { type: "text", text: `${field.title}: ` }
-      ];
-      if (field.type.isArray) {
-        if (!Array.isArray(value)) {
-          throw new Error("Image field value must be an array.");
-        }
-        result = result.concat(
-          value.map((v) => {
-            const validated = validateImage(v);
-            return {
-              type: "image",
-              mimeType: validated.mimeType,
-              image: validated.data
-            };
-          })
-        );
-      } else {
-        const validated = validateImage(value);
-        result.push({
-          type: "image",
-          mimeType: validated.mimeType,
-          image: validated.data
-        });
+        throw new Error("Invalid boolean");
       }
-      return result;
     }
-    if (field.type?.name === "audio") {
-      const validateAudio = (value2) => {
-        if (!value2) {
-          throw new Error("Audio field value is required.");
-        }
-        if (typeof value2 !== "object") {
-          throw new Error("Audio field value must be an object.");
-        }
-        if (!("data" in value2)) {
-          throw new Error("Audio field must have data");
-        }
-        return value2;
-      };
-      let result = [
-        { type: "text", text: `${field.title}: ` }
-      ];
-      if (field.type.isArray) {
-        if (!Array.isArray(value)) {
-          throw new Error("Audio field value must be an array.");
+    case "date":
+      return parseLLMFriendlyDate(field, val, required);
+    case "datetime":
+      return parseLLMFriendlyDateTime(field, val, required);
+    case "class":
+      const className = val;
+      if (field.type.options && !field.type.options.includes(className)) {
+        if (field.isOptional) {
+          return;
         }
-        result = result.concat(
-          value.map((v) => {
-            const validated = validateAudio(v);
-            return {
-              type: "audio",
-              format: validated.format ?? "wav",
-              data: validated.data
-            };
-          })
+        throw new Error(
+          `Invalid class '${val}', expected one of the following: ${field.type.options.join(", ")}`
         );
-      } else {
-        const validated = validateAudio(value);
-        result.push({
-          type: "audio",
-          format: validated.format ?? "wav",
-          data: validated.data
-        });
-      }
-      return result;
-    }
-    const text = [field.title, ": "];
-    if (Array.isArray(value)) {
-      text.push("\n");
-      text.push(value.map((v) => `- ${v}`).join("\n"));
-    } else {
-      text.push(value);
-    }
-    return [{ type: "text", text: text.join("") }];
-  };
-};
-var renderDescFields = (list) => list.map((v) => `\`${v.title}\``).join(", ");
-var renderInputFields = (fields) => {
-  const rows = fields.map((field) => {
-    const name = field.title;
-    const type = field.type?.name ? toFieldType(field.type) : "string";
-    const requiredMsg = field.isOptional ? `This optional ${type} field may be omitted` : `A ${type} field`;
-    const description = field.description ? ` ${formatDescription(field.description)}` : "";
-    return `${name}: (${requiredMsg})${description}`.trim();
-  });
-  return rows.join("\n");
-};
-var renderOutputFields = (fields) => {
-  const rows = fields.map((field) => {
-    const name = field.title;
-    const type = field.type?.name ? toFieldType(field.type) : "string";
-    const requiredMsg = field.isOptional ? `Only include this ${type} field if its value is available` : `This ${type} field must be included`;
-    let description = "";
-    if (field.description && field.description.length > 0) {
-      const value = field.type?.name === "class" ? field.description : formatDescription(field.description);
-      description = ` ${value}`;
-    }
-    if (field.type?.options && field.type.options.length > 0) {
-      if (description.length > 0) {
-        description += `. `;
       }
-      description += `Allowed values: ${field.type.options.join(", ")}`;
-    }
-    return `${name}: (${requiredMsg})${description}`.trim();
-  });
-  return rows.join("\n");
+      return className;
+    default:
+      return val;
+  }
 };
-var processValue = (field, value) => {
-  if (field.type?.name === "date" && value instanceof Date) {
-    const v = value.toISOString();
-    return v.slice(0, v.indexOf("T"));
+function* yieldDelta(content, field, s2, e, xstate, index) {
+  const { name: fieldName, isInternal } = field;
+  const { isArray: fieldIsArray, name: fieldTypeName } = field.type ?? {};
+  if (isInternal || fieldIsArray || fieldTypeName && fieldTypeName !== "string" && fieldTypeName !== "code") {
+    return;
   }
-  if (field.type?.name === "datetime" && value instanceof Date) {
-    return formatDateWithTimezone(value);
+  const pos = xstate.streamedIndex[fieldName] ?? 0;
+  const isFirstChunk = pos === 0;
+  const d1 = content.substring(s2 + pos, e);
+  if (d1.length === 0) {
+    return;
   }
-  if (field.type?.name === "image" && typeof value === "object") {
-    return value;
+  let d2 = d1.replace(/\s+$/, "");
+  if (xstate.currField?.type?.name === "code") {
+    d2 = d2.replace(/\s*```\s*$/, "");
   }
-  if (field.type?.name === "audio" && typeof value === "object") {
-    return value;
+  let d3 = isFirstChunk ? d2.trimStart() : d2;
+  if (xstate.currField?.type?.name === "code") {
+    d3 = d3.replace(/^[ ]*```[a-zA-Z0-9]*\n\s*/, "");
   }
-  if (typeof value === "string") {
-    return value;
+  if (d3.length > 0) {
+    yield { index, delta: { [fieldName]: d3 } };
+    xstate.streamedIndex[fieldName] = pos + d2.length;
   }
-  return JSON.stringify(value, null, 2);
-};
-var toFieldType = (type) => {
-  const baseType = (() => {
-    switch (type?.name) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "boolean":
-        return "boolean";
-      case "date":
-        return 'date ("YYYY-MM-DD" format)';
-      case "datetime":
-        return 'date time ("YYYY-MM-DD HH:mm Timezone" format)';
-      case "json":
-        return "JSON object";
-      case "class":
-        return "classification class";
-      case "code":
-        return "code";
-      default:
-        return "string";
-    }
-  })();
-  return type?.isArray ? `json array of ${baseType} items` : baseType;
-};
-function combineConsecutiveStrings(separator) {
-  return (acc, current) => {
-    if (current.type === "text") {
-      const previous = acc.length > 0 ? acc[acc.length - 1] : null;
-      if (previous && previous.type === "text") {
-        previous.text += separator + current.text;
-      } else {
-        acc.push(current);
-      }
-    } else {
-      acc.push(current);
-    }
-    return acc;
-  };
 }
-var isEmptyValue = (field, value, context3) => {
-  if (typeof value === "boolean") {
-    return false;
+function* streamValues(sig, content, values, xstate, index) {
+  for (const prevField of xstate.prevFields ?? []) {
+    const { field, s: s2, e } = prevField;
+    yield* yieldDelta(content, field, s2, e, xstate, index);
   }
-  if (!value || (Array.isArray(value) || typeof value === "string") && value.length === 0) {
-    if (context3?.isExample) {
-      return true;
+  xstate.prevFields = void 0;
+  if (!xstate.currField || xstate.currField.isInternal) {
+    return;
+  }
+  yield* yieldDelta(
+    content,
+    xstate.currField,
+    xstate.s,
+    content.length,
+    xstate,
+    index
+  );
+  const outputFields = sig.getOutputFields();
+  for (const key of Object.keys(values)) {
+    const field = outputFields.find((f2) => f2.name === key);
+    if (!field || field.isInternal) {
+      continue;
     }
-    if (field.isOptional || field.isInternal) {
-      return true;
+    const value = values[key];
+    if (Array.isArray(value)) {
+      const s2 = xstate.streamedIndex?.[key] ?? 0;
+      const v = value.slice(s2);
+      if (v && v.length > 0) {
+        yield { index, delta: { [key]: v } };
+        xstate.streamedIndex[key] = s2 + v.length;
+      }
+      continue;
+    }
+    if (!xstate.streamedIndex[key]) {
+      yield { index, delta: { [key]: value } };
+      xstate.streamedIndex[key] = 1;
     }
-    const fieldType = context3?.isInputField !== false ? "input" : "output";
-    throw new Error(`Value for ${fieldType} field '${field.name}' is required.`);
   }
-  return false;
-};
-function formatDescription(str) {
-  const value = str.trim();
-  return value.length > 0 ? `${value.charAt(0).toUpperCase()}${value.slice(1)}${value.endsWith(".") ? "" : "."}` : "";
 }
-
-// dsp/validate.ts
-var ValidationError = class extends Error {
-  fields;
-  constructor({
-    message,
-    fields
-  }) {
-    super(message);
-    this.fields = fields;
-    this.name = this.constructor.name;
+function validateAndParseFieldValue(field, fieldValue) {
+  if (!fieldValue || fieldValue === "" || /^(null|undefined)\s*$/i.test(fieldValue)) {
+    if (field.isOptional) {
+      return;
+    }
+    throw new ValidationError({
+      message: "Required field is missing",
+      fields: [field],
+      value: fieldValue
+    });
   }
-  getFixingInstructions = () => {
-    return this.fields.map((field) => ({
-      name: "outputError",
-      title: "Output Correction Required",
-      description: `The section labeled '${field.title}' either was not generated by the LLM or does not match the expected format of '${toFieldType(field.type)}'. ${this.message} Please revise your response to ensure it conforms to the specified format.`
-    }));
-  };
-  toString() {
-    return [
-      `${this.name}: ${this.message}`,
-      ...this.fields.map(
-        (field) => `  - ${field.title}: Expected format '${toFieldType(field.type)}'`
-      )
-    ].join("\n");
-  }
-  [Symbol.for("nodejs.util.inspect.custom")](_depth, _options) {
-    return this.toString();
-  }
-};
-function handleValidationError(mem, errorFields, ai, promptTemplate, sessionId) {
-  mem.add(
-    {
-      role: "user",
-      content: promptTemplate.renderExtraFields(errorFields)
-    },
-    sessionId
-  );
-  mem.addTag("error");
-  if (ai.getOptions().debug) {
-    const errors = errorFields.map((field) => `- ${field.title}: ${field.description}`).join("\n");
-    const logger = ai.getLogger();
-    logger(`\u274C Error Correction:
-${errors}`, {
-      tags: ["error"]
-    });
-  }
-}
-
-// dsp/datetime.ts
-function parseLLMFriendlyDate(field, dateStr, required = false) {
-  try {
-    return _parseLLMFriendlyDate(dateStr);
-  } catch (err) {
-    if (field.isOptional && !required) {
-      return;
+  let value;
+  if (field.type?.name === "json") {
+    try {
+      const text = extractBlock(fieldValue);
+      value = JSON.parse(text);
+      return value;
+    } catch (e) {
+      throw new ValidationError({
+        message: "Invalid JSON: " + e.message,
+        fields: [field],
+        value: fieldValue
+      });
     }
-    const message = err.message;
-    throw new ValidationError({ fields: [field], message, value: dateStr });
   }
-}
-function _parseLLMFriendlyDate(dateStr) {
-  if (!moment(dateStr, "YYYY-MM-DD", true).isValid()) {
-    throw new Error(
-      'Invalid date format. Please provide the date in "YYYY-MM-DD" format.'
-    );
+  if (field.type?.isArray) {
+    try {
+      try {
+        value = JSON.parse(fieldValue);
+      } catch {
+        value = parseMarkdownList(fieldValue);
+      }
+      if (!Array.isArray(value)) {
+        throw new Error("Expected an array");
+      }
+    } catch (e) {
+      throw new ValidationError({
+        message: "Invalid Array: " + e.message,
+        fields: [field],
+        value: fieldValue
+      });
+    }
   }
-  const date = moment.utc(dateStr, "YYYY-MM-DD").startOf("day");
-  return date.toDate();
-}
-function parseLLMFriendlyDateTime(field, dateStr, required = false) {
   try {
-    return _parseLLMFriendlyDateTime(dateStr);
-  } catch (err) {
-    if (field.isOptional && !required) {
-      return;
+    if (Array.isArray(value)) {
+      for (const [index, item] of value.entries()) {
+        if (item !== void 0) {
+          const v = typeof item === "string" ? item.trim() : item;
+          value[index] = convertValueToType(field, v, true);
+        }
+      }
+    } else {
+      value = convertValueToType(field, fieldValue);
     }
-    const message = err.message;
-    throw new ValidationError({ fields: [field], message, value: dateStr });
+  } catch (e) {
+    throw new ValidationError({
+      message: e.message,
+      fields: [field],
+      value: fieldValue
+    });
+  }
+  if (typeof value === "string" && value === "") {
+    return void 0;
   }
+  return value;
 }
-function _parseLLMFriendlyDateTime(dateTimeStr) {
-  const dateTimeRegex = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?) (.+)$/;
-  const match = dateTimeStr.match(dateTimeRegex);
+var extractBlock = (input) => {
+  const markdownBlockPattern = /```([A-Za-z]*)\n([\s\S]*?)\n```/g;
+  const match = markdownBlockPattern.exec(input);
   if (!match) {
-    throw new Error(
-      'Invalid date and time format. Please provide the date and time in "YYYY-MM-DD HH:mm" or "YYYY-MM-DD HH:mm:ss" format, followed by the timezone.'
-    );
-  }
-  const [, dateTime, timeZone] = match;
-  if (!dateTime || !timeZone) {
-    throw new Error(
-      'Invalid date and time format. Please provide the date and time in "YYYY-MM-DD HH:mm" or "YYYY-MM-DD HH:mm:ss" format, followed by the timezone.'
-    );
+    return input;
   }
-  const zone = moment.tz.zone(timeZone);
-  if (!zone) {
-    throw new Error(
-      `Unrecognized time zone ${timeZone}. Please provide a valid time zone name, abbreviation, or offset. For example, "America/New_York", or "EST".`
-    );
+  if (match.length === 3) {
+    return match[2];
   }
-  const date = moment.tz(
-    dateTime,
-    ["YYYY-MM-DD HH:mm", "YYYY-MM-DD HH:mm:ss"],
-    zone.name
-  );
-  if (!date.isValid()) {
-    throw new Error(
-      "Invalid date and time values. Please ensure all components are correct."
-    );
+  if (match.length === 2) {
+    return match[1];
   }
-  return date.utc().toDate();
-}
-var formatDateWithTimezone = (date) => {
-  const momentDate = moment(date).utc();
-  return momentDate.format(`YYYY-MM-DD HH:mm:ss UTC`);
+  return input;
 };
 
-// dsp/extract.ts
-var extractValues = (sig, values, content) => {
-  const xstate = { extractedFields: [], streamedIndex: {}, s: -1 };
-  streamingExtractValues(sig, values, xstate, content);
-  streamingExtractFinalValue(sig, values, xstate, content);
-  for (const field of sig.getOutputFields()) {
-    if (field.isInternal) {
-      delete values[field.name];
-    }
-  }
-};
-var checkMissingRequiredFields = (xstate, values, currentIndex) => {
-  const missingFields = [];
-  for (let i = 0; i < currentIndex; i++) {
-    const field = xstate.extractedFields[i];
-    if (field && !field.isOptional && values[field.name] === void 0) {
-      missingFields.push(field);
+// dsp/fieldProcessor.ts
+async function processFieldProcessors(fieldProcessors, values, mem, sessionId) {
+  for (const processor of fieldProcessors) {
+    if (values[processor.field.name] === void 0) {
+      continue;
     }
-  }
-  if (missingFields.length > 0) {
-    throw new ValidationError({
-      message: `Required ${missingFields.length === 1 ? "field" : "fields"} not found`,
-      fields: missingFields
+    const processFn = processor.process;
+    const result = await processFn(values[processor.field.name], {
+      sessionId,
+      values,
+      done: true
     });
+    addToMemory(processor.field, mem, result, sessionId);
   }
-};
-var streamingExtractValues = (sig, values, xstate, content, streamingValidation = false) => {
-  const fields = sig.getOutputFields();
-  for (const [index, field] of fields.entries()) {
-    if (field.name in values) {
+}
+async function processStreamingFieldProcessors(fieldProcessors, content, xstate, mem, values, sessionId, done = false) {
+  for (const processor of fieldProcessors) {
+    if (xstate.currField?.name !== processor.field.name) {
       continue;
     }
-    const isFirst = xstate.extractedFields.length === 0;
-    const prefix = (isFirst ? "" : "\n") + field.title + ":";
-    let e = matchesContent(content, prefix, xstate.s);
-    switch (e) {
-      case -1:
-        if (streamingValidation && values.length == 0 && !field.isOptional) {
-          throw new ValidationError({
-            message: "Required field not found",
-            fields: [field]
-          });
-        }
-        continue;
-      // Field is not found, continue to the next field
-      case -2:
-        return true;
-      // Partial match at end, skip and gather more content
-      case -3:
-        return true;
-      // String is only whitespace, skip and gather more content
-      case -4:
-        xstate.inBlock = true;
-        return true;
-    }
-    let prefixLen = prefix.length;
-    if (xstate.currField) {
-      const val = content.substring(xstate.s, e).trim();
-      const parsedValue = validateAndParseFieldValue(xstate.currField, val);
-      if (parsedValue !== void 0) {
-        values[xstate.currField.name] = parsedValue;
-      }
-      if (xstate.prevFields) {
-        xstate.prevFields?.push({ field: xstate.currField, s: xstate.s, e });
-      } else {
-        xstate.prevFields = [{ field: xstate.currField, s: xstate.s, e }];
-      }
-    }
-    checkMissingRequiredFields(xstate, values, index);
-    xstate.s = e + prefixLen;
-    xstate.currField = field;
-    xstate.currFieldIndex = index;
-    if (!xstate.extractedFields.includes(field)) {
-      xstate.extractedFields.push(field);
-    }
-    if (xstate.streamedIndex[field.name] === void 0) {
-      xstate.streamedIndex[field.name] = 0;
+    let value = content.substring(xstate.s);
+    if (xstate.currField?.type?.name === "code") {
+      value = value.replace(/^[ ]*```[a-zA-Z0-9]*\n\s*/, "");
+      value = value.replace(/\s*```\s*$/, "");
     }
+    const processFn = processor.process;
+    const result = await processFn(value, {
+      sessionId,
+      values,
+      done
+    });
+    addToMemory(xstate.currField, mem, result, sessionId);
   }
-};
-var streamingExtractFinalValue = (sig, values, xstate, content) => {
-  if (xstate.currField) {
-    let val = content.substring(xstate.s).trim();
-    const parsedValue = validateAndParseFieldValue(xstate.currField, val);
-    if (parsedValue !== void 0) {
-      values[xstate.currField.name] = parsedValue;
-    }
+}
+var addToMemory = (field, mem, result, sessionId) => {
+  if (result === void 0 || typeof result === "string" && (result === "" || /^(null|undefined)\s*$/i.test(result))) {
+    return;
   }
-  const sigFields = sig.getOutputFields();
-  checkMissingRequiredFields(xstate, values, sigFields.length);
-};
-var convertValueToType = (field, val, required = false) => {
-  switch (field.type?.name) {
-    case "code":
-      return extractBlock(val);
-    case "string":
-      return val;
-    case "number": {
-      const v = Number(val);
-      if (Number.isNaN(v)) {
-        if (field.isOptional && !required) {
-          return;
-        }
-        throw new Error("Invalid number");
-      }
-      return v;
-    }
-    case "boolean": {
-      if (typeof val === "boolean") {
-        return val;
-      }
-      const v = val.toLowerCase();
-      if (v === "true") {
-        return true;
-      } else if (v === "false") {
-        return false;
-      } else {
-        if (field.isOptional && !required) {
-          return;
-        }
-        throw new Error("Invalid boolean");
-      }
-    }
-    case "date":
-      return parseLLMFriendlyDate(field, val, required);
-    case "datetime":
-      return parseLLMFriendlyDateTime(field, val, required);
-    case "class":
-      const className = val;
-      if (field.type.options && !field.type.options.includes(className)) {
-        if (field.isOptional) {
-          return;
-        }
-        throw new Error(
-          `Invalid class '${val}', expected one of the following: ${field.type.options.join(", ")}`
-        );
-      }
-      return className;
-    default:
-      return val;
-  }
-};
-function* yieldDelta(content, field, s2, e, xstate) {
-  const { name: fieldName, isInternal } = field;
-  const { isArray: fieldIsArray, name: fieldTypeName } = field.type ?? {};
-  if (isInternal || fieldIsArray || fieldTypeName && fieldTypeName !== "string" && fieldTypeName !== "code") {
-    return;
-  }
-  const pos = xstate.streamedIndex[fieldName] ?? 0;
-  const isFirstChunk = pos === 0;
-  const d1 = content.substring(s2 + pos, e);
-  if (d1.length === 0) {
-    return;
-  }
-  let d2 = d1.replace(/\s+$/, "");
-  if (xstate.currField?.type?.name === "code") {
-    d2 = d2.replace(/\s*```\s*$/, "");
-  }
-  let d3 = isFirstChunk ? d2.trimStart() : d2;
-  if (xstate.currField?.type?.name === "code") {
-    d3 = d3.replace(/^[ ]*```[a-zA-Z0-9]*\n\s*/, "");
-  }
-  if (d3.length > 0) {
-    yield { [fieldName]: d3 };
-    xstate.streamedIndex[fieldName] = pos + d2.length;
-  }
-}
-function* streamValues(sig, content, values, xstate) {
-  for (const prevField of xstate.prevFields ?? []) {
-    const { field, s: s2, e } = prevField;
-    yield* yieldDelta(content, field, s2, e, xstate);
-  }
-  xstate.prevFields = void 0;
-  if (!xstate.currField || xstate.currField.isInternal) {
-    return;
-  }
-  yield* yieldDelta(
-    content,
-    xstate.currField,
-    xstate.s,
-    content.length,
-    xstate
-  );
-  const outputFields = sig.getOutputFields();
-  for (const key of Object.keys(values)) {
-    const field = outputFields.find((f2) => f2.name === key);
-    if (!field || field.isInternal) {
-      continue;
-    }
-    const value = values[key];
-    if (Array.isArray(value)) {
-      const s2 = xstate.streamedIndex?.[key] ?? 0;
-      const v = value.slice(s2);
-      if (v && v.length > 0) {
-        yield { [key]: v };
-        xstate.streamedIndex[key] = s2 + v.length;
-      }
-      continue;
-    }
-    if (!xstate.streamedIndex[key]) {
-      yield { [key]: value };
-      xstate.streamedIndex[key] = 1;
-    }
-  }
-}
-function validateAndParseFieldValue(field, fieldValue) {
-  if (!fieldValue || fieldValue === "" || /^(null|undefined)\s*$/i.test(fieldValue)) {
-    if (field.isOptional) {
-      return;
-    }
-    throw new ValidationError({
-      message: "Required field is missing",
-      fields: [field],
-      value: fieldValue
-    });
-  }
-  let value;
-  if (field.type?.name === "json") {
-    try {
-      const text = extractBlock(fieldValue);
-      value = JSON.parse(text);
-      return value;
-    } catch (e) {
-      throw new ValidationError({
-        message: "Invalid JSON: " + e.message,
-        fields: [field],
-        value: fieldValue
-      });
-    }
-  }
-  if (field.type?.isArray) {
-    try {
-      try {
-        value = JSON.parse(fieldValue);
-      } catch {
-        value = parseMarkdownList(fieldValue);
-      }
-      if (!Array.isArray(value)) {
-        throw new Error("Expected an array");
-      }
-    } catch (e) {
-      throw new ValidationError({
-        message: "Invalid Array: " + e.message,
-        fields: [field],
-        value: fieldValue
-      });
-    }
-  }
-  try {
-    if (Array.isArray(value)) {
-      for (const [index, item] of value.entries()) {
-        if (item !== void 0) {
-          const v = typeof item === "string" ? item.trim() : item;
-          value[index] = convertValueToType(field, v, true);
-        }
-      }
-    } else {
-      value = convertValueToType(field, fieldValue);
-    }
-  } catch (e) {
-    throw new ValidationError({
-      message: e.message,
-      fields: [field],
-      value: fieldValue
-    });
-  }
-  if (typeof value === "string" && value === "") {
-    return void 0;
-  }
-  return value;
-}
-var extractBlock = (input) => {
-  const markdownBlockPattern = /```([A-Za-z]*)\n([\s\S]*?)\n```/g;
-  const match = markdownBlockPattern.exec(input);
-  if (!match) {
-    return input;
-  }
-  if (match.length === 3) {
-    return match[2];
-  }
-  if (match.length === 2) {
-    return match[1];
-  }
-  return input;
-};
-
-// dsp/fieldProcessor.ts
-async function processFieldProcessors(fieldProcessors, values, mem, sessionId) {
-  for (const processor of fieldProcessors) {
-    if (values[processor.field.name] === void 0) {
-      continue;
-    }
-    const processFn = processor.process;
-    const result = await processFn(values[processor.field.name], {
-      sessionId,
-      values,
-      done: true
-    });
-    addToMemory(processor.field, mem, result, sessionId);
-  }
-}
-async function processStreamingFieldProcessors(fieldProcessors, content, xstate, mem, values, sessionId, done = false) {
-  for (const processor of fieldProcessors) {
-    if (xstate.currField?.name !== processor.field.name) {
-      continue;
-    }
-    let value = content.substring(xstate.s);
-    if (xstate.currField?.type?.name === "code") {
-      value = value.replace(/^[ ]*```[a-zA-Z0-9]*\n\s*/, "");
-      value = value.replace(/\s*```\s*$/, "");
-    }
-    const processFn = processor.process;
-    const result = await processFn(value, {
-      sessionId,
-      values,
-      done
-    });
-    addToMemory(xstate.currField, mem, result, sessionId);
-  }
-}
-var addToMemory = (field, mem, result, sessionId) => {
-  if (result === void 0 || typeof result === "string" && (result === "" || /^(null|undefined)\s*$/i.test(result))) {
-    return;
-  }
-  let resultText = JSON.stringify(
-    result,
-    (key, value) => typeof value === "bigint" ? Number(value) : value,
-    2
-  );
-  const text = getFieldProcessingMessage(field, resultText);
-  mem.add({ role: "user", content: [{ type: "text", text }] }, sessionId);
-  mem.addTag(`processor`, sessionId);
+  let resultText = JSON.stringify(
+    result,
+    (key, value) => typeof value === "bigint" ? Number(value) : value,
+    2
+  );
+  const text = getFieldProcessingMessage(field, resultText);
+  mem.addRequest(
+    [{ role: "user", content: [{ type: "text", text }] }],
+    sessionId
+  );
+  mem.addTag(`processor`, sessionId);
 };
 function getFieldProcessingMessage(field, resultText) {
   const isCodeField = field.type?.name === "code";
@@ -7233,10 +7396,10 @@ var AxFunctionProcessor = class {
     } : void 0;
     if (!fnSpec.parameters) {
       const res2 = fnSpec.func.length === 1 ? await fnSpec.func(opt) : await fnSpec.func();
-      return typeof res2 === "string" ? res2 : JSON.stringify(res2, null, 2);
+      return typeof res2 === "string" ? res2 : res2 === void 0 || res2 === null ? "" : JSON.stringify(res2, null, 2);
     }
     const res = fnSpec.func.length === 2 ? await fnSpec.func(args, opt) : await fnSpec.func(args);
-    return typeof res === "string" ? res : JSON.stringify(res, null, 2);
+    return typeof res === "string" ? res : res === void 0 || res === null ? "" : JSON.stringify(res, null, 2);
   };
   execute = async (func, options) => {
     const fnSpec = this.funcList.find(
@@ -7275,7 +7438,17 @@ var parseFunctions = (newFuncs, existingFuncs) => {
   }
   return [...existingFuncs ?? [], ...functions];
 };
-var processFunctions = async (ai, functionList, functionCalls, mem, sessionId, traceId, span, excludeContentFromTelemetry) => {
+var processFunctions = async ({
+  ai,
+  functionList,
+  functionCalls,
+  mem,
+  sessionId,
+  traceId,
+  span,
+  excludeContentFromTrace,
+  index
+}) => {
   const funcProc = new AxFunctionProcessor(functionList);
   const functionsExecuted = /* @__PURE__ */ new Set();
   const promises = functionCalls.map((func) => {
@@ -7288,16 +7461,16 @@ var processFunctions = async (ai, functionList, functionCalls, mem, sessionId, t
         const eventData = {
           name: func.name
         };
-        if (!excludeContentFromTelemetry) {
+        if (!excludeContentFromTrace) {
           eventData.args = func.args;
           eventData.result = functionResult ?? "";
         }
         span.addEvent("function.call", eventData);
       }
       return {
-        role: "function",
         result: functionResult ?? "",
-        functionId: func.id
+        functionId: func.id,
+        index
       };
     }).catch((e) => {
       if (e instanceof FunctionError) {
@@ -7307,22 +7480,22 @@ var processFunctions = async (ai, functionList, functionCalls, mem, sessionId, t
             name: func.name,
             message: e.toString()
           };
-          if (!excludeContentFromTelemetry) {
+          if (!excludeContentFromTrace) {
             errorEventData.args = func.args;
             errorEventData.fixing_instructions = result;
           }
           span.addEvent("function.error", errorEventData);
         }
-        mem.add(
+        mem.addFunctionResult(
           {
-            role: "function",
             functionId: func.id,
             isError: true,
+            index,
             result
           },
           sessionId
         );
-        mem.addTag("error");
+        mem.addTag("error", sessionId);
         if (ai.getOptions().debug) {
           const logger = ai.getLogger();
           logger(`\u274C Function Error Correction:
@@ -7339,7 +7512,7 @@ ${result}`, {
   const results = await Promise.all(promises);
   for (const result of results) {
     if (result) {
-      mem.add(result, sessionId);
+      mem.addFunctionResult(result, sessionId);
     }
   }
   return functionsExecuted;
@@ -7359,36 +7532,41 @@ function parseFunctionCalls(ai, functionCalls, values, model) {
   return funcs;
 }
 
-// dsp/registry.ts
-var AxInstanceRegistry = class {
-  reg;
-  // To track keys for iteration
-  constructor() {
-    this.reg = /* @__PURE__ */ new Set();
-  }
-  register(instance) {
-    this.reg.add(instance);
-  }
-  *[Symbol.iterator]() {
-    const items = Array.from(this.reg);
-    for (let i = 0; i < items.length; i++) {
-      yield items[i];
-    }
-  }
-};
-
-// dsp/sig.ts
-import { createHash } from "crypto";
-
-// dsp/globals.ts
-var axGlobals = {
-  signatureStrict: true
-  // Controls reservedNames enforcement in signature parsing/validation
-};
+// dsp/processResponse.ts
+import "stream/web";
 
-// dsp/parser.ts
-var SignatureValidationError = class extends Error {
-  constructor(message, position, context3, suggestion) {
+// ai/util.ts
+function mergeFunctionCalls(functionCalls, functionCallDeltas) {
+  for (const _fc of functionCallDeltas) {
+    const fc = functionCalls.find((fc2) => fc2.id === _fc.id);
+    if (fc) {
+      if (typeof _fc.function.name == "string" && _fc.function.name.length > 0) {
+        fc.function.name += _fc.function.name;
+      }
+      if (typeof _fc.function.params == "string" && _fc.function.params.length > 0) {
+        fc.function.params += _fc.function.params;
+      }
+      if (typeof _fc.function.params == "object") {
+        fc.function.params = _fc.function.params;
+      }
+    } else {
+      functionCalls.push(_fc);
+    }
+  }
+}
+
+// dsp/sig.ts
+import { createHash } from "crypto";
+
+// dsp/globals.ts
+var axGlobals = {
+  signatureStrict: true
+  // Controls reservedNames enforcement in signature parsing/validation
+};
+
+// dsp/parser.ts
+var SignatureValidationError = class extends Error {
+  constructor(message, position, context3, suggestion) {
     super(message);
     this.position = position;
     this.context = context3;
@@ -8585,32 +8763,828 @@ function validateFieldType(field, context3) {
         );
       }
     }
-    const uniqueOptions = new Set(
-      type.options.map((opt) => opt.trim().toLowerCase())
-    );
-    if (uniqueOptions.size !== type.options.length) {
-      throw new AxSignatureValidationError(
-        "Duplicate class options found",
-        field.name,
-        "Each class option must be unique (case-insensitive)"
-      );
+    const uniqueOptions = new Set(
+      type.options.map((opt) => opt.trim().toLowerCase())
+    );
+    if (uniqueOptions.size !== type.options.length) {
+      throw new AxSignatureValidationError(
+        "Duplicate class options found",
+        field.name,
+        "Each class option must be unique (case-insensitive)"
+      );
+    }
+  }
+  if (type.name === "code" && type.isArray) {
+    throw new AxSignatureValidationError(
+      "Arrays of code are not commonly supported",
+      field.name,
+      "Consider using a single code field or an array of strings instead"
+    );
+  }
+  if (field.isInternal && context3 === "input") {
+    throw new AxSignatureValidationError(
+      "Internal marker (!) is not allowed on input fields",
+      field.name,
+      "Internal markers are only allowed on output fields"
+    );
+  }
+}
+
+// dsp/processResponse.ts
+async function* processStreamingResponse({
+  res,
+  usage,
+  states,
+  ...args
+}) {
+  const skipEarlyFail = (args.ai.getFeatures().functionCot ?? false) && args.functions !== void 0 && args.functions.length > 0;
+  for await (const v of res) {
+    if (v.modelUsage) {
+      usage.push(v.modelUsage);
+    }
+    for (const result of v.results) {
+      if (result.content === "" && (!result.functionCalls || result.functionCalls.length === 0)) {
+        continue;
+      }
+      const state = states.find((s2) => s2.index === result.index);
+      if (!state) {
+        throw new Error(`No state found for result (index: ${result.index})`);
+      }
+      yield* _processStreamingResponse({
+        ...args,
+        result,
+        skipEarlyFail,
+        state
+      });
+    }
+  }
+  for (const state of states) {
+    yield* finalizeStreamingResponse({
+      ...args,
+      state
+    });
+  }
+}
+async function* _processStreamingResponse({
+  result,
+  mem,
+  sessionId,
+  strictMode,
+  skipEarlyFail,
+  state,
+  signature,
+  streamingFieldProcessors,
+  thoughtFieldName,
+  streamingAsserts,
+  asserts
+}) {
+  if (result.functionCalls && result.functionCalls.length > 0) {
+    mergeFunctionCalls(state.functionCalls, result.functionCalls);
+    mem.updateResult(
+      {
+        name: result.name,
+        content: result.content,
+        functionCalls: state.functionCalls,
+        delta: result.functionCalls?.[0]?.function?.params,
+        index: result.index
+      },
+      sessionId
+    );
+  } else if (result.content && result.content.length > 0) {
+    if (result.thought && result.thought.length > 0) {
+      yield {
+        index: result.index,
+        delta: { [thoughtFieldName]: result.thought }
+      };
+    }
+    state.content += result.content;
+    mem.updateResult(
+      {
+        name: result.name,
+        content: state.content,
+        delta: result.content,
+        index: result.index
+      },
+      sessionId
+    );
+    const skip = streamingExtractValues(
+      signature,
+      state.values,
+      state.xstate,
+      state.content,
+      { strictMode, skipEarlyFail }
+    );
+    if (skip) {
+      return;
+    }
+    if (streamingAsserts.length !== 0) {
+      await assertStreamingAssertions(
+        streamingAsserts,
+        state.xstate,
+        state.content
+      );
+    }
+    if (streamingFieldProcessors.length !== 0) {
+      await processStreamingFieldProcessors(
+        streamingFieldProcessors,
+        state.content,
+        state.xstate,
+        mem,
+        state.values,
+        sessionId
+      );
+    }
+    yield* streamValues(
+      signature,
+      state.content,
+      state.values,
+      state.xstate,
+      result.index
+    );
+    await assertAssertions(asserts, state.values);
+  } else if (result.thought && result.thought.length > 0) {
+    state.values[thoughtFieldName] = (state.values[thoughtFieldName] ?? "") + result.thought;
+    yield {
+      index: result.index,
+      delta: { [thoughtFieldName]: result.thought }
+    };
+  }
+  if (result.finishReason === "length") {
+    throw new Error(
+      `Max tokens reached before completion
+Content: ${state.content}`
+    );
+  }
+}
+async function* finalizeStreamingResponse({
+  state,
+  signature,
+  ai,
+  model,
+  functions,
+  mem,
+  sessionId,
+  traceId,
+  span,
+  excludeContentFromTrace,
+  streamingAsserts,
+  asserts,
+  fieldProcessors,
+  streamingFieldProcessors
+}) {
+  const funcs = parseFunctionCalls(ai, state.functionCalls, state.values, model);
+  if (funcs) {
+    if (!functions) {
+      throw new Error("Functions are not defined");
+    }
+    const fx = await processFunctions({
+      ai,
+      functionList: functions,
+      functionCalls: funcs,
+      mem,
+      sessionId,
+      traceId,
+      span,
+      index: state.index,
+      excludeContentFromTrace
+    });
+    state.functionsExecuted = /* @__PURE__ */ new Set([...state.functionsExecuted, ...fx]);
+  } else {
+    streamingExtractFinalValue(
+      signature,
+      state.values,
+      state.xstate,
+      state.content
+    );
+    await assertStreamingAssertions(
+      streamingAsserts,
+      state.xstate,
+      state.content,
+      true
+    );
+    await assertAssertions(asserts, state.values);
+    if (fieldProcessors.length) {
+      await processFieldProcessors(
+        fieldProcessors,
+        state.values,
+        mem,
+        sessionId
+      );
+    }
+    if (streamingFieldProcessors.length !== 0) {
+      await processStreamingFieldProcessors(
+        streamingFieldProcessors,
+        state.content,
+        state.xstate,
+        mem,
+        state.values,
+        sessionId,
+        true
+      );
+    }
+    yield* streamValues(
+      signature,
+      state.content,
+      state.values,
+      state.xstate,
+      state.index
+    );
+  }
+}
+async function* processResponse({
+  ai,
+  res,
+  mem,
+  sessionId,
+  traceId,
+  functions,
+  span,
+  strictMode,
+  states,
+  usage,
+  excludeContentFromTrace,
+  asserts,
+  fieldProcessors,
+  thoughtFieldName,
+  signature
+}) {
+  let results = res.results ?? [];
+  mem.addResponse(results, sessionId);
+  for (const result of results) {
+    const state = states[result.index];
+    if (!state) {
+      throw new Error(`No state found for result (index: ${result.index})`);
+    }
+    if (res.modelUsage) {
+      usage.push(res.modelUsage);
+    }
+    if (result.functionCalls?.length) {
+      const funcs = parseFunctionCalls(ai, result.functionCalls, state.values);
+      if (funcs) {
+        if (!functions) {
+          throw new Error("Functions are not defined");
+        }
+        const fx = await processFunctions({
+          ai,
+          functionList: functions,
+          functionCalls: funcs,
+          mem,
+          sessionId,
+          traceId,
+          span,
+          excludeContentFromTrace,
+          index: result.index
+        });
+        state.functionsExecuted = /* @__PURE__ */ new Set([...state.functionsExecuted, ...fx]);
+      }
+    } else if (result.content) {
+      if (result.thought && result.thought.length > 0) {
+        state.values[thoughtFieldName] = result.thought;
+      }
+      extractValues(signature, state.values, result.content, strictMode);
+      await assertAssertions(asserts, state.values);
+      if (fieldProcessors.length) {
+        await processFieldProcessors(
+          fieldProcessors,
+          state.values,
+          mem,
+          sessionId
+        );
+      }
+    }
+    if (result.finishReason === "length") {
+      throw new Error(
+        `Max tokens reached before completion
+Content: ${result.content}`
+      );
+    }
+  }
+  const values = states.map((s2) => s2.values);
+  for (const v of values) {
+    for (const field of signature.getOutputFields()) {
+      if (field.isInternal) {
+        delete v[field.name];
+      }
+    }
+  }
+  const outputFields = signature.getOutputFields();
+  const deltas = values.map((v, index) => {
+    const delta = {};
+    for (const field of outputFields) {
+      if (field.isInternal) {
+        continue;
+      }
+      delta[field.name] = v[field.name];
+    }
+    if (v[thoughtFieldName] !== void 0) {
+      delta[thoughtFieldName] = v[thoughtFieldName];
+    }
+    return { index, delta };
+  });
+  for (const delta of deltas) {
+    yield delta;
+  }
+}
+function shouldContinueSteps(mem, stopFunction, states, sessionId) {
+  const lastMemItem = mem.getLast(sessionId);
+  if (!lastMemItem) {
+    return true;
+  }
+  for (const [index, state] of states.entries()) {
+    const stopFunctionExecuted = stopFunction && state.functionsExecuted.has(stopFunction);
+    const chat = lastMemItem.chat[index];
+    if (!chat) {
+      throw new Error(`No chat message found for result (index: ${index})`);
+    }
+    const isFunction = lastMemItem.role === "function";
+    const isProcessor = lastMemItem.tags ? lastMemItem.tags.some((tag) => tag === "processor") : false;
+    if (isFunction && stopFunction && stopFunctionExecuted) {
+      return false;
+    }
+    if (!(isFunction || isProcessor)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// dsp/prompt.ts
+var functionCallInstructions = `
+## Function Call Instructions
+- Complete the task, using the functions defined earlier in this prompt. 
+- Output fields should only be generated after all functions have been called.
+- Use the function results to generate the output fields.`;
+var formattingRules = `
+## Strict Output Formatting Rules
+- Output must strictly follow the defined plain-text \`field name: value\` field format.
+- Output field, values must strictly adhere to the specified output field formatting rules.
+- No formatting rules should override these **Strict Output Formatting Rules**
+- Do not add any text before or after the output fields, just the field name and value.
+- Do not use code blocks.`;
+var AxPromptTemplate = class {
+  sig;
+  fieldTemplates;
+  task;
+  thoughtFieldName;
+  functions;
+  constructor(sig, options, fieldTemplates) {
+    this.sig = sig;
+    this.fieldTemplates = fieldTemplates;
+    this.thoughtFieldName = options?.thoughtFieldName ?? "thought";
+    this.functions = options?.functions;
+    const task = [];
+    const inArgs = renderDescFields(this.sig.getInputFields());
+    const outArgs = renderDescFields(this.sig.getOutputFields());
+    task.push(
+      `You will be provided with the following fields: ${inArgs}. Your task is to generate new fields: ${outArgs}.`
+    );
+    const funcs = this.functions?.map((f2) => "toFunction" in f2 ? f2.toFunction() : f2)?.flat();
+    const funcList = funcs?.map((fn) => `- \`${fn.name}\`: ${formatDescription(fn.description)}`).join("\n");
+    if (funcList && funcList.length > 0) {
+      task.push(`## Available Functions
+${funcList}`);
+    }
+    const inputFields = renderInputFields(this.sig.getInputFields());
+    task.push(`## Input Fields
+${inputFields}`);
+    const outputFields = renderOutputFields(this.sig.getOutputFields());
+    task.push(`## Output Fields
+${outputFields}`);
+    if (funcList && funcList.length > 0) {
+      task.push(functionCallInstructions.trim());
+    }
+    task.push(formattingRules.trim());
+    const desc = this.sig.getDescription();
+    if (desc) {
+      const text = formatDescription(desc);
+      task.push(text);
+    }
+    this.task = {
+      type: "text",
+      text: task.join("\n\n")
+    };
+  }
+  renderSingleValueUserContent = (values, renderedExamples, renderedDemos, examplesInSystemPrompt) => {
+    const completion = this.renderInputFields(values);
+    const promptList = examplesInSystemPrompt ? completion : [...renderedExamples, ...renderedDemos, ...completion];
+    const prompt = promptList.filter((v) => v !== void 0);
+    return prompt.every((v) => v.type === "text") ? prompt.map((v) => v.text).join("\n") : prompt.reduce(combineConsecutiveStrings("\n"), []);
+  };
+  render = (values, {
+    examples,
+    demos
+  }) => {
+    const renderedExamples = examples ? [
+      { type: "text", text: "\n\n## Examples\n" },
+      ...this.renderExamples(examples)
+    ] : [];
+    const renderedDemos = demos ? this.renderDemos(demos) : [];
+    const allTextExamples = renderedExamples.every((v) => v.type === "text");
+    const allTextDemos = renderedDemos.every((v) => v.type === "text");
+    const examplesInSystemPrompt = allTextExamples && allTextDemos;
+    let systemContent = this.task.text;
+    if (examplesInSystemPrompt) {
+      const combinedItems = [
+        { type: "text", text: systemContent },
+        ...renderedExamples,
+        ...renderedDemos
+      ];
+      combinedItems.reduce(combineConsecutiveStrings(""), []);
+      if (combinedItems && combinedItems[0]) {
+        systemContent = combinedItems[0].text;
+      }
+    }
+    const systemPrompt = {
+      role: "system",
+      content: systemContent
+    };
+    if (Array.isArray(values)) {
+      let messages = [];
+      const history = values;
+      let firstItem = true;
+      for (const message of history) {
+        let content;
+        if (firstItem) {
+          content = this.renderSingleValueUserContent(
+            message.values,
+            renderedExamples,
+            renderedDemos,
+            examplesInSystemPrompt
+          );
+          firstItem = false;
+        } else {
+          content = this.renderSingleValueUserContent(
+            message.values,
+            [],
+            [],
+            false
+          );
+        }
+        if (message.role === "user") {
+          messages.push({ role: "user", content });
+          continue;
+        }
+        if (message.role !== "assistant") {
+          throw new Error("Invalid message role");
+        }
+        if (typeof content !== "string") {
+          throw new Error(
+            "Assistant message cannot contain non-text content like images, files,etc"
+          );
+        }
+        messages.push({ role: "assistant", content });
+      }
+      return [systemPrompt, ...messages];
+    }
+    const userContent = this.renderSingleValueUserContent(
+      values,
+      renderedExamples,
+      renderedDemos,
+      examplesInSystemPrompt
+    );
+    return [systemPrompt, { role: "user", content: userContent }];
+  };
+  renderExtraFields = (extraFields) => {
+    const prompt = [];
+    if (!extraFields || extraFields.length === 0) {
+      return prompt;
+    }
+    const groupedFields = extraFields.reduce(
+      (acc, field) => {
+        const title = field.title;
+        if (!acc[title]) {
+          acc[title] = [];
+        }
+        acc[title].push(field);
+        return acc;
+      },
+      {}
+    );
+    const formattedGroupedFields = Object.entries(groupedFields).map(([title, fields]) => {
+      if (fields.length === 1) {
+        const field = fields[0];
+        return {
+          title,
+          name: field.name,
+          description: field.description
+        };
+      } else if (fields.length > 1) {
+        const valuesList = fields.map((field) => `- ${field.description}`).join("\n");
+        return {
+          title,
+          name: fields[0].name,
+          description: valuesList
+        };
+      }
+    }).filter(Boolean);
+    formattedGroupedFields.forEach((field) => {
+      const fn = this.fieldTemplates?.[field.name] ?? this.defaultRenderInField;
+      prompt.push(...fn(field, field.description));
+    });
+    return prompt;
+  };
+  renderExamples = (data) => {
+    const list = [];
+    const exampleContext = {
+      isExample: true
+    };
+    for (const [index, item] of data.entries()) {
+      const renderedInputItem = this.sig.getInputFields().map(
+        (field) => this.renderInField(field, item, {
+          ...exampleContext,
+          isInputField: true
+        })
+      ).filter((v) => v !== void 0).flat();
+      const renderedOutputItem = this.sig.getOutputFields().map(
+        (field) => this.renderInField(field, item, {
+          ...exampleContext,
+          isInputField: false
+        })
+      ).filter((v) => v !== void 0).flat();
+      const renderedItem = [...renderedInputItem, ...renderedOutputItem];
+      if (index > 0 && renderedItem.length > 0 && renderedItem[0]?.type === "text") {
+        list.push({ type: "text", text: "---\n\n" });
+      }
+      renderedItem.forEach((v) => {
+        if ("text" in v) {
+          v.text = v.text + "\n";
+        }
+        list.push(v);
+      });
+    }
+    return list;
+  };
+  renderDemos = (data) => {
+    const list = [];
+    const inputFields = this.sig.getInputFields();
+    const outputFields = this.sig.getOutputFields();
+    const demoContext = {
+      isExample: true
+    };
+    for (const item of data) {
+      const inputRenderedItems = inputFields.map(
+        (field) => this.renderInField(field, item, {
+          ...demoContext,
+          isInputField: true
+        })
+      ).filter((v) => v !== void 0).flat();
+      const outputRenderedItems = outputFields.map(
+        (field) => this.renderInField(field, item, {
+          ...demoContext,
+          isInputField: false
+        })
+      ).filter((v) => v !== void 0).flat();
+      const renderedItem = [...inputRenderedItems, ...outputRenderedItems];
+      renderedItem.slice(0, -1).forEach((v) => {
+        if ("text" in v) {
+          v.text = v.text + "\n";
+        }
+        list.push(v);
+      });
+    }
+    return list;
+  };
+  renderInputFields = (values) => {
+    const renderedItems = this.sig.getInputFields().map((field) => this.renderInField(field, values, void 0)).filter((v) => v !== void 0).flat();
+    renderedItems.filter((v) => v.type === "text").forEach((v) => {
+      v.text = v.text + "\n";
+    });
+    return renderedItems;
+  };
+  renderInField = (field, values, context3) => {
+    const value = values[field.name];
+    if (isEmptyValue(field, value, context3)) {
+      return;
+    }
+    if (field.type) {
+      validateValue(field, value);
+    }
+    const processedValue = processValue(field, value);
+    const textFieldFn = this.fieldTemplates?.[field.name] ?? this.defaultRenderInField;
+    return textFieldFn(field, processedValue);
+  };
+  defaultRenderInField = (field, value) => {
+    if (field.type?.name === "image") {
+      const validateImage = (value2) => {
+        if (!value2) {
+          throw new Error("Image field value is required.");
+        }
+        if (typeof value2 !== "object") {
+          throw new Error("Image field value must be an object.");
+        }
+        if (!("mimeType" in value2)) {
+          throw new Error("Image field must have mimeType");
+        }
+        if (!("data" in value2)) {
+          throw new Error("Image field must have data");
+        }
+        return value2;
+      };
+      let result = [
+        { type: "text", text: `${field.title}: ` }
+      ];
+      if (field.type.isArray) {
+        if (!Array.isArray(value)) {
+          throw new Error("Image field value must be an array.");
+        }
+        result = result.concat(
+          value.map((v) => {
+            const validated = validateImage(v);
+            return {
+              type: "image",
+              mimeType: validated.mimeType,
+              image: validated.data
+            };
+          })
+        );
+      } else {
+        const validated = validateImage(value);
+        result.push({
+          type: "image",
+          mimeType: validated.mimeType,
+          image: validated.data
+        });
+      }
+      return result;
+    }
+    if (field.type?.name === "audio") {
+      const validateAudio = (value2) => {
+        if (!value2) {
+          throw new Error("Audio field value is required.");
+        }
+        if (typeof value2 !== "object") {
+          throw new Error("Audio field value must be an object.");
+        }
+        if (!("data" in value2)) {
+          throw new Error("Audio field must have data");
+        }
+        return value2;
+      };
+      let result = [
+        { type: "text", text: `${field.title}: ` }
+      ];
+      if (field.type.isArray) {
+        if (!Array.isArray(value)) {
+          throw new Error("Audio field value must be an array.");
+        }
+        result = result.concat(
+          value.map((v) => {
+            const validated = validateAudio(v);
+            return {
+              type: "audio",
+              format: validated.format ?? "wav",
+              data: validated.data
+            };
+          })
+        );
+      } else {
+        const validated = validateAudio(value);
+        result.push({
+          type: "audio",
+          format: validated.format ?? "wav",
+          data: validated.data
+        });
+      }
+      return result;
+    }
+    const text = [field.title, ": "];
+    if (Array.isArray(value)) {
+      text.push("\n");
+      text.push(value.map((v) => `- ${v}`).join("\n"));
+    } else {
+      text.push(value);
+    }
+    return [{ type: "text", text: text.join("") }];
+  };
+};
+var renderDescFields = (list) => list.map((v) => `\`${v.title}\``).join(", ");
+var renderInputFields = (fields) => {
+  const rows = fields.map((field) => {
+    const name = field.title;
+    const type = field.type?.name ? toFieldType(field.type) : "string";
+    const requiredMsg = field.isOptional ? `This optional ${type} field may be omitted` : `A ${type} field`;
+    const description = field.description ? ` ${formatDescription(field.description)}` : "";
+    return `${name}: (${requiredMsg})${description}`.trim();
+  });
+  return rows.join("\n");
+};
+var renderOutputFields = (fields) => {
+  const rows = fields.map((field) => {
+    const name = field.title;
+    const type = field.type?.name ? toFieldType(field.type) : "string";
+    const requiredMsg = field.isOptional ? `Only include this ${type} field if its value is available` : `This ${type} field must be included`;
+    let description = "";
+    if (field.description && field.description.length > 0) {
+      const value = field.type?.name === "class" ? field.description : formatDescription(field.description);
+      description = ` ${value}`;
+    }
+    if (field.type?.options && field.type.options.length > 0) {
+      if (description.length > 0) {
+        description += `. `;
+      }
+      description += `Allowed values: ${field.type.options.join(", ")}`;
+    }
+    return `${name}: (${requiredMsg})${description}`.trim();
+  });
+  return rows.join("\n");
+};
+var processValue = (field, value) => {
+  if (field.type?.name === "date" && value instanceof Date) {
+    const v = value.toISOString();
+    return v.slice(0, v.indexOf("T"));
+  }
+  if (field.type?.name === "datetime" && value instanceof Date) {
+    return formatDateWithTimezone(value);
+  }
+  if (field.type?.name === "image" && typeof value === "object") {
+    return value;
+  }
+  if (field.type?.name === "audio" && typeof value === "object") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value, null, 2);
+};
+var toFieldType = (type) => {
+  const baseType = (() => {
+    switch (type?.name) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "date":
+        return 'date ("YYYY-MM-DD" format)';
+      case "datetime":
+        return 'date time ("YYYY-MM-DD HH:mm Timezone" format)';
+      case "json":
+        return "JSON object";
+      case "class":
+        return "classification class";
+      case "code":
+        return "code";
+      default:
+        return "string";
+    }
+  })();
+  return type?.isArray ? `json array of ${baseType} items` : baseType;
+};
+function combineConsecutiveStrings(separator) {
+  return (acc, current) => {
+    if (current.type === "text") {
+      const previous = acc.length > 0 ? acc[acc.length - 1] : null;
+      if (previous && previous.type === "text") {
+        previous.text += separator + current.text;
+      } else {
+        acc.push(current);
+      }
+    } else {
+      acc.push(current);
+    }
+    return acc;
+  };
+}
+var isEmptyValue = (field, value, context3) => {
+  if (typeof value === "boolean") {
+    return false;
+  }
+  if (!value || (Array.isArray(value) || typeof value === "string") && value.length === 0) {
+    if (context3?.isExample) {
+      return true;
     }
+    if (field.isOptional || field.isInternal) {
+      return true;
+    }
+    const fieldType = context3?.isInputField !== false ? "input" : "output";
+    throw new Error(`Value for ${fieldType} field '${field.name}' is required.`);
   }
-  if (type.name === "code" && type.isArray) {
-    throw new AxSignatureValidationError(
-      "Arrays of code are not commonly supported",
-      field.name,
-      "Consider using a single code field or an array of strings instead"
-    );
+  return false;
+};
+function formatDescription(str) {
+  const value = str.trim();
+  return value.length > 0 ? `${value.charAt(0).toUpperCase()}${value.slice(1)}${value.endsWith(".") ? "" : "."}` : "";
+}
+
+// dsp/registry.ts
+var AxInstanceRegistry = class {
+  reg;
+  // To track keys for iteration
+  constructor() {
+    this.reg = /* @__PURE__ */ new Set();
   }
-  if (field.isInternal && context3 === "input") {
-    throw new AxSignatureValidationError(
-      "Internal marker (!) is not allowed on input fields",
-      field.name,
-      "Internal markers are only allowed on output fields"
-    );
+  register(instance) {
+    this.reg.add(instance);
   }
-}
+  *[Symbol.iterator]() {
+    const items = Array.from(this.reg);
+    for (let i = 0; i < items.length; i++) {
+      yield items[i];
+    }
+  }
+};
 
 // dsp/program.ts
 var AxProgramWithSignature = class {
@@ -8813,6 +9787,28 @@ var AxProgram = class {
   }
 };
 
+// dsp/validate.ts
+function handleValidationError(mem, errorFields, ai, promptTemplate, sessionId) {
+  mem.addRequest(
+    [
+      {
+        role: "user",
+        content: promptTemplate.renderExtraFields(errorFields)
+      }
+    ],
+    sessionId
+  );
+  mem.addTag("error", sessionId);
+  if (ai.getOptions().debug) {
+    const errors = errorFields.map((field) => `- ${field.title}: ${field.description}`).join("\n");
+    const logger = ai.getLogger();
+    logger(`\u274C Error Correction:
+${errors}`, {
+      tags: ["error"]
+    });
+  }
+}
+
 // dsp/generate.ts
 var AxGen = class extends AxProgramWithSignature {
   promptTemplate;
@@ -8820,10 +9816,8 @@ var AxGen = class extends AxProgramWithSignature {
   streamingAsserts;
   options;
   functions;
-  functionsExecuted = /* @__PURE__ */ new Set();
   fieldProcessors = [];
   streamingFieldProcessors = [];
-  values = {};
   excludeContentFromTrace = false;
   thoughtFieldName;
   constructor(signature, options) {
@@ -8846,6 +9840,20 @@ var AxGen = class extends AxProgramWithSignature {
       this.functions = parseFunctions(options.functions);
     }
   }
+  createStates(n) {
+    return Array.from({ length: n }, (_, index) => ({
+      index,
+      functionCalls: [],
+      values: {},
+      content: "",
+      functionsExecuted: /* @__PURE__ */ new Set(),
+      xstate: {
+        extractedFields: [],
+        streamedIndex: {},
+        s: -1
+      }
+    }));
+  }
   addAssert = (fn, message) => {
     this.asserts.push({ fn, message });
   };
@@ -8886,7 +9894,6 @@ var AxGen = class extends AxProgramWithSignature {
     const {
       sessionId,
       traceId,
-      modelConfig,
       model,
       rateLimiter,
       stream,
@@ -8895,7 +9902,7 @@ var AxGen = class extends AxProgramWithSignature {
       thinkingTokenBudget,
       showThoughts
     } = options ?? {};
-    const chatPrompt = mem?.history(sessionId) ?? [];
+    const chatPrompt = mem?.history(0, sessionId) ?? [];
     if (chatPrompt.length === 0) {
       throw new Error("No chat prompt found");
     }
@@ -8904,6 +9911,10 @@ var AxGen = class extends AxProgramWithSignature {
     if (!firstStep && (functionCall === "required" || typeof functionCall === "function")) {
       functionCall = void 0;
     }
+    const modelConfig = {
+      ...options?.modelConfig,
+      ...options?.sampleCount ? { n: options.sampleCount } : {}
+    };
     const res = await ai.chat(
       {
         chatPrompt,
@@ -8936,9 +9947,11 @@ var AxGen = class extends AxProgramWithSignature {
     traceContext
   }) {
     const { sessionId, traceId, functions: _functions } = options ?? {};
-    const fastFail = options?.fastFail ?? this.options?.fastFail;
+    const strictMode = options?.strictMode ?? false;
     const model = options.model;
-    const functions = _functions?.map((f2) => "toFunction" in f2 ? f2.toFunction() : f2)?.flat();
+    const states = this.createStates(options.sampleCount ?? 1);
+    const usage = this.usage;
+    const functions = _functions?.map((f2) => "toFunction" in f2 ? f2.toFunction() : f2)?.flat() ?? [];
     const res = await this.forwardSendRequest({
       ai,
       mem,
@@ -8946,8 +9959,8 @@ var AxGen = class extends AxProgramWithSignature {
       traceContext,
       firstStep
     });
-    if (res instanceof ReadableStream2) {
-      yield* this.processStreamingResponse({
+    if (res instanceof ReadableStream3) {
+      yield* processStreamingResponse({
         ai,
         model,
         res,
@@ -8955,12 +9968,21 @@ var AxGen = class extends AxProgramWithSignature {
         traceId,
         sessionId,
         functions,
-        fastFail,
-        span
+        strictMode,
+        span,
+        states,
+        usage,
+        asserts: this.asserts,
+        streamingAsserts: this.streamingAsserts,
+        fieldProcessors: this.fieldProcessors,
+        streamingFieldProcessors: this.streamingFieldProcessors,
+        thoughtFieldName: this.thoughtFieldName,
+        excludeContentFromTrace: this.excludeContentFromTrace,
+        signature: this.signature
       });
       this.getLogger(ai, options)?.("", { tags: ["responseEnd"] });
     } else {
-      yield await this.processResponse({
+      yield* processResponse({
         ai,
         model,
         res,
@@ -8968,233 +9990,19 @@ var AxGen = class extends AxProgramWithSignature {
         traceId,
         sessionId,
         functions,
-        span
-      });
-    }
-  }
-  async *processStreamingResponse({
-    ai,
-    model,
-    res,
-    mem,
-    sessionId,
-    traceId,
-    functions,
-    fastFail,
-    span
-  }) {
-    const streamingValidation = fastFail ?? ai.getFeatures(model).functionCot !== true;
-    const functionCalls = [];
-    this.values = {};
-    const xstate = {
-      extractedFields: [],
-      streamedIndex: {},
-      s: -1
-    };
-    let content = "";
-    mem.addResult(
-      {
-        content: "",
-        functionCalls: []
-      },
-      sessionId
-    );
-    for await (const v of res) {
-      const result = v.results[0];
-      if (!result) {
-        continue;
-      }
-      if (v.modelUsage) {
-        this.usage.push(v.modelUsage);
-      }
-      if (result.functionCalls && result.functionCalls.length > 0) {
-        mergeFunctionCalls(functionCalls, result.functionCalls);
-        mem.updateResult(
-          {
-            name: result.name,
-            content,
-            functionCalls,
-            delta: result.functionCalls?.[0]?.function?.params
-          },
-          sessionId
-        );
-      } else if (result.content && result.content.length > 0) {
-        if (result.thought && result.thought.length > 0) {
-          yield {
-            [this.thoughtFieldName]: result.thought
-          };
-        }
-        content += result.content;
-        mem.updateResult(
-          { name: result.name, content, delta: result.content },
-          sessionId
-        );
-        const skip = streamingExtractValues(
-          this.signature,
-          this.values,
-          xstate,
-          content,
-          streamingValidation
-        );
-        if (skip) {
-          continue;
-        }
-        if (this.streamingAsserts.length !== 0) {
-          await assertStreamingAssertions(
-            this.streamingAsserts,
-            xstate,
-            content
-          );
-        }
-        if (this.streamingFieldProcessors.length !== 0) {
-          await processStreamingFieldProcessors(
-            this.streamingFieldProcessors,
-            content,
-            xstate,
-            mem,
-            this.values,
-            sessionId
-          );
-        }
-        yield* streamValues(
-          this.signature,
-          content,
-          this.values,
-          xstate
-        );
-        await assertAssertions(this.asserts, this.values);
-      } else if (result.thought && result.thought.length > 0) {
-        this.values[this.thoughtFieldName] = (this.values[this.thoughtFieldName] ?? "") + result.thought;
-        yield {
-          [this.thoughtFieldName]: result.thought
-        };
-      }
-      if (result.finishReason === "length") {
-        throw new Error(
-          `Max tokens reached before completion
-Content: ${content}`
-        );
-      }
-    }
-    const funcs = parseFunctionCalls(ai, functionCalls, this.values, model);
-    if (funcs) {
-      if (!functions) {
-        throw new Error("Functions are not defined");
-      }
-      const fx = await processFunctions(
-        ai,
-        functions,
-        funcs,
-        mem,
-        sessionId,
-        traceId,
         span,
-        this.excludeContentFromTrace
-      );
-      this.functionsExecuted = /* @__PURE__ */ new Set([...this.functionsExecuted, ...fx]);
-    } else {
-      streamingExtractFinalValue(this.signature, this.values, xstate, content);
-      await assertStreamingAssertions(
-        this.streamingAsserts,
-        xstate,
-        content,
-        true
-      );
-      await assertAssertions(this.asserts, this.values);
-      if (this.fieldProcessors.length) {
-        await processFieldProcessors(
-          this.fieldProcessors,
-          this.values,
-          mem,
-          sessionId
-        );
-      }
-      if (this.streamingFieldProcessors.length !== 0) {
-        await processStreamingFieldProcessors(
-          this.streamingFieldProcessors,
-          content,
-          xstate,
-          mem,
-          this.values,
-          sessionId,
-          true
-        );
-      }
-      yield* streamValues(
-        this.signature,
-        content,
-        this.values,
-        xstate
-      );
-    }
-  }
-  async processResponse({
-    ai,
-    res,
-    mem,
-    sessionId,
-    traceId,
-    functions,
-    span
-  }) {
-    this.values = {};
-    let results = res.results ?? [];
-    if (results.length > 1) {
-      results = results.filter((r) => r.functionCalls);
-    }
-    for (const result of results) {
-      if (res.modelUsage) {
-        this.usage.push(res.modelUsage);
-      }
-      mem.addResult(result, sessionId);
-      if (result.functionCalls?.length) {
-        const funcs = parseFunctionCalls(ai, result.functionCalls, this.values);
-        if (funcs) {
-          if (!functions) {
-            throw new Error("Functions are not defined");
-          }
-          const fx = await processFunctions(
-            ai,
-            functions,
-            funcs,
-            mem,
-            sessionId,
-            traceId,
-            span,
-            this.excludeContentFromTrace
-          );
-          this.functionsExecuted = /* @__PURE__ */ new Set([...this.functionsExecuted, ...fx]);
-        }
-      } else if (result.content) {
-        if (result.thought && result.thought.length > 0) {
-          this.values[this.thoughtFieldName] = result.thought;
-        }
-        extractValues(this.signature, this.values, result.content);
-        await assertAssertions(this.asserts, this.values);
-        if (this.fieldProcessors.length) {
-          await processFieldProcessors(
-            this.fieldProcessors,
-            this.values,
-            mem,
-            sessionId
-          );
-        }
-      }
-      if (result.finishReason === "length") {
-        throw new Error(
-          `Max tokens reached before completion
-Content: ${result.content}`
-        );
-      }
-    }
-    for (const field of this.signature.getOutputFields()) {
-      if (field.isInternal) {
-        delete this.values[field.name];
-      }
+        strictMode,
+        states,
+        usage,
+        asserts: this.asserts,
+        fieldProcessors: this.fieldProcessors,
+        thoughtFieldName: this.thoughtFieldName,
+        excludeContentFromTrace: this.excludeContentFromTrace,
+        signature: this.signature
+      });
     }
-    return { ...this.values };
   }
-  async *_forward2(ai, values, options, span, traceContext) {
+  async *_forward2(ai, values, states, options, span, traceContext) {
     const stopFunction = (options?.stopFunction ?? this.options?.stopFunction)?.toLowerCase();
     const maxRetries = options.maxRetries ?? this.options?.maxRetries ?? 10;
     const maxSteps = options.maxSteps ?? this.options?.maxSteps ?? 10;
@@ -9203,7 +10011,7 @@ Content: ${result.content}`
       debug: this.isDebug(ai, options),
       debugHideSystemPrompt
     };
-    const mem = options.mem ?? this.options?.mem ?? new AxMemory(1e4, memOptions);
+    const mem = options.mem ?? this.options?.mem ?? new AxMemory(memOptions);
     let err;
     if (options?.functions && options.functions.length > 0) {
       const promptTemplateClass = this.options?.promptTemplate ?? AxPromptTemplate;
@@ -9230,7 +10038,7 @@ Content: ${result.content}`
         demos: this.demos
       });
     }
-    mem.add(prompt, options?.sessionId);
+    mem.addRequest(prompt, options.sessionId);
     multiStepLoop: for (let n = 0; n < maxSteps; n++) {
       const firstStep = n === 0;
       for (let errCount = 0; errCount < maxRetries; errCount++) {
@@ -9243,15 +10051,20 @@ Content: ${result.content}`
             span,
             traceContext
           });
-          for await (const delta of generator) {
-            if (delta !== void 0) {
-              yield { version: errCount, delta };
+          for await (const result of generator) {
+            if (result !== void 0) {
+              yield {
+                version: errCount,
+                index: result.index,
+                delta: result.delta
+              };
             }
           }
-          const lastMemItem = mem.getLast(options?.sessionId);
-          const shouldContinue = this.shouldContinueSteps(
-            lastMemItem,
-            stopFunction
+          const shouldContinue = shouldContinueSteps(
+            mem,
+            stopFunction,
+            states,
+            options?.sessionId
           );
           if (shouldContinue) {
             continue multiStepLoop;
@@ -9307,26 +10120,15 @@ Content: ${result.content}`
       this.signature
     );
   }
-  shouldContinueSteps(lastMemItem, stopFunction) {
-    const stopFunctionExecuted = stopFunction && this.functionsExecuted.has(stopFunction);
-    const isFunction = lastMemItem?.chat?.role === "function";
-    const isProcessor = lastMemItem?.tags ? lastMemItem.tags.some((tag) => tag === "processor") : false;
-    if (isFunction && stopFunction && stopFunctionExecuted) {
-      return false;
-    }
-    if (isFunction || isProcessor) {
-      return true;
-    }
-    return false;
-  }
   async *_forward1(ai, values, options) {
+    const states = this.createStates(options.sampleCount ?? 1);
     const tracer = options?.tracer ?? this.options?.tracer ?? ai.getOptions().tracer;
     let functions = this.functions;
     if (options?.functions) {
       functions = parseFunctions(options.functions, this.functions);
     }
     if (!tracer) {
-      yield* this._forward2(ai, values, {
+      yield* this._forward2(ai, values, states, {
         ...options,
         functions
       });
@@ -9341,8 +10143,7 @@ Content: ${result.content}`
       ...options?.thinkingTokenBudget ? { thinking_token_budget: options.thinkingTokenBudget } : {},
       ...options?.showThoughts ? { show_thoughts: options.showThoughts } : {},
       ...options?.maxSteps ? { max_steps: options.maxSteps } : {},
-      ...options?.maxRetries ? { max_retries: options.maxRetries } : {},
-      ...options?.fastFail ? { fast_fail: options.fastFail } : {}
+      ...options?.maxRetries ? { max_retries: options.maxRetries } : {}
     };
     const traceLabel = options.traceLabel ?? this.options?.traceLabel;
     const spanName = traceLabel ? `${traceLabel} (AxGen)` : "AxGen";
@@ -9359,6 +10160,7 @@ Content: ${result.content}`
       yield* this._forward2(
         ai,
         values,
+        states,
         {
           ...options,
           functions
@@ -9367,8 +10169,10 @@ Content: ${result.content}`
         traceContext
       );
       if (!this.excludeContentFromTrace) {
+        const valuesList = states.map((s2) => s2.values);
+        const values2 = valuesList.length === 1 ? valuesList[0] : valuesList;
         span.addEvent("output", {
-          content: JSON.stringify(this.values, null, 2)
+          content: JSON.stringify(values2, null, 2)
         });
       }
     } finally {
@@ -9377,17 +10181,18 @@ Content: ${result.content}`
   }
   async forward(ai, values, options) {
     const generator = this._forward1(ai, values, options ?? {});
-    let buffer = {};
+    let buffer = [];
     let currentVersion = 0;
-    for await (const item of generator) {
-      if (item.version !== currentVersion) {
-        buffer = {};
+    for await (const delta of generator) {
+      if (delta.version !== currentVersion) {
+        buffer = [];
       }
-      currentVersion = item.version;
-      buffer = mergeDeltas(buffer, item.delta);
+      currentVersion = delta.version;
+      buffer = mergeDeltas(buffer, delta);
     }
-    this.trace = { ...values, ...buffer };
-    return buffer;
+    const result = buffer[0]?.delta ?? {};
+    this.trace = { ...values, ...result };
+    return result;
   }
   async *streamingForward(ai, values, options) {
     yield* this._forward1(ai, values, {
@@ -9408,9 +10213,13 @@ Content: ${result.content}`
 var AxGenerateError = class extends Error {
   details;
   constructor(message, details, options) {
-    super(message, options);
+    super(message);
     this.name = "AxGenerateError";
     this.details = details;
+    if (options?.cause) {
+      ;
+      this.cause = options.cause;
+    }
   }
 };
 function enhanceError(e, ai, signature) {
@@ -10107,6 +10916,9 @@ var AxBaseOptimizer = class {
   checkpointLoad;
   checkpointInterval;
   resumeFromCheckpoint;
+  // Logging fields
+  logger;
+  verbose;
   // Checkpoint state
   currentRound = 0;
   scoreHistory = [];
@@ -10130,6 +10942,8 @@ var AxBaseOptimizer = class {
     this.checkpointLoad = args.checkpointLoad;
     this.checkpointInterval = args.checkpointInterval ?? 10;
     this.resumeFromCheckpoint = args.resumeFromCheckpoint;
+    this.logger = args.logger;
+    this.verbose = args.verbose;
     const costTracker = new AxDefaultCostTracker({
       maxTokens: 1e6
     });
@@ -10308,8 +11122,14 @@ var AxBaseOptimizer = class {
   async compilePareto(program, metricFn, options) {
     const startTime = Date.now();
     if (options?.verbose) {
-      console.log("Starting Pareto optimization using base implementation");
-      console.log("This will run multiple single-objective optimizations");
+      this.getLogger(options)?.(
+        "Starting Pareto optimization using base implementation",
+        { tags: ["discovery"] }
+      );
+      this.getLogger(options)?.(
+        "This will run multiple single-objective optimizations",
+        { tags: ["discovery"] }
+      );
     }
     const solutions = await this.generateWeightedSolutions(
       program,
@@ -10323,13 +11143,22 @@ var AxBaseOptimizer = class {
     );
     const allSolutions = [...solutions, ...constraintSolutions];
     if (options?.verbose) {
-      console.log(`Generated ${allSolutions.length} candidate solutions`);
+      this.getLogger(options)?.(
+        `Generated ${allSolutions.length} candidate solutions`,
+        { tags: ["discovery"] }
+      );
     }
     const paretoFront = this.findParetoFrontier(allSolutions);
     const hypervolume = this.calculateHypervolume(paretoFront);
     if (options?.verbose) {
-      console.log(`Found ${paretoFront.length} non-dominated solutions`);
-      console.log(`Hypervolume: ${hypervolume?.toFixed(4) || "N/A"}`);
+      this.getLogger(options)?.(
+        `Found ${paretoFront.length} non-dominated solutions`,
+        { tags: ["discovery"] }
+      );
+      this.getLogger(options)?.(
+        `Hypervolume: ${hypervolume?.toFixed(4) || "N/A"}`,
+        { tags: ["discovery"] }
+      );
     }
     this.updateResourceUsage(startTime);
     this.stats.convergenceInfo.converged = true;
@@ -10367,13 +11196,19 @@ var AxBaseOptimizer = class {
     });
     const objectives = Object.keys(sampleScores);
     if (options?.verbose) {
-      console.log(`Detected objectives: ${objectives.join(", ")}`);
+      this.getLogger(options)?.(
+        `Detected objectives: ${objectives.join(", ")}`,
+        { tags: ["discovery"] }
+      );
     }
     const weightCombinations = this.generateWeightCombinations(objectives);
     for (let i = 0; i < weightCombinations.length; i++) {
       const weights = weightCombinations[i];
       if (options?.verbose) {
-        console.log(`Optimizing with weights: ${JSON.stringify(weights)}`);
+        this.getLogger(options)?.(
+          `Optimizing with weights: ${JSON.stringify(weights)}`,
+          { tags: ["discovery"] }
+        );
       }
       const weightedMetric = async ({ prediction, example }) => {
         const scores = await metricFn({ prediction, example });
@@ -10405,9 +11240,9 @@ var AxBaseOptimizer = class {
         });
       } catch (error) {
         if (options?.verbose) {
-          console.warn(
-            `Failed optimization with weights ${JSON.stringify(weights)}:`,
-            error
+          this.getLogger(options)?.(
+            `Failed optimization with weights ${JSON.stringify(weights)}: ${error}`,
+            { tags: ["warning"] }
           );
         }
         continue;
@@ -10432,8 +11267,9 @@ var AxBaseOptimizer = class {
     const objectives = Object.keys(sampleScores);
     for (const primaryObjective of objectives) {
       if (options?.verbose) {
-        console.log(
-          `Optimizing ${primaryObjective} with constraints on other objectives`
+        this.getLogger(options)?.(
+          `Optimizing ${primaryObjective} with constraints on other objectives`,
+          { tags: ["discovery"] }
         );
       }
       const constraintMetric = async ({ prediction, example }) => {
@@ -10470,9 +11306,9 @@ var AxBaseOptimizer = class {
         });
       } catch (error) {
         if (options?.verbose) {
-          console.warn(
-            `Failed constraint optimization for ${primaryObjective}:`,
-            error
+          this.getLogger(options)?.(
+            `Failed constraint optimization for ${primaryObjective}: ${error}`,
+            { tags: ["warning"] }
           );
         }
         continue;
@@ -10707,6 +11543,39 @@ var AxBaseOptimizer = class {
       );
     }
   }
+  /**
+   * Get the logger function with fallback hierarchy:
+   * 1. Explicit logger passed to optimizer
+   * 2. Logger from student AI service
+   * 3. Default optimizer logger
+   * 4. undefined if verbose is false
+   */
+  getLogger(options) {
+    const isVerbose = this.isLoggingEnabled(options);
+    if (!isVerbose) {
+      return void 0;
+    }
+    if (this.logger) {
+      return this.logger;
+    }
+    try {
+      const aiLogger = this.studentAI.getLogger();
+      if (aiLogger) {
+        return aiLogger;
+      }
+    } catch {
+    }
+    return axDefaultOptimizerLogger;
+  }
+  /**
+   * Check if logging is enabled based on verbose settings
+   */
+  isLoggingEnabled(options) {
+    if (options?.verbose !== void 0) {
+      return options.verbose;
+    }
+    return this.verbose ?? true;
+  }
 };
 
 // db/base.ts
@@ -11425,23 +12294,6 @@ var getTopInPercent = (entries, percent = 0.1) => {
   return sortedEntries.slice(0, topTenPercentCount);
 };
 
-// docs/rewriter.ts
-var AxDefaultQueryRewriter = class extends AxGen {
-  constructor(options) {
-    const signature = `"You are a query rewriter assistant tasked with rewriting a given query to improve its clarity, specificity, and relevance. Your role involves analyzing the query to identify any ambiguities, generalizations, or irrelevant information and then rephrasing it to make it more focused and precise. The rewritten query should be concise, easy to understand, and directly related to the original query. Output only the rewritten query."
-    query: string -> rewrittenQuery: string`;
-    super(signature, options);
-  }
-};
-var AxRewriter = class extends AxGen {
-  constructor(options) {
-    super(
-      '"Rewrite a given text to be clear and concise" original -> rewritten "improved text"',
-      options
-    );
-  }
-};
-
 // funcs/docker.ts
 var AxDockerSession = class {
   apiUrl;
@@ -12289,9 +13141,9 @@ var AxBootstrapFewShot = class extends AxBaseOptimizer {
         this.stats.earlyStopped = true;
         this.stats.earlyStopping.reason = `No improvement for ${this.earlyStoppingPatience} rounds`;
         if (this.verboseMode || this.debugMode) {
-          console.log(
-            `
-Early stopping triggered after ${roundIndex + 1} rounds. No improvement for ${this.earlyStoppingPatience} rounds.`
+          this.getLogger()?.(
+            `Early stopping after ${roundIndex + 1} rounds (no improvement for ${this.earlyStoppingPatience} rounds)`,
+            { tags: ["optimizer", "warning"] }
           );
         }
         return;
@@ -12302,6 +13154,16 @@ Early stopping triggered after ${roundIndex + 1} rounds. No improvement for ${th
     const maxRounds = options?.maxIterations ?? this.maxRounds;
     this.traces = [];
     this.reset();
+    if (this.verboseMode || this.debugMode) {
+      this.getLogger()?.(
+        `Starting BootstrapFewshot optimization with ${maxRounds} rounds`,
+        { tags: ["optimizer", "start"] }
+      );
+      this.getLogger()?.(
+        `Using ${this.examples.length} examples, max ${this.maxDemos} demos`,
+        { tags: ["optimizer", "config"] }
+      );
+    }
     for (let i = 0; i < maxRounds; i++) {
       await this.compileRound(program, i, metricFn, options);
       if (this.stats.earlyStopped) {
@@ -12318,6 +13180,12 @@ Early stopping triggered after ${roundIndex + 1} rounds. No improvement for ${th
     if (this.traces.length > 0) {
       bestScore = this.stats.successfulDemos / Math.max(1, this.stats.totalCalls);
     }
+    if (this.verboseMode || this.debugMode) {
+      this.getLogger()?.(
+        `Bootstrap complete. Generated ${demos.length} demos with ${bestScore.toFixed(3)} success rate`,
+        { tags: ["optimizer", "complete"] }
+      );
+    }
     return {
       demos,
       stats: this.stats,
@@ -12383,7 +13251,6 @@ var AxMiPRO = class extends AxBaseOptimizer {
   viewDataBatchSize;
   tipAwareProposer;
   fewshotAwareProposer;
-  verbose;
   earlyStoppingTrials;
   minImprovementThreshold;
   bayesianOptimization;
@@ -12405,7 +13272,6 @@ var AxMiPRO = class extends AxBaseOptimizer {
     this.viewDataBatchSize = options.viewDataBatchSize ?? 10;
     this.tipAwareProposer = options.tipAwareProposer ?? true;
     this.fewshotAwareProposer = options.fewshotAwareProposer ?? true;
-    this.verbose = options.verbose ?? false;
     this.earlyStoppingTrials = options.earlyStoppingTrials ?? 5;
     this.minImprovementThreshold = options.minImprovementThreshold ?? 0.01;
     this.bayesianOptimization = options.bayesianOptimization ?? false;
@@ -12496,8 +13362,10 @@ var AxMiPRO = class extends AxBaseOptimizer {
    * Bootstraps few-shot examples for the program
    */
   async bootstrapFewShotExamples(program, metricFn) {
-    if (this.verbose) {
-      console.log("Bootstrapping few-shot examples...");
+    if (this.isLoggingEnabled()) {
+      this.getLogger()?.("Bootstrapping few-shot examples...", {
+        tags: ["optimizer", "phase"]
+      });
     }
     const bootstrapper = new AxBootstrapFewShot({
       studentAI: this.studentAI,
@@ -12505,7 +13373,7 @@ var AxMiPRO = class extends AxBaseOptimizer {
       options: {
         maxDemos: this.maxBootstrappedDemos,
         maxRounds: 3,
-        verboseMode: this.verbose
+        verboseMode: this.isLoggingEnabled()
       }
     });
     const result = await bootstrapper.compile(program, metricFn, {
@@ -12550,9 +13418,10 @@ var AxMiPRO = class extends AxBaseOptimizer {
         options
       );
       if (checkpoint && checkpoint.optimizerType === "MiPRO") {
-        if (this.verbose || options?.verbose) {
-          console.log(
-            `Resuming from checkpoint at round ${checkpoint.currentRound}`
+        if (this.isLoggingEnabled(options)) {
+          this.getLogger(options)?.(
+            `Resuming from checkpoint at round ${checkpoint.currentRound}`,
+            { tags: ["optimizer", "checkpoint"] }
           );
         }
         this.restoreFromCheckpoint(checkpoint);
@@ -12562,6 +13431,12 @@ var AxMiPRO = class extends AxBaseOptimizer {
         stagnationRounds = checkpoint.stats.convergenceInfo?.stagnationRounds || 0;
       }
     }
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Running optimization trials (${this.numTrials} total)`,
+        { tags: ["optimizer", "phase"] }
+      );
+    }
     for (let i = startRound; i < this.numTrials; i++) {
       const config = {
         instruction: instructions[i % instructions.length] || instructions[0] || "",
@@ -12588,6 +13463,12 @@ var AxMiPRO = class extends AxBaseOptimizer {
         bestScore = score;
         bestConfig = config;
         stagnationRounds = 0;
+        if (this.isLoggingEnabled(options)) {
+          this.getLogger(options)?.(
+            `Trial ${i + 1}/${this.numTrials}: New best score ${bestScore.toFixed(3)}`,
+            { tags: ["optimizer", "progress"] }
+          );
+        }
       } else {
         stagnationRounds++;
       }
@@ -12706,38 +13587,53 @@ var AxMiPRO = class extends AxBaseOptimizer {
       this.configureAuto(miproOptions.auto);
     }
     const valset = this.getValidationSet(options) || (miproOptions?.valset ?? this.examples.slice(0, Math.floor(this.examples.length * 0.2)));
-    if (this.verbose || options?.verbose) {
-      console.log(`Starting MIPROv2 optimization with ${this.numTrials} trials`);
-      console.log(
-        `Using ${this.examples.length} examples for training and ${valset.length} for validation`
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Starting MIPROv2 optimization with ${this.numTrials} trials`,
+        { tags: ["optimizer", "start"] }
+      );
+      this.getLogger(options)?.(
+        `Using ${this.examples.length} examples for training and ${valset.length} for validation`,
+        { tags: ["optimizer", "config"] }
       );
       if (this.teacherAI) {
-        console.log("Using separate teacher model for instruction generation");
+        this.getLogger(options)?.(
+          "Using separate teacher model for instruction generation",
+          { tags: ["optimizer", "config"] }
+        );
       }
     }
     let bootstrappedDemos = [];
     if (this.maxBootstrappedDemos > 0) {
       bootstrappedDemos = await this.bootstrapFewShotExamples(program, metricFn);
-      if (this.verbose) {
-        console.log(
-          `Generated ${bootstrappedDemos.length} bootstrapped demonstrations`
+      if (this.isLoggingEnabled(options)) {
+        this.getLogger(options)?.(
+          `Generated ${bootstrappedDemos.length} bootstrapped demonstrations`,
+          { tags: ["optimizer", "result"] }
         );
       }
     }
     let labeledExamples = [];
     if (this.maxLabeledDemos > 0) {
       labeledExamples = this.selectLabeledExamples();
-      if (this.verbose) {
-        console.log(
-          `Selected ${labeledExamples.length} labeled examples from training set`
+      if (this.isLoggingEnabled(options)) {
+        this.getLogger(options)?.(
+          `Selected ${labeledExamples.length} labeled examples from training set`,
+          { tags: ["optimizer", "result"] }
         );
       }
     }
     const instructions = await this.proposeInstructionCandidates(options);
-    if (this.verbose) {
-      console.log(`Generated ${instructions.length} instruction candidates`);
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Generated ${instructions.length} instruction candidates`,
+        { tags: ["optimizer", "result"] }
+      );
       if (this.hasTeacherAI(options)) {
-        console.log("Using teacher AI for instruction generation");
+        this.getLogger(options)?.(
+          "Using teacher AI for instruction generation",
+          { tags: ["optimizer", "config"] }
+        );
       }
     }
     const { bestConfig, bestScore } = await this.runOptimization(
@@ -12749,9 +13645,15 @@ var AxMiPRO = class extends AxBaseOptimizer {
       metricFn,
       options
     );
-    if (this.verbose || options?.verbose) {
-      console.log(`Optimization complete. Best score: ${bestScore}`);
-      console.log(`Best configuration: ${JSON.stringify(bestConfig)}`);
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Optimization complete. Best score: ${bestScore}`,
+        { tags: ["optimizer", "complete"] }
+      );
+      this.getLogger(options)?.(
+        `Best configuration: ${JSON.stringify(bestConfig)}`,
+        { tags: ["optimizer", "result"] }
+      );
     }
     if (this.checkTargetScore(bestScore)) {
       this.triggerEarlyStopping(
@@ -12878,9 +13780,6 @@ var AxMiPRO = class extends AxBaseOptimizer {
     if (config.minImprovementThreshold !== void 0) {
       this.minImprovementThreshold = config.minImprovementThreshold;
     }
-    if (config.verbose !== void 0) {
-      this.verbose = config.verbose;
-    }
   }
   /**
    * Reset optimizer state for reuse with different programs
@@ -12985,6 +13884,7 @@ var AxMockAIService = class {
     return this.config.chatResponse ?? {
       results: [
         {
+          index: 0,
           content: "Mock response",
           finishReason: "stop"
         }
@@ -15285,7 +16185,6 @@ export {
   AxDBPinecone,
   AxDBWeaviate,
   AxDefaultCostTracker,
-  AxDefaultQueryRewriter,
   AxDefaultResultReranker,
   AxDockerSession,
   AxEmbeddingAdapter,
@@ -15312,7 +16211,6 @@ export {
   AxPromptTemplate,
   AxRAG,
   AxRateLimiterTokenUsage,
-  AxRewriter,
   AxSignature,
   AxSimpleClassifier,
   AxSimpleClassifierClass,
@@ -15354,6 +16252,10 @@ export {
   axAITogetherDefaultConfig,
   axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig,
+  axCreateDefaultLogger,
+  axCreateDefaultTextLogger,
+  axCreateOptimizerLogger,
+  axDefaultOptimizerLogger,
   axGlobals,
   axModelInfoAnthropic,
   axModelInfoCohere,
@@ -15368,6 +16270,8 @@ export {
   axModelInfoTogether,
   axSpanAttributes,
   axSpanEvents,
+  axValidateChatRequestMessage,
+  axValidateChatResponseResult,
   f,
   s
 };