@ax-llm/ax 12.0.17 → 12.0.18

package/index.js

@@ -1254,6 +1254,14 @@ var AxBaseAI = class {
     if (options?.showThoughts && !this.getFeatures(model).hasShowThoughts) {
       throw new Error(`Model ${model} does not support showThoughts.`);
     }
+    const modelInfo = this.modelInfo.find(
+      (info) => info.name === model
+    );
+    if (modelInfo?.isExpensive && options?.useExpensiveModel !== "yes") {
+      throw new Error(
+        `Model ${model} is marked as expensive and requires explicit confirmation. Set useExpensiveModel: "yes" to proceed.`
+      );
+    }
     modelConfig.stream = (options?.stream !== void 0 ? options.stream : modelConfig.stream) ?? true;
     const canStream = this.getFeatures(model).streaming;
     if (!canStream) {
@@ -2388,8 +2396,6 @@ function mapFinishReason(stopReason) {
 
 // ai/openai/chat_types.ts
 var AxAIOpenAIModel = /* @__PURE__ */ ((AxAIOpenAIModel2) => {
-  AxAIOpenAIModel2["O1"] = "o1";
-  AxAIOpenAIModel2["O1Mini"] = "o1-mini";
   AxAIOpenAIModel2["GPT4"] = "gpt-4";
   AxAIOpenAIModel2["GPT41"] = "gpt-4.1";
   AxAIOpenAIModel2["GPT41Mini"] = "gpt-4.1-mini";
@@ -2402,6 +2408,11 @@ var AxAIOpenAIModel = /* @__PURE__ */ ((AxAIOpenAIModel2) => {
   AxAIOpenAIModel2["GPT35TextDavinci002"] = "text-davinci-002";
   AxAIOpenAIModel2["GPT3TextBabbage002"] = "text-babbage-002";
   AxAIOpenAIModel2["GPT3TextAda001"] = "text-ada-001";
+  AxAIOpenAIModel2["O1"] = "o1";
+  AxAIOpenAIModel2["O1Mini"] = "o1-mini";
+  AxAIOpenAIModel2["O3"] = "o3";
+  AxAIOpenAIModel2["O3Mini"] = "o3-mini";
+  AxAIOpenAIModel2["O4Mini"] = "o4-mini";
   return AxAIOpenAIModel2;
 })(AxAIOpenAIModel || {});
 var AxAIOpenAIEmbedModel = /* @__PURE__ */ ((AxAIOpenAIEmbedModel2) => {
@@ -2413,8 +2424,6 @@ var AxAIOpenAIEmbedModel = /* @__PURE__ */ ((AxAIOpenAIEmbedModel2) => {
 
 // ai/openai/responses_types.ts
 var AxAIOpenAIResponsesModel = /* @__PURE__ */ ((AxAIOpenAIResponsesModel2) => {
-  AxAIOpenAIResponsesModel2["O1"] = "o1";
-  AxAIOpenAIResponsesModel2["O1Mini"] = "o1-mini";
   AxAIOpenAIResponsesModel2["GPT4"] = "gpt-4";
   AxAIOpenAIResponsesModel2["GPT41"] = "gpt-4.1";
   AxAIOpenAIResponsesModel2["GPT41Mini"] = "gpt-4.1-mini";
@@ -2427,6 +2436,10 @@ var AxAIOpenAIResponsesModel = /* @__PURE__ */ ((AxAIOpenAIResponsesModel2) => {
   AxAIOpenAIResponsesModel2["GPT35TextDavinci002"] = "text-davinci-002";
   AxAIOpenAIResponsesModel2["GPT3TextBabbage002"] = "text-babbage-002";
   AxAIOpenAIResponsesModel2["GPT3TextAda001"] = "text-ada-001";
+  AxAIOpenAIResponsesModel2["O1Pro"] = "o1-pro";
+  AxAIOpenAIResponsesModel2["O1"] = "o1";
+  AxAIOpenAIResponsesModel2["O1Mini"] = "o1-mini";
+  AxAIOpenAIResponsesModel2["O3Pro"] = "o3-pro";
   AxAIOpenAIResponsesModel2["O3"] = "o3";
   AxAIOpenAIResponsesModel2["O3Mini"] = "o3-mini";
   AxAIOpenAIResponsesModel2["O4Mini"] = "o4-mini";
@@ -2435,20 +2448,7 @@ var AxAIOpenAIResponsesModel = /* @__PURE__ */ ((AxAIOpenAIResponsesModel2) => {
 
 // ai/openai/info.ts
 var axModelInfoOpenAI = [
-  {
-    name: "o1" /* O1 */,
-    currency: "usd",
-    promptTokenCostPer1M: 15,
-    completionTokenCostPer1M: 60,
-    hasThinkingBudget: true
-  },
-  {
-    name: "o1-mini" /* O1Mini */,
-    currency: "usd",
-    promptTokenCostPer1M: 1.1,
-    completionTokenCostPer1M: 14.4,
-    hasThinkingBudget: true
-  },
+  // Not Reasoning models
   {
     name: "gpt-4" /* GPT4 */,
     currency: "usd",
@@ -2497,30 +2497,36 @@ var axModelInfoOpenAI = [
     promptTokenCostPer1M: 0.5,
     completionTokenCostPer1M: 1.5
   },
-  // Responses API only models
+  // Reasoning models
+  {
+    name: "o1" /* O1 */,
+    currency: "usd",
+    promptTokenCostPer1M: 15,
+    completionTokenCostPer1M: 60
+  },
+  {
+    name: "o1-mini" /* O1Mini */,
+    currency: "usd",
+    promptTokenCostPer1M: 1.1,
+    completionTokenCostPer1M: 14.4
+  },
   {
     name: "o3" /* O3 */,
     currency: "usd",
     promptTokenCostPer1M: 15,
-    completionTokenCostPer1M: 60,
-    hasThinkingBudget: true,
-    hasShowThoughts: true
+    completionTokenCostPer1M: 60
   },
   {
     name: "o3-mini" /* O3Mini */,
     currency: "usd",
     promptTokenCostPer1M: 1.1,
-    completionTokenCostPer1M: 4.4,
-    hasThinkingBudget: true,
-    hasShowThoughts: true
+    completionTokenCostPer1M: 4.4
   },
   {
     name: "o4-mini" /* O4Mini */,
     currency: "usd",
     promptTokenCostPer1M: 1.1,
-    completionTokenCostPer1M: 4.4,
-    hasThinkingBudget: true,
-    hasShowThoughts: true
+    completionTokenCostPer1M: 4.4
   },
   // Embedding models
   {
@@ -2542,8 +2548,123 @@ var axModelInfoOpenAI = [
     completionTokenCostPer1M: 0.13
   }
 ];
+var axModelInfoOpenAIResponses = [
+  // Not Reasoning models
+  {
+    name: "gpt-4" /* GPT4 */,
+    currency: "usd",
+    promptTokenCostPer1M: 30,
+    completionTokenCostPer1M: 60
+  },
+  {
+    name: "gpt-4.1" /* GPT41 */,
+    currency: "usd",
+    promptTokenCostPer1M: 2,
+    completionTokenCostPer1M: 8
+  },
+  {
+    name: "gpt-4.1-mini" /* GPT41Mini */,
+    currency: "usd",
+    promptTokenCostPer1M: 0.4,
+    completionTokenCostPer1M: 1.6
+  },
+  {
+    name: "gpt-4o" /* GPT4O */,
+    currency: "usd",
+    promptTokenCostPer1M: 5,
+    completionTokenCostPer1M: 15
+  },
+  {
+    name: "gpt-4o-mini" /* GPT4OMini */,
+    currency: "usd",
+    promptTokenCostPer1M: 0.15,
+    completionTokenCostPer1M: 0.6
+  },
+  {
+    name: "chatgpt-4o-latest" /* GPT4ChatGPT4O */,
+    currency: "usd",
+    promptTokenCostPer1M: 5,
+    completionTokenCostPer1M: 15
+  },
+  {
+    name: "gpt-4-turbo" /* GPT4Turbo */,
+    currency: "usd",
+    promptTokenCostPer1M: 10,
+    completionTokenCostPer1M: 30
+  },
+  {
+    name: "gpt-3.5-turbo" /* GPT35Turbo */,
+    currency: "usd",
+    promptTokenCostPer1M: 0.5,
+    completionTokenCostPer1M: 1.5
+  },
+  // Reasoning models
+  {
+    name: "o1-pro" /* O1Pro */,
+    currency: "usd",
+    promptTokenCostPer1M: 150,
+    completionTokenCostPer1M: 600,
+    hasThinkingBudget: true,
+    hasShowThoughts: true,
+    isExpensive: true
+  },
+  {
+    name: "o1" /* O1 */,
+    currency: "usd",
+    promptTokenCostPer1M: 15,
+    completionTokenCostPer1M: 60,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
+  },
+  {
+    name: "o3-pro" /* O3Pro */,
+    currency: "usd",
+    promptTokenCostPer1M: 20,
+    completionTokenCostPer1M: 80,
+    hasThinkingBudget: true,
+    hasShowThoughts: true,
+    isExpensive: true
+  },
+  {
+    name: "o3" /* O3 */,
+    currency: "usd",
+    promptTokenCostPer1M: 15,
+    completionTokenCostPer1M: 60,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
+  },
+  {
+    name: "o3-mini" /* O3Mini */,
+    currency: "usd",
+    promptTokenCostPer1M: 1.1,
+    completionTokenCostPer1M: 4.4,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
+  },
+  {
+    name: "o4-mini" /* O4Mini */,
+    currency: "usd",
+    promptTokenCostPer1M: 1.1,
+    completionTokenCostPer1M: 4.4,
+    hasThinkingBudget: true,
+    hasShowThoughts: true
+  }
+];
 
 // ai/openai/api.ts
+var isOpenAIThinkingModel = (model) => {
+  const thinkingModels = [
+    "o1" /* O1 */,
+    "o1-mini" /* O1Mini */,
+    "o3" /* O3 */,
+    "o3-mini" /* O3Mini */,
+    "o4-mini" /* O4Mini */,
+    // Pro models (string values since they're not in the regular chat enum)
+    "o1-pro",
+    "o3-pro"
+  ];
+  return thinkingModels.includes(model) || thinkingModels.includes(model);
+};
 var axAIOpenAIDefaultConfig = () => structuredClone({
   model: "gpt-4.1" /* GPT41 */,
   embedModel: "text-embedding-3-small" /* TextEmbedding3Small */,
@@ -2607,20 +2728,24 @@ var AxAIOpenAIImpl = class {
     const frequencyPenalty = req.modelConfig?.frequencyPenalty ?? this.config.frequencyPenalty;
     const stream = req.modelConfig?.stream ?? this.config.stream;
     const store = this.config.store;
+    const isThinkingModel = isOpenAIThinkingModel(model);
     let reqValue = {
       model,
       messages,
       response_format: this.config?.responseFormat ? { type: this.config.responseFormat } : void 0,
       tools,
       tool_choice: toolsChoice,
-      max_completion_tokens: req.modelConfig?.maxTokens ?? this.config.maxTokens,
-      temperature: req.modelConfig?.temperature ?? this.config.temperature,
-      top_p: req.modelConfig?.topP ?? this.config.topP ?? 1,
-      n: req.modelConfig?.n ?? this.config.n,
+      // For thinking models, don't set these parameters as they're not supported
+      ...isThinkingModel ? {} : {
+        max_completion_tokens: req.modelConfig?.maxTokens ?? this.config.maxTokens,
+        temperature: req.modelConfig?.temperature ?? this.config.temperature,
+        top_p: req.modelConfig?.topP ?? this.config.topP ?? 1,
+        n: req.modelConfig?.n ?? this.config.n,
+        presence_penalty: req.modelConfig?.presencePenalty ?? this.config.presencePenalty,
+        ...frequencyPenalty ? { frequency_penalty: frequencyPenalty } : {}
+      },
       stop: req.modelConfig?.stopSequences ?? this.config.stop,
-      presence_penalty: req.modelConfig?.presencePenalty ?? this.config.presencePenalty,
       logit_bias: this.config.logitBias,
-      ...frequencyPenalty ? { frequency_penalty: frequencyPenalty } : {},
       ...stream && this.streamingUsage ? { stream: true, stream_options: { include_usage: true } } : {},
       ...store ? { store } : {},
       ...this.config.serviceTier ? { service_tier: this.config.serviceTier } : {},
@@ -4512,6 +4637,18 @@ var AxAIOllama = class extends AxAIOpenAIBase {
 };
 
 // ai/openai/responses_api.ts
+var isOpenAIResponsesThinkingModel = (model) => {
+  const thinkingModels = [
+    "o1" /* O1 */,
+    "o1-mini" /* O1Mini */,
+    "o1-pro" /* O1Pro */,
+    "o3" /* O3 */,
+    "o3-mini" /* O3Mini */,
+    "o3-pro" /* O3Pro */,
+    "o4-mini" /* O4Mini */
+  ];
+  return thinkingModels.includes(model);
+};
 var AxAIOpenAIResponsesImpl = class {
   constructor(config, streamingUsage, responsesReqUpdater) {
     this.config = config;
@@ -4667,10 +4804,37 @@ var AxAIOpenAIResponsesImpl = class {
         parameters: v.parameters ?? {}
       })
     );
-    const includeFields = [];
-    const shouldShowThoughts = config?.thinkingTokenBudget === "none" ? false : config?.showThoughts;
-    if (shouldShowThoughts) {
-      includeFields.push("reasoning.encrypted_content");
+    const includeFields = (
+      // | 'computer_call_output.output.image_url'
+      // | 'reasoning.encrypted_content'
+      // | 'code_interpreter_call.outputs'
+      []
+    );
+    const isThinkingModel = isOpenAIResponsesThinkingModel(model);
+    let reasoningSummary = this.config.reasoningSummary;
+    if (!config?.showThoughts) {
+      reasoningSummary = void 0;
+    } else if (!reasoningSummary) {
+      reasoningSummary = "auto";
+    }
+    let reasoningEffort = this.config.reasoningEffort;
+    if (config?.thinkingTokenBudget) {
+      switch (config.thinkingTokenBudget) {
+        case "none":
+          reasoningEffort = void 0;
+          break;
+        case "minimal":
+          reasoningEffort = "low";
+          break;
+        case "low":
+          reasoningEffort = "medium";
+          break;
+        case "medium":
+        case "high":
+        case "highest":
+          reasoningEffort = "high";
+          break;
+      }
     }
     let mutableReq = {
       model,
@@ -4679,9 +4843,15 @@ var AxAIOpenAIResponsesImpl = class {
       instructions: finalInstructions,
       tools: tools?.length ? tools : void 0,
       tool_choice: req.functionCall === "none" || req.functionCall === "auto" || req.functionCall === "required" ? req.functionCall : typeof req.functionCall === "object" && req.functionCall.function ? { type: "function", name: req.functionCall.function.name } : void 0,
-      max_output_tokens: req.modelConfig?.maxTokens ?? this.config.maxTokens ?? void 0,
-      temperature: req.modelConfig?.temperature ?? this.config.temperature ?? void 0,
-      top_p: req.modelConfig?.topP ?? this.config.topP ?? void 0,
+      // For thinking models, don't set these parameters as they're not supported
+      ...isThinkingModel ? {
+        max_output_tokens: req.modelConfig?.maxTokens ?? this.config.maxTokens ?? void 0
+      } : {
+        temperature: req.modelConfig?.temperature ?? this.config.temperature ?? void 0,
+        top_p: req.modelConfig?.topP ?? this.config.topP ?? void 0,
+        presence_penalty: req.modelConfig?.presencePenalty ?? this.config.presencePenalty ?? void 0,
+        frequency_penalty: req.modelConfig?.frequencyPenalty ?? this.config.frequencyPenalty ?? void 0
+      },
       stream: req.modelConfig?.stream ?? this.config.stream ?? false,
       // Sourced from modelConfig or global config
       // Optional fields from AxAIOpenAIResponsesRequest that need to be in Mutable for initialization
@@ -4690,7 +4860,12 @@ var AxAIOpenAIResponsesImpl = class {
       metadata: void 0,
       parallel_tool_calls: this.config.parallelToolCalls,
       previous_response_id: void 0,
-      reasoning: void 0,
+      ...reasoningEffort ? {
+        reasoning: {
+          effort: reasoningEffort,
+          summary: reasoningSummary
+        }
+      } : {},
       service_tier: this.config.serviceTier,
       store: this.config.store,
       text: void 0,
@@ -5110,19 +5285,6 @@ var AxAIOpenAIResponsesImpl = class {
               ];
             }
             break;
-          case "reasoning":
-            {
-              const reasoningItem = event.item;
-              baseResult.id = event.item.id;
-              if (reasoningItem.encrypted_content) {
-                baseResult.thought = reasoningItem.encrypted_content;
-              } else if (reasoningItem.summary) {
-                baseResult.thought = reasoningItem.summary.map(
-                  (s2) => typeof s2 === "object" ? JSON.stringify(s2) : s2
-                ).join("\n");
-              }
-            }
-            break;
         }
         break;
       case "response.content_part.added":
@@ -5148,16 +5310,21 @@ var AxAIOpenAIResponsesImpl = class {
           }
         ];
         break;
-      case "response.function_call_arguments.done":
-        break;
+      // case 'response.function_call_arguments.done':
+      //     // Function call arguments done - don't return function calls here
+      //     // The mergeFunctionCalls will handle combining name and arguments
+      //     baseResult.id = event.item_id
+      //     baseResult.finishReason = 'function_call'
+      //     break
       case "response.reasoning_summary_text.delta":
         baseResult.id = event.item_id;
         baseResult.thought = event.delta;
         break;
-      case "response.reasoning_summary_text.done":
-        baseResult.id = event.item_id;
-        baseResult.thought = event.text;
-        break;
+      // case 'response.reasoning_summary_text.done':
+      //     // Reasoning summary done
+      //     baseResult.id = event.item_id
+      //     baseResult.thought = event.text
+      //     break
       // File search tool events
       case "response.file_search_call.in_progress":
       case "response.file_search_call.searching":
@@ -5251,10 +5418,6 @@ var AxAIOpenAIResponsesImpl = class {
             baseResult.id = event.item.id;
             baseResult.finishReason = "function_call";
             break;
-          case "reasoning":
-            baseResult.id = event.item.id;
-            baseResult.finishReason = "stop";
-            break;
         }
         break;
       case "response.completed":
@@ -5382,7 +5545,7 @@ var AxAIOpenAIResponses = class extends AxAIOpenAIResponsesBase {
     if (!apiKey || apiKey === "") {
       throw new Error("OpenAI API key not set");
     }
-    modelInfo = [...axModelInfoOpenAI, ...modelInfo ?? []];
+    modelInfo = [...axModelInfoOpenAIResponses, ...modelInfo ?? []];
     const supportFor = (model) => {
       const mi = getModelInfo({
         model,
@@ -8966,7 +9129,7 @@ async function* processStreamingResponse({
       usage.push(v.modelUsage);
     }
     for (const result of v.results) {
-      if (result.content === "" && (!result.functionCalls || result.functionCalls.length === 0)) {
+      if (result.content === "" && (!result.thought || result.thought === "") && (!result.functionCalls || result.functionCalls.length === 0)) {
         continue;
       }
       const state = states.find((s2) => s2.index === result.index);
@@ -9678,7 +9841,7 @@ var toFieldType = (type) => {
       case "number":
         return "number";
       case "boolean":
-        return "boolean";
+        return "boolean (true or false)";
       case "date":
         return 'date ("YYYY-MM-DD" format)';
       case "datetime":
@@ -12836,56 +12999,494 @@ var AxDockerSession = class {
   }
 };
 
-// dsp/loader.ts
-var AxHFDataLoader = class {
-  rows = [];
-  baseUrl;
-  dataset;
-  split;
-  config;
-  options;
-  constructor({
-    dataset,
-    split,
-    config,
-    options
-  }) {
-    this.baseUrl = "https://datasets-server.huggingface.co/rows";
-    this.dataset = dataset;
-    this.split = split;
-    this.config = config;
-    this.options = options;
+// flow/flow.ts
+var AxFlow = class extends AxProgramWithSignature {
+  nodes = /* @__PURE__ */ new Map();
+  flowDefinition = [];
+  nodeGenerators = /* @__PURE__ */ new Map();
+  loopStack = [];
+  stepLabels = /* @__PURE__ */ new Map();
+  branchContext = null;
+  constructor(signature = "userInput:string -> flowOutput:string") {
+    super(signature);
   }
-  async fetchDataFromAPI(url) {
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Error fetching data: ${response.statusText}`);
-      }
-      const data = await response.json();
-      if (!data?.rows) {
-        throw new Error("Invalid data format");
-      }
-      return data.rows;
-    } catch (error) {
-      console.error("Error fetching data from API:", error);
-      throw error;
+  /**
+   * Declares a reusable computational node and its input/output signature.
+   * Returns a new AxFlow type that tracks this node in the TNodes registry.
+   *
+   * @param name - The name of the node
+   * @param signature - Signature string in the same format as AxSignature
+   * @param options - Optional program forward options (same as AxGen)
+   * @returns New AxFlow instance with updated TNodes type
+   *
+   * @example
+   * ```typescript
+   * flow.node('summarizer', 'text:string -> summary:string')
+   * flow.node('analyzer', 'text:string -> analysis:string, confidence:number', { debug: true })
+   * ```
+   */
+  node(name, signature, options) {
+    if (!signature) {
+      throw new Error(
+        `Invalid signature for node '${name}': signature cannot be empty`
+      );
     }
+    this.nodes.set(name, {
+      inputs: {},
+      outputs: {}
+    });
+    this.nodeGenerators.set(name, new AxGen(signature, options));
+    return this;
   }
-  // https://datasets-server.huggingface.co/rows?dataset=hotpot_qa&config=distractor&split=train&offset=0&length=100
-  async loadData() {
-    const offset = this.options?.offset ?? 0;
-    const length = this.options?.length ?? 100;
-    const ds = encodeURIComponent(this.dataset);
-    const url = `${this.baseUrl}?dataset=${ds}&config=${this.config}&split=${this.split}&offset=${offset}&length=${length}`;
-    console.log("Downloading data from API.");
-    this.rows = await this.fetchDataFromAPI(url);
-    return this.rows;
-  }
-  setData(rows) {
-    this.rows = rows;
+  /**
+   * Applies a synchronous transformation to the state object.
+   * Returns a new AxFlow type with the evolved state.
+   *
+   * @param transform - Function that takes the current state and returns a new state
+   * @returns New AxFlow instance with updated TState type
+   *
+   * @example
+   * ```typescript
+   * flow.map(state => ({ ...state, processedText: state.text.toLowerCase() }))
+   * ```
+   */
+  map(transform) {
+    const step = (state) => {
+      return transform(state);
+    };
+    if (this.branchContext?.currentBranchValue !== void 0) {
+      const currentBranch = this.branchContext.branches.get(
+        this.branchContext.currentBranchValue
+      ) || [];
+      currentBranch.push(step);
+      this.branchContext.branches.set(
+        this.branchContext.currentBranchValue,
+        currentBranch
+      );
+    } else {
+      this.flowDefinition.push(step);
+    }
+    return this;
   }
-  getData() {
+  /**
+   * Labels a step for later reference (useful for feedback loops).
+   *
+   * @param label - The label to assign to the current step position
+   * @returns this (for chaining, no type change)
+   *
+   * @example
+   * ```typescript
+   * flow.label('retry-point')
+   *   .execute('queryGen', ...)
+   * ```
+   */
+  label(label) {
+    if (this.branchContext?.currentBranchValue !== void 0) {
+      throw new Error("Cannot create labels inside branch blocks");
+    }
+    this.stepLabels.set(label, this.flowDefinition.length);
+    return this;
+  }
+  /**
+   * Executes a previously defined node with full type safety.
+   * The node name must exist in TNodes, and the mapping function is typed based on the node's signature.
+   *
+   * @param nodeName - The name of the node to execute (must exist in TNodes)
+   * @param mapping - Typed function that takes the current state and returns the input for the node
+   * @param dynamicContext - Optional object to override the AI service or options for this specific step
+   * @returns New AxFlow instance with TState augmented with the node's result
+   *
+   * @example
+   * ```typescript
+   * flow.execute('summarizer', state => ({ text: state.originalText }), { ai: cheapAI })
+   * ```
+   */
+  execute(nodeName, mapping, dynamicContext) {
+    if (!this.nodes.has(nodeName)) {
+      throw new Error(
+        `Node '${nodeName}' not found. Make sure to define it with .node() first.`
+      );
+    }
+    const nodeGenerator = this.nodeGenerators.get(nodeName);
+    if (!nodeGenerator) {
+      throw new Error(`Node generator for '${nodeName}' not found.`);
+    }
+    const step = async (state, context3) => {
+      const ai = dynamicContext?.ai ?? context3.mainAi;
+      const options = dynamicContext?.options ?? context3.mainOptions;
+      const nodeInputs = mapping(state);
+      const result = await nodeGenerator.forward(ai, nodeInputs, options);
+      return {
+        ...state,
+        [`${nodeName}Result`]: result
+      };
+    };
+    if (this.branchContext?.currentBranchValue !== void 0) {
+      const currentBranch = this.branchContext.branches.get(
+        this.branchContext.currentBranchValue
+      ) || [];
+      currentBranch.push(step);
+      this.branchContext.branches.set(
+        this.branchContext.currentBranchValue,
+        currentBranch
+      );
+    } else {
+      this.flowDefinition.push(step);
+    }
+    return this;
+  }
+  /**
+   * Starts a conditional branch based on a predicate function.
+   *
+   * @param predicate - Function that takes state and returns a value to branch on
+   * @returns this (for chaining)
+   *
+   * @example
+   * ```typescript
+   * flow.branch(state => state.qualityResult.needsMoreInfo)
+   *   .when(true)
+   *     .execute('queryGen', ...)
+   *   .when(false)
+   *     .execute('answer', ...)
+   *   .merge()
+   * ```
+   */
+  branch(predicate) {
+    if (this.branchContext) {
+      throw new Error("Nested branches are not supported");
+    }
+    this.branchContext = {
+      predicate: (state) => predicate(state),
+      branches: /* @__PURE__ */ new Map(),
+      currentBranchValue: void 0
+    };
+    return this;
+  }
+  /**
+   * Defines a branch case for the current branch context.
+   *
+   * @param value - The value to match against the branch predicate result
+   * @returns this (for chaining)
+   */
+  when(value) {
+    if (!this.branchContext) {
+      throw new Error("when() called without matching branch()");
+    }
+    this.branchContext.currentBranchValue = value;
+    this.branchContext.branches.set(value, []);
+    return this;
+  }
+  /**
+   * Ends the current branch and merges all branch paths back into the main flow.
+   *
+   * @returns this (for chaining)
+   */
+  merge() {
+    if (!this.branchContext) {
+      throw new Error("merge() called without matching branch()");
+    }
+    const branchContext = this.branchContext;
+    this.branchContext = null;
+    this.flowDefinition.push(async (state, context3) => {
+      const branchValue = branchContext.predicate(state);
+      const branchSteps = branchContext.branches.get(branchValue);
+      if (!branchSteps) {
+        return state;
+      }
+      let currentState = state;
+      for (const step of branchSteps) {
+        currentState = await step(currentState, context3);
+      }
+      return currentState;
+    });
+    return this;
+  }
+  /**
+   * Executes multiple operations in parallel and merges their results.
+   * Both typed and legacy untyped branches are supported.
+   *
+   * @param branches - Array of functions that define parallel operations
+   * @returns Object with merge method for combining results
+   *
+   * @example
+   * ```typescript
+   * flow.parallel([
+   *   subFlow => subFlow.execute('retrieve1', state => ({ query: state.query1 })),
+   *   subFlow => subFlow.execute('retrieve2', state => ({ query: state.query2 })),
+   *   subFlow => subFlow.execute('retrieve3', state => ({ query: state.query3 }))
+   * ]).merge('documents', (docs1, docs2, docs3) => [...docs1, ...docs2, ...docs3])
+   * ```
+   */
+  parallel(branches) {
+    const parallelStep = async (state, context3) => {
+      const promises = branches.map(async (branchFn) => {
+        const subContext = new AxFlowSubContextImpl(this.nodeGenerators);
+        const populatedSubContext = branchFn(
+          subContext
+        );
+        return await populatedSubContext.executeSteps(state, context3);
+      });
+      const results = await Promise.all(promises);
+      return {
+        ...state,
+        _parallelResults: results
+      };
+    };
+    this.flowDefinition.push(parallelStep);
+    return {
+      merge: (resultKey, mergeFunction) => {
+        this.flowDefinition.push((state) => {
+          const results = state._parallelResults;
+          if (!Array.isArray(results)) {
+            throw new Error("No parallel results found for merge");
+          }
+          const mergedValue = mergeFunction(...results);
+          const newState = { ...state };
+          delete newState._parallelResults;
+          newState[resultKey] = mergedValue;
+          return newState;
+        });
+        return this;
+      }
+    };
+  }
+  /**
+   * Creates a feedback loop that jumps back to a labeled step if a condition is met.
+   *
+   * @param condition - Function that returns true to trigger the feedback loop
+   * @param targetLabel - The label to jump back to
+   * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 10)
+   * @returns this (for chaining)
+   *
+   * @example
+   * ```typescript
+   * flow.label('retry-point')
+   *   .execute('answer', ...)
+   *   .execute('qualityCheck', ...)
+   *   .feedback(state => state.qualityCheckResult.confidence < 0.7, 'retry-point')
+   * ```
+   */
+  feedback(condition, targetLabel, maxIterations = 10) {
+    if (!this.stepLabels.has(targetLabel)) {
+      throw new Error(
+        `Label '${targetLabel}' not found. Make sure to define it with .label() before the feedback point.`
+      );
+    }
+    const targetIndex = this.stepLabels.get(targetLabel);
+    const feedbackStepIndex = this.flowDefinition.length;
+    this.flowDefinition.push(async (state, context3) => {
+      let currentState = state;
+      let iterations = 1;
+      const iterationKey = `_feedback_${targetLabel}_iterations`;
+      if (typeof currentState[iterationKey] !== "number") {
+        currentState = { ...currentState, [iterationKey]: 1 };
+      }
+      while (condition(currentState) && iterations < maxIterations) {
+        iterations++;
+        currentState = { ...currentState, [iterationKey]: iterations };
+        for (let i = targetIndex; i < feedbackStepIndex; i++) {
+          const step = this.flowDefinition[i];
+          if (step) {
+            currentState = await step(currentState, context3);
+          }
+        }
+      }
+      return currentState;
+    });
+    return this;
+  }
+  /**
+   * Marks the beginning of a loop block.
+   *
+   * @param condition - Function that takes the current state and returns a boolean
+   * @returns this (for chaining)
+   *
+   * @example
+   * ```typescript
+   * flow.while(state => state.iterations < 3)
+   *   .map(state => ({ ...state, iterations: (state.iterations || 0) + 1 }))
+   *   .endWhile()
+   * ```
+   */
+  while(condition) {
+    const loopStartIndex = this.flowDefinition.length;
+    this.loopStack.push(loopStartIndex);
+    const placeholderStep = Object.assign(
+      (state) => state,
+      {
+        _condition: condition,
+        _isLoopStart: true
+      }
+    );
+    this.flowDefinition.push(placeholderStep);
+    return this;
+  }
+  /**
+   * Marks the end of a loop block.
+   *
+   * @returns this (for chaining)
+   */
+  endWhile() {
+    if (this.loopStack.length === 0) {
+      throw new Error("endWhile() called without matching while()");
+    }
+    const loopStartIndex = this.loopStack.pop();
+    const placeholderStep = this.flowDefinition[loopStartIndex];
+    if (!placeholderStep || !("_isLoopStart" in placeholderStep)) {
+      throw new Error("Loop start step not found or invalid");
+    }
+    const condition = placeholderStep._condition;
+    const loopBodySteps = this.flowDefinition.splice(loopStartIndex + 1);
+    this.flowDefinition[loopStartIndex] = async (state, context3) => {
+      let currentState = state;
+      while (condition(currentState)) {
+        for (const step of loopBodySteps) {
+          currentState = await step(currentState, context3);
+        }
+      }
+      return currentState;
+    };
+    return this;
+  }
+  /**
+   * Executes the flow with the given AI service and input values.
+   *
+   * @param ai - The AI service to use as the default for all steps
+   * @param values - The input values for the flow
+   * @param options - Optional forward options to use as defaults
+   * @returns Promise that resolves to the final output
+   */
+  async forward(ai, values, options) {
+    let state = { ...values };
+    const context3 = {
+      mainAi: ai,
+      mainOptions: options
+    };
+    for (const step of this.flowDefinition) {
+      state = await step(state, context3);
+    }
+    return state;
+  }
+};
+var AxFlowSubContextImpl = class {
+  constructor(nodeGenerators) {
+    this.nodeGenerators = nodeGenerators;
+  }
+  steps = [];
+  execute(nodeName, mapping, dynamicContext) {
+    const nodeGenerator = this.nodeGenerators.get(nodeName);
+    if (!nodeGenerator) {
+      throw new Error(`Node generator for '${nodeName}' not found.`);
+    }
+    this.steps.push(async (state, context3) => {
+      const ai = dynamicContext?.ai ?? context3.mainAi;
+      const options = dynamicContext?.options ?? context3.mainOptions;
+      const nodeInputs = mapping(state);
+      const result = await nodeGenerator.forward(ai, nodeInputs, options);
+      return {
+        ...state,
+        [`${nodeName}Result`]: result
+      };
+    });
+    return this;
+  }
+  map(transform) {
+    this.steps.push((state) => transform(state));
+    return this;
+  }
+  async executeSteps(initialState, context3) {
+    let currentState = initialState;
+    for (const step of this.steps) {
+      currentState = await step(currentState, context3);
+    }
+    return currentState;
+  }
+};
+var AxFlowTypedSubContextImpl = class {
+  constructor(nodeGenerators) {
+    this.nodeGenerators = nodeGenerators;
+  }
+  steps = [];
+  execute(nodeName, mapping, dynamicContext) {
+    const nodeGenerator = this.nodeGenerators.get(nodeName);
+    if (!nodeGenerator) {
+      throw new Error(`Node generator for '${nodeName}' not found.`);
+    }
+    this.steps.push(async (state, context3) => {
+      const ai = dynamicContext?.ai ?? context3.mainAi;
+      const options = dynamicContext?.options ?? context3.mainOptions;
+      const nodeInputs = mapping(state);
+      const result = await nodeGenerator.forward(ai, nodeInputs, options);
+      return {
+        ...state,
+        [`${nodeName}Result`]: result
+      };
+    });
+    return this;
+  }
+  map(transform) {
+    this.steps.push((state) => transform(state));
+    return this;
+  }
+  async executeSteps(initialState, context3) {
+    let currentState = initialState;
+    for (const step of this.steps) {
+      currentState = await step(currentState, context3);
+    }
+    return currentState;
+  }
+};
+
+// dsp/loader.ts
+var AxHFDataLoader = class {
+  rows = [];
+  baseUrl;
+  dataset;
+  split;
+  config;
+  options;
+  constructor({
+    dataset,
+    split,
+    config,
+    options
+  }) {
+    this.baseUrl = "https://datasets-server.huggingface.co/rows";
+    this.dataset = dataset;
+    this.split = split;
+    this.config = config;
+    this.options = options;
+  }
+  async fetchDataFromAPI(url) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Error fetching data: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (!data?.rows) {
+        throw new Error("Invalid data format");
+      }
+      return data.rows;
+    } catch (error) {
+      console.error("Error fetching data from API:", error);
+      throw error;
+    }
+  }
+  // https://datasets-server.huggingface.co/rows?dataset=hotpot_qa&config=distractor&split=train&offset=0&length=100
+  async loadData() {
+    const offset = this.options?.offset ?? 0;
+    const length = this.options?.length ?? 100;
+    const ds = encodeURIComponent(this.dataset);
+    const url = `${this.baseUrl}?dataset=${ds}&config=${this.config}&split=${this.split}&offset=${offset}&length=${length}`;
+    console.log("Downloading data from API.");
+    this.rows = await this.fetchDataFromAPI(url);
+    return this.rows;
+  }
+  setData(rows) {
+    this.rows = rows;
+  }
+  getData() {
     return this.rows;
   }
   async getRows({
@@ -16251,198 +16852,6 @@ var AxEvalUtil = {
   novelF1ScoreOptimized
 };
 
-// flow/flow.ts
-var AxFlow = class extends AxProgramWithSignature {
-  nodes = /* @__PURE__ */ new Map();
-  flowDefinition = [];
-  nodeGenerators = /* @__PURE__ */ new Map();
-  loopStack = [];
-  constructor(signature = "userInput:string -> flowOutput:string") {
-    super(signature);
-  }
-  /**
-   * Declares a reusable computational node and its input/output signature.
-   *
-   * @param name - The name of the node
-   * @param signature - An object where the key is a string representation of inputs
-   *                   and the value is an object representing outputs
-   * @returns this (for chaining)
-   *
-   * @example
-   * ```typescript
-   * flow.node('summarizer', { 'text:string': { summary: f.string() } })
-   * ```
-   */
-  node(name, signature) {
-    const [inputSignature, outputSignature] = Object.entries(signature)[0] ?? [
-      "",
-      {}
-    ];
-    if (!inputSignature || !outputSignature) {
-      throw new Error(
-        `Invalid signature for node '${name}': signature must have at least one input->output mapping`
-      );
-    }
-    const outputFields = Object.entries(outputSignature).map(([key, value]) => {
-      if (typeof value === "object" && value !== null && "type" in value) {
-        const fieldType = value;
-        let fieldString = `${key}:`;
-        if (fieldType.isOptional) {
-          const colonIndex = fieldString.lastIndexOf(":");
-          fieldString = fieldString.slice(0, colonIndex) + "?" + fieldString.slice(colonIndex);
-        }
-        if (fieldType.isInternal) {
-          const colonIndex = fieldString.lastIndexOf(":");
-          fieldString = fieldString.slice(0, colonIndex) + "!" + fieldString.slice(colonIndex);
-        }
-        fieldString += fieldType.type;
-        if (fieldType.isArray) {
-          fieldString += "[]";
-        }
-        if (fieldType.type === "class" && fieldType.options) {
-          fieldString += ` "${fieldType.options.join(", ")}"`;
-        }
-        if (fieldType.description && (fieldType.type !== "class" || !fieldType.options)) {
-          fieldString += ` "${fieldType.description}"`;
-        }
-        return fieldString;
-      }
-      return `${key}:string`;
-    }).join(", ");
-    const signatureString = `${inputSignature} -> ${outputFields}`;
-    this.nodes.set(name, {
-      inputs: { [inputSignature]: true },
-      outputs: outputSignature
-    });
-    this.nodeGenerators.set(name, new AxGen(signatureString));
-    return this;
-  }
-  /**
-   * Applies a synchronous transformation to the state object.
-   *
-   * @param transform - Function that takes the current state and returns a new state
-   * @returns this (for chaining)
-   *
-   * @example
-   * ```typescript
-   * flow.map(state => ({ ...state, processedText: state.text.toLowerCase() }))
-   * ```
-   */
-  map(transform) {
-    this.flowDefinition.push((state) => {
-      return transform(state);
-    });
-    return this;
-  }
-  /**
-   * Executes a previously defined node.
-   *
-   * @param nodeName - The name of the node to execute (must exist in the nodes map)
-   * @param mapping - Function that takes the current state and returns the input object required by the node
-   * @param dynamicContext - Optional object to override the AI service or options for this specific step
-   * @returns this (for chaining)
-   *
-   * @example
-   * ```typescript
-   * flow.execute('summarizer', state => ({ text: state.originalText }), { ai: cheapAI })
-   * ```
-   */
-  execute(nodeName, mapping, dynamicContext) {
-    if (!this.nodes.has(nodeName)) {
-      throw new Error(
-        `Node '${nodeName}' not found. Make sure to define it with .node() first.`
-      );
-    }
-    const nodeGenerator = this.nodeGenerators.get(nodeName);
-    if (!nodeGenerator) {
-      throw new Error(`Node generator for '${nodeName}' not found.`);
-    }
-    this.flowDefinition.push(async (state, context3) => {
-      const ai = dynamicContext?.ai ?? context3.mainAi;
-      const options = dynamicContext?.options ?? context3.mainOptions;
-      const nodeInputs = mapping(state);
-      const result = await nodeGenerator.forward(ai, nodeInputs, options);
-      return {
-        ...state,
-        [`${nodeName}Result`]: result
-      };
-    });
-    return this;
-  }
-  /**
-   * Marks the beginning of a loop block.
-   *
-   * @param condition - Function that takes the current state and returns a boolean
-   * @returns this (for chaining)
-   *
-   * @example
-   * ```typescript
-   * flow.while(state => state.iterations < 3)
-   *   .map(state => ({ ...state, iterations: (state.iterations || 0) + 1 }))
-   *   .endWhile()
-   * ```
-   */
-  while(condition) {
-    const loopStartIndex = this.flowDefinition.length;
-    this.loopStack.push(loopStartIndex);
-    const placeholderStep = Object.assign(
-      (state) => state,
-      {
-        _condition: condition,
-        _isLoopStart: true
-      }
-    );
-    this.flowDefinition.push(placeholderStep);
-    return this;
-  }
-  /**
-   * Marks the end of a loop block.
-   *
-   * @returns this (for chaining)
-   */
-  endWhile() {
-    if (this.loopStack.length === 0) {
-      throw new Error("endWhile() called without matching while()");
-    }
-    const loopStartIndex = this.loopStack.pop();
-    const placeholderStep = this.flowDefinition[loopStartIndex];
-    if (!placeholderStep || !("_isLoopStart" in placeholderStep)) {
-      throw new Error("Loop start step not found or invalid");
-    }
-    const condition = placeholderStep._condition;
-    const loopBodySteps = this.flowDefinition.splice(loopStartIndex + 1);
-    this.flowDefinition[loopStartIndex] = async (state, context3) => {
-      let currentState = state;
-      while (condition(currentState)) {
-        for (const step of loopBodySteps) {
-          currentState = await step(currentState, context3);
-        }
-      }
-      return currentState;
-    };
-    return this;
-  }
-  /**
-   * Executes the flow with the given AI service and input values.
-   *
-   * @param ai - The AI service to use as the default for all steps
-   * @param values - The input values for the flow
-   * @param options - Optional forward options to use as defaults
-   * @returns Promise that resolves to the final output
-   */
-  async forward(ai, values, options) {
-    let state = { ...values };
-    const context3 = {
-      mainAi: ai,
-      mainOptions: options
-    };
-    for (const step of this.flowDefinition) {
-      state = await step(state, context3);
-    }
-    return state;
-  }
-};
-
 // ../../node_modules/uuid/dist/esm-node/rng.js
 import crypto4 from "crypto";
 var rnds8Pool = new Uint8Array(256);
@@ -17012,6 +17421,7 @@ export {
   AxEmbeddingAdapter,
   AxEvalUtil,
   AxFlow,
+  AxFlowTypedSubContextImpl,
   AxFunctionError,
   AxFunctionProcessor,
   AxGen,
@@ -17089,6 +17499,7 @@ export {
   axModelInfoHuggingFace,
   axModelInfoMistral,
   axModelInfoOpenAI,
+  axModelInfoOpenAIResponses,
   axModelInfoReka,
   axModelInfoTogether,
   axSpanAttributes,