@ax-llm/ax 12.0.9 → 12.0.12

package/index.js

@@ -1212,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
@@ -1283,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,
@@ -1334,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()) {
@@ -1472,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) {
@@ -1640,26 +1648,6 @@ function validateAxMessageArray(values) {
     }
   }
 }
-function validateChatPrompt(chatPrompt) {
-  for (let i = 0; i < chatPrompt.length; i++) {
-    const message = chatPrompt[i];
-    if (message && "functionCalls" in message && Array.isArray(message.functionCalls) && message.functionCalls.length === 0) {
-      throw new Error(
-        `Chat prompt validation failed: Message at index ${i} has empty functionCalls`
-      );
-    }
-    if (message && "content" in message && Array.isArray(message.content) && message.content.length === 0) {
-      throw new Error(
-        `Chat prompt validation failed: Message at index ${i} has empty content`
-      );
-    }
-    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) {
@@ -1731,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
   {
@@ -1746,7 +1738,9 @@ var axModelInfoAnthropic = [
     currency: "usd",
     promptTokenCostPer1M: 3,
     completionTokenCostPer1M: 15,
-    maxTokens: 64e3
+    maxTokens: 64e3,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
   },
   // 3.5
   {
@@ -1802,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 {
@@ -1817,6 +1845,7 @@ var AxAIAnthropicImpl = class {
     this.isVertex = isVertex;
   }
   tokensUsed;
+  currentPromptConfig;
   getTokenUsage() {
     return this.tokensUsed;
   }
@@ -1835,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;
@@ -1891,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];
@@ -1911,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: [
             {
@@ -1928,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,
@@ -1953,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,
@@ -1967,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") {
@@ -1984,7 +2089,7 @@ var AxAIAnthropicImpl = class {
             }
           ];
           return {
-            results: [{ functionCalls }]
+            results: [{ index, functionCalls }]
           };
         }
       }
@@ -1993,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") {
@@ -2012,7 +2133,7 @@ var AxAIAnthropicImpl = class {
           }
         ];
         return {
-          results: [{ functionCalls }]
+          results: [{ index, functionCalls }]
         };
       }
     }
@@ -2024,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: "" }]
     };
   };
 };
@@ -2071,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,
@@ -2078,7 +2217,7 @@ var AxAIAnthropic = class extends AxBaseAI {
       modelInfo: axModelInfoAnthropic,
       defaults: { model: _config.model },
       options,
-      supportFor: { functions: true, streaming: true, functionCot: true },
+      supportFor,
       models
     });
   }
@@ -2208,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";
@@ -2558,6 +2681,7 @@ var AxAIOpenAIImpl = class {
         })
       );
       return {
+        index: choice.index,
         id: `${choice.index}`,
         content: choice.message.content,
         thought: choice.message.reasoning_content,
@@ -2583,6 +2707,7 @@ var AxAIOpenAIImpl = class {
     }
     const results = choices.map(
       ({
+        index,
         delta: {
           content,
           role,
@@ -2592,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;
           }
@@ -2607,6 +2732,7 @@ var AxAIOpenAIImpl = class {
           };
         }).filter((v) => v !== null);
         return {
+          index,
           content,
           role,
           thought,
@@ -2641,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 };
@@ -2690,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"
           );
@@ -2710,6 +2836,7 @@ function createMessages2(req) {
         throw new Error("Invalid role");
     }
   });
