llm-exe 2.3.0 → 2.3.2

package/dist/index.mjs

@@ -125,6 +125,10 @@ var BaseExecutor = class {
      */
     __publicField(this, "hooks");
     __publicField(this, "allowedHooks", [hookOnComplete, hookOnError, hookOnSuccess]);
+    /**
+     * @property maxHooksPerEvent - Maximum number of hooks allowed per event
+     */
+    __publicField(this, "maxHooksPerEvent", 100);
     this.id = uuidv4();
     this.type = type;
     this.name = name;
@@ -230,6 +234,11 @@ var BaseExecutor = class {
         const _hooks = Array.isArray(hookInput) ? hookInput : [hookInput];
         for (const hook of _hooks) {
           if (hook && typeof hook === "function" && !this.hooks[hookKey].find((h) => h === hook)) {
+            if (this.hooks[hookKey].length >= this.maxHooksPerEvent) {
+              throw new Error(
+                `Maximum number of hooks (${this.maxHooksPerEvent}) reached for event "${String(hookKey)}". Consider removing unused hooks or increasing the limit.`
+              );
+            }
             this.hooks[hookKey].push(hook);
           }
         }
@@ -257,10 +266,18 @@ var BaseExecutor = class {
   }
   once(eventName, fn) {
     if (typeof fn !== "function") return this;
+    if (this.hooks[eventName] && this.hooks[eventName].length >= this.maxHooksPerEvent) {
+      throw new Error(
+        `Maximum number of hooks (${this.maxHooksPerEvent}) reached for event "${String(eventName)}". Consider removing unused hooks or increasing the limit.`
+      );
+    }
     const onceWrapper = (...args) => {
       fn(...args);
       this.off(eventName, onceWrapper);
     };
+    if (!this.hooks[eventName]) {
+      this.hooks[eventName] = [];
+    }
     this.hooks[eventName].push(onceWrapper);
     return this;
   }
@@ -271,6 +288,40 @@ var BaseExecutor = class {
   getTraceId() {
     return this.traceId;
   }
+  /**
+   * Clear all hooks for a specific event or all events
+   * Useful for preventing memory leaks in long-running processes
+   * @param eventName - The event name to clear hooks for
+   */
+  clearHooks(eventName) {
+    if (eventName) {
+      if (this.hooks[eventName]) {
+        this.hooks[eventName] = [];
+      }
+    } else {
+      for (const key of this.allowedHooks) {
+        if (this.hooks[key]) {
+          this.hooks[key] = [];
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Get the count of hooks for monitoring memory usage
+   * @param eventName - Optional event name to get count for
+   * @returns Hook count for specific event or all events
+   */
+  getHookCount(eventName) {
+    if (eventName) {
+      return this.hooks[eventName]?.length || 0;
+    }
+    const counts = {};
+    for (const key of this.allowedHooks) {
+      counts[key] = this.hooks[key]?.length || 0;
+    }
+    return counts;
+  }
 };
 
 // src/utils/modules/inferFunctionName.ts
@@ -2057,6 +2108,63 @@ function getEnvironmentVariable(name) {
   }
 }
 
+// src/llm/output/_util.ts
+function formatOptions(response, handler) {
+  const out = [];
+  for (const item of response) {
+    const result = handler(item);
+    if (result) {
+      out.push([result]);
+    }
+  }
+  return out;
+}
+
+// src/llm/output/openai.ts
+function formatResult(result) {
+  const out = [];
+  if (typeof result?.message?.content === "string") {
+    out.push({
+      type: "text",
+      text: result.message.content
+    });
+  }
+  if (result?.message?.tool_calls) {
+    for (const call of result.message.tool_calls) {
+      out.push({
+        functionId: call.id,
+        type: "function_use",
+        name: call.function.name,
+        input: maybeParseJSON(call.function.arguments)
+      });
+    }
+  }
+  return out;
+}
+function OutputOpenAIChat(result, _config) {
+  const id = result.id;
+  const name = result.model || _config?.options.model?.default || "openai.unknown";
+  const created = result.created;
+  const [_content, ..._options] = result?.choices || [];
+  const stopReason = _content?.finish_reason;
+  const content = formatResult(_content);
+  const options = formatOptions(_options, formatResult);
+  const usage = {
+    output_tokens: result?.usage?.completion_tokens,
+    input_tokens: result?.usage?.prompt_tokens,
+    total_tokens: result?.usage?.total_tokens
+  };
+  return {
+    id,
+    name,
+    created,
+    usage,
+    stopReason,
+    content,
+    options
+  };
+}
+
 // src/llm/config/openai/promptSanitizeMessageCallback.ts
 function openaiPromptMessageCallback(_message) {
   let message = { ..._message };
@@ -2090,38 +2198,127 @@ function openaiPromptSanitize(_messages, _inputBodyObj, _outputObj) {
   return _messages.map(openaiPromptMessageCallback);
 }
 
-// src/llm/config/openai/index.ts
-var openAiChatV1 = {
-  key: "openai.chat.v1",
-  provider: "openai.chat",
-  endpoint: `https://api.openai.com/v1/chat/completions`,
-  options: {
-    prompt: {},
-    topP: {},
-    useJson: {},
-    openAiApiKey: {
-      default: getEnvironmentVariable("OPENAI_API_KEY")
+// src/llm/output/_utils/cleanJsonSchemaFor.ts
+var providerFieldExclusions = {
+  "openai.chat": ["default"],
+  // fields to exclude for openai.chat, xai, deepseek
+  "anthropic.chat": [],
+  "google.chat": ["additionalProperties"]
+};
+function cleanJsonSchemaFor(schema = {}, provider) {
+  const clone = deepClone(schema);
+  if (Object.keys(clone).length === 0) {
+    return {
+      type: "object",
+      properties: {},
+      required: []
+    };
+  }
+  const exclusions = providerFieldExclusions[provider] || [];
+  function removeDisallowedFields(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map(removeDisallowedFields);
+    } else if (typeof obj === "object" && obj !== null) {
+      return Object.keys(obj).reduce((acc, key) => {
+        if (!exclusions.includes(key)) {
+          acc[key] = removeDisallowedFields(obj[key]);
+        }
+        return acc;
+      }, {});
     }
-  },
-  method: "POST",
-  headers: `{"Authorization":"Bearer {{openAiApiKey}}", "Content-Type": "application/json" }`,
-  mapBody: {
-    prompt: {
-      key: "messages",
-      sanitize: openaiPromptSanitize
+    return obj;
+  }
+  return removeDisallowedFields(clone);
+}
+
+// src/llm/config/openai/compatible.ts
+function createOpenAiCompatibleConfiguration(overrides) {
+  const [apiKeyPropertyKey, apiKeyPropertyValue] = overrides.apiKeyMapping;
+  const config = {
+    key: overrides.key,
+    provider: overrides.provider,
+    endpoint: overrides.endpoint,
+    options: {
+      prompt: {},
+      effort: {},
+      topP: {},
+      useJson: {},
+      [apiKeyPropertyKey]: {
+        default: getEnvironmentVariable(apiKeyPropertyValue)
+      }
     },
-    model: {
-      key: "model"
+    method: "POST",
+    headers: `{"Authorization":"Bearer {{${apiKeyPropertyKey}}}", "Content-Type": "application/json" }`,
+    mapBody: {
+      prompt: {
+        key: "messages",
+        transform: openaiPromptSanitize
+      },
+      model: {
+        key: "model"
+      },
+      topP: {
+        key: "top_p"
+      },
+      useJson: {
+        key: "response_format.type",
+        transform: (v) => v ? "json_object" : "text"
+      },
+      effort: {
+        key: "reasoning_effort",
+        transform: (v, _s) => {
+          if (
+            // only supported reasoning models
+            ["gpt-5"].includes(_s.model) && typeof v === "string" && ["minimal", "low", "medium", "high"].includes(v)
+          ) {
+            return v;
+          }
+          return void 0;
+        }
+      }
     },
-    topP: {
-      key: "top_p"
+    mapOptions: {
+      jsonSchema: (schema, options, currentInput) => ({
+        response_format: {
+          ...currentInput?.response_format || {},
+          type: "json_schema",
+          json_schema: {
+            name: "output",
+            strict: !!options?.functionCallStrictInput,
+            schema: cleanJsonSchemaFor(schema, "openai.chat")
+          }
+        }
+      }),
+      functionCall: (call) => {
+        if (call === "any") return { tool_choice: "required" };
+        if (call === "none") return { tool_choice: "none" };
+        if (call === "auto") return { tool_choice: "auto" };
+        return { tool_choice: call };
+      },
+      functions: (functions, options) => ({
+        tools: functions.map((f) => ({
+          type: "function",
+          function: {
+            name: f.name,
+            description: f.description,
+            parameters: cleanJsonSchemaFor(f.parameters, "openai.chat"),
+            strict: !!options?.functionCallStrictInput
+          }
+        }))
+      })
     },
-    useJson: {
-      key: "response_format.type",
-      sanitize: (v) => v ? "json_object" : "text"
-    }
-  }
-};
+    transformResponse: overrides.transformResponse ?? OutputOpenAIChat
+  };
+  return config;
+}
+
+// src/llm/config/openai/index.ts
+var openAiChatV1 = createOpenAiCompatibleConfiguration({
+  key: "openai.chat.v1",
+  provider: "openai.chat",
+  endpoint: `https://api.openai.com/v1/chat/completions`,
+  apiKeyMapping: ["openAiApiKey", "OPENAI_API_KEY"]
+});
 var openAiChatMockV1 = {
   key: "openai.chat-mock.v1",
   provider: "openai.chat-mock",
@@ -2148,9 +2345,10 @@ var openAiChatMockV1 = {
     },
     useJson: {
       key: "response_format.type",
-      sanitize: (v) => v ? "json_object" : "text"
+      transform: (v) => v ? "json_object" : "text"
     }
-  }
+  },
+  transformResponse: OutputOpenAIChat
 };
 var openai = {
   "openai.chat.v1": openAiChatV1,
@@ -2228,8 +2426,75 @@ function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
   ].map(anthropicPromptMessageCallback);
 }
 
+// src/llm/output/claude.ts
+function formatResult2(response) {
+  const content = response?.content || [];
+  const out = [];
+  for (let i = 0; i < content.length; i++) {
+    const result = content[i];
+    if (result.type === "text") {
+      out.push({
+        type: "text",
+        text: result.text
+      });
+    } else if (result.type === "tool_use") {
+      out.push({
+        functionId: result.id,
+        type: "function_use",
+        name: result.name,
+        input: result.input
+      });
+    }
+  }
+  return out;
+}
+function OutputAnthropicClaude3Chat(result, _config) {
+  const id = result.id;
+  const name = result.model || _config?.options.model?.default || "anthropic.unknown";
+  const stopReason = result.stop_reason;
+  const content = formatResult2(result);
+  const usage = {
+    input_tokens: result?.usage?.input_tokens,
+    output_tokens: result?.usage?.output_tokens,
+    total_tokens: result?.usage?.input_tokens + result?.usage?.output_tokens
+  };
+  return {
+    id,
+    name,
+    created: Date.now(),
+    usage,
+    stopReason,
+    content
+  };
+}
+
+// src/llm/output/llama.ts
+function OutputMetaLlama3Chat(result, _config) {
+  const id = uuidv4();
+  const name = _config?.options?.model?.default || "meta";
+  const created = (/* @__PURE__ */ new Date()).getTime();
+  const stopReason = result.stop_reason;
+  const content = [
+    { type: "text", text: result.generation }
+  ];
+  const usage = {
+    output_tokens: result?.generation_token_count,
+    input_tokens: result?.prompt_token_count,
+    total_tokens: result?.generation_token_count + result?.prompt_token_count
+  };
+  return {
+    id,
+    name,
+    created,
+    usage,
+    stopReason,
+    content,
+    options: []
+  };
+}
+
 // src/llm/config/bedrock/index.ts
-var ANTORPIC_BEDROCK_VERSION = "bedrock-2023-05-31";
+var ANTHROPIC_BEDROCK_VERSION = "bedrock-2023-05-31";
 var amazonAnthropicChatV1 = {
   key: "amazon:anthropic.chat.v1",
   provider: "amazon:anthropic.chat",
@@ -2250,7 +2515,7 @@ var amazonAnthropicChatV1 = {
   mapBody: {
     prompt: {
       key: "messages",
-      sanitize: anthropicPromptSanitize
+      transform: anthropicPromptSanitize
     },
     topP: {
       key: "top_p"
@@ -2261,9 +2526,26 @@ var amazonAnthropicChatV1 = {
     },
     anthropic_version: {
       key: "anthropic_version",
-      default: ANTORPIC_BEDROCK_VERSION
+      default: ANTHROPIC_BEDROCK_VERSION
     }
-  }
+  },
+  mapOptions: {
+    functionCall: (call, _options) => {
+      if (call === "none") return { _clearFunctions: true };
+      if (call === "auto" || call === "any") {
+        return { tool_choice: { type: call } };
+      }
+      return { tool_choice: call };
+    },
+    functions: (functions) => ({
+      tools: functions.map((f) => ({
+        name: f.name,
+        description: f.description,
+        input_schema: cleanJsonSchemaFor(f.parameters, "anthropic.chat")
+      }))
+    })
+  },
+  transformResponse: OutputAnthropicClaude3Chat
 };
 var amazonMetaChatV1 = {
   key: "amazon:meta.chat.v1",
@@ -2285,7 +2567,7 @@ var amazonMetaChatV1 = {
   mapBody: {
     prompt: {
       key: "prompt",
-      sanitize: (messages) => {
+      transform: (messages) => {
         if (typeof messages === "string") {
           return messages;
         } else {
@@ -2305,7 +2587,8 @@ var amazonMetaChatV1 = {
       key: "max_gen_len",
       default: 2048
     }
-  }
+  },
+  transformResponse: OutputMetaLlama3Chat
 };
 var bedrock = {
   "amazon:anthropic.chat.v1": amazonAnthropicChatV1,
@@ -2344,16 +2627,65 @@ var anthropicChatV1 = {
     },
     prompt: {
       key: "messages",
-      sanitize: anthropicPromptSanitize
+      transform: anthropicPromptSanitize
+    },
+    temperature: {
+      key: "temperature"
+    },
+    topP: {
+      key: "top_p"
+    },
+    topK: {
+      key: "top_k"
+    },
+    stopSequences: {
+      key: "stop_sequences"
+    },
+    stream: {
+      key: "stream"
+    },
+    metadata: {
+      key: "metadata"
+    },
+    serviceTier: {
+      key: "service_tier"
+      // Map camelCase to snake_case
     }
-  }
+  },
+  mapOptions: {
+    functionCall: (call, _options) => {
+      if (call === "none") return { _clearFunctions: true };
+      if (call === "auto" || call === "any") {
+        return { tool_choice: { type: call } };
+      }
+      return { tool_choice: call };
+    },
+    functions: (functions) => ({
+      tools: functions.map((f) => ({
+        name: f.name,
+        description: f.description,
+        input_schema: cleanJsonSchemaFor(f.parameters, "anthropic.chat")
+      }))
+    })
+  },
+  transformResponse: OutputAnthropicClaude3Chat
 };
 var anthropic = {
   "anthropic.chat.v1": anthropicChatV1,
-  "anthropic.claude-3-7-sonnet": withDefaultModel(
+  // Claude 4 models (latest generation)
+  "anthropic.claude-sonnet-4": withDefaultModel(
     anthropicChatV1,
-    "claude-3-7-sonnet-latest"
+    "claude-sonnet-4-0"
   ),
+  "anthropic.claude-opus-4": withDefaultModel(
+    anthropicChatV1,
+    "claude-opus-4-0"
+  ),
+  "anthropic.claude-3-7-sonnet": withDefaultModel(
+    anthropicChatV1,
+    "claude-3-7-sonnet-20250219"
+  ),
+  // Claude 3.5 models
   "anthropic.claude-3-5-sonnet": withDefaultModel(
     anthropicChatV1,
     "claude-3-5-sonnet-latest"
@@ -2362,54 +2694,103 @@ var anthropic = {
     anthropicChatV1,
     "claude-3-5-haiku-latest"
   ),
+  // Deprecated
   "anthropic.claude-3-opus": withDefaultModel(
     anthropicChatV1,
-    "claude-3-opus-latest"
+    "claude-3-opus-20240229"
+  ),
+  "anthropic.claude-3-haiku": withDefaultModel(
+    anthropicChatV1,
+    "claude-3-haiku-20240307"
   )
 };
 
 // src/llm/config/x/index.ts
-var xaiChatV1 = {
+var xaiChatV1 = createOpenAiCompatibleConfiguration({
   key: "xai.chat.v1",
   provider: "xai.chat",
   endpoint: `https://api.x.ai/v1/chat/completions`,
-  options: {
-    prompt: {},
-    topP: {},
-    useJson: {},
-    xAiApiKey: {
-      default: getEnvironmentVariable("XAI_API_KEY")
-    }
-  },
-  method: "POST",
-  headers: `{"Authorization":"Bearer {{xAiApiKey}}", "Content-Type": "application/json" }`,
-  mapBody: {
-    prompt: {
-      key: "messages",
-      sanitize: (v) => {
-        if (typeof v === "string") {
-          return [{ role: "user", content: v }];
-        }
-        return v;
-      }
-    },
-    model: {
-      key: "model"
-    },
-    topP: {
-      key: "top_p"
-    },
-    useJson: {
-      key: "response_format.type",
-      sanitize: (v) => v ? "json_object" : "text"
-    }
-  }
-};
+  apiKeyMapping: ["xAiApiKey", "XAI_API_KEY"]
+});
 var xai = {
   "xai.chat.v1": xaiChatV1,
-  "xai.grok-2": withDefaultModel(xaiChatV1, "grok-2-latest")
+  "xai.grok-2": withDefaultModel(xaiChatV1, "grok-2-latest"),
+  "xai.grok-3": withDefaultModel(xaiChatV1, "grok-3"),
+  "xai.grok-4": withDefaultModel(xaiChatV1, "grok-4")
 };
 
+// src/llm/output/_utils/combineJsonl.ts
+function combineJsonl(jsonl) {
+  const lines = jsonl.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch (e) {
+      throw new Error(`Invalid JSON: ${line}`);
+    }
+  });
+  if (lines.length === 0) {
+    throw new Error("No JSON lines provided.");
+  }
+  lines.sort(
+    (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+  );
+  let combinedContent = lines.map((line) => line?.message?.content ?? "").join("");
+  combinedContent = combinedContent.replace(/\\u003c/g, "<").replace(/\\u003e/g, ">");
+  const finalLine = lines.find((line) => line.done === true);
+  if (!finalLine) {
+    throw new Error("No line found where done = true.");
+  }
+  const result = {
+    model: finalLine.model,
+    created_at: finalLine.created_at,
+    message: {
+      role: finalLine?.message?.role || "assistant",
+      content: combinedContent
+    },
+    done_reason: finalLine.done_reason,
+    done: finalLine.done,
+    total_duration: finalLine.total_duration,
+    load_duration: finalLine.load_duration,
+    prompt_eval_count: finalLine.prompt_eval_count,
+    prompt_eval_duration: finalLine.prompt_eval_duration,
+    eval_count: finalLine.eval_count,
+    eval_duration: finalLine.eval_duration
+  };
+  const content = {
+    type: "text",
+    text: combinedContent
+  };
+  return {
+    lines,
+    result,
+    content
+  };
+}
+
+// src/llm/output/ollama.ts
+function OutputOllamaChat(result, _config) {
+  const combined = combineJsonl(result);
+  const id = `${combined.result.model}.${combined.result.created_at}`;
+  const name = combined.result.model || _config?.options.model?.default || "ollama.unknown";
+  const created = (/* @__PURE__ */ new Date(`${combined.result.created_at}`)).getTime();
+  const stopReason = `${combined?.result?.done_reason || "stop"}`;
+  const content = [combined.content];
+  const usage = {
+    output_tokens: 0,
+    input_tokens: 0,
+    total_tokens: 0
+  };
+  return {
+    id,
+    name,
+    created,
+    usage,
+    stopReason,
+    content,
+    options: []
+  };
+}
+
 // src/llm/config/ollama/index.ts
 var ollamaChatV1 = {
   key: "ollama.chat.v1",
@@ -2423,7 +2804,7 @@ var ollamaChatV1 = {
   mapBody: {
     prompt: {
       key: "messages",
-      sanitize: (v) => {
+      transform: (v) => {
         if (typeof v === "string") {
           return [{ role: "user", content: v }];
         }
@@ -2433,7 +2814,8 @@ var ollamaChatV1 = {
     model: {
       key: "model"
     }
-  }
+  },
+  transformResponse: OutputOllamaChat
 };
 var ollama = {
   "ollama.chat.v1": ollamaChatV1,
@@ -2463,507 +2845,72 @@ function googleGeminiPromptMessageCallback(_message) {
     parts.push({
       functionResponse: {
         name: message.name,
-        response: {
-          result: message.content
-        }
-      }
-    });
-    delete message.id;
-  }
-  if (message?.function_call) {
-    const { function_call } = message;
-    const toolsArr = Array.isArray(function_call) ? function_call : [function_call];
-    role = "model";
-    parts.push(
-      ...toolsArr.map((call) => {
-        const { name, arguments: input } = call;
-        return {
-          functionCall: {
-            name,
-            args: maybeParseJSON(input)
-          }
-        };
-      })
-    );
-    delete message.function_call;
-  }
-  return {
-    role,
-    parts
-  };
-}
-
-// src/llm/config/google/promptSanitize.ts
-function googleGeminiPromptSanitize(_messages, _inputBodyObj, _outputObj) {
-  if (typeof _messages === "string") {
-    return [{ role: "user", parts: [{ text: _messages }] }];
-  }
-  if (Array.isArray(_messages)) {
-    if (_messages.length === 0) {
-      throw new Error("Empty messages array");
-    }
-    if (_messages.length === 1 && _messages[0].role === "system") {
-      return [{ role: "user", parts: [{ text: _messages[0].content }] }];
-    }
-    const hasSystemInstruction = _messages.some(
-      (message) => message.role === "system"
-    );
-    if (hasSystemInstruction) {
-      const theSystemInstructions = _messages.filter(
-        (message) => message.role === "system"
-      );
-      const withoutSystemInstructions = _messages.filter(
-        (message) => message.role !== "system"
-      );
-      _outputObj.system_instruction = {
-        parts: theSystemInstructions.map((message) => ({
-          text: message.content
-        }))
-      };
-      return withoutSystemInstructions.map(googleGeminiPromptMessageCallback);
-    }
-    return _messages.map(googleGeminiPromptMessageCallback);
-  }
-  throw new Error("Invalid messages format");
-}
-
-// src/llm/config/google/index.ts
-var googleGeminiChatV1 = {
-  key: "google.chat.v1",
-  provider: "google.chat",
-  endpoint: `https://generativelanguage.googleapis.com/v1beta/models/{{model}}:generateContent?key={{geminiApiKey}}`,
-  options: {
-    prompt: {},
-    // topP: {},
-    geminiApiKey: {
-      default: getEnvironmentVariable("GEMINI_API_KEY")
-    }
-  },
-  method: "POST",
-  headers: `{"Content-Type": "application/json" }`,
-  mapBody: {
-    prompt: {
-      key: "contents",
-      sanitize: googleGeminiPromptSanitize
-    }
-    // topP: {
-    //   key: "top_p",
-    // }
-  }
-};
-var google = {
-  "google.chat.v1": googleGeminiChatV1,
-  "google.gemini-2.0-flash": withDefaultModel(
-    googleGeminiChatV1,
-    "gemini-2.0-flash"
-  ),
-  "google.gemini-2.0-flash-lite": withDefaultModel(
-    googleGeminiChatV1,
-    "gemini-2.0-flash-lite"
-  ),
-  "google.gemini-1.5-pro": withDefaultModel(
-    googleGeminiChatV1,
-    "gemini-1.5-pro"
-  )
-};
-
-// src/llm/config/deepseek/index.ts
-var deepseekChatV1 = {
-  key: "deepseek.chat.v1",
-  provider: "deepseek.chat",
-  endpoint: `https://api.deepseek.com/v1/chat/completions`,
-  options: {
-    prompt: {},
-    topP: {},
-    useJson: {},
-    deepseekApiKey: {
-      default: getEnvironmentVariable("DEEPSEEK_API_KEY")
-    }
-  },
-  method: "POST",
-  headers: `{"Authorization":"Bearer {{deepseekApiKey}}", "Content-Type": "application/json" }`,
-  mapBody: {
-    prompt: {
-      key: "messages",
-      sanitize: (v) => {
-        if (typeof v === "string") {
-          return [{ role: "user", content: v }];
-        }
-        return v;
-      }
-    },
-    model: {
-      key: "model"
-    },
-    topP: {
-      key: "top_p"
-    },
-    useJson: {
-      key: "response_format.type",
-      sanitize: (v) => v ? "json_object" : "text"
-    }
-  }
-};
-var deepseek = {
-  "deepseek.chat.v1": deepseekChatV1,
-  "deepseek.chat": withDefaultModel(deepseekChatV1, "deepseek-chat")
-};
-
-// src/llm/config.ts
-var configs = {
-  ...openai,
-  ...anthropic,
-  ...bedrock,
-  ...xai,
-  ...ollama,
-  ...google,
-  ...deepseek
-};
-function getLlmConfig(provider) {
-  if (!provider) {
-    throw new LlmExeError(`Missing provider`, "unknown", {
-      error: "Missing provider",
-      resolution: "Provide a valid provider"
-    });
-  }
-  const pick2 = configs[provider];
-  if (pick2) {
-    return pick2;
-  }
-  throw new LlmExeError(`Invalid provider: ${provider}`, "unknown", {
-    provider,
-    error: `Invalid provider: ${provider}`,
-    resolution: "Provide a valid provider"
-  });
-}
-
-// src/llm/output/_utils/getResultContent.ts
-function getResultContent(result, index) {
-  if (typeof index === "number" && index > 0) {
-    const arr = result?.options || [];
-    const val = arr[index];
-    return val ? val : [];
-  }
-  return [...result.content];
-}
-
-// src/llm/output/_utils/getResultText.ts
-function getResultText(result, index) {
-  if (typeof index === "number" && index > 0) {
-    const arr = result?.options || [];
-    const val = arr[index];
-    return isOutputResultContentText(val?.[0]) ? val[0]?.text : "";
-  }
-  return isOutputResultContentText(result?.content?.[0]) ? result.content[0]?.text : "";
-}
-
-// src/llm/output/base.ts
-function BaseLlmOutput2(result) {
-  const __result = Object.freeze({
-    id: result.id || uuidv4(),
-    name: result.name,
-    usage: result.usage,
-    stopReason: result.stopReason,
-    options: [...result?.options || []],
-    content: [...result.content],
-    created: result?.created || (/* @__PURE__ */ new Date()).getTime()
-  });
-  function getResult() {
-    return {
-      id: __result.id,
-      name: __result.name,
-      created: __result.created,
-      usage: __result.usage,
-      options: __result.options,
-      content: __result.content,
-      stopReason: __result.stopReason
-    };
-  }
-  return {
-    getResultContent: (index) => getResultContent(__result, index),
-    getResultText: (index) => getResultText(__result, index),
-    getResult
-  };
-}
-
-// src/llm/output/_util.ts
-function normalizeFunctionCall(input, provider) {
-  if (input === "any") {
-    if (provider === "openai") {
-      return "required";
-    }
-  }
-  return input;
-}
-function formatOptions(response, handler) {
-  const out = [];
-  for (const item of response) {
-    const result = handler(item);
-    if (result) {
-      out.push([result]);
-    }
-  }
-  return out;
-}
-function formatContent(response, handler) {
-  const out = [];
-  const result = handler(response);
-  if (result) {
-    out.push(result);
-  }
-  return out;
-}
-
-// src/llm/output/openai.ts
-function formatResult(result) {
-  const out = [];
-  if (typeof result?.message?.content === "string") {
-    out.push({
-      type: "text",
-      text: result.message.content
-    });
-  }
-  if (result?.message?.tool_calls) {
-    for (const call of result.message.tool_calls) {
-      out.push({
-        functionId: call.id,
-        type: "function_use",
-        name: call.function.name,
-        input: maybeParseJSON(call.function.arguments)
-      });
-    }
-  }
-  return out;
-}
-function OutputOpenAIChat(result, _config) {
-  const id = result.id;
-  const name = result.model || _config?.model || "openai.unknown";
-  const created = result.created;
-  const [_content, ..._options] = result?.choices || [];
-  const stopReason = _content?.finish_reason;
-  const content = formatResult(_content);
-  const options = formatOptions(_options, formatResult);
-  const usage = {
-    output_tokens: result?.usage?.completion_tokens,
-    input_tokens: result?.usage?.prompt_tokens,
-    total_tokens: result?.usage?.total_tokens
-  };
-  return BaseLlmOutput2({
-    id,
-    name,
-    created,
-    usage,
-    stopReason,
-    content,
-    options
-  });
-}
-
-// src/llm/output/claude.ts
-function formatResult2(response) {
-  const content = response?.content || [];
-  const out = [];
-  for (let i = 0; i < content.length; i++) {
-    const result = content[i];
-    if (result.type === "text") {
-      out.push({
-        type: "text",
-        text: result.text
-      });
-    } else if (result.type === "tool_use") {
-      out.push({
-        functionId: result.id,
-        type: "function_use",
-        name: result.name,
-        input: result.input
-      });
-    }
-  }
-  return out;
-}
-function OutputAnthropicClaude3Chat(result, _config) {
-  const id = result.id;
-  const name = result.model || _config?.model || "anthropic.unknown";
-  const stopReason = result.stop_reason;
-  const content = formatResult2(result);
-  const usage = {
-    input_tokens: result?.usage?.input_tokens,
-    output_tokens: result?.usage?.output_tokens,
-    total_tokens: result?.usage?.input_tokens + result?.usage?.input_tokens
-  };
-  return BaseLlmOutput2({
-    id,
-    name,
-    usage,
-    stopReason,
-    content
-  });
-}
-
-// src/llm/output/llama.ts
-function OutputMetaLlama3Chat(result, _config) {
-  const name = _config?.model || "meta";
-  const stopReason = result.stop_reason;
-  const content = [
-    { type: "text", text: result.generation }
-  ];
-  const usage = {
-    output_tokens: result?.generation_token_count,
-    input_tokens: result?.prompt_token_count,
-    total_tokens: result?.generation_token_count + result?.prompt_token_count
-  };
-  return BaseLlmOutput2({
-    name,
-    usage,
-    stopReason,
-    content
-  });
-}
-
-// src/llm/output/default.ts
-function OutputDefault(result, _config) {
-  const name = _config.model || "unknown";
-  const stopReason = result?.stopReason || "stop";
-  const content = [];
-  if (result?.text) {
-    content.push({ type: "text", text: result.text });
-  }
-  const usage = {
-    output_tokens: result?.output_tokens || 0,
-    input_tokens: result?.input_tokens || 0,
-    total_tokens: (result?.input_tokens || 0) + (result?.output_tokens || 0)
-  };
-  return BaseLlmOutput2({
-    name,
-    usage,
-    stopReason,
-    content
-  });
-}
-
-// src/llm/output/xai.ts
-function formatResult3(result) {
-  if (typeof result?.message?.content === "string") {
-    return {
-      type: "text",
-      text: result.message.content
-    };
-  } else if (result?.message && "tool_calls" in result.message) {
-    const tool_calls = result.message.tool_calls;
-    if (tool_calls) {
-      for (const call of tool_calls) {
-        return {
-          functionId: call.id,
-          type: "function_use",
-          name: call.function.name,
-          input: JSON.parse(call.function.arguments)
-        };
-      }
-    }
-  }
-  return {
-    type: "text",
-    text: ""
-  };
-}
-function OutputXAIChat(result, _config) {
-  const id = result.id;
-  const name = result?.model;
-  const created = result.created;
-  const [_content, ..._options] = result?.choices || [];
-  const stopReason = _content?.finish_reason;
-  const content = formatContent(_content, formatResult3);
-  const options = formatOptions(_options, formatResult3);
-  const usage = {
-    output_tokens: result?.usage?.completion_tokens,
-    input_tokens: result?.usage?.prompt_tokens,
-    total_tokens: result?.usage?.total_tokens
-  };
-  return BaseLlmOutput2({
-    id,
-    name,
-    created,
-    usage,
-    stopReason,
-    content,
-    options
-  });
-}
-
-// src/llm/output/_utils/combineJsonl.ts
-function combineJsonl(jsonl) {
-  const lines = jsonl.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-    try {
-      return JSON.parse(line);
-    } catch (e) {
-      throw new Error(`Invalid JSON: ${line}`);
-    }
-  });
-  if (lines.length === 0) {
-    throw new Error("No JSON lines provided.");
+        response: {
+          result: message.content
+        }
+      }
+    });
+    delete message.id;
   }
-  lines.sort(
-    (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
-  );
-  let combinedContent = lines.map((line) => line?.message?.content ?? "").join("");
-  combinedContent = combinedContent.replace(/\\u003c/g, "<").replace(/\\u003e/g, ">");
-  const finalLine = lines.find((line) => line.done === true);
-  if (!finalLine) {
-    throw new Error("No line found where done = true.");
+  if (message?.function_call) {
+    const { function_call } = message;
+    const toolsArr = Array.isArray(function_call) ? function_call : [function_call];
+    role = "model";
+    parts.push(
+      ...toolsArr.map((call) => {
+        const { name, arguments: input } = call;
+        return {
+          functionCall: {
+            name,
+            args: maybeParseJSON(input)
+          }
+        };
+      })
+    );
+    delete message.function_call;
   }
-  const result = {
-    model: finalLine.model,
-    created_at: finalLine.created_at,
-    message: {
-      role: finalLine?.message?.role || "assistant",
-      content: combinedContent
-    },
-    done_reason: finalLine.done_reason,
-    done: finalLine.done,
-    total_duration: finalLine.total_duration,
-    load_duration: finalLine.load_duration,
-    prompt_eval_count: finalLine.prompt_eval_count,
-    prompt_eval_duration: finalLine.prompt_eval_duration,
-    eval_count: finalLine.eval_count,
-    eval_duration: finalLine.eval_duration
-  };
-  const content = {
-    type: "text",
-    text: combinedContent
-  };
   return {
-    lines,
-    result,
-    content
+    role,
+    parts
   };
 }
 
-// src/llm/output/ollama.ts
-function OutputOllamaChat(result, _config) {
-  const combined = combineJsonl(result);
-  const id = `${combined.result.model}.${combined.result.created_at}`;
-  const name = combined.result.model || _config?.model || "ollama.unknown";
-  const created = (/* @__PURE__ */ new Date(`${combined.result.created_at}`)).getTime();
-  const stopReason = `${combined?.result?.done_reason || "stop"}`;
-  const content = [combined.content];
-  const usage = {
-    output_tokens: 0,
-    input_tokens: 0,
-    total_tokens: 0
-  };
-  return BaseLlmOutput2({
-    id,
-    name,
-    created,
-    usage,
-    stopReason,
-    content,
-    options: []
-  });
+// src/llm/config/google/promptSanitize.ts
+function googleGeminiPromptSanitize(_messages, _inputBodyObj, _outputObj) {
+  if (typeof _messages === "string") {
+    return [{ role: "user", parts: [{ text: _messages }] }];
+  }
+  if (Array.isArray(_messages)) {
+    if (_messages.length === 0) {
+      throw new Error("Empty messages array");
+    }
+    if (_messages.length === 1 && _messages[0].role === "system") {
+      return [{ role: "user", parts: [{ text: _messages[0].content }] }];
+    }
+    const hasSystemInstruction = _messages.some(
+      (message) => message.role === "system"
+    );
+    if (hasSystemInstruction) {
+      const theSystemInstructions = _messages.filter(
+        (message) => message.role === "system"
+      );
+      const withoutSystemInstructions = _messages.filter(
+        (message) => message.role !== "system"
+      );
+      _outputObj.system_instruction = {
+        parts: theSystemInstructions.map((message) => ({
+          text: message.content
+        }))
+      };
+      return withoutSystemInstructions.map(googleGeminiPromptMessageCallback);
+    }
+    return _messages.map(googleGeminiPromptMessageCallback);
+  }
+  throw new Error("Invalid messages format");
 }
 
 // src/llm/output/google.gemini/formatResult.ts
-function formatResult4(result, id) {
+function formatResult3(result, id) {
   const { parts = [] } = result?.content || {};
   const out = [];
   for (let i = 0; i < parts.length; i++) {
@@ -2988,18 +2935,18 @@ function formatResult4(result, id) {
 // src/llm/output/google.gemini/index.ts
 function OutputGoogleGeminiChat(result, _config) {
   const id = result.responseId;
-  const name = result.modelVersion || _config?.model || "gemini";
+  const name = result.modelVersion || _config?.options.model?.default || "gemini";
   const created = (/* @__PURE__ */ new Date()).getTime();
   const [_content, ..._options] = result?.candidates || [];
   const stopReason = _content?.finishReason?.toLowerCase();
-  const content = formatResult4(_content, id);
-  const options = formatOptions(_options, formatResult4);
+  const content = formatResult3(_content, id);
+  const options = formatOptions(_options, formatResult3);
   const usage = {
     output_tokens: result?.usageMetadata?.candidatesTokenCount,
     input_tokens: result?.usageMetadata?.promptTokenCount,
     total_tokens: result?.usageMetadata?.totalTokenCount
   };
-  return BaseLlmOutput2({
+  return {
     id,
     name,
     created,
@@ -3007,38 +2954,152 @@ function OutputGoogleGeminiChat(result, _config) {
     stopReason,
     content,
     options
-  });
+  };
 }
 
-// src/llm/output/index.ts
-function normalizeLlmOutputToInternalFormat(config, response) {
-  switch (config?.key) {
-    case "openai.chat.v1":
-    case "openai.chat-mock.v1":
-      return OutputOpenAIChat(response, config);
-    case "anthropic.chat.v1":
-    case "amazon:anthropic.chat.v1":
-      return OutputAnthropicClaude3Chat(response, config);
-    case "amazon:meta.chat.v1":
-      return OutputMetaLlama3Chat(response, config);
-    // case "amazon:nova.chat.v1":
-    // return OutputDefault(response, config);
-    case "xai.chat.v1":
-      return OutputXAIChat(response, config);
-    case "ollama.chat.v1":
-      return OutputOllamaChat(response, config);
-    case "google.chat.v1":
-      return OutputGoogleGeminiChat(response, config);
-    case "deepseek.chat.v1":
-      return OutputOpenAIChat(response, config);
-    // use oai for now
-    default: {
-      if (config?.key?.startsWith("custom:")) {
-        return OutputDefault(response, config);
+// src/llm/config/google/index.ts
+var googleGeminiChatV1 = {
+  key: "google.chat.v1",
+  provider: "google.chat",
+  endpoint: `https://generativelanguage.googleapis.com/v1beta/models/{{model}}:generateContent?key={{geminiApiKey}}`,
+  options: {
+    effort: {},
+    prompt: {},
+    // topP: {},
+    geminiApiKey: {
+      default: getEnvironmentVariable("GEMINI_API_KEY")
+    }
+  },
+  method: "POST",
+  headers: `{"Content-Type": "application/json" }`,
+  mapBody: {
+    prompt: {
+      key: "contents",
+      transform: googleGeminiPromptSanitize
+    },
+    effort: {
+      key: "config.thinkingConfig.thinkingBudget",
+      transform: (v, _s) => {
+        if (
+          // only supported reasoning models
+          ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-light"].includes(
+            _s.model
+          ) && typeof v === "string" && ["minimal", "low", "medium", "high"].includes(v)
+        ) {
+          if (v === "low" || v === "minimal") {
+            return 1024;
+          } else if (v === "medium") {
+            return 8192;
+          } else if (v === "high") {
+            return 24576;
+          }
+        }
+        return void 0;
       }
-      throw new Error("Unsupported provider");
     }
+  },
+  mapOptions: {
+    functionCall: (call) => ({
+      toolConfig: {
+        functionCallingConfig: {
+          mode: call === "any" ? "any" : call === "none" ? "none" : "auto"
+        }
+      }
+    }),
+    functions: (functions) => ({
+      tools: [
+        {
+          functionDeclarations: functions.map((f) => ({
+            name: f.name,
+            description: f.description,
+            parameters: cleanJsonSchemaFor(f.parameters, "google.chat")
+          }))
+        }
+      ]
+    })
+  },
+  transformResponse: OutputGoogleGeminiChat
+};
+var google = {
+  "google.chat.v1": googleGeminiChatV1,
+  "google.gemini-2.0-flash": withDefaultModel(
+    googleGeminiChatV1,
+    "gemini-2.0-flash"
+  ),
+  "google.gemini-2.0-flash-lite": withDefaultModel(
+    googleGeminiChatV1,
+    "gemini-2.0-flash-lite"
+  ),
+  "google.gemini-2.5-flash": withDefaultModel(
+    googleGeminiChatV1,
+    "gemini-2.5-flash"
+  ),
+  "google.gemini-2.5-flash-lite": withDefaultModel(
+    googleGeminiChatV1,
+    "gemini-2.5-flash-lite"
+  ),
+  "google.gemini-1.5-pro": withDefaultModel(
+    googleGeminiChatV1,
+    "gemini-1.5-pro"
+  ),
+  "google.gemini-2.5-pro": withDefaultModel(
+    googleGeminiChatV1,
+    "gemini-2.5-pro"
+  )
+};
+
+// src/llm/config/deepseek/index.ts
+var deepseekChatV1 = createOpenAiCompatibleConfiguration({
+  key: "deepseek.chat.v1",
+  provider: "deepseek.chat",
+  endpoint: `https://api.deepseek.com/v1/chat/completions`,
+  apiKeyMapping: ["deepseekApiKey", "DEEPSEEK_API_KEY"]
+});
+var deepseek = {
+  "deepseek.chat.v1": deepseekChatV1,
+  "deepseek.chat": withDefaultModel(deepseekChatV1, "deepseek-chat")
+};
+
+// src/llm/config.ts
+var configs = {
+  ...openai,
+  ...anthropic,
+  ...bedrock,
+  ...xai,
+  ...ollama,
+  ...google,
+  ...deepseek
+};
+function getLlmConfig(provider) {
+  if (!provider) {
+    throw new LlmExeError(`Missing provider`, "unknown", {
+      error: "Missing provider",
+      resolution: "Provide a valid provider"
+    });
+  }
+  const pick2 = configs[provider];
+  if (pick2) {
+    return pick2;
   }
+  throw new LlmExeError(`Invalid provider: ${provider}`, "unknown", {
+    provider,
+    error: `Invalid provider: ${provider}`,
+    resolution: "Provide a valid provider"
+  });
+}
+
+// src/utils/modules/maskApiKeysInDebug.ts
+function maskApiKeys(log) {
+  return log.replace(
+    /\b(Bearer\s+[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+|Bearer\s+[A-Za-z0-9\-_]{20,}|sk-[A-Za-z0-9]{20,}|AKIA[A-Z0-9]{16}|[A-Za-z0-9]{32,})\b/g,
+    (match) => {
+      if (match.length <= 8) return match;
+      const prefix = match.substring(0, 4);
+      const suffix = match.substring(match.length - 4);
+      const maskLength = match.length - 8;
+      return `${prefix}${"*".repeat(maskLength)}${suffix}`;
+    }
+  );
 }
 
 // src/utils/modules/debug.ts
@@ -3064,7 +3125,15 @@ function debug(...args) {
         logs.push(arg.toString());
       } else {
         try {
-          logs.push(JSON.stringify(arg, null, 2));
+          let shouldMask = false;
+          if (arg.headers && arg.headers.Authorization) {
+            shouldMask = true;
+          }
+          let str = JSON.stringify(arg, null, 2);
+          if (shouldMask) {
+            str = maskApiKeys(str);
+          }
+          logs.push(str);
         } catch (error) {
           console.error("Error parsing object:", error);
         }
@@ -3112,7 +3181,8 @@ async function apiRequest(url, options) {
       }
       throw new Error(message);
     }
-    if (response.headers.get("content-type")?.includes("application/json")) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
       const responseData = await response.json();
       return responseData;
     } else {
@@ -3129,20 +3199,26 @@ async function apiRequest(url, options) {
 function convertDotNotation(obj) {
   const result = {};
   for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      if (key.includes(".")) {
-        const keys = key.split(".");
-        let currentLevel = result;
-        for (let i = 0; i < keys.length; i++) {
-          if (i === keys.length - 1) {
-            currentLevel[keys[i]] = obj[key];
-          } else {
-            currentLevel[keys[i]] = currentLevel[keys[i]] || {};
-            currentLevel = currentLevel[keys[i]];
+    if (Object.prototype.hasOwnProperty.call(obj, key) && !key.includes(".")) {
+      result[key] = obj[key];
+    }
+  }
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key) && key.includes(".")) {
+      const keys = key.split(".");
+      let currentLevel = result;
+      for (let i = 0; i < keys.length; i++) {
+        const currentKey = keys[i];
+        if (i === keys.length - 1) {
+          currentLevel[currentKey] = obj[key];
+        } else {
+          if (!(currentKey in currentLevel)) {
+            currentLevel[currentKey] = {};
+          } else if (typeof currentLevel[currentKey] !== "object" || currentLevel[currentKey] === null || Array.isArray(currentLevel[currentKey])) {
+            currentLevel[currentKey] = {};
           }
+          currentLevel = currentLevel[currentKey];
         }
-      } else {
-        result[key] = obj[key];
       }
     }
   }
@@ -3159,8 +3235,8 @@ function mapBody(template, body) {
     const { key: providerSpecificKey, default: defaultValue } = providerSpecificSettings;
     if (providerSpecificKey) {
       let valueForThisKey = body[genericInputKey];
-      if (providerSpecificSettings.sanitize && typeof providerSpecificSettings.sanitize === "function") {
-        valueForThisKey = providerSpecificSettings.sanitize(
+      if (providerSpecificSettings.transform && typeof providerSpecificSettings.transform === "function") {
+        valueForThisKey = providerSpecificSettings.transform(
           valueForThisKey,
           Object.freeze({ ...body }),
           output
@@ -3184,28 +3260,70 @@ import { Sha256 } from "@aws-crypto/sha256-js";
 
 // src/utils/modules/runWithTemporaryEnv.ts
 async function runWithTemporaryEnv(env, handler) {
-  const previousEnv = { ...process.env };
+  const modifiedKeys = [];
+  const originalValues = {};
+  const envBefore = { ...process.env };
   try {
-    env();
+    try {
+      env();
+    } catch (envError) {
+      const envAfter2 = process.env;
+      for (const key in envAfter2) {
+        if (envBefore[key] !== envAfter2[key]) {
+          modifiedKeys.push(key);
+          originalValues[key] = envBefore[key];
+        }
+      }
+      for (const key in envBefore) {
+        if (!(key in envAfter2) && !modifiedKeys.includes(key)) {
+          modifiedKeys.push(key);
+          originalValues[key] = envBefore[key];
+        }
+      }
+      throw envError;
+    }
+    const envAfter = process.env;
+    for (const key in envAfter) {
+      if (envBefore[key] !== envAfter[key]) {
+        modifiedKeys.push(key);
+        originalValues[key] = envBefore[key];
+      }
+    }
+    for (const key in envBefore) {
+      if (!(key in envAfter) && !modifiedKeys.includes(key)) {
+        modifiedKeys.push(key);
+        originalValues[key] = envBefore[key];
+      }
+    }
     const value = await handler();
     return value;
   } finally {
-    process.env = previousEnv;
+    for (const key of modifiedKeys) {
+      const originalValue = originalValues[key];
+      if (originalValue === void 0) {
+        delete process.env[key];
+      } else {
+        process.env[key] = originalValue;
+      }
+    }
   }
 }
 
 // src/utils/modules/getAwsAuthorizationHeaders.ts
 async function getAwsAuthorizationHeaders(req, props) {
+  if (!props.url || !props.regionName) {
+    throw new Error("URL and region name are required for AWS authorization");
+  }
   const providerChain = fromNodeProviderChain();
   const credentials = await runWithTemporaryEnv(
     () => {
-      if (props.awsAccessKey) {
+      if (props.awsAccessKey && typeof props.awsAccessKey === "string") {
         process.env["AWS_ACCESS_KEY_ID"] = props.awsAccessKey;
       }
-      if (props.awsSecretKey) {
+      if (props.awsSecretKey && typeof props.awsSecretKey === "string") {
         process.env["AWS_SECRET_ACCESS_KEY"] = props.awsSecretKey;
       }
-      if (props.awsSessionToken) {
+      if (props.awsSessionToken && typeof props.awsSessionToken === "string") {
         process.env["AWS_SESSION_TOKEN"] = props.awsSessionToken;
       }
     },
@@ -3235,8 +3353,21 @@ async function getAwsAuthorizationHeaders(req, props) {
 // src/llm/_utils.parseHeaders.ts
 async function parseHeaders(config, replacements, payload) {
   const replace = replaceTemplateStringSimple(config.headers, replacements);
-  const parse = replace ? JSON.parse(replace) : {};
-  const headers = Object.assign({}, payload.headers, parse);
+  let parsedHeaders = {};
+  if (replace) {
+    try {
+      parsedHeaders = JSON.parse(replace);
+      if (typeof parsedHeaders !== "object" || parsedHeaders === null || Array.isArray(parsedHeaders)) {
+        throw new Error("Headers must be a JSON object");
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(
+        `Failed to parse headers configuration: ${errorMessage}. Headers template: "${config.headers}". After replacement: "${replace}"`
+      );
+    }
+  }
+  const headers = Object.assign({}, payload.headers, parsedHeaders);
   if (config.provider.startsWith("amazon:") || config.provider.startsWith("amazon.")) {
     const url = payload.url;
     return getAwsAuthorizationHeaders(
@@ -3257,122 +3388,129 @@ async function parseHeaders(config, replacements, payload) {
   }
 }
 
-// src/llm/output/_utils/cleanJsonSchemaFor.ts
-var providerFieldExclusions = {
-  "openai.chat": ["default"],
-  // fields to exclude for openai.chat
-  "anthropic.chat": []
-  // fields to exclude for openai.chat
-};
-function cleanJsonSchemaFor(schema = {}, provider) {
-  const clone = deepClone(schema);
-  if (Object.keys(clone).length === 0) {
+// src/llm/output/default.ts
+function OutputDefault(result, _config) {
+  const name = _config?.options.model?.default || "unknown";
+  const stopReason = result?.stopReason || "stop";
+  const content = [];
+  if (result?.text) {
+    content.push({ type: "text", text: result.text });
+  }
+  const usage = {
+    output_tokens: result?.output_tokens || 0,
+    input_tokens: result?.input_tokens || 0,
+    total_tokens: (result?.input_tokens || 0) + (result?.output_tokens || 0)
+  };
+  return {
+    name,
+    usage,
+    stopReason,
+    content
+  };
+}
+
+// src/llm/output/_utils/getResultContent.ts
+function getResultContent(result, index) {
+  if (typeof index === "number" && index > 0) {
+    const arr = result?.options || [];
+    const val = arr[index];
+    return val ? val : [];
+  }
+  return [...result.content];
+}
+
+// src/llm/output/_utils/getResultText.ts
+function getResultText(result, index) {
+  if (typeof index === "number" && index > 0) {
+    const arr = result?.options || [];
+    const val = arr[index];
+    return isOutputResultContentText(val?.[0]) ? val[0]?.text : "";
+  }
+  return isOutputResultContentText(result?.content?.[0]) ? result.content[0]?.text : "";
+}
+
+// src/llm/output/base.ts
+function BaseLlmOutput(result) {
+  const __result = Object.freeze({
+    id: result.id || uuidv4(),
+    name: result.name,
+    usage: result.usage,
+    stopReason: result.stopReason,
+    options: [...result?.options || []],
+    content: [...result.content],
+    created: result?.created || (/* @__PURE__ */ new Date()).getTime()
+  });
+  function getResult() {
     return {
-      type: "object",
-      properties: {},
-      required: []
+      id: __result.id,
+      name: __result.name,
+      created: __result.created,
+      usage: __result.usage,
+      options: __result.options,
+      content: __result.content,
+      stopReason: __result.stopReason
     };
   }
-  const exclusions = providerFieldExclusions[provider] || [];
-  function removeDisallowedFields(obj) {
-    if (Array.isArray(obj)) {
-      return obj.map(removeDisallowedFields);
-    } else if (typeof obj === "object" && obj !== null) {
-      return Object.keys(obj).reduce((acc, key) => {
-        if (!exclusions.includes(key)) {
-          acc[key] = removeDisallowedFields(obj[key]);
-        }
-        return acc;
-      }, {});
+  return {
+    getResultContent: (index) => getResultContent(__result, index),
+    getResultText: (index) => getResultText(__result, index),
+    getResult
+  };
+}
+
+// src/llm/_utils.mapOptions.ts
+function mapOptions(input, options, config) {
+  if (!config?.mapOptions || !options) {
+    return input;
+  }
+  let result = { ...input };
+  let processedOptions = options;
+  if (options.functionCall && config.mapOptions.functionCall) {
+    const mapping = config.mapOptions.functionCall(
+      options.functionCall,
+      options,
+      result,
+      config
+    );
+    if (mapping._clearFunctions) {
+      processedOptions = { ...options, functions: [] };
+      const { _clearFunctions, ...rest } = mapping;
+      result = { ...result, ...rest };
+    } else {
+      result = { ...result, ...mapping };
     }
-    return obj;
   }
-  return removeDisallowedFields(clone);
+  if (processedOptions.functions?.length && config.mapOptions.functions) {
+    result = {
+      ...result,
+      ...config.mapOptions.functions(
+        processedOptions.functions,
+        processedOptions,
+        result,
+        config
+      )
+    };
+  }
+  if (options.jsonSchema && config.mapOptions.jsonSchema) {
+    result = {
+      ...result,
+      ...config.mapOptions.jsonSchema(options.jsonSchema, options, result, config)
+    };
+  }
+  return result;
 }
 
 // src/llm/llm.call.ts
 async function useLlm_call(state, messages, _options) {
   const config = getLlmConfig(state.key);
-  const { functionCallStrictInput = false } = _options || {};
-  const input = mapBody(
+  const transformBody = mapBody(
     config.mapBody,
     Object.assign({}, state, {
       prompt: messages
     })
   );
-  if (_options && _options?.jsonSchema) {
-    if (state.provider.startsWith("openai")) {
-      const curr = input["response_format"] || {};
-      input["response_format"] = Object.assign(curr, {
-        type: "json_schema",
-        json_schema: {
-          name: "output",
-          strict: !!functionCallStrictInput,
-          schema: cleanJsonSchemaFor(_options?.jsonSchema, "openai.chat")
-        }
-      });
-    }
-  }
-  if (_options && _options?.functionCall) {
-    if (state.provider.startsWith("anthropic")) {
-      if (_options?.functionCall === "none") {
-        _options.functions = [];
-      } else if (_options?.functionCall === "auto" || _options?.functionCall === "any") {
-        input["tool_choice"] = { type: _options?.functionCall };
-      } else {
-        input["tool_choice"] = _options?.functionCall;
-      }
-    } else if (state.provider.startsWith("openai")) {
-      input["tool_choice"] = normalizeFunctionCall(
-        _options?.functionCall,
-        "openai"
-      );
-    } else if (state.provider.startsWith("google")) {
-      input["toolConfig"] = {
-        functionCallingConfig: {
-          mode: normalizeFunctionCall(_options?.functionCall, "google")
-        }
-      };
-    }
-  }
-  if (_options && _options?.functions?.length) {
-    if (state.provider.startsWith("anthropic")) {
-      input["tools"] = _options.functions.map((f) => ({
-        name: f.name,
-        description: f.description,
-        input_schema: cleanJsonSchemaFor(f.parameters, "anthropic.chat")
-      }));
-    } else if (state.provider.startsWith("openai")) {
-      input["tools"] = _options.functions.map((f) => {
-        const props = {
-          name: f?.name,
-          description: f?.description,
-          parameters: f?.parameters
-        };
-        return {
-          type: "function",
-          function: Object.assign(
-            props,
-            {
-              parameters: cleanJsonSchemaFor(props.parameters, "openai.chat")
-            },
-            { strict: functionCallStrictInput }
-          )
-        };
-      });
-    } else if (state.provider.startsWith("google")) {
-      input["tools"] = [
-        {
-          functionDeclarations: _options.functions.map((f) => ({
-            name: f.name,
-            description: f.description,
-            parameters: cleanJsonSchemaFor(f.parameters, "google.chat")
-          }))
-        }
-      ];
-    }
-  }
-  const body = JSON.stringify(input);
+  const applyOptions = mapOptions(transformBody, _options, config);
+  const body = JSON.stringify(applyOptions);
   const url = replaceTemplateStringSimple(config.endpoint, state);
   const headers = await parseHeaders(config, state, {
     url,
@@ -3399,7 +3537,9 @@ async function useLlm_call(state, messages, _options) {
     body,
     headers
   });
-  return normalizeLlmOutputToInternalFormat(state, response);
+  const { transformResponse = OutputDefault } = config;
+  const normalized = transformResponse(response, config);
+  return BaseLlmOutput(normalized);
 }
 
 // src/llm/_utils.stateFromOptions.ts
@@ -3542,6 +3682,80 @@ function useLlm(provider, options = {}) {
   const config = getLlmConfig(provider);
   return apiRequestWrapper(config, options, useLlm_call);
 }
+function useLlmConfiguration(config) {
+  return (options = {}) => apiRequestWrapper(config, options, useLlm_call);
+}
+
+// src/embedding/output/BaseEmbeddingOutput.ts
+function BaseEmbeddingOutput(result) {
+  const __result = Object.freeze({
+    id: result.id || uuidv4(),
+    model: result.model,
+    usage: result.usage,
+    embedding: [...result?.embedding || []],
+    created: result?.created || (/* @__PURE__ */ new Date()).getTime()
+  });
+  function getResult() {
+    return {
+      id: __result.id,
+      model: __result.model,
+      created: __result.created,
+      usage: __result.usage,
+      embedding: __result.embedding
+    };
+  }
+  function getEmbedding(index) {
+    if (index && index > 0) {
+      const arr = __result?.embedding;
+      const val = arr[index];
+      return val ? val : [];
+    }
+    return __result.embedding[0];
+  }
+  return {
+    getEmbedding,
+    getResult
+  };
+}
+
+// src/embedding/output/OpenAiEmbedding.ts
+function OpenAiEmbedding(result, config) {
+  const __result = deepClone(result);
+  const model = __result.model || config.model || "openai.unknown";
+  const created = (/* @__PURE__ */ new Date()).getTime();
+  const results = result?.data || [];
+  const embedding = results.map((a) => a.embedding);
+  const usage = {
+    output_tokens: 0,
+    input_tokens: result?.usage?.prompt_tokens,
+    total_tokens: result?.usage?.total_tokens
+  };
+  return BaseEmbeddingOutput({
+    model,
+    created,
+    usage,
+    embedding
+  });
+}
+
+// src/embedding/output/AmazonTitan.ts
+function AmazonTitanEmbedding(result, config) {
+  const __result = deepClone(result);
+  const model = config.model || "amazon.unknown";
+  const created = (/* @__PURE__ */ new Date()).getTime();
+  const embedding = [__result.embedding];
+  const usage = {
+    output_tokens: 0,
+    input_tokens: __result.inputTextTokenCount,
+    total_tokens: __result.inputTextTokenCount
+  };
+  return BaseEmbeddingOutput({
+    model,
+    created,
+    usage,
+    embedding
+  });
+}
 
 // src/embedding/config.ts
 var embeddingConfigs = {
@@ -3574,7 +3788,8 @@ var embeddingConfigs = {
       encodingFormat: {
         key: "encoding_format"
       }
-    }
+    },
+    transformResponse: OpenAiEmbedding
   },
   "amazon.embedding.v1": {
     key: "amazon.embedding.v1",
@@ -3601,7 +3816,8 @@ var embeddingConfigs = {
       dimensions: {
         key: "dimensions"
       }
-    }
+    },
+    transformResponse: AmazonTitanEmbedding
   }
 };
 function getEmbeddingConfig(provider) {
@@ -3615,77 +3831,6 @@ function getEmbeddingConfig(provider) {
   throw new Error(`Invalid provider: ${provider}`);
 }
 
-// src/embedding/output/BaseEmbeddingOutput.ts
-function BaseEmbeddingOutput(result) {
-  const __result = Object.freeze({
-    id: result.id || uuidv4(),
-    model: result.model,
-    usage: result.usage,
-    embedding: [...result?.embedding || []],
-    created: result?.created || (/* @__PURE__ */ new Date()).getTime()
-  });
-  function getResult() {
-    return {
-      id: __result.id,
-      model: __result.model,
-      created: __result.created,
-      usage: __result.usage,
-      embedding: __result.embedding
-    };
-  }
-  function getEmbedding(index) {
-    if (index && index > 0) {
-      const arr = __result?.embedding;
-      const val = arr[index];
-      return val ? val : [];
-    }
-    return __result.embedding[0];
-  }
-  return {
-    getEmbedding,
-    getResult
-  };
-}
-
-// src/embedding/output/AmazonTitan.ts
-function AmazonTitanEmbedding(result, config) {
-  const __result = deepClone(result);
-  const model = config.model || "amazon.unknown";
-  const created = (/* @__PURE__ */ new Date()).getTime();
-  const embedding = [__result.embedding];
-  const usage = {
-    output_tokens: 0,
-    input_tokens: __result.inputTextTokenCount,
-    total_tokens: __result.inputTextTokenCount
-  };
-  return BaseEmbeddingOutput({
-    model,
-    created,
-    usage,
-    embedding
-  });
-}
-
-// src/embedding/output/OpenAiEmbedding.ts
-function OpenAiEmbedding(result, config) {
-  const __result = deepClone(result);
-  const model = __result.model || config.model || "openai.unknown";
-  const created = (/* @__PURE__ */ new Date()).getTime();
-  const results = result?.data || [];
-  const embedding = results.map((a) => a.embedding);
-  const usage = {
-    output_tokens: 0,
-    input_tokens: result?.usage?.prompt_tokens,
-    total_tokens: result?.usage?.total_tokens
-  };
-  return BaseEmbeddingOutput({
-    model,
-    created,
-    usage,
-    embedding
-  });
-}
-
 // src/embedding/output/getEmbeddingOutputParser.ts
 function getEmbeddingOutputParser(config, response) {
   switch (config.key) {
@@ -4703,6 +4848,9 @@ var Dialogue = class extends BaseStateItem {
    * @returns this for chaining
    */
   addFromOutput(output) {
+    if (!output || typeof output !== "object") {
+      return this;
+    }
     const result = "getResult" in output ? output.getResult() : output;
     if (!result || typeof result !== "object") {
       return this;
@@ -4838,6 +4986,7 @@ export {
   createEmbedding,
   createLlmExecutor,
   createLlmFunctionExecutor,
+  createOpenAiCompatibleConfiguration,
   createParser,
   createPrompt,
   createState,
@@ -4848,5 +4997,6 @@ export {
   registerPartials,
   useExecutors,
   useLlm,
+  useLlmConfiguration,
   utils_exports as utils
 };