ak-gemini 1.0.5 → 1.0.7

package/README.md

@@ -7,7 +7,7 @@ Use this to power LLM-driven data pipelines, JSON mapping, or any automated AI t
 
 ## Features
 
-* **Model-Agnostic:** Use any Gemini model (`gemini-2.0-flash` by default)
+* **Model-Agnostic:** Use any Gemini model (`gemini-2.5-flash` by default)
 * **Declarative Few-shot Examples:** Seed transformations using example mappings, with support for custom keys (`PROMPT`, `ANSWER`, `CONTEXT`, or your own)
 * **Automatic Validation & Repair:** Validate outputs with your own async function; auto-repair failed payloads with LLM feedback loop (exponential backoff, fully configurable)
 * **Token Counting & Safety:** Preview the *exact* Gemini token consumption for any operation—including all examples, instructions, and your input—before sending, so you can avoid window errors and manage costs.
@@ -47,7 +47,7 @@ or pass it directly in the constructor options.
 import AITransformer from 'ak-gemini';
 
 const transformer = new AITransformer({
-  modelName: 'gemini-2.0-flash',    // or your preferred Gemini model
+  modelName: 'gemini-2.5-flash',    // or your preferred Gemini model
   sourceKey: 'INPUT',               // Custom prompt key (default: 'PROMPT')
   targetKey: 'OUTPUT',              // Custom answer key (default: 'ANSWER')
   contextKey: 'CONTEXT',            // Optional, for per-example context
@@ -116,7 +116,7 @@ new AITransformer(options)
 
 | Option             | Type   | Default            | Description                                       |
 | ------------------ | ------ | ------------------ | ------------------------------------------------- |
-| modelName          | string | 'gemini-2.0-flash' | Gemini model to use                               |
+| modelName          | string | 'gemini-2.5-flash' | Gemini model to use                               |
 | sourceKey          | string | 'PROMPT'           | Key for prompt/example input                      |
 | targetKey          | string | 'ANSWER'           | Key for expected output in examples               |
 | contextKey         | string | 'CONTEXT'          | Key for per-example context (optional)            |
@@ -125,6 +125,7 @@ new AITransformer(options)
 | responseSchema     | object | null               | Optional JSON schema for strict output validation |
 | maxRetries         | number | 3                  | Retries for validation+rebuild loop               |
 | retryDelay         | number | 1000               | Initial retry delay in ms (exponential backoff)   |
+| logLevel           | string | 'info'             | Log level: 'trace', 'debug', 'info', 'warn', 'error', 'fatal', or 'none' |
 | chatConfig         | object | ...                | Gemini chat config overrides                      |
 | systemInstructions | string | ...                | System prompt for Gemini                          |
 

package/index.cjs

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.js
 var index_exports = {};
 __export(index_exports, {
-  default: () => AITransformer,
+  ThinkingLevel: () => import_genai.ThinkingLevel,
+  default: () => index_default,
   log: () => logger_default
 });
 module.exports = __toCommonJS(index_exports);
@@ -56,10 +57,7 @@ var logger_default = logger;
 // index.js
 var import_meta = {};
 import_dotenv.default.config();
-var { NODE_ENV = "unknown", GEMINI_API_KEY } = process.env;
-if (NODE_ENV === "dev") logger_default.level = "debug";
-if (NODE_ENV === "test") logger_default.level = "warn";
-if (NODE_ENV.startsWith("prod")) logger_default.level = "error";
+var { NODE_ENV = "unknown", GEMINI_API_KEY, LOG_LEVEL = "" } = process.env;
 var DEFAULT_SAFETY_SETTINGS = [
   { category: import_genai.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: import_genai.HarmBlockThreshold.BLOCK_NONE },
   { category: import_genai.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: import_genai.HarmBlockThreshold.BLOCK_NONE }
@@ -67,7 +65,7 @@ var DEFAULT_SAFETY_SETTINGS = [
 var DEFAULT_SYSTEM_INSTRUCTIONS = `
 You are an expert JSON transformation engine. Your task is to accurately convert data payloads from one format to another.
 
-You will be provided with example transformations (Source JSON -> Target JSON). 
+You will be provided with example transformations (Source JSON -> Target JSON).
 
 Learn the mapping rules from these examples.
 
@@ -77,6 +75,19 @@ Always respond ONLY with a valid JSON object that strictly adheres to the expect
 
 Do not include any additional text, explanations, or formatting before or after the JSON object.
 `;
+var DEFAULT_THINKING_CONFIG = {
+  thinkingBudget: 0,
+  thinkingLevel: import_genai.ThinkingLevel.MINIMAL
+};
+var THINKING_SUPPORTED_MODELS = [
+  /^gemini-3-flash(-preview)?$/,
+  /^gemini-3-pro(-preview|-image-preview)?$/,
+  /^gemini-2\.5-pro/,
+  /^gemini-2\.5-flash(-preview)?$/,
+  /^gemini-2\.5-flash-lite(-preview)?$/,
+  /^gemini-2\.0-flash$/
+  // Experimental support, exact match only
+];
 var DEFAULT_CHAT_CONFIG = {
   responseMimeType: "application/json",
   temperature: 0.2,
@@ -95,53 +106,110 @@ var AITransformer = class {
     this.promptKey = "";
     this.answerKey = "";
     this.contextKey = "";
+    this.explanationKey = "";
+    this.systemInstructionKey = "";
     this.maxRetries = 3;
     this.retryDelay = 1e3;
     this.systemInstructions = "";
     this.chatConfig = {};
     this.apiKey = GEMINI_API_KEY;
+    this.onlyJSON = true;
+    this.asyncValidator = null;
+    this.logLevel = "info";
     AITransformFactory.call(this, options);
     this.init = initChat.bind(this);
     this.seed = seedWithExamples.bind(this);
-    this.message = transformJSON.bind(this);
+    this.rawMessage = rawMessage.bind(this);
+    this.message = (payload, opts = {}, validatorFn = null) => {
+      return prepareAndValidateMessage.call(this, payload, opts, validatorFn || this.asyncValidator);
+    };
     this.rebuild = rebuildPayload.bind(this);
     this.reset = resetChat.bind(this);
     this.getHistory = getChatHistory.bind(this);
-    this.transformWithValidation = transformWithValidation.bind(this);
+    this.messageAndValidate = prepareAndValidateMessage.bind(this);
+    this.transformWithValidation = prepareAndValidateMessage.bind(this);
     this.estimate = estimateTokenUsage.bind(this);
+    this.estimateTokenUsage = estimateTokenUsage.bind(this);
   }
 };
+var index_default = AITransformer;
 function AITransformFactory(options = {}) {
-  this.modelName = options.modelName || "gemini-2.0-flash";
+  this.modelName = options.modelName || "gemini-2.5-flash";
   this.systemInstructions = options.systemInstructions || DEFAULT_SYSTEM_INSTRUCTIONS;
-  this.apiKey = options.apiKey || GEMINI_API_KEY;
+  if (options.logLevel) {
+    this.logLevel = options.logLevel;
+    if (this.logLevel === "none") {
+      logger_default.level = "silent";
+    } else {
+      logger_default.level = this.logLevel;
+    }
+  } else if (LOG_LEVEL) {
+    this.logLevel = LOG_LEVEL;
+    logger_default.level = LOG_LEVEL;
+  } else if (NODE_ENV === "dev") {
+    this.logLevel = "debug";
+    logger_default.level = "debug";
+  } else if (NODE_ENV === "test") {
+    this.logLevel = "warn";
+    logger_default.level = "warn";
+  } else if (NODE_ENV.startsWith("prod")) {
+    this.logLevel = "error";
+    logger_default.level = "error";
+  } else {
+    this.logLevel = "info";
+    logger_default.level = "info";
+  }
+  this.apiKey = options.apiKey !== void 0 && options.apiKey !== null ? options.apiKey : GEMINI_API_KEY;
   if (!this.apiKey) throw new Error("Missing Gemini API key. Provide via options.apiKey or GEMINI_API_KEY env var.");
   this.chatConfig = {
     ...DEFAULT_CHAT_CONFIG,
     ...options.chatConfig,
     systemInstruction: this.systemInstructions
   };
+  const modelSupportsThinking = THINKING_SUPPORTED_MODELS.some(
+    (pattern) => pattern.test(this.modelName)
+  );
+  if (modelSupportsThinking && options.thinkingConfig) {
+    const thinkingConfig = {
+      ...DEFAULT_THINKING_CONFIG,
+      ...options.thinkingConfig
+    };
+    this.chatConfig.thinkingConfig = thinkingConfig;
+    if (logger_default.level !== "silent") {
+      logger_default.debug(`Model ${this.modelName} supports thinking. Applied thinkingConfig:`, thinkingConfig);
+    }
+  } else if (options.thinkingConfig && !modelSupportsThinking) {
+    if (logger_default.level !== "silent") {
+      logger_default.warn(`Model ${this.modelName} does not support thinking features. Ignoring thinkingConfig.`);
+    }
+  }
   if (options.responseSchema) {
     this.chatConfig.responseSchema = options.responseSchema;
   }
   this.examplesFile = options.examplesFile || null;
   this.exampleData = options.exampleData || null;
-  this.promptKey = options.sourceKey || "PROMPT";
-  this.answerKey = options.targetKey || "ANSWER";
+  this.promptKey = options.promptKey || options.sourceKey || "PROMPT";
+  this.answerKey = options.answerKey || options.targetKey || "ANSWER";
   this.contextKey = options.contextKey || "CONTEXT";
+  this.explanationKey = options.explanationKey || "EXPLANATION";
+  this.systemInstructionsKey = options.systemInstructionsKey || "SYSTEM";
   this.maxRetries = options.maxRetries || 3;
   this.retryDelay = options.retryDelay || 1e3;
+  this.asyncValidator = options.asyncValidator || null;
+  this.onlyJSON = options.onlyJSON !== void 0 ? options.onlyJSON : true;
   if (this.promptKey === this.answerKey) {
     throw new Error("Source and target keys cannot be the same. Please provide distinct keys.");
   }
-  logger_default.debug(`Creating AI Transformer with model: ${this.modelName}`);
-  logger_default.debug(`Using keys - Source: "${this.promptKey}", Target: "${this.answerKey}", Context: "${this.contextKey}"`);
+  if (logger_default.level !== "silent") {
+    logger_default.debug(`Creating AI Transformer with model: ${this.modelName}`);
+    logger_default.debug(`Using keys - Source: "${this.promptKey}", Target: "${this.answerKey}", Context: "${this.contextKey}"`);
+  }
   const ai = new import_genai.GoogleGenAI({ apiKey: this.apiKey });
   this.genAIClient = ai;
   this.chat = null;
 }
-async function initChat() {
-  if (this.chat) return;
+async function initChat(force = false) {
+  if (this.chat && !force) return;
   logger_default.debug(`Initializing Gemini chat session with model: ${this.modelName}...`);
   this.chat = await this.genAIClient.chats.create({
     model: this.modelName,
@@ -149,6 +217,12 @@ async function initChat() {
     config: this.chatConfig,
     history: []
   });
+  try {
+    await this.genAIClient.models.list();
+    logger_default.debug("Gemini API connection successful.");
+  } catch (e) {
+    throw new Error(`Gemini chat initialization failed: ${e.message}`);
+  }
   logger_default.debug("Gemini chat session initialized.");
 }
 async function seedWithExamples(examples) {
@@ -156,117 +230,130 @@ async function seedWithExamples(examples) {
   if (!examples || !Array.isArray(examples) || examples.length === 0) {
     if (this.examplesFile) {
       logger_default.debug(`No examples provided, loading from file: ${this.examplesFile}`);
-      examples = await import_ak_tools.default.load(import_path.default.resolve(this.examplesFile), true);
+      try {
+        examples = await import_ak_tools.default.load(import_path.default.resolve(this.examplesFile), true);
+      } catch (err) {
+        throw new Error(`Could not load examples from file: ${this.examplesFile}. Please check the file path and format.`);
+      }
+    } else if (this.exampleData) {
+      logger_default.debug(`Using example data provided in options.`);
+      if (Array.isArray(this.exampleData)) {
+        examples = this.exampleData;
+      } else {
+        throw new Error(`Invalid example data provided. Expected an array of examples.`);
+      }
     } else {
       logger_default.debug("No examples provided and no examples file specified. Skipping seeding.");
       return;
     }
   }
+  const instructionExample = examples.find((ex) => ex[this.systemInstructionsKey]);
+  if (instructionExample) {
+    logger_default.debug(`Found system instructions in examples; reinitializing chat with new instructions.`);
+    this.systemInstructions = instructionExample[this.systemInstructionsKey];
+    this.chatConfig.systemInstruction = this.systemInstructions;
+    await this.init(true);
+  }
   logger_default.debug(`Seeding chat with ${examples.length} transformation examples...`);
   const historyToAdd = [];
   for (const example of examples) {
     const contextValue = example[this.contextKey] || "";
     const promptValue = example[this.promptKey] || "";
     const answerValue = example[this.answerKey] || "";
+    const explanationValue = example[this.explanationKey] || "";
+    let userText = "";
+    let modelResponse = {};
     if (contextValue) {
-      let contextText = import_ak_tools.default.isJSON(contextValue) ? JSON.stringify(contextValue, null, 2) : contextValue;
-      historyToAdd.push({
-        role: "user",
-        parts: [{ text: `Context: ${contextText}` }]
-      });
-      historyToAdd.push({
-        role: "model",
-        parts: [{ text: "I understand the context." }]
-      });
+      let contextText = isJSON(contextValue) ? JSON.stringify(contextValue, null, 2) : contextValue;
+      userText += `CONTEXT:
+${contextText}
+
+`;
     }
     if (promptValue) {
-      let promptText = import_ak_tools.default.isJSON(promptValue) ? JSON.stringify(promptValue, null, 2) : promptValue;
-      historyToAdd.push({ role: "user", parts: [{ text: promptText }] });
+      let promptText = isJSON(promptValue) ? JSON.stringify(promptValue, null, 2) : promptValue;
+      userText += promptText;
     }
-    if (answerValue) {
-      let answerText = import_ak_tools.default.isJSON(answerValue) ? JSON.stringify(answerValue, null, 2) : answerValue;
-      historyToAdd.push({ role: "model", parts: [{ text: answerText }] });
+    if (answerValue) modelResponse.data = answerValue;
+    if (explanationValue) modelResponse.explanation = explanationValue;
+    const modelText = JSON.stringify(modelResponse, null, 2);
+    if (userText.trim().length && modelText.trim().length > 0) {
+      historyToAdd.push({ role: "user", parts: [{ text: userText.trim() }] });
+      historyToAdd.push({ role: "model", parts: [{ text: modelText.trim() }] });
     }
   }
   const currentHistory = this?.chat?.getHistory() || [];
+  logger_default.debug(`Adding ${historyToAdd.length} examples to chat history (${currentHistory.length} current examples)...`);
   this.chat = await this.genAIClient.chats.create({
     model: this.modelName,
     // @ts-ignore
     config: this.chatConfig,
     history: [...currentHistory, ...historyToAdd]
   });
-  logger_default.debug("Transformation examples seeded successfully.");
+  const newHistory = this.chat.getHistory();
+  logger_default.debug(`Created new chat session with ${newHistory.length} examples.`);
+  return newHistory;
 }
-async function transformJSON(sourcePayload) {
+async function rawMessage(sourcePayload) {
   if (!this.chat) {
-    throw new Error("Chat session not initialized. Call initChat() or seedWithExamples() first.");
+    throw new Error("Chat session not initialized.");
   }
-  let result;
-  let actualPayload;
-  if (sourcePayload && import_ak_tools.default.isJSON(sourcePayload)) actualPayload = JSON.stringify(sourcePayload, null, 2);
-  else if (typeof sourcePayload === "string") actualPayload = sourcePayload;
-  else throw new Error("Invalid source payload. Must be a JSON object or a valid JSON string.");
+  const actualPayload = typeof sourcePayload === "string" ? sourcePayload : JSON.stringify(sourcePayload, null, 2);
   try {
-    result = await this.chat.sendMessage({ message: actualPayload });
+    const result = await this.chat.sendMessage({ message: actualPayload });
+    const modelResponse = result.text;
+    const extractedJSON = extractJSON(modelResponse);
+    if (extractedJSON?.data) {
+      return extractedJSON.data;
+    }
+    return extractedJSON;
   } catch (error) {
-    logger_default.error("Error with Gemini API:", error);
+    if (this.onlyJSON && error.message.includes("Could not extract valid JSON")) {
+      throw new Error(`Invalid JSON response from Gemini: ${error.message}`);
+    }
     throw new Error(`Transformation failed: ${error.message}`);
   }
-  try {
-    const modelResponse = result.text;
-    const parsedResponse = JSON.parse(modelResponse);
-    return parsedResponse;
-  } catch (parseError) {
-    logger_default.error("Error parsing Gemini response:", parseError);
-    throw new Error(`Invalid JSON response from Gemini: ${parseError.message}`);
-  }
 }
-async function transformWithValidation(sourcePayload, validatorFn, options = {}) {
+async function prepareAndValidateMessage(sourcePayload, options = {}, validatorFn = null) {
+  if (!this.chat) {
+    throw new Error("Chat session not initialized. Please call init() first.");
+  }
   const maxRetries = options.maxRetries ?? this.maxRetries;
   const retryDelay = options.retryDelay ?? this.retryDelay;
-  let lastPayload = null;
   let lastError = null;
+  let lastPayload = null;
+  if (sourcePayload && isJSON(sourcePayload)) {
+    lastPayload = JSON.stringify(sourcePayload, null, 2);
+  } else if (typeof sourcePayload === "string") {
+    lastPayload = sourcePayload;
+  } else if (typeof sourcePayload === "boolean" || typeof sourcePayload === "number") {
+    lastPayload = sourcePayload.toString();
+  } else if (sourcePayload === null || sourcePayload === void 0) {
+    lastPayload = JSON.stringify({});
+  } else {
+    throw new Error("Invalid source payload. Must be a JSON object or string.");
+  }
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
-      const transformedPayload = attempt === 0 ? await this.message(sourcePayload) : await this.rebuild(lastPayload, lastError.message);
-      const validatedPayload = await validatorFn(transformedPayload);
-      logger_default.debug(`Transformation and validation succeeded on attempt ${attempt + 1}`);
-      return validatedPayload;
+      const transformedPayload = attempt === 0 ? await this.rawMessage(lastPayload) : await this.rebuild(lastPayload, lastError.message);
+      lastPayload = transformedPayload;
+      if (validatorFn) {
+        await validatorFn(transformedPayload);
+      }
+      logger_default.debug(`Transformation succeeded on attempt ${attempt + 1}`);
+      return transformedPayload;
     } catch (error) {
       lastError = error;
-      if (attempt === 0) {
-        lastPayload = await this.message(sourcePayload).catch(() => null);
-      }
-      if (attempt < maxRetries) {
-        const delay = retryDelay * Math.pow(2, attempt);
-        logger_default.warn(`Attempt ${attempt + 1} failed, retrying in ${delay}ms...`, error.message);
-        await new Promise((res) => setTimeout(res, delay));
-      } else {
-        logger_default.error(`All ${maxRetries + 1} attempts failed`);
-        throw new Error(`Transformation with validation failed after ${maxRetries + 1} attempts. Last error: ${error.message}`);
+      logger_default.warn(`Attempt ${attempt + 1} failed: ${error.message}`);
+      if (attempt >= maxRetries) {
+        logger_default.error(`All ${maxRetries + 1} attempts failed.`);
+        throw new Error(`Transformation failed after ${maxRetries + 1} attempts. Last error: ${error.message}`);
       }
+      const delay = retryDelay * Math.pow(2, attempt);
+      await new Promise((res) => setTimeout(res, delay));
     }
   }
 }
-async function estimateTokenUsage(nextPayload) {
-  const contents = [];
-  if (this.systemInstructions) {
-    contents.push({ parts: [{ text: this.systemInstructions }] });
-  }
-  if (this.chat && typeof this.chat.getHistory === "function") {
-    const history = this.chat.getHistory();
-    if (Array.isArray(history) && history.length > 0) {
-      contents.push(...history);
-    }
-  }
-  const nextMessage = typeof nextPayload === "string" ? nextPayload : JSON.stringify(nextPayload, null, 2);
-  contents.push({ parts: [{ text: nextMessage }] });
-  const resp = await this.genAIClient.models.countTokens({
-    model: this.modelName,
-    contents
-  });
-  return resp;
-}
 async function rebuildPayload(lastPayload, serverError) {
   await this.init();
   const prompt = `
@@ -276,6 +363,7 @@ The server's error message is quoted afterward.
 ---------------- BAD PAYLOAD ----------------
 ${JSON.stringify(lastPayload, null, 2)}
 
+
 ---------------- SERVER ERROR ----------------
 ${serverError}
 
@@ -295,6 +383,25 @@ Respond with JSON only \u2013 no comments or explanations.
     throw new Error(`Gemini returned non-JSON while repairing payload: ${parseErr.message}`);
   }
 }
+async function estimateTokenUsage(nextPayload) {
+  const contents = [];
+  if (this.systemInstructions) {
+    contents.push({ parts: [{ text: this.systemInstructions }] });
+  }
+  if (this.chat && typeof this.chat.getHistory === "function") {
+    const history = this.chat.getHistory();
+    if (Array.isArray(history) && history.length > 0) {
+      contents.push(...history);
+    }
+  }
+  const nextMessage = typeof nextPayload === "string" ? nextPayload : JSON.stringify(nextPayload, null, 2);
+  contents.push({ parts: [{ text: nextMessage }] });
+  const resp = await this.genAIClient.models.countTokens({
+    model: this.modelName,
+    contents
+  });
+  return resp;
+}
 async function resetChat() {
   if (this.chat) {
     logger_default.debug("Resetting Gemini chat session...");
@@ -316,13 +423,135 @@ function getChatHistory() {
   }
   return this.chat.getHistory();
 }
+function isJSON(data) {
+  try {
+    const attempt = JSON.stringify(data);
+    if (attempt?.startsWith("{") || attempt?.startsWith("[")) {
+      if (attempt?.endsWith("}") || attempt?.endsWith("]")) {
+        return true;
+      }
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+function isJSONStr(string) {
+  if (typeof string !== "string") return false;
+  try {
+    const result = JSON.parse(string);
+    const type = Object.prototype.toString.call(result);
+    return type === "[object Object]" || type === "[object Array]";
+  } catch (err) {
+    return false;
+  }
+}
+function extractJSON(text) {
+  if (!text || typeof text !== "string") {
+    throw new Error("No text provided for JSON extraction");
+  }
+  if (isJSONStr(text.trim())) {
+    return JSON.parse(text.trim());
+  }
+  const codeBlockPatterns = [
+    /```json\s*\n?([\s\S]*?)\n?\s*```/gi,
+    /```\s*\n?([\s\S]*?)\n?\s*```/gi
+  ];
+  for (const pattern of codeBlockPatterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        const jsonContent = match.replace(/```json\s*\n?/gi, "").replace(/```\s*\n?/gi, "").trim();
+        if (isJSONStr(jsonContent)) {
+          return JSON.parse(jsonContent);
+        }
+      }
+    }
+  }
+  const jsonPatterns = [
+    // Match complete JSON objects
+    /\{[\s\S]*\}/g,
+    // Match complete JSON arrays
+    /\[[\s\S]*\]/g
+  ];
+  for (const pattern of jsonPatterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        const candidate = match.trim();
+        if (isJSONStr(candidate)) {
+          return JSON.parse(candidate);
+        }
+      }
+    }
+  }
+  const advancedExtract = findCompleteJSONStructures(text);
+  if (advancedExtract.length > 0) {
+    for (const candidate of advancedExtract) {
+      if (isJSONStr(candidate)) {
+        return JSON.parse(candidate);
+      }
+    }
+  }
+  const cleanedText = text.replace(/^\s*Sure,?\s*here\s+is\s+your?\s+.*?[:\n]/gi, "").replace(/^\s*Here\s+is\s+the\s+.*?[:\n]/gi, "").replace(/^\s*The\s+.*?is\s*[:\n]/gi, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").trim();
+  if (isJSONStr(cleanedText)) {
+    return JSON.parse(cleanedText);
+  }
+  throw new Error(`Could not extract valid JSON from model response. Response preview: ${text.substring(0, 200)}...`);
+}
+function findCompleteJSONStructures(text) {
+  const results = [];
+  const startChars = ["{", "["];
+  for (let i = 0; i < text.length; i++) {
+    if (startChars.includes(text[i])) {
+      const extracted = extractCompleteStructure(text, i);
+      if (extracted) {
+        results.push(extracted);
+      }
+    }
+  }
+  return results;
+}
+function extractCompleteStructure(text, startPos) {
+  const startChar = text[startPos];
+  const endChar = startChar === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = startPos; i < text.length; i++) {
+    const char = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"' && !escaped) {
+      inString = !inString;
+      continue;
+    }
+    if (!inString) {
+      if (char === startChar) {
+        depth++;
+      } else if (char === endChar) {
+        depth--;
+        if (depth === 0) {
+          return text.substring(startPos, i + 1);
+        }
+      }
+    }
+  }
+  return null;
+}
 if (import_meta.url === new URL(`file://${process.argv[1]}`).href) {
   logger_default.info("RUNNING AI Transformer as standalone script...");
   (async () => {
     try {
       logger_default.info("Initializing AI Transformer...");
       const transformer = new AITransformer({
-        modelName: "gemini-2.0-flash",
+        modelName: "gemini-2.5-flash",
         sourceKey: "INPUT",
         // Custom source key
         targetKey: "OUTPUT",
@@ -360,7 +589,7 @@ if (import_meta.url === new URL(`file://${process.argv[1]}`).href) {
         }
         return payload;
       };
-      const validatedResponse = await transformer.transformWithValidation(
+      const validatedResponse = await transformer.messageAndValidate(
         { "name": "Lynn" },
         mockValidator
       );
@@ -374,5 +603,6 @@ if (import_meta.url === new URL(`file://${process.argv[1]}`).href) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ThinkingLevel,
   log
 });