+  return openaiReq;
 }
 var AxAIOpenAIBase = class extends AxBaseAI {
   constructor({
@@ -3063,6 +3190,7 @@ var AxAICohereImpl = class {
     }
     const results = [
       {
+        index: 0,
         id: resp.generation_id,
         content: resp.text,
         functionCalls,
@@ -3695,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";
@@ -4092,6 +4220,7 @@ ${fc}`;
     return {
       results: [
         {
+          index: 0,
           content: resp.generated_text
         }
       ]
@@ -4733,7 +4862,7 @@ var AxAIOpenAIResponsesImpl = class {
       }
     }
     return {
-      results: [currentResult],
+      results: [{ ...currentResult, index: 0 }],
       remoteId: id
     };
   }
@@ -4741,6 +4870,7 @@ var AxAIOpenAIResponsesImpl = class {
   createChatStreamResp(streamEvent) {
     const event = streamEvent;
     const baseResult = {
+      index: 0,
       id: "",
       content: "",
       finishReason: "stop"
@@ -5308,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") {
@@ -5317,6 +5447,7 @@ var AxAIRekaImpl = class {
         content = res.message.content.text;
       }
       return {
+        index,
         id: `${id}`,
         content,
         finishReason
@@ -5331,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") {
@@ -5340,6 +5471,7 @@ var AxAIRekaImpl = class {
         content = res.chunk.content.text;
       }
       return {
+        index,
         id: `${id}`,
         content,
         finishReason
@@ -5693,116 +5825,330 @@ 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;
+// ai/validate.ts
+function axValidateChatRequestMessage(item) {
+  if (!item) {
+    throw new Error("Chat request message item cannot be null or undefined");
+  }
+  if (!item.role) {
+    throw new Error("Chat request message must have a role");
+  }
+  switch (item.role) {
+    case "system":
+      if (!item.content || item.content.trim() === "") {
+        throw new Error(
+          "System message content cannot be empty or whitespace-only"
+        );
       }
-      if (typeof _fc.function.params == "string" && _fc.function.params.length > 0) {
-        fc.function.params += _fc.function.params;
+      break;
+    case "user":
+      if (!item.content) {
+        throw new Error("User message content cannot be undefined");
       }
-      if (typeof _fc.function.params == "object") {
-        fc.function.params = _fc.function.params;
+      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"
+        );
       }
-    } else {
-      functionCalls.push(_fc);
-    }
+      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}`
+      );
   }
 }
-
-// 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);
-    }
+function axValidateChatResponseResult(results) {
+  const resultsArray = Array.isArray(results) ? results : [results];
+  if (resultsArray.length === 0) {
+    throw new Error("Chat response results cannot be empty");
   }
-  add(value) {
-    this.addMemory(value);
-    if (this.options?.debug) {
-      debugRequest(value, this.options?.debugHideSystemPrompt);
+  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`
+      );
     }
-  }
-  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 });
+    if (typeof result.index !== "number") {
+      throw new Error(
+        `Chat response result at index ${arrayIndex} must have a numeric index`
+      );
     }
-  }
-  addResult({
-    content,
-    name,
-    functionCalls
-  }) {
-    this.addResultMessage({ content, name, functionCalls });
-    if (this.options?.debug) {
-      debugResponse({ content, name, functionCalls });
+    if (result.index < 0) {
+      throw new Error(
+        `Chat response result at index ${arrayIndex} must have a non-negative index`
+      );
     }
-  }
-  updateResult({
-    content,
-    name,
-    functionCalls,
-    delta
-  }) {
-    const lastItem = this.data.at(-1);
-    if (!lastItem || lastItem.chat.role !== "assistant") {
-      throw new Error("No assistant message to update");
+    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 (typeof content === "string" && content.trim() !== "") {
-      lastItem.chat.content = content;
+    if (result.content !== void 0 && typeof result.content !== "string") {
+      throw new Error(
+        `Chat response result content at index ${arrayIndex} must be a string`
+      );
     }
-    if (name && name.trim() !== "") {
-      lastItem.chat.name = name;
+    if (result.thought !== void 0 && typeof result.thought !== "string") {
+      throw new Error(
+        `Chat response result thought at index ${arrayIndex} must be a string`
+      );
     }
-    if (functionCalls && functionCalls.length > 0) {
-      lastItem.chat.functionCalls = functionCalls;
+    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 (this.options?.debug) {
-      if (delta && typeof delta === "string") {
-        debugResponseDelta(delta);
-      } else if (!delta && (content || functionCalls)) {
-        debugResponse({ content, name, functionCalls });
+    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`
+        );
       }
     }
-  }
-  addTag(name) {
-    const lastItem = this.data.at(-1);
-    if (!lastItem) {
-      return;
+    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(", ")}`
+        );
+      }
+    }
+  }
+}
+
+// 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) {
+      for (const result of results) {
+        debugResponse(result);
+      }
+    }
+  }
+  updateResult({
+    content,
+    name,
+    functionCalls,
+    delta,
+    index
+  }) {
+    const lastItem = this.data.at(-1);
+    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;
+    }
+    const chat = lastItem.chat.find((v) => v.index === index);
+    if (!chat) {
+      lastItem.chat.push({
+        index,
+        value: structuredClone({ content, name, functionCalls })
+      });
+      log();
+      return;
+    }
+    if ("content" in chat.value && typeof content === "string" && content.trim() !== "") {
+      chat.value.content = content;
+    }
+    if ("name" in chat.value && name && name.trim() !== "") {
+      chat.value.name = name;
+    }
+    if ("functionCalls" in chat.value && functionCalls && functionCalls.length > 0) {
+      chat.value.functionCalls = functionCalls;
+    }
+    log();
+  }
+  addTag(name) {
+    const lastItem = this.data.at(-1);
+    if (!lastItem) {
+      return;
     }
     if (!lastItem.tags) {
       lastItem.tags = [];
@@ -5816,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) => {
@@ -5829,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;
@@ -5859,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);
@@ -5878,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();
@@ -5888,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));
     }
   }
 };
@@ -5969,8 +6334,156 @@ var assertStreamingAssertions = async (asserts, xstate, content, final = false)
   }
 };
 
+// dsp/errors.ts
+var ValidationError = class extends Error {
+  fields;
+  constructor({
+    message,
+    fields
+  }) {
+    super(message);
+    this.fields = fields;
+    this.name = this.constructor.name;
+  }
+  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.`
+    }));
+  };
+  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();
@@ -6133,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;
@@ -6261,904 +6780,340 @@ 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());
+// 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];
     }
