@ax-llm/ax 12.0.16 → 12.0.18

package/index.js

@@ -1,71 +1,3 @@
-// ai/base.ts
-import crypto2 from "crypto";
-import { context, SpanKind } from "@opentelemetry/api";
-
-// trace/trace.ts
-var axSpanAttributes = {
-  // LLM
-  LLM_SYSTEM: "gen_ai.system",
-  LLM_OPERATION_NAME: "gen_ai.operation.name",
-  LLM_REQUEST_MODEL: "gen_ai.request.model",
-  LLM_REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens",
-  LLM_REQUEST_TEMPERATURE: "gen_ai.request.temperature",
-  LLM_REQUEST_TOP_K: "gen_ai.request.top_k",
-  LLM_REQUEST_FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty",
-  LLM_REQUEST_PRESENCE_PENALTY: "gen_ai.request.presence_penalty",
-  LLM_REQUEST_STOP_SEQUENCES: "gen_ai.request.stop_sequences",
-  LLM_REQUEST_LLM_IS_STREAMING: "gen_ai.request.llm_is_streaming",
-  LLM_REQUEST_TOP_P: "gen_ai.request.top_p",
-  LLM_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
-  LLM_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
-  LLM_USAGE_TOTAL_TOKENS: "gen_ai.usage.total_tokens",
-  LLM_USAGE_THOUGHTS_TOKENS: "gen_ai.usage.thoughts_tokens",
-  // Vector DB
-  DB_SYSTEM: "db.system",
-  DB_TABLE: "db.table",
-  DB_NAMESPACE: "db.namespace",
-  DB_ID: "db.id",
-  DB_QUERY_TEXT: "db.query.text",
-  DB_VECTOR: "db.vector",
-  DB_OPERATION_NAME: "db.operation.name",
-  DB_VECTOR_QUERY_TOP_K: "db.vector.query.top_k",
-  DB_QUERY_EMBEDDINGS: "db.query.embeddings",
-  DB_QUERY_RESULT: "db.query.result",
-  // Query Embeddings
-  DB_QUERY_EMBEDDINGS_VECTOR: "db.query.embeddings.vector",
-  // Query Result (canonical format)
-  DB_QUERY_RESULT_ID: "db.query.result.id",
-  DB_QUERY_RESULT_SCORE: "db.query.result.score",
-  DB_QUERY_RESULT_DISTANCE: "db.query.result.distance",
-  DB_QUERY_RESULT_METADATA: "db.query.result.metadata",
-  DB_QUERY_RESULT_VECTOR: "db.query.result.vector",
-  DB_QUERY_RESULT_DOCUMENT: "db.query.result.document"
-};
-var axSpanEvents = {
-  GEN_AI_USER_MESSAGE: "gen_ai.user.message",
-  GEN_AI_SYSTEM_MESSAGE: "gen_ai.system.message",
-  GEN_AI_ASSISTANT_MESSAGE: "gen_ai.assistant.message",
-  GEN_AI_TOOL_MESSAGE: "gen_ai.tool.message",
-  // For tool messages in request & response tool calls
-  GEN_AI_CHOICE: "gen_ai.choice",
-  GEN_AI_USAGE: "gen_ai.usage"
-};
-var AxLLMRequestTypeValues = /* @__PURE__ */ ((AxLLMRequestTypeValues2) => {
-  AxLLMRequestTypeValues2["COMPLETION"] = "completion";
-  AxLLMRequestTypeValues2["CHAT"] = "chat";
-  AxLLMRequestTypeValues2["RERANK"] = "rerank";
-  AxLLMRequestTypeValues2["UNKNOWN"] = "unknown";
-  return AxLLMRequestTypeValues2;
-})(AxLLMRequestTypeValues || {});
-var AxSpanKindValues = /* @__PURE__ */ ((AxSpanKindValues2) => {
-  AxSpanKindValues2["WORKFLOW"] = "workflow";
-  AxSpanKindValues2["TASK"] = "task";
-  AxSpanKindValues2["AGENT"] = "agent";
-  AxSpanKindValues2["TOOL"] = "tool";
-  AxSpanKindValues2["UNKNOWN"] = "unknown";
-  return AxSpanKindValues2;
-})(AxSpanKindValues || {});
-
 // util/apicall.ts
 import crypto from "crypto";
 import {
@@ -320,6 +252,33 @@ var AxAIServiceAuthenticationError = class extends AxAIServiceError {
     this.name = this.constructor.name;
   }
 };
