llm-exe 3.0.0-beta.1 → 3.0.0-beta.3

package/dist/index.js

@@ -1266,9 +1266,12 @@ var BOOLEAN_VALUES = ["true", "false", "yes", "no", "y", "n", "1", "0"];
 var TRUTHY_VALUES = /* @__PURE__ */ new Set(["true", "yes", "y", "1"]);
 var FALSY_VALUES = /* @__PURE__ */ new Set(["false", "no", "n", "0"]);
 var MAX_ERROR_INPUT_EXCERPT_LENGTH = 500;
+var BOOLEAN_TOKEN_PATTERN = /(?<![\p{L}\p{N}])(?:true|false|yes|no|y|n|1|0)(?![\p{L}\p{N}])/giu;
 var BooleanParser = class extends BaseParser {
-  constructor() {
+  constructor(options) {
     super("boolean");
+    __publicField(this, "match");
+    this.match = options?.match ?? "exact";
   }
   getInputErrorContext(text) {
     const context = {
@@ -1316,6 +1319,36 @@ var BooleanParser = class extends BaseParser {
     if (FALSY_VALUES.has(clean)) {
       return false;
     }
+    if (this.match === "extract") {
+      const matches = Array.from(
+        text.toLowerCase().matchAll(BOOLEAN_TOKEN_PATTERN)
+      ).map((match) => match[0]);
+      const values = Array.from(
+        new Set(
+          matches.map((match) => {
+            if (TRUTHY_VALUES.has(match)) return true;
+            return false;
+          })
+        )
+      );
+      if (values.length === 1) {
+        return values[0];
+      }
+      if (values.length > 1) {
+        throw new LlmExeError(`Multiple boolean values found in input.`, {
+          code: "parser.parse_failed",
+          context: {
+            operation: "BooleanParser.parse",
+            parser: "boolean",
+            reason: "ambiguous_boolean",
+            expected: "one boolean value",
+            match: this.match,
+            matchCount: values.length,
+            ...this.getInputErrorContext(text)
+          }
+        });
+      }
+    }
     throw new LlmExeError(`No boolean value found in input.`, {
       code: "parser.parse_failed",
       context: {
@@ -1323,6 +1356,7 @@ var BooleanParser = class extends BaseParser {
         parser: "boolean",
         reason: "unrecognized_boolean",
         expected: BOOLEAN_VALUES,
+        match: this.match,
         ...this.getInputErrorContext(text)
       }
     });
@@ -1347,7 +1381,7 @@ function toNumber(value) {
 
 // src/parser/parsers/NumberParser.ts
 var NUMERIC_TOKEN_PATTERN = /(^|[^\w.,])([+-]?(?:(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)(?![\w,])/g;
-var WHOLE_NUMERIC_PATTERN = /^[+-]?(?:(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+var EXACT_NUMERIC_PATTERN = /^[+-]?(?:(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/;
 var NumberParser = class extends BaseParser {
   constructor(options) {
     super("number");
@@ -1382,16 +1416,16 @@ var NumberParser = class extends BaseParser {
         }
       });
     }
-    if (this.match === "whole") {
+    if (this.match === "exact") {
       const trimmed = text.trim();
-      if (!WHOLE_NUMERIC_PATTERN.test(trimmed)) {
-        throw new LlmExeError(`Input is not a whole numeric value.`, {
+      if (!EXACT_NUMERIC_PATTERN.test(trimmed)) {
+        throw new LlmExeError(`Input is not an exact numeric value.`, {
           code: "parser.parse_failed",
           context: {
             operation: "NumberParser.parse",
             parser: "number",
             reason: "no_numeric_value",
-            expected: "whole number",
+            expected: "exact number",
             match: this.match,
             inputLength: text.length
           }
@@ -1658,9 +1692,11 @@ function isPlainObject2(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function normalizeWholeResponseJsonText(input) {
+function normalizeExactResponseJsonText(input) {
   const trimmed = input.trim();
-  const fenceMatch = trimmed.match(/^```([a-zA-Z]*)[^\S\r\n]*\r?\n([\s\S]*)```$/);
+  const fenceMatch = trimmed.match(
+    /^```([a-zA-Z]*)[^\S\r\n]*\r?\n([\s\S]*)```$/
+  );
   if (!fenceMatch) {
     return trimmed;
   }
@@ -1670,19 +1706,82 @@ function normalizeWholeResponseJsonText(input) {
   }
   return body.trim();
 }
+function findBalancedJsonEnd(input, start) {
+  const first = input[start];
+  const stack = first === "{" ? ["}"] : first === "[" ? ["]"] : [];
+  let inString = false;
+  let escaping = false;
+  for (let index = start + 1; index < input.length; index += 1) {
+    const char = input[index];
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+      } else if (char === "\\") {
+        escaping = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      stack.push(char === "{" ? "}" : "]");
+      continue;
+    }
+    if (char !== "}" && char !== "]") {
+      continue;
+    }
+    if (stack[stack.length - 1] !== char) {
+      return void 0;
+    }
+    stack.pop();
+    if (stack.length === 0) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function extractJsonCandidates(input) {
+  const candidates = [];
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (char !== "{" && char !== "[") {
+      continue;
+    }
+    const end = findBalancedJsonEnd(input, index);
+    if (end === void 0) {
+      continue;
+    }
+    const candidate = input.slice(index, end + 1);
+    try {
+      candidates.push({
+        parsed: JSON.parse(candidate)
+      });
+      index = end;
+    } catch {
+    }
+  }
+  return candidates;
+}
 var JsonParser = class extends BaseParserWithJson {
   constructor(options = {}) {
     super("json", options);
     __publicField(this, "shouldValidateSchema");
+    __publicField(this, "match");
+    this.match = options.match ?? "exact";
     this.shouldValidateSchema = !!options.schema && options.validateSchema !== false;
   }
   /**
    * v3 parser contract:
    * Category: strict
-   * Mode: whole-output
+   * Mode: exact
    *
-   * Parses strict JSON object/array output only. Invalid JSON, empty input,
-   * JSON primitives, and non-plain runtime objects throw typed parser errors.
+   * Parses strict JSON object/array output by default. Pass match: "extract"
+   * to extract one JSON object or array from surrounding text. Invalid JSON,
+   * empty input, JSON primitives, and non-plain runtime objects throw typed parser errors.
    * Schema validation is on by default when a schema is provided unless
    * validateSchema: false is explicitly set.
    *
@@ -1705,19 +1804,52 @@ var JsonParser = class extends BaseParserWithJson {
         });
       }
       try {
-        parsed = JSON.parse(normalizeWholeResponseJsonText(text));
+        parsed = JSON.parse(normalizeExactResponseJsonText(text));
       } catch (cause) {
-        throw new LlmExeError(`Invalid JSON input.`, {
-          code: "parser.parse_failed",
-          context: {
-            operation: "JsonParser.parse",
-            parser: "json",
-            reason: "invalid_json",
-            expected: "JSON object or array",
-            inputLength
-          },
-          cause
-        });
+        if (this.match === "extract") {
+          const candidates = extractJsonCandidates(text);
+          if (candidates.length === 1) {
+            parsed = candidates[0].parsed;
+          } else if (candidates.length > 1) {
+            throw new LlmExeError(`Multiple JSON values found in input.`, {
+              code: "parser.parse_failed",
+              context: {
+                operation: "JsonParser.parse",
+                parser: "json",
+                reason: "ambiguous_json_match",
+                expected: "one JSON object or array",
+                match: this.match,
+                inputLength,
+                matchCount: candidates.length
+              }
+            });
+          } else {
+            throw new LlmExeError(`No JSON value found in input.`, {
+              code: "parser.parse_failed",
+              context: {
+                operation: "JsonParser.parse",
+                parser: "json",
+                reason: "no_json_value",
+                expected: "JSON object or array",
+                match: this.match,
+                inputLength
+              },
+              cause
+            });
+          }
+        } else {
+          throw new LlmExeError(`Invalid JSON input.`, {
+            code: "parser.parse_failed",
+            context: {
+              operation: "JsonParser.parse",
+              parser: "json",
+              reason: "invalid_json",
+              expected: "JSON object or array",
+              inputLength
+            },
+            cause
+          });
+        }
       }
     } else if (Array.isArray(text) || isPlainObject2(text)) {
       parsed = text;
@@ -2988,7 +3120,7 @@ var StringExtractParser = class extends BaseParser {
    * Mode: configured value extraction
    *
    * Returns the single configured enum value found in input. Matching is
-   * word-bounded by default; pass match: "whole" to require exact input or
+   * word-bounded by default; pass match: "exact" to require exact input or
    * match: "substring" for legacy contains() behavior. Case-insensitive by
    * default.
    *
@@ -3070,8 +3202,8 @@ var StringExtractParser = class extends BaseParser {
   }
   findMatches(text) {
     switch (this.match) {
-      case "whole":
-        return this.matchWhole(text);
+      case "exact":
+        return this.matchExact(text);
       case "substring":
         return this.matchSubstring(text);
       case "word":
@@ -3079,7 +3211,7 @@ var StringExtractParser = class extends BaseParser {
         return this.matchWord(text);
     }
   }
-  matchWhole(text) {
+  matchExact(text) {
     const candidate = this.ignoreCase ? text.trim().toLowerCase() : text.trim();
     return this.enum.filter((option) => {
       if (option === "") return false;
@@ -3129,36 +3261,33 @@ function createParser(...args) {
     case "replaceStringTemplate":
       return new ReplaceStringTemplateParser();
     case "boolean":
-      return new BooleanParser();
+      return new BooleanParser(options);
     case "number":
       return new NumberParser(options);
     case "string":
       return new StringParser();
     default:
-      throw new LlmExeError(
-        `Invalid parser type: "${type}"`,
-        {
-          code: "parser.invalid_type",
-          context: {
-            operation: "createParser",
-            parser: type,
-            availableParsers: [
-              "json",
-              "string",
-              "boolean",
-              "number",
-              "stringExtract",
-              "listToArray",
-              "listToJson",
-              "listToKeyValue",
-              "replaceStringTemplate",
-              "markdownCodeBlock",
-              "markdownCodeBlocks"
-            ],
-            resolution: "Use a registered parser type, or define a custom parser."
-          }
+      throw new LlmExeError(`Invalid parser type: "${type}"`, {
+        code: "parser.invalid_type",
+        context: {
+          operation: "createParser",
+          parser: type,
+          availableParsers: [
+            "json",
+            "string",
+            "boolean",
+            "number",
+            "stringExtract",
+            "listToArray",
+            "listToJson",
+            "listToKeyValue",
+            "replaceStringTemplate",
+            "markdownCodeBlock",
+            "markdownCodeBlocks"
+          ],
+          resolution: "Use a registered parser type, or define a custom parser."
         }
-      );
+      });
   }
 }
 function createCustomParser(name, parserFn) {
@@ -4223,6 +4352,20 @@ function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
   return mergeConsecutiveSameRole(result);
 }
 
+// src/llm/output/_utils/getBedrockTokenCounts.ts
+function getBedrockTokenCounts(headers) {
+  if (!headers) return void 0;
+  const input = parseInt(headers["x-amzn-bedrock-input-token-count"], 10);
+  const output = parseInt(headers["x-amzn-bedrock-output-token-count"], 10);
+  if (!Number.isFinite(input) && !Number.isFinite(output)) {
+    return void 0;
+  }
+  return {
+    input_tokens: Number.isFinite(input) ? input : 0,
+    output_tokens: Number.isFinite(output) ? output : 0
+  };
+}
+
 // src/llm/output/claude.ts
 function formatResult2(response) {
   const content = response?.content || [];
@@ -4245,15 +4388,18 @@ function formatResult2(response) {
   }
   return out;
 }
-function OutputAnthropicClaude3Chat(result, _config) {
+function OutputAnthropicClaude3Chat(result, _config, headers) {
   const id = result.id;
   const name = result.model || _config?.options.model?.default || "anthropic.unknown";
   const stopReason = result.stop_reason;
   const content = formatResult2(result);
+  const headerUsage = getBedrockTokenCounts(headers);
+  const input_tokens = result?.usage?.input_tokens ?? headerUsage?.input_tokens ?? 0;
+  const output_tokens = result?.usage?.output_tokens ?? headerUsage?.output_tokens ?? 0;
   const usage = {
-    input_tokens: result?.usage?.input_tokens,
-    output_tokens: result?.usage?.output_tokens,
-    total_tokens: result?.usage?.input_tokens + result?.usage?.output_tokens
+    input_tokens,
+    output_tokens,
+    total_tokens: input_tokens + output_tokens
   };
   return {
     id,
@@ -4266,7 +4412,7 @@ function OutputAnthropicClaude3Chat(result, _config) {
 }
 
 // src/llm/output/llama.ts
-function OutputMetaLlama3Chat(result, _config) {
+function OutputMetaLlama3Chat(result, _config, headers) {
   const id = (0, import_uuid.v4)();
   const name = _config?.options?.model?.default || "meta";
   const created = (/* @__PURE__ */ new Date()).getTime();
@@ -4274,10 +4420,13 @@ function OutputMetaLlama3Chat(result, _config) {
   const content = [
     { type: "text", text: result.generation }
   ];
+  const headerUsage = getBedrockTokenCounts(headers);
+  const output_tokens = result?.generation_token_count ?? headerUsage?.output_tokens ?? 0;
+  const input_tokens = result?.prompt_token_count ?? headerUsage?.input_tokens ?? 0;
   const usage = {
-    output_tokens: result?.generation_token_count,
-    input_tokens: result?.prompt_token_count,
-    total_tokens: result?.generation_token_count + result?.prompt_token_count
+    output_tokens,
+    input_tokens,
+    total_tokens: output_tokens + input_tokens
   };
   return {
     id,
@@ -4395,7 +4544,7 @@ var bedrock = {
 
 // src/llm/config/anthropic/index.ts
 var ANTHROPIC_VERSION = "2023-06-01";
-var MODELS_REJECTING_SAMPLING_PARAMS = ["claude-opus-4-7"];
+var MODELS_REJECTING_SAMPLING_PARAMS = ["claude-opus-4-7", "claude-opus-4-8"];
 var isClaude4x = (model) => /^claude-(opus|sonnet|haiku)-4-/.test(model);
 var dropIfModelRejectsSamplingParams = (v, body) => MODELS_REJECTING_SAMPLING_PARAMS.includes(body.model) ? void 0 : v;
 var topPTransform = (v, body) => {
@@ -4480,6 +4629,11 @@ var anthropicChatV1 = {
 };
 var anthropic = {
   "anthropic.chat.v1": anthropicChatV1,
+  // Claude 4.8 models
+  "anthropic.claude-opus-4-8": withDefaultModel(
+    anthropicChatV1,
+    "claude-opus-4-8"
+  ),
   // Claude 4.7 models
   "anthropic.claude-opus-4-7": withDefaultModel(
     anthropicChatV1,
@@ -4663,7 +4817,11 @@ var ollamaChatV1 = {
   provider: "ollama.chat",
   endpoint: `${getEnvironmentVariable("OLLAMA_ENDPOINT") || `http://localhost:11434`}/api/chat`,
   options: {
-    prompt: {}
+    prompt: {},
+    temperature: {},
+    topP: {},
+    maxTokens: {},
+    stopSequences: {}
   },
   method: "POST",
   headers: `{"Content-Type": "application/json" }`,
@@ -4679,6 +4837,18 @@ var ollamaChatV1 = {
     },
     model: {
       key: "model"
+    },
+    temperature: {
+      key: "options.temperature"
+    },
+    topP: {
+      key: "options.top_p"
+    },
+    maxTokens: {
+      key: "options.num_predict"
+    },
+    stopSequences: {
+      key: "options.stop"
     }
   },
   transformResponse: OutputOllamaChat
@@ -4874,7 +5044,10 @@ var googleGeminiChatV1 = {
   options: {
     effort: {},
     prompt: {},
-    // topP: {},
+    temperature: {},
+    topP: {},
+    maxTokens: {},
+    stopSequences: {},
     geminiApiKey: {
       default: getEnvironmentVariable("GEMINI_API_KEY")
     }
@@ -4886,6 +5059,18 @@ var googleGeminiChatV1 = {
       key: "contents",
       transform: googleGeminiPromptSanitize
     },
+    temperature: {
+      key: "generationConfig.temperature"
+    },
+    topP: {
+      key: "generationConfig.topP"
+    },
+    maxTokens: {
+      key: "generationConfig.maxOutputTokens"
+    },
+    stopSequences: {
+      key: "generationConfig.stopSequences"
+    },
     effort: {
       key: "config.thinkingConfig.thinkingBudget",
       transform: (v, _s) => {
@@ -5027,6 +5212,13 @@ function isValidUrl(input) {
 }
 
 // src/utils/modules/request.ts
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key.toLowerCase()] = value;
+  });
+  return record;
+}
 async function apiRequest(url, options) {
   const finalOptions = {
     ...options
@@ -5112,13 +5304,16 @@ async function apiRequest(url, options) {
     });
   }
   const contentType = response.headers.get("content-type");
+  const headers = headersToRecord(response.headers);
   if (contentType?.includes("application/json")) {
-    const responseData = await response.json();
-    return responseData;
-  } else {
-    const responseData = await response.text();
-    return responseData;
+    const responseData2 = await response.json();
+    return { data: responseData2, headers };
   }
+  const responseData = await response.text();
+  return {
+    data: responseData,
+    headers
+  };
 }
 
 // src/utils/modules/convertDotNotation.ts
@@ -5490,7 +5685,7 @@ async function useLlm_call(state, messages, _options) {
         }
       ]
     };
-    return BaseLlmOutput(transformResponse(mockResponse, config));
+    return BaseLlmOutput(transformResponse(mockResponse, config, {}));
   }
   try {
     const response = await apiRequest(url, {
@@ -5498,7 +5693,9 @@ async function useLlm_call(state, messages, _options) {
       body,
       headers
     });
-    return BaseLlmOutput(transformResponse(response, config));
+    return BaseLlmOutput(
+      transformResponse(response.data, config, response.headers)
+    );
   } catch (e) {
     if (!isLlmExeError(e, "request.http_error")) throw e;
     const ctx = e.context ?? {};
@@ -5679,7 +5876,9 @@ var embeddingConfigs = {
   "openai.embedding.v1": {
     key: "openai.embedding.v1",
     provider: "openai.embedding",
-    endpoint: `https://api.openai.com/v1/embeddings`,
+    // Templated host: `baseUrl` defaults to OpenAI. Override to point at any
+    // OpenAI-compatible embeddings server (Baseten, vLLM, TEI, Together, etc.).
+    endpoint: `{{baseUrl}}/embeddings`,
     method: "POST",
     headers: `{"Authorization":"Bearer {{openAiApiKey}}", "Content-Type": "application/json" }`,
     options: {
@@ -5690,6 +5889,9 @@ var embeddingConfigs = {
       encodingFormat: {},
       openAiApiKey: {
         default: getEnvironmentVariable("OPENAI_API_KEY")
+      },
+      baseUrl: {
+        default: "https://api.openai.com/v1"
       }
     },
     mapBody: {
@@ -5876,15 +6078,34 @@ function AmazonTitanEmbedding(result, config) {
 }
 
 // src/embedding/output/CohereBedrockEmbedding.ts
-function CohereBedrockEmbedding(result, config) {
+function resolveEmbeddings(embeddings, model) {
+  if (Array.isArray(embeddings)) {
+    return embeddings;
+  }
+  if (embeddings && typeof embeddings === "object") {
+    if (Array.isArray(embeddings.float)) {
+      return embeddings.float;
+    }
+    throw new Error(
+      `Unexpected embeddings in Cohere Bedrock response (model: "${model}"). Expected float embeddings, received object with keys: [${Object.keys(embeddings).join(", ")}]`
+    );
+  }
+  throw new Error(
+    `Unexpected embeddings shape in Cohere Bedrock response (model: "${model}"). Expected an array (Embed v3) or an object with float embeddings (Embed v4), received: ${embeddings === null ? "null" : typeof embeddings}`
+  );
+}
+function CohereBedrockEmbedding(result, config, headers) {
+  const headerUsage = getBedrockTokenCounts(headers);
   const __result = deepClone(result);
   const model = config.model || "cohere.unknown";
   const created = (/* @__PURE__ */ new Date()).getTime();
-  const embedding = Array.isArray(__result.embeddings) ? __result.embeddings : [];
+  const embedding = resolveEmbeddings(__result.embeddings, model);
+  const input_tokens = headerUsage?.input_tokens ?? 0;
+  const output_tokens = headerUsage?.output_tokens ?? 0;
   const usage = {
-    output_tokens: 0,
-    input_tokens: 0,
-    total_tokens: 0
+    output_tokens,
+    input_tokens,
+    total_tokens: input_tokens + output_tokens
   };
   return BaseEmbeddingOutput({
     id: __result.id,
@@ -5916,14 +6137,14 @@ function OpenAiEmbedding(result, config) {
 }
 
 // src/embedding/output/getEmbeddingOutputParser.ts
-function getEmbeddingOutputParser(config, response) {
+function getEmbeddingOutputParser(config, response, headers) {
   switch (config.key) {
     case "openai.embedding.v1":
       return OpenAiEmbedding(response, config);
     case "amazon.embedding.v1":
       return AmazonTitanEmbedding(response, config);
     case "amazon:cohere.embedding.v1":
-      return CohereBedrockEmbedding(response, config);
+      return CohereBedrockEmbedding(response, config, headers);
     default:
       throw new LlmExeError("Unsupported provider", {
         code: "embedding.invalid_response_shape",
@@ -5960,7 +6181,7 @@ async function createEmbedding_call(state, _input, _options) {
       body,
       headers
     });
-    return getEmbeddingOutputParser(state, request);
+    return getEmbeddingOutputParser(state, request.data, request.headers);
   } catch (e) {
     if (!isLlmExeError(e, "request.http_error")) throw e;
     const ctx = e.context ?? {};