-    task.push(formattingRules.trim());
-    const desc = this.sig.getDescription();
-    if (desc) {
-      const text = formatDescription(desc);
-      task.push(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);
     }
-    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;
-      }
+  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;
     }
-    const systemPrompt = {
-      role: "system",
-      content: systemContent
-    };
-    if (Array.isArray(values)) {
-      let messages = [];
-      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") {
-          messages.push({ role: "user", content });
+    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]
+          });
         }
-        messages.push({ role: "assistant", content });
-      }
-      return [systemPrompt, ...messages];
+        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");
-        }
-        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.");
+  }
+  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;
         }
-        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 number");
       }
-      return result;
+      return v;
     }
-    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
-            };
-          })
-        );
+    case "boolean": {
+      if (typeof val === "boolean") {
+        return val;
+      }
+      const v = val.toLowerCase();
+      if (v === "true") {
+        return true;
+      } else if (v === "false") {
+        return false;
       } else {
-        const validated = validateAudio(value);
-        result.push({
-          type: "audio",
-          format: validated.format ?? "wav",
-          data: validated.data
-        });
+        if (field.isOptional && !required) {
+          return;
+        }
+        throw new Error("Invalid boolean");
       }
-      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 += `. `;
+    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(", ")}`
+        );
       }
-      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";
+}
+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);
+  }
+  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;
     }
-  })();
-  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);
+    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;
       }
-    } else {
-      acc.push(current);
+      continue;
+    }
+    if (!xstate.streamedIndex[key]) {
+      yield { index, delta: { [key]: value } };
+      xstate.streamedIndex[key] = 1;
     }
-    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.`);
-  }
-  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;
-  }
-  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"]
+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
     });
   }
-}
-
-// 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, 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];
-    }
-  }
-};
-var checkMissingRequiredFields = (xstate, values, outputFields) => {
-  const missingFields = [];
-  for (const field of outputFields) {
-    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, strictMode = false) => {
-  const fields = sig.getOutputFields();
-  let expectedField;
-  for (const [index, field] of fields.entries()) {
-    if (index === xstate.currFieldIndex) {
-      continue;
-    }
-    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);
-    let prefixLen = prefix.length;
-    switch (e) {
-      case -1:
-        if (!strictMode && fields.length === 1 && xstate.currField === void 0) {
-          prefixLen = 0;
-          e = 0;
-          break;
-        }
-        if (xstate.currField === void 0 && !field.isOptional) {
-          throw new ValidationError({
-            message: "Expected (Required) field not found",
-            fields: [field]
-          });
-        }
-        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;
-    }
-    if (expectedField && expectedField.name !== field.name) {
-      throw new ValidationError({
-        message: "Expected (Required) field not found",
-        fields: [expectedField]
-      });
-    }
-    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 }];
-      }
-    }
-    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;
-    }
-  }
-};
-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;
-    }
-  }
-  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;
-        }
-        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*$/, "");
+    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, {
@@ -7179,7 +7134,10 @@ var addToMemory = (field, mem, result, sessionId) => {
     2
   );
   const text = getFieldProcessingMessage(field, resultText);
-  mem.add({ role: "user", content: [{ type: "text", text }] }, sessionId);
+  mem.addRequest(
+    [{ role: "user", content: [{ type: "text", text }] }],
+    sessionId
+  );
   mem.addTag(`processor`, sessionId);
 };
 function getFieldProcessingMessage(field, resultText) {
@@ -7438,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(
@@ -7480,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) => {
@@ -7493,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) {
@@ -7512,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:
@@ -7544,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;
@@ -7564,23 +7532,28 @@ 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/processResponse.ts
+import "stream/web";
+
+// 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";
@@ -8465,357 +8438,1153 @@ var AxSignature = class _AxSignature {
       );
     }
   };