+var AxAIRefusalError = class extends Error {
+  constructor(refusalMessage, model, requestId) {
+    super(`Model refused to fulfill request: ${refusalMessage}`);
+    this.refusalMessage = refusalMessage;
+    this.model = model;
+    this.requestId = requestId;
+    this.name = "AxAIRefusalError";
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    this.errorId = crypto.randomUUID();
+  }
+  timestamp;
+  errorId;
+  toString() {
+    return [
+      `${this.name}: ${this.message}`,
+      `Refusal: ${this.refusalMessage}`,
+      this.model ? `Model: ${this.model}` : "",
+      this.requestId ? `Request ID: ${this.requestId}` : "",
+      `Timestamp: ${this.timestamp}`,
+      `Error ID: ${this.errorId}`
+    ].filter(Boolean).join("\n");
+  }
+  // For Node.js, override the custom inspect method so console.log shows our custom string.
+  [Symbol.for("nodejs.util.inspect.custom")](_depth, _options) {
+    return this.toString();
+  }
+};
 async function safeReadResponseBody(response) {
   try {
     if (response.headers.get("content-type")?.includes("application/json")) {
@@ -623,6 +582,74 @@ var apiCall = async (api, json) => {
   }
 };
 
+// ai/base.ts
+import crypto2 from "crypto";
+import { context, SpanKind } from "@opentelemetry/api";
+
+// trace/trace.ts
+var axSpanAttributes = {
+  // LLM
+  LLM_SYSTEM: "gen_ai.system",
+  LLM_OPERATION_NAME: "gen_ai.operation.name",
+  LLM_REQUEST_MODEL: "gen_ai.request.model",
+  LLM_REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens",
+  LLM_REQUEST_TEMPERATURE: "gen_ai.request.temperature",
+  LLM_REQUEST_TOP_K: "gen_ai.request.top_k",
+  LLM_REQUEST_FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty",
+  LLM_REQUEST_PRESENCE_PENALTY: "gen_ai.request.presence_penalty",
+  LLM_REQUEST_STOP_SEQUENCES: "gen_ai.request.stop_sequences",
+  LLM_REQUEST_LLM_IS_STREAMING: "gen_ai.request.llm_is_streaming",
+  LLM_REQUEST_TOP_P: "gen_ai.request.top_p",
+  LLM_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+  LLM_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+  LLM_USAGE_TOTAL_TOKENS: "gen_ai.usage.total_tokens",
+  LLM_USAGE_THOUGHTS_TOKENS: "gen_ai.usage.thoughts_tokens",
+  // Vector DB
+  DB_SYSTEM: "db.system",
+  DB_TABLE: "db.table",
+  DB_NAMESPACE: "db.namespace",
+  DB_ID: "db.id",
+  DB_QUERY_TEXT: "db.query.text",
+  DB_VECTOR: "db.vector",
+  DB_OPERATION_NAME: "db.operation.name",
+  DB_VECTOR_QUERY_TOP_K: "db.vector.query.top_k",
+  DB_QUERY_EMBEDDINGS: "db.query.embeddings",
+  DB_QUERY_RESULT: "db.query.result",
+  // Query Embeddings
+  DB_QUERY_EMBEDDINGS_VECTOR: "db.query.embeddings.vector",
+  // Query Result (canonical format)
+  DB_QUERY_RESULT_ID: "db.query.result.id",
+  DB_QUERY_RESULT_SCORE: "db.query.result.score",
+  DB_QUERY_RESULT_DISTANCE: "db.query.result.distance",
+  DB_QUERY_RESULT_METADATA: "db.query.result.metadata",
+  DB_QUERY_RESULT_VECTOR: "db.query.result.vector",
+  DB_QUERY_RESULT_DOCUMENT: "db.query.result.document"
+};
+var axSpanEvents = {
+  GEN_AI_USER_MESSAGE: "gen_ai.user.message",
+  GEN_AI_SYSTEM_MESSAGE: "gen_ai.system.message",
+  GEN_AI_ASSISTANT_MESSAGE: "gen_ai.assistant.message",
+  GEN_AI_TOOL_MESSAGE: "gen_ai.tool.message",
+  // For tool messages in request & response tool calls
+  GEN_AI_CHOICE: "gen_ai.choice",
+  GEN_AI_USAGE: "gen_ai.usage"
+};
+var AxLLMRequestTypeValues = /* @__PURE__ */ ((AxLLMRequestTypeValues2) => {
+  AxLLMRequestTypeValues2["COMPLETION"] = "completion";
+  AxLLMRequestTypeValues2["CHAT"] = "chat";
+  AxLLMRequestTypeValues2["RERANK"] = "rerank";
+  AxLLMRequestTypeValues2["UNKNOWN"] = "unknown";
+  return AxLLMRequestTypeValues2;
+})(AxLLMRequestTypeValues || {});
+var AxSpanKindValues = /* @__PURE__ */ ((AxSpanKindValues2) => {
+  AxSpanKindValues2["WORKFLOW"] = "workflow";
+  AxSpanKindValues2["TASK"] = "task";
+  AxSpanKindValues2["AGENT"] = "agent";
+  AxSpanKindValues2["TOOL"] = "tool";
+  AxSpanKindValues2["UNKNOWN"] = "unknown";
+  return AxSpanKindValues2;
+})(AxSpanKindValues || {});
+
 // util/transform.ts
 import {
   TransformStream as TransformStream4
@@ -1227,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) {
@@ -1988,7 +2023,13 @@ var AxAIAnthropicImpl = class {
   };
   createChatResp = (resp) => {
     if (resp.type === "error") {
-      throw new Error(`Anthropic Chat API Error: ${resp.error.message}`);
+      throw new AxAIRefusalError(
+        resp.error.message,
+        void 0,
+        // model not specified in error response
+        void 0
+        // requestId not specified in error response
+      );
     }
     const finishReason = mapFinishReason(resp.stop_reason);
     const showThoughts = this.currentPromptConfig?.thinkingTokenBudget !== "none" && this.currentPromptConfig?.showThoughts !== false;
@@ -2044,7 +2085,13 @@ var AxAIAnthropicImpl = class {
     }
     if (resp.type === "error") {
       const { error } = resp;
-      throw new Error(error.message);
+      throw new AxAIRefusalError(
+        error.message,
+        void 0,
+        // model not specified in error event
+        void 0
+        // requestId not specified in error event
+      );
     }
     const index = 0;
     if (resp.type === "message_start") {
@@ -2349,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";
@@ -2363,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) => {
@@ -2374,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";
@@ -2388,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";
@@ -2396,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",
@@ -2458,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
   {
@@ -2503,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 */,
@@ -2568,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 } : {},
@@ -2672,6 +2836,9 @@ var AxAIOpenAIImpl = class {
       totalTokens: usage.total_tokens
     } : void 0;
     const results = choices.map((choice) => {
+      if (choice.message.refusal) {
+        throw new AxAIRefusalError(choice.message.refusal, resp.model, resp.id);
+      }
       const finishReason = mapFinishReason2(choice.finish_reason);
       const functionCalls = choice.message.tool_calls?.map(
         ({ id: id2, function: { arguments: params, name } }) => ({
@@ -2683,8 +2850,9 @@ var AxAIOpenAIImpl = class {
       return {
         index: choice.index,
         id: `${choice.index}`,
-        content: choice.message.content,
+        content: choice.message.content ?? void 0,
         thought: choice.message.reasoning_content,
+        annotations: choice.message.annotations,
         functionCalls,
         finishReason
       };
@@ -2711,11 +2879,16 @@ var AxAIOpenAIImpl = class {
         delta: {
           content,
           role,
+          refusal,
           tool_calls: toolCalls,
-          reasoning_content: thought
+          reasoning_content: thought,
+          annotations
         },
         finish_reason: oaiFinishReason
       }) => {
+        if (refusal) {
+          throw new AxAIRefusalError(refusal, void 0, id);
+        }
         const finishReason = mapFinishReason2(oaiFinishReason);
         const functionCalls = toolCalls?.map(({ id: _id, index: index2, function: { name, arguments: params } }) => {
           if (typeof _id === "string" && typeof index2 === "number" && !sstate.indexIdMap[index2]) {
@@ -2733,9 +2906,10 @@ var AxAIOpenAIImpl = class {
         }).filter((v) => v !== null);
         return {
           index,
-          content,
+          content: content ?? void 0,
           role,
           thought,
+          annotations,
           functionCalls,
           finishReason,
           id
@@ -3832,11 +4006,29 @@ var AxAIGoogleGeminiImpl = class {
             result.finishReason = "stop";
             break;
           case "SAFETY":
-            throw new Error("Finish reason: SAFETY");
+            throw new AxAIRefusalError(
+              "Content was blocked due to safety settings",
+              void 0,
+              // model not available in candidate
+              void 0
+              // requestId not available
+            );
           case "RECITATION":
-            throw new Error("Finish reason: RECITATION");
+            throw new AxAIRefusalError(
+              "Content was blocked due to recitation policy",
+              void 0,
+              // model not available in candidate
+              void 0
+              // requestId not available
+            );
           case "MALFORMED_FUNCTION_CALL":
-            throw new Error("Finish reason: MALFORMED_FUNCTION_CALL");
+            throw new AxAIRefusalError(
+              "Function call was malformed and blocked",
+              void 0,
+              // model not available in candidate
+              void 0
+              // requestId not available
+            );
         }
         if (!candidate.content || !candidate.content.parts) {
           return result;
@@ -4445,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;
@@ -4600,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,
@@ -4612,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
@@ -4623,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,
@@ -4714,7 +4956,7 @@ var AxAIOpenAIResponsesImpl = class {
       switch (item.type) {
         case "message":
           currentResult.id = item.id;
-          currentResult.content = contentToText(item.content);
+          currentResult.content = contentToText(item.content, id);
           currentResult.finishReason = item.status === "completed" ? "stop" : "content_filter";
           break;
         case "reasoning":
@@ -4887,7 +5129,10 @@ var AxAIOpenAIResponsesImpl = class {
         switch (event.item.type) {
           case "message":
             baseResult.id = event.item.id;
-            baseResult.content = contentToText(event.item.content);
+            baseResult.content = contentToText(
+              event.item.content,
+              event.item.id
+            );
             break;
           case "function_call":
             baseResult.id = event.item.id;
@@ -5040,24 +5285,11 @@ 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":
         baseResult.id = event.item_id;
-        baseResult.content = contentToText([event.part]);
+        baseResult.content = contentToText([event.part], event.item_id);
         break;
       case "response.output_text.delta":
         baseResult.id = event.item_id;
@@ -5078,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":
@@ -5181,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":
@@ -5242,11 +5475,13 @@ var AxAIOpenAIResponsesImpl = class {
     return [apiConfig, reqValue];
   }
 };
-var contentToText = (content) => {
-  return [
-    ...content.filter((c) => c.type === "output_text").map((c) => c.text),
-    ...content.filter((c) => c.type === "refusal").map((c) => c.refusal)
-  ].join("\n");
+var contentToText = (content, responseId) => {
+  const refusalContent = content.filter((c) => c.type === "refusal");
+  if (refusalContent.length > 0) {
+    const refusalMessage = refusalContent.map((c) => c.refusal).join("\n");
+    throw new AxAIRefusalError(refusalMessage, void 0, responseId);
+  }
+  return content.filter((c) => c.type === "output_text").map((c) => c.text).join("\n");
 };
 
 // ai/openai/responses_api_base.ts
@@ -5310,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,
@@ -5834,213 +6069,279 @@ import {
 
 // ai/validate.ts
 function axValidateChatRequestMessage(item) {
+  const value = (v) => JSON.stringify(v, null, 2);
   if (!item) {
-    throw new Error("Chat request message item cannot be null or undefined");
+    throw new Error(
+      `Chat request message item cannot be null or undefined, received: ${value(item)}`
+    );
   }
-  if (!item.role) {
-    throw new Error("Chat request message must have a role");
+  const role = item?.role;
+  if (!role) {
+    throw new Error(
+      `Chat request message must have a role, received: ${value(role)}`
+    );
   }
-  switch (item.role) {
-    case "system":
-      if (!item.content || item.content.trim() === "") {
+  switch (role) {
+    case "system": {
+      const systemItem = item;
+      if (!systemItem.content || systemItem.content.trim() === "") {
         throw new Error(
-          "System message content cannot be empty or whitespace-only"
+          `System message content cannot be empty or whitespace-only, received: ${value(systemItem.content)}`
         );
       }
       break;
-    case "user":
-      if (!item.content) {
-        throw new Error("User message content cannot be undefined");
+    }
+    case "user": {
+      const userItem = item;
+      if (!userItem.content) {
+        throw new Error(
+          `User message content cannot be undefined, received: ${value(userItem.content)}`
+        );
       }
-      if (typeof item.content === "string") {
-        if (item.content.trim() === "") {
+      if (typeof userItem.content === "string") {
+        if (userItem.content.trim() === "") {
           throw new Error(
-            "User message content cannot be empty or whitespace-only"
+            `User message content cannot be empty or whitespace-only, received: ${value(userItem.content)}`
           );
         }
-      } else if (Array.isArray(item.content)) {
-        if (item.content.length === 0) {
-          throw new Error("User message content array cannot be empty");
+      } else if (Array.isArray(userItem.content)) {
+        if (userItem.content.length === 0) {
+          throw new Error(
+            `User message content array cannot be empty, received: ${value(userItem.content)}`
+          );
         }
-        for (let index = 0; index < item.content.length; index++) {
-          const contentItem = item.content[index];
+        for (let index = 0; index < userItem.content.length; index++) {
+          const contentItem = userItem.content[index];
           if (!contentItem || typeof contentItem !== "object") {
             throw new Error(
-              `User message content item at index ${index} must be an object`
+              `User message content item at index ${index} must be an object, received: ${value(contentItem)}`
             );
           }
-          if (!contentItem.type) {
+          const contentType = contentItem?.type;
+          if (!contentType) {
             throw new Error(
-              `User message content item at index ${index} must have a type`
+              `User message content item at index ${index} must have a type, received: ${value(contentType)}`
             );
           }
-          switch (contentItem.type) {
-            case "text":
-              if (!contentItem.text || contentItem.text.trim() === "") {
+          switch (contentType) {
+            case "text": {
+              const textItem = contentItem;
+              if (!textItem.text || textItem.text.trim() === "") {
                 throw new Error(
-                  `User message text content at index ${index} cannot be empty or whitespace-only`
+                  `User message text content at index ${index} cannot be empty or whitespace-only, received: ${value(textItem.text)}`
                 );
               }
               break;
-            case "image":
-              if (!contentItem.image || contentItem.image.trim() === "") {
+            }
+            case "image": {
+              const imageItem = contentItem;
+              if (!imageItem.image || imageItem.image.trim() === "") {
                 throw new Error(
-                  `User message image content at index ${index} cannot be empty`
+                  `User message image content at index ${index} cannot be empty, received: ${value(imageItem.image)}`
                 );
               }
-              if (!contentItem.mimeType || contentItem.mimeType.trim() === "") {
+              if (!imageItem.mimeType || imageItem.mimeType.trim() === "") {
                 throw new Error(
-                  `User message image content at index ${index} must have a mimeType`
+                  `User message image content at index ${index} must have a mimeType, received: ${value(imageItem.mimeType)}`
                 );
               }
               break;
-            case "audio":
-              if (!contentItem.data || contentItem.data.trim() === "") {
+            }
+            case "audio": {
+              const audioItem = contentItem;
+              if (!audioItem.data || audioItem.data.trim() === "") {
                 throw new Error(
-                  `User message audio content at index ${index} cannot be empty`
+                  `User message audio content at index ${index} cannot be empty, received: ${value(audioItem.data)}`
                 );
               }
               break;
+            }
             default:
               throw new Error(
-                `User message content item at index ${index} has unsupported type: ${contentItem.type}`
+                `User message content item at index ${index} has unsupported type: ${value(contentType)}`
               );
           }
         }
       } else {
         throw new Error(
-          "User message content must be a string or array of content objects"
+          `User message content must be a string or array of content objects, received: ${value(userItem.content)}`
         );
       }
       break;
-    case "assistant":
-      if (!item.content && !item.functionCalls) {
+    }
+    case "assistant": {
+      const assistantItem = item;
+      if (!assistantItem.content && !assistantItem.functionCalls) {
         throw new Error(
-          "Assistant message must have either content or function calls"
+          `Assistant message must have either content or function calls, received content: ${value(assistantItem.content)}, functionCalls: ${value(assistantItem.functionCalls)}`
         );
       }
-      if (item.content && typeof item.content !== "string") {
-        throw new Error("Assistant message content must be a string");
+      if (assistantItem.content && typeof assistantItem.content !== "string") {
+        throw new Error(
+          `Assistant message content must be a string, received: ${value(assistantItem.content)}`
+        );
       }
-      if (item.functionCalls && !Array.isArray(item.functionCalls)) {
-        throw new Error("Assistant message function calls must be an array");
+      if (assistantItem.functionCalls && !Array.isArray(assistantItem.functionCalls)) {
+        throw new Error(
+          `Assistant message function calls must be an array, received: ${value(assistantItem.functionCalls)}`
+        );
       }
       break;
-    case "function":
-      if (!item.functionId || item.functionId.trim() === "") {
-        throw new Error("Function message must have a non-empty functionId");
+    }
+    case "function": {
+      const functionItem = item;
+      if (!functionItem.functionId || functionItem.functionId.trim() === "") {
+        throw new Error(
+          `Function message must have a non-empty functionId, received: ${value(functionItem.functionId)}`
+        );
       }
-      if (item.result === void 0 || item.result === null) {
-        throw new Error("Function message must have a result");
+      if (functionItem.result === void 0 || functionItem.result === null) {
+        throw new Error(
+          `Function message must have a result, received: ${value(functionItem.result)}`
+        );
       }
-      if (typeof item.result !== "string") {
-        throw new Error("Function message result must be a string");
+      if (typeof functionItem.result !== "string") {
+        throw new Error(
+          `Function message result must be a string, received: ${value(functionItem.result)}`
+        );
       }
       break;
+    }
     default:
-      throw new Error(
-        `Unsupported message role: ${item.role}`
-      );
+      throw new Error(`Unsupported message role: ${value(role)}`);
   }
 }
 function axValidateChatResponseResult(results) {
+  const value = (v) => JSON.stringify(v, null, 2);
   const resultsArray = Array.isArray(results) ? results : [results];
   if (resultsArray.length === 0) {
-    throw new Error("Chat response results cannot be empty");
+    throw new Error(
+      `Chat response results cannot be empty, received: ${value(resultsArray)}`
+    );
   }
   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`
+        `Chat response result at index ${arrayIndex} cannot be null or undefined, received: ${value(result)}`
       );
     }
     if (typeof result.index !== "number") {
       throw new Error(
-        `Chat response result at index ${arrayIndex} must have a numeric index`
+        `Chat response result at index ${arrayIndex} must have a numeric index, received: ${value(result.index)}`
       );
     }
     if (result.index < 0) {
       throw new Error(
-        `Chat response result at index ${arrayIndex} must have a non-negative index`
+        `Chat response result at index ${arrayIndex} must have a non-negative index, received: ${value(result.index)}`
       );
     }
     if (!result.content && !result.thought && !result.functionCalls && !result.finishReason) {
       throw new Error(
-        `Chat response result at index ${arrayIndex} must have at least one of: content, thought, functionCalls, or finishReason`
+        `Chat response result at index ${arrayIndex} must have at least one of: content, thought, functionCalls, or finishReason, received: ${value({ content: result.content, thought: result.thought, functionCalls: result.functionCalls, finishReason: result.finishReason })}`
       );
     }
     if (result.content !== void 0 && typeof result.content !== "string") {
       throw new Error(
-        `Chat response result content at index ${arrayIndex} must be a string`
+        `Chat response result content at index ${arrayIndex} must be a string, received: ${value(result.content)}`
       );
     }
     if (result.thought !== void 0 && typeof result.thought !== "string") {
       throw new Error(
-        `Chat response result thought at index ${arrayIndex} must be a string`
+        `Chat response result thought at index ${arrayIndex} must be a string, received: ${value(result.thought)}`
       );
     }
     if (result.name !== void 0) {
       if (typeof result.name !== "string") {
         throw new Error(
-          `Chat response result name at index ${arrayIndex} must be a string`
+          `Chat response result name at index ${arrayIndex} must be a string, received: ${value(result.name)}`
         );
       }
       if (result.name.trim() === "") {
         throw new Error(
-          `Chat response result name at index ${arrayIndex} cannot be empty or whitespace-only`
+          `Chat response result name at index ${arrayIndex} cannot be empty or whitespace-only, received: ${value(result.name)}`
+        );
+      }
+    }
+    if (result.annotations !== void 0) {
+      if (!Array.isArray(result.annotations)) {
+        throw new Error(
+          `Chat response result annotations at index ${arrayIndex} must be an array, received: ${value(result.annotations)}`
         );
       }
+      for (let i = 0; i < result.annotations.length; i++) {
+        const annotation = result.annotations[i];
+        if (!annotation || typeof annotation !== "object") {
+          throw new Error(
+            `Chat response result annotation at index ${arrayIndex}[${i}] must be an object, received: ${value(annotation)}`
+          );
+        }
+        if (annotation.type !== "url_citation") {
+          throw new Error(
+            `Chat response result annotation at index ${arrayIndex}[${i}] must have type 'url_citation', received: ${value(annotation.type)}`
+          );
+        }
+        if (!annotation.url_citation || typeof annotation.url_citation !== "object") {
+          throw new Error(
+            `Chat response result annotation at index ${arrayIndex}[${i}] must have a valid url_citation object, received: ${value(annotation.url_citation)}`
+          );
+        }
+        if (typeof annotation.url_citation.url !== "string") {
+          throw new Error(
+            `Chat response result annotation at index ${arrayIndex}[${i}] url_citation.url must be a string, received: ${value(annotation.url_citation.url)}`
+          );
+        }
+      }
     }
     if (result.id !== void 0) {
       if (typeof result.id !== "string") {
         throw new Error(
-          `Chat response result id at index ${arrayIndex} must be a string`
+          `Chat response result id at index ${arrayIndex} must be a string, received: ${value(result.id)}`
         );
       }
       if (result.id.trim() === "") {
         throw new Error(
-          `Chat response result id at index ${arrayIndex} cannot be empty or whitespace-only`
+          `Chat response result id at index ${arrayIndex} cannot be empty or whitespace-only, received: ${value(result.id)}`
         );
       }
     }
     if (result.functionCalls !== void 0) {
       if (!Array.isArray(result.functionCalls)) {
         throw new Error(
-          `Chat response result functionCalls at index ${arrayIndex} must be an array`
+          `Chat response result functionCalls at index ${arrayIndex} must be an array, received: ${value(result.functionCalls)}`
         );
       }
       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`
+            `Function call at index ${callIndex} in result ${arrayIndex} cannot be null or undefined, received: ${value(functionCall)}`
           );
         }
         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`
+            `Function call at index ${callIndex} in result ${arrayIndex} must have a non-empty string id, received: ${value(functionCall.id)}`
           );
         }
         if (functionCall.type !== "function") {
           throw new Error(
-            `Function call at index ${callIndex} in result ${arrayIndex} must have type 'function'`
+            `Function call at index ${callIndex} in result ${arrayIndex} must have type 'function', received: ${value(functionCall.type)}`
           );
         }
         if (!functionCall.function) {
           throw new Error(
-            `Function call at index ${callIndex} in result ${arrayIndex} must have a function object`
+            `Function call at index ${callIndex} in result ${arrayIndex} must have a function object, received: ${value(functionCall.function)}`
           );
         }
         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`
+            `Function call at index ${callIndex} in result ${arrayIndex} must have a non-empty function name, received: ${value(functionCall.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`
+              `Function call params at index ${callIndex} in result ${arrayIndex} must be a string or object, received: ${value(functionCall.function.params)}`
             );
           }
         }
@@ -6056,7 +6357,7 @@ function axValidateChatResponseResult(results) {
       ];
       if (!validFinishReasons.includes(result.finishReason)) {
         throw new Error(
-          `Chat response result finishReason at index ${arrayIndex} must be one of: ${validFinishReasons.join(", ")}`
+          `Chat response result finishReason at index ${arrayIndex} must be one of: ${validFinishReasons.join(", ")}, received: ${value(result.finishReason)}`
         );
       }
     }
@@ -8828,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);
@@ -9540,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":
@@ -12698,6 +12999,444 @@ var AxDockerSession = class {
   }
 };
 
+// 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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 = [];
@@ -16649,6 +17388,7 @@ export {
   AxAIOpenAIResponsesBase,
   AxAIOpenAIResponsesImpl,
   AxAIOpenAIResponsesModel,
+  AxAIRefusalError,
   AxAIReka,
   AxAIRekaModel,
   AxAIServiceAbortedError,
@@ -16680,6 +17420,8 @@ export {
   AxDockerSession,
   AxEmbeddingAdapter,
   AxEvalUtil,
+  AxFlow,
+  AxFlowTypedSubContextImpl,
   AxFunctionError,
   AxFunctionProcessor,
   AxGen,
@@ -16757,6 +17499,7 @@ export {
   axModelInfoHuggingFace,
   axModelInfoMistral,
   axModelInfoOpenAI,
+  axModelInfoOpenAIResponses,
   axModelInfoReka,
   axModelInfoTogether,
   axSpanAttributes,