-  getInputFields = () => this.inputFields;
-  getOutputFields = () => this.outputFields;
-  getDescription = () => this.description;
-  invalidateValidationCache = () => {
-    this.validatedAtHash = void 0;
-  };
-  toTitle = (name) => {
-    let result = name.replace(/_/g, " ");
-    result = result.replace(/([A-Z]|[0-9]+)/g, " $1").trim();
-    return result.charAt(0).toUpperCase() + result.slice(1);
-  };
-  toJSONSchema = () => {
-    const properties = {};
-    const required = [];
-    for (const f2 of this.inputFields) {
-      const type = f2.type ? f2.type.name : "string";
-      if (f2.type?.isArray) {
-        properties[f2.name] = {
-          description: f2.description,
-          type: "array",
-          items: {
-            type,
-            description: f2.description
-          }
+  getInputFields = () => this.inputFields;
+  getOutputFields = () => this.outputFields;
+  getDescription = () => this.description;
+  invalidateValidationCache = () => {
+    this.validatedAtHash = void 0;
+  };
+  toTitle = (name) => {
+    let result = name.replace(/_/g, " ");
+    result = result.replace(/([A-Z]|[0-9]+)/g, " $1").trim();
+    return result.charAt(0).toUpperCase() + result.slice(1);
+  };
+  toJSONSchema = () => {
+    const properties = {};
+    const required = [];
+    for (const f2 of this.inputFields) {
+      const type = f2.type ? f2.type.name : "string";
+      if (f2.type?.isArray) {
+        properties[f2.name] = {
+          description: f2.description,
+          type: "array",
+          items: {
+            type,
+            description: f2.description
+          }
+        };
+      } else {
+        properties[f2.name] = {
+          description: f2.description,
+          type
+        };
+      }
+      if (!f2.isOptional) {
+        required.push(f2.name);
+      }
+    }
+    const schema = {
+      type: "object",
+      properties,
+      required
+    };
+    return schema;
+  };
+  updateHashLight = () => {
+    try {
+      this.getInputFields().forEach((field) => {
+        validateField(field, "input");
+      });
+      this.getOutputFields().forEach((field) => {
+        validateField(field, "output");
+      });
+      this.sigHash = createHash("sha256").update(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
+      this.sigString = renderSignature(
+        this.description,
+        this.inputFields,
+        this.outputFields
+      );
+      return [this.sigHash, this.sigString];
+    } catch (error) {
+      if (error instanceof AxSignatureValidationError) {
+        throw error;
+      }
+      throw new AxSignatureValidationError(
+        `Signature validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  };
+  updateHash = () => {
+    try {
+      this.getInputFields().forEach((field) => {
+        validateField(field, "input");
+      });
+      this.getOutputFields().forEach((field) => {
+        validateField(field, "output");
+      });
+      this.validateSignatureConsistency();
+      this.sigHash = createHash("sha256").update(this.description ?? "").update(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
+      this.sigString = renderSignature(
+        this.description,
+        this.inputFields,
+        this.outputFields
+      );
+      return [this.sigHash, this.sigString];
+    } catch (error) {
+      if (error instanceof AxSignatureValidationError) {
+        throw error;
+      }
+      throw new AxSignatureValidationError(
+        `Signature validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  };
+  validateSignatureConsistency() {
+    const inputNames = /* @__PURE__ */ new Set();
+    for (const field of this.inputFields) {
+      if (inputNames.has(field.name)) {
+        throw new AxSignatureValidationError(
+          `Duplicate input field name: "${field.name}"`,
+          field.name,
+          "Each field name must be unique within the signature"
+        );
+      }
+      inputNames.add(field.name);
+    }
+    const outputNames = /* @__PURE__ */ new Set();
+    for (const field of this.outputFields) {
+      if (outputNames.has(field.name)) {
+        throw new AxSignatureValidationError(
+          `Duplicate output field name: "${field.name}"`,
+          field.name,
+          "Each field name must be unique within the signature"
+        );
+      }
+      outputNames.add(field.name);
+    }
+    for (const outputField of this.outputFields) {
+      if (inputNames.has(outputField.name)) {
+        throw new AxSignatureValidationError(
+          `Field name "${outputField.name}" appears in both inputs and outputs`,
+          outputField.name,
+          "Use different names for input and output fields to avoid confusion"
+        );
+      }
+    }
+    if (this.inputFields.length === 0) {
+      throw new AxSignatureValidationError(
+        "Signature must have at least one input field",
+        void 0,
+        'Add an input field. Example: "userInput:string -> ..."'
+      );
+    }
+    if (this.outputFields.length === 0) {
+      throw new AxSignatureValidationError(
+        "Signature must have at least one output field",
+        void 0,
+        'Add an output field. Example: "... -> responseText:string"'
+      );
+    }
+  }
+  validate = () => {
+    if (this.validatedAtHash === this.sigHash) {
+      return true;
+    }
+    try {
+      this.updateHash();
+      this.validatedAtHash = this.sigHash;
+      return true;
+    } catch (error) {
+      this.validatedAtHash = void 0;
+      throw error;
+    }
+  };
+  hash = () => this.sigHash;
+  toString = () => this.sigString;
+  toJSON = () => {
+    return {
+      id: this.hash(),
+      description: this.description,
+      inputFields: this.inputFields,
+      outputFields: this.outputFields
+    };
+  };
+};
+function renderField(field) {
+  let result = field.name;
+  if (field.isOptional) {
+    result += "?";
+  }
+  if (field.isInternal) {
+    result += "!";
+  }
+  if (field.type) {
+    result += ":" + field.type.name;
+    if (field.type.isArray) {
+      result += "[]";
+    }
+    if (field.type.name === "class" && field.type.options) {
+      result += ` "${field.type.options.join(" | ")}"`;
+    }
+  }
+  if (field.description && field.type?.name !== "class") {
+    result += ` "${field.description}"`;
+  }
+  return result;
+}
+function renderSignature(description, inputFields, outputFields) {
+  const descriptionPart = description ? `"${description}" ` : "";
+  const inputFieldsRendered = inputFields.map(renderField).join(", ");
+  const outputFieldsRendered = outputFields.map(renderField).join(", ");
+  return `${descriptionPart}${inputFieldsRendered} -> ${outputFieldsRendered}`;
+}
+function isValidCase(inputString) {
+  const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
+  const snakeCaseRegex = /^[a-z]+(_[a-z0-9]+)*$/;
+  return camelCaseRegex.test(inputString) || snakeCaseRegex.test(inputString);
+}
+function validateField(field, context3) {
+  if (!field.name || field.name.length === 0) {
+    throw new AxSignatureValidationError(
+      "Field name cannot be blank",
+      field.name,
+      "Every field must have a descriptive name"
+    );
+  }
+  if (!isValidCase(field.name)) {
+    throw new AxSignatureValidationError(
+      `Invalid field name '${field.name}' - must be camelCase or snake_case`,
+      field.name,
+      'Use camelCase (e.g., "userInput") or snake_case (e.g., "user_input")'
+    );
+  }
+  if (axGlobals.signatureStrict) {
+    const reservedNames = [
+      "text",
+      "object",
+      "image",
+      "string",
+      "number",
+      "boolean",
+      "json",
+      "array",
+      "datetime",
+      "date",
+      "time",
+      "type",
+      "class",
+      "input",
+      "output",
+      "data",
+      "value",
+      "result",
+      "response",
+      "request",
+      "item",
+      "element"
+    ];
+    if (reservedNames.includes(field.name.toLowerCase())) {
+      const suggestions = context3 === "input" ? [
+        "userInput",
+        "questionText",
+        "documentContent",
+        "messageText",
+        "queryString"
+      ] : [
+        "responseText",
+        "analysisResult",
+        "categoryType",
+        "summaryText",
+        "outputData"
+      ];
+      throw new AxSignatureValidationError(
+        `Field name '${field.name}' is too generic`,
+        field.name,
+        `Use a more descriptive name. Examples for ${context3} fields: ${suggestions.join(", ")}`
+      );
+    }
+  }
+  if (field.name.length < 2) {
+    throw new AxSignatureValidationError(
+      `Field name '${field.name}' is too short`,
+      field.name,
+      "Field names must be at least 2 characters long"
+    );
+  }
+  if (field.name.length > 50) {
+    throw new AxSignatureValidationError(
+      `Field name '${field.name}' is too long (${field.name.length} characters)`,
+      field.name,
+      "Field names should be 50 characters or less"
+    );
+  }
+  if (field.type) {
+    validateFieldType(field, context3);
+  }
+}
+function validateFieldType(field, context3) {
+  if (!field.type) return;
+  const { type } = field;
+  if (type.name === "image" || type.name === "audio") {
+    if (context3 === "output") {
+      throw new AxSignatureValidationError(
+        `${type.name} type is not supported in output fields`,
+        field.name,
+        `${type.name} types can only be used in input fields`
+      );
+    }
+    if (type.isArray) {
+      throw new AxSignatureValidationError(
+        `Arrays of ${type.name} are not supported`,
+        field.name,
+        `Use a single ${type.name} type instead`
+      );
+    }
+  }
+  if (type.name === "class") {
+    if (context3 === "input") {
+      throw new AxSignatureValidationError(
+        "Class type is not supported in input fields",
+        field.name,
+        'Class types are only allowed on output fields. Use "string" type for input classifications'
+      );
+    }
+    if (!type.options || type.options.length === 0) {
+      throw new AxSignatureValidationError(
+        "Class type requires options",
+        field.name,
+        'Provide class options. Example: class "positive, negative, neutral"'
+      );
+    }
+    for (const option of type.options) {
+      if (!option || option.trim().length === 0) {
+        throw new AxSignatureValidationError(
+          "Empty class option found",
+          field.name,
+          "All class options must be non-empty strings"
+        );
+      }
+      const trimmedOption = option.trim();
+      if (trimmedOption.includes(",") || trimmedOption.includes("|")) {
+        throw new AxSignatureValidationError(
+          `Invalid class option "${trimmedOption}"`,
+          field.name,
+          "Class options cannot contain commas (,) or pipes (|) as they are used to separate options"
+        );
+      }
+    }
+    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 {
-        properties[f2.name] = {
-          description: f2.description,
-          type
+      } else if (fields.length > 1) {
+        const valuesList = fields.map((field) => `- ${field.description}`).join("\n");
+        return {
+          title,
+          name: fields[0].name,
+          description: valuesList
         };
       }
-      if (!f2.isOptional) {
-        required.push(f2.name);
-      }
-    }
-    const schema = {
-      type: "object",
-      properties,
-      required
-    };
-    return schema;
+    }).filter(Boolean);
+    formattedGroupedFields.forEach((field) => {
+      const fn = this.fieldTemplates?.[field.name] ?? this.defaultRenderInField;
+      prompt.push(...fn(field, field.description));
+    });
+    return prompt;
   };
-  updateHashLight = () => {
-    try {
-      this.getInputFields().forEach((field) => {
-        validateField(field, "input");
-      });
-      this.getOutputFields().forEach((field) => {
-        validateField(field, "output");
-      });
-      this.sigHash = createHash("sha256").update(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
-      this.sigString = renderSignature(
-        this.description,
-        this.inputFields,
-        this.outputFields
-      );
-      return [this.sigHash, this.sigString];
-    } catch (error) {
-      if (error instanceof AxSignatureValidationError) {
-        throw error;
+  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" });
       }
-      throw new AxSignatureValidationError(
-        `Signature validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
+      renderedItem.forEach((v) => {
+        if ("text" in v) {
+          v.text = v.text + "\n";
+        }
+        list.push(v);
+      });
     }
+    return list;
   };
-  updateHash = () => {
-    try {
-      this.getInputFields().forEach((field) => {
-        validateField(field, "input");
-      });
-      this.getOutputFields().forEach((field) => {
-        validateField(field, "output");
+  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);
       });
-      this.validateSignatureConsistency();
-      this.sigHash = createHash("sha256").update(this.description ?? "").update(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
-      this.sigString = renderSignature(
-        this.description,
-        this.inputFields,
-        this.outputFields
-      );
-      return [this.sigHash, this.sigString];
-    } catch (error) {
-      if (error instanceof AxSignatureValidationError) {
-        throw error;
-      }
-      throw new AxSignatureValidationError(
-        `Signature validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
     }
+    return list;
   };
-  validateSignatureConsistency() {
-    const inputNames = /* @__PURE__ */ new Set();
-    for (const field of this.inputFields) {
-      if (inputNames.has(field.name)) {
-        throw new AxSignatureValidationError(
-          `Duplicate input field name: "${field.name}"`,
-          field.name,
-          "Each field name must be unique within the signature"
-        );
-      }
-      inputNames.add(field.name);
+  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;
     }
-    const outputNames = /* @__PURE__ */ new Set();
-    for (const field of this.outputFields) {
-      if (outputNames.has(field.name)) {
-        throw new AxSignatureValidationError(
-          `Duplicate output field name: "${field.name}"`,
-          field.name,
-          "Each field name must be unique within the signature"
+    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
+        });
       }
-      outputNames.add(field.name);
+      return result;
     }
-    for (const outputField of this.outputFields) {
-      if (inputNames.has(outputField.name)) {
-        throw new AxSignatureValidationError(
-          `Field name "${outputField.name}" appears in both inputs and outputs`,
-          outputField.name,
-          "Use different names for input and output fields to avoid confusion"
+    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;
     }
-    if (this.inputFields.length === 0) {
-      throw new AxSignatureValidationError(
-        "Signature must have at least one input field",
-        void 0,
-        'Add an input field. Example: "userInput:string -> ..."'
-      );
-    }
-    if (this.outputFields.length === 0) {
-      throw new AxSignatureValidationError(
-        "Signature must have at least one output field",
-        void 0,
-        'Add an output field. Example: "... -> responseText:string"'
-      );
-    }
-  }
-  validate = () => {
-    if (this.validatedAtHash === this.sigHash) {
-      return true;
-    }
-    try {
-      this.updateHash();
-      this.validatedAtHash = this.sigHash;
-      return true;
-    } catch (error) {
-      this.validatedAtHash = void 0;
-      throw error;
+    const text = [field.title, ": "];
+    if (Array.isArray(value)) {
+      text.push("\n");
+      text.push(value.map((v) => `- ${v}`).join("\n"));
+    } else {
+      text.push(value);
     }
-  };
-  hash = () => this.sigHash;
-  toString = () => this.sigString;
-  toJSON = () => {
-    return {
-      id: this.hash(),
-      description: this.description,
-      inputFields: this.inputFields,
-      outputFields: this.outputFields
-    };
+    return [{ type: "text", text: text.join("") }];
   };
 };
-function renderField(field) {
-  let result = field.name;
-  if (field.isOptional) {
-    result += "?";
-  }
-  if (field.isInternal) {
-    result += "!";
-  }
-  if (field.type) {
-    result += ":" + field.type.name;
-    if (field.type.isArray) {
-      result += "[]";
+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.name === "class" && field.type.options) {
-      result += ` "${field.type.options.join(" | ")}"`;
+    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.description && field.type?.name !== "class") {
-    result += ` "${field.description}"`;
-  }
-  return result;
-}
-function renderSignature(description, inputFields, outputFields) {
-  const descriptionPart = description ? `"${description}" ` : "";
-  const inputFieldsRendered = inputFields.map(renderField).join(", ");
-  const outputFieldsRendered = outputFields.map(renderField).join(", ");
-  return `${descriptionPart}${inputFieldsRendered} -> ${outputFieldsRendered}`;
-}
-function isValidCase(inputString) {
-  const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
-  const snakeCaseRegex = /^[a-z]+(_[a-z0-9]+)*$/;
-  return camelCaseRegex.test(inputString) || snakeCaseRegex.test(inputString);
-}
-function validateField(field, context3) {
-  if (!field.name || field.name.length === 0) {
-    throw new AxSignatureValidationError(
-      "Field name cannot be blank",
-      field.name,
-      "Every field must have a descriptive name"
-    );
-  }
-  if (!isValidCase(field.name)) {
-    throw new AxSignatureValidationError(
-      `Invalid field name '${field.name}' - must be camelCase or snake_case`,
-      field.name,
-      'Use camelCase (e.g., "userInput") or snake_case (e.g., "user_input")'
-    );
-  }
-  if (axGlobals.signatureStrict) {
-    const reservedNames = [
-      "text",
-      "object",
-      "image",
-      "string",
-      "number",
-      "boolean",
-      "json",
-      "array",
-      "datetime",
-      "date",
-      "time",
-      "type",
-      "class",
-      "input",
-      "output",
-      "data",
-      "value",
-      "result",
-      "response",
-      "request",
-      "item",
-      "element"
-    ];
-    if (reservedNames.includes(field.name.toLowerCase())) {
-      const suggestions = context3 === "input" ? [
-        "userInput",
-        "questionText",
-        "documentContent",
-        "messageText",
-        "queryString"
-      ] : [
-        "responseText",
-        "analysisResult",
-        "categoryType",
-        "summaryText",
-        "outputData"
-      ];
-      throw new AxSignatureValidationError(
-        `Field name '${field.name}' is too generic`,
-        field.name,
-        `Use a more descriptive name. Examples for ${context3} fields: ${suggestions.join(", ")}`
-      );
-    }
+  if (field.type?.name === "datetime" && value instanceof Date) {
+    return formatDateWithTimezone(value);
   }
-  if (field.name.length < 2) {
-    throw new AxSignatureValidationError(
-      `Field name '${field.name}' is too short`,
-      field.name,
-      "Field names must be at least 2 characters long"
-    );
+  if (field.type?.name === "image" && typeof value === "object") {
+    return value;
   }
-  if (field.name.length > 50) {
-    throw new AxSignatureValidationError(
-      `Field name '${field.name}' is too long (${field.name.length} characters)`,
-      field.name,
-      "Field names should be 50 characters or less"
-    );
+  if (field.type?.name === "audio" && typeof value === "object") {
+    return value;
   }
-  if (field.type) {
-    validateFieldType(field, context3);
+  if (typeof value === "string") {
+    return value;
   }
-}
-function validateFieldType(field, context3) {
-  if (!field.type) return;
-  const { type } = field;
-  if (type.name === "image" || type.name === "audio") {
-    if (context3 === "output") {
-      throw new AxSignatureValidationError(
-        `${type.name} type is not supported in output fields`,
-        field.name,
-        `${type.name} types can only be used in input fields`
-      );
+  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";
     }
-    if (type.isArray) {
-      throw new AxSignatureValidationError(
-        `Arrays of ${type.name} are not supported`,
-        field.name,
-        `Use a single ${type.name} type instead`
-      );
+  })();
+  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 (type.name === "class") {
-    if (context3 === "input") {
-      throw new AxSignatureValidationError(
-        "Class type is not supported in input fields",
-        field.name,
-        'Class types are only allowed on output fields. Use "string" type for input classifications'
-      );
-    }
-    if (!type.options || type.options.length === 0) {
-      throw new AxSignatureValidationError(
-        "Class type requires options",
-        field.name,
-        'Provide class options. Example: class "positive, negative, neutral"'
-      );
-    }
-    for (const option of type.options) {
-      if (!option || option.trim().length === 0) {
-        throw new AxSignatureValidationError(
-          "Empty class option found",
-          field.name,
-          "All class options must be non-empty strings"
-        );
-      }
-      const trimmedOption = option.trim();
-      if (trimmedOption.includes(",") || trimmedOption.includes("|")) {
-        throw new AxSignatureValidationError(
-          `Invalid class option "${trimmedOption}"`,
-          field.name,
-          "Class options cannot contain commas (,) or pipes (|) as they are used to separate options"
-        );
-      }
+  if (!value || (Array.isArray(value) || typeof value === "string") && value.length === 0) {
+    if (context3?.isExample) {
+      return true;
     }
-    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 (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 {
@@ -9018,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;
@@ -9025,10 +9816,8 @@ var AxGen = class extends AxProgramWithSignature {
   streamingAsserts;
   options;
   functions;
-  functionsExecuted = /* @__PURE__ */ new Set();
   fieldProcessors = [];
   streamingFieldProcessors = [];
-  values = {};
   excludeContentFromTrace = false;
   thoughtFieldName;
   constructor(signature, options) {
@@ -9051,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 });
   };
@@ -9091,7 +9894,6 @@ var AxGen = class extends AxProgramWithSignature {
     const {
       sessionId,
       traceId,
-      modelConfig,
       model,
       rateLimiter,
       stream,
@@ -9100,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");
     }
@@ -9109,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,
@@ -9143,7 +9949,9 @@ var AxGen = class extends AxProgramWithSignature {
     const { sessionId, traceId, functions: _functions } = options ?? {};
     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,
@@ -9151,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,
@@ -9161,11 +9969,20 @@ var AxGen = class extends AxProgramWithSignature {
         sessionId,
         functions,
         strictMode,
-        span
+        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,
@@ -9174,233 +9991,18 @@ var AxGen = class extends AxProgramWithSignature {
         sessionId,
         functions,
         span,
-        strictMode
+        strictMode,
+        states,
+        usage,
+        asserts: this.asserts,
+        fieldProcessors: this.fieldProcessors,
+        thoughtFieldName: this.thoughtFieldName,
+        excludeContentFromTrace: this.excludeContentFromTrace,
+        signature: this.signature
       });
     }
   }
-  async *processStreamingResponse({
-    ai,
-    model,
-    res,
-    mem,
-    sessionId,
-    traceId,
-    functions,
-    strictMode,
-    span
-  }) {
-    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,
-          strictMode
-        );
-        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,
-    strictMode
-  }) {
-    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, strictMode);
-        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];
-      }
-    }
-    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;
@@ -9409,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;
@@ -9436,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++) {
@@ -9449,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;
@@ -9513,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
       });
@@ -9564,6 +10160,7 @@ Content: ${result.content}`
       yield* this._forward2(
         ai,
         values,
+        states,
         {
           ...options,
           functions
@@ -9572,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 {
@@ -9582,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, {
@@ -9613,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) {
@@ -11690,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;
@@ -13297,6 +13884,7 @@ var AxMockAIService = class {
     return this.config.chatResponse ?? {
       results: [
         {
+          index: 0,
           content: "Mock response",
           finishReason: "stop"
         }
@@ -15597,7 +16185,6 @@ export {
   AxDBPinecone,
   AxDBWeaviate,
   AxDefaultCostTracker,
-  AxDefaultQueryRewriter,
   AxDefaultResultReranker,
   AxDockerSession,
   AxEmbeddingAdapter,
@@ -15624,7 +16211,6 @@ export {
   AxPromptTemplate,
   AxRAG,
   AxRateLimiterTokenUsage,
-  AxRewriter,
   AxSignature,
   AxSimpleClassifier,
   AxSimpleClassifierClass,
@@ -15684,6 +16270,8 @@ export {
   axModelInfoTogether,
   axSpanAttributes,
   axSpanEvents,
+  axValidateChatRequestMessage,
+  axValidateChatResponseResult,
   f,
   s
 };