@adaptic/lumic-utils 1.0.22 → 1.0.24

package/dist/{index-DfuMX-MS.js → index-KzQOh2uu.js}

@@ -100,13 +100,21 @@ const OPENAI_COMPATIBLE_PROVIDERS = {
  */
 const SUPPORTED_MODELS = {
     // ── OpenAI GPT-5.5 series (current flagship) ─────────────────────────
+    // GPT-5.x series: OpenAI's 2026 API constraint — only the default
+    // temperature value (1.0) is accepted. Passing any other value returns
+    // HTTP 400: "Unsupported value: 'temperature' does not support 0.2 with
+    // this model. Only the default (1) value is supported." Mark
+    // supportsTemperature=false so the lumic-utils gate at llm-call.ts:194
+    // OMITS the parameter entirely (OpenAI then uses its default of 1.0).
+    // Ref: community.openai.com/t/temperature-in-gpt-5-models/1337133
+    // Ref: developers.openai.com/api/docs/models/gpt-5.4-nano
     'gpt-5.5': {
         provider: 'openai',
         supportsTools: true,
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     'gpt-5.5-pro': {
@@ -115,7 +123,7 @@ const SUPPORTED_MODELS = {
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     // ── OpenAI GPT-5.4 series ────────────────────────────────────────────
@@ -125,7 +133,7 @@ const SUPPORTED_MODELS = {
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     'gpt-5.4-mini': {
@@ -134,7 +142,7 @@ const SUPPORTED_MODELS = {
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     'gpt-5.4-nano': {
@@ -143,7 +151,7 @@ const SUPPORTED_MODELS = {
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     // ── OpenAI GPT-5 series ──────────────────────────────────────────────
@@ -153,7 +161,7 @@ const SUPPORTED_MODELS = {
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     'gpt-5-mini': {
@@ -162,7 +170,7 @@ const SUPPORTED_MODELS = {
         supportsJson: true,
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
-        supportsTemperature: true,
+        supportsTemperature: false,
         isReasoningModel: false,
     },
     // ── OpenAI GPT-4.1 series ────────────────────────────────────────────
@@ -563,10 +571,19 @@ function getModelProvider(model) {
     return SUPPORTED_MODELS[model].provider;
 }
 /**
- * Default model tiers per provider for use with LLM_MODEL_MINI/NORMAL/ADVANCED env vars
+ * Default model tiers per provider for use with LLM_MODEL_MINI/NORMAL/ADVANCED env vars.
+ *
+ * OpenAI `advanced` was reverted from `gpt-5.5` back to `gpt-5.4` on 2026-05-30:
+ * the heavy tool-call prompt in adaptic-engine's trading-decision path was
+ * timing out even after the engine raised `LLM_CALL_TIMEOUT_MS` to 90s (5+
+ * tickers per loop still exceeded the budget). `gpt-5.5`'s 1M-context window
+ * is not required on that path — the prompt fits comfortably inside `gpt-5.4`'s
+ * envelope and `gpt-5.4` returns inside the original 25-30s p95. `gpt-5.5`
+ * remains registered in OPENAI_MODELS and reachable by explicit model id;
+ * only the `advanced` tier default is rolled back.
  */
 const PROVIDER_DEFAULT_MODELS = {
-    openai: { mini: 'gpt-5.4-nano', normal: 'gpt-5.4-mini', advanced: 'gpt-5.5' },
+    openai: { mini: 'gpt-5.4-nano', normal: 'gpt-5.4-mini', advanced: 'gpt-5.4' },
     anthropic: { mini: 'claude-haiku-4-5', normal: 'claude-sonnet-4-6', advanced: 'claude-opus-4-7' },
     deepseek: { mini: 'deepseek-v4-flash', normal: 'deepseek-v4-flash', advanced: 'deepseek-v4-pro' },
     kimi: { mini: 'kimi-k2-0905-preview', normal: 'kimi-k2.5', advanced: 'kimi-k2.6' },
@@ -1520,11 +1537,13 @@ let openai;
 function initializeOpenAI(apiKey) {
     const key = apiKey || getSecrets().openai.apiKey;
     if (!key) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
+        throw new Error("OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set");
     }
     return new OpenAI({
         apiKey: key,
-        defaultHeaders: { 'User-Agent': 'My Server-side Application (compatible; OpenAI API Client)' },
+        defaultHeaders: {
+            "User-Agent": "My Server-side Application (compatible; OpenAI API Client)",
+        },
     });
 }
 /**
@@ -1542,9 +1561,7 @@ function initializeOpenAI(apiKey) {
  */
 async function fixJsonWithAI(jsonStr, options) {
     // Backward compatibility: handle string apiKey as first positional param
-    const opts = typeof options === 'string'
-        ? { apiKey: options }
-        : (options ?? {});
+    const opts = typeof options === "string" ? { apiKey: options } : (options ?? {});
     const apiKey = opts.apiKey;
     const maxDepth = opts.maxDepth ?? 2;
     const depth = opts._depth ?? 0;
@@ -1557,18 +1574,18 @@ async function fixJsonWithAI(jsonStr, options) {
             openai = initializeOpenAI(apiKey);
         }
         const completion = await openai.chat.completions.create({
-            model: 'gpt-5-mini',
+            model: "gpt-5-mini",
             messages: [
                 {
-                    role: 'system',
-                    content: 'You are a JSON fixer. Return only valid JSON without any additional text or explanation.'
+                    role: "system",
+                    content: "You are a JSON fixer. Return only valid JSON without any additional text or explanation.",
                 },
                 {
-                    role: 'user',
-                    content: `Fix this broken JSON:\n${jsonStr}`
-                }
+                    role: "user",
+                    content: `Fix this broken JSON:\n${jsonStr}`,
+                },
             ],
-            response_format: { type: 'json_object' }
+            response_format: { type: "json_object" },
         });
         const fixedJson = completion.choices[0]?.message?.content;
         if (fixedJson && isValidJson(fixedJson)) {
@@ -1582,23 +1599,32 @@ async function fixJsonWithAI(jsonStr, options) {
                 _depth: depth + 1,
             });
         }
-        throw new JsonParseError('Failed to fix JSON with AI: returned invalid JSON');
+        throw new JsonParseError("Failed to fix JSON with AI: returned invalid JSON");
     }
     catch (err) {
         // Re-throw JsonParseError as-is (e.g. max depth exceeded)
         if (err instanceof JsonParseError) {
             throw err;
         }
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+        const errorMessage = err instanceof Error ? err.message : "Unknown error occurred";
         throw new JsonParseError(`Error fixing JSON with AI: ${errorMessage}`);
     }
 }
 
 // llm-utils.ts
 function normalizeModelName(model) {
-    return model.replace(/_/g, '-').toLowerCase();
-}
-const CODE_BLOCK_TYPES = ['javascript', 'js', 'graphql', 'json', 'typescript', 'python', 'markdown', 'yaml'];
+    return model.replace(/_/g, "-").toLowerCase();
+}
+const CODE_BLOCK_TYPES = [
+    "javascript",
+    "js",
+    "graphql",
+    "json",
+    "typescript",
+    "python",
+    "markdown",
+    "yaml",
+];
 /**
  * Tries to parse JSON from the given content string according to the specified
  * response format. If the response format is 'json' or a JSON schema object, it
@@ -1622,7 +1648,9 @@ async function parseResponse(content, responseFormat, options = {}) {
     if (recursionDepth > maxRetries) {
         throw new Error(`Maximum recursion depth (${maxRetries}) exceeded while parsing JSON. AI fixing may have returned broken JSON.`);
     }
-    if (responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat?.type === 'json_schema')) {
+    if (responseFormat === "json" ||
+        (typeof responseFormat === "object" &&
+            responseFormat?.type === "json_schema")) {
         let cleanedContent = content.trim();
         let detectedType = null;
         // Remove code block markers if present
@@ -1633,8 +1661,8 @@ async function parseResponse(content, responseFormat, options = {}) {
             }
             return false;
         });
-        if (startsWithCodeBlock && cleanedContent.endsWith('```')) {
-            const firstLineEndIndex = cleanedContent.indexOf('\n');
+        if (startsWithCodeBlock && cleanedContent.endsWith("```")) {
+            const firstLineEndIndex = cleanedContent.indexOf("\n");
             if (firstLineEndIndex !== -1) {
                 cleanedContent = cleanedContent.slice(firstLineEndIndex + 1, -3).trim();
                 getLumicLogger().info(`Code block for type ${detectedType} detected and removed. Cleaned content: ${cleanedContent}`);
@@ -1667,7 +1695,7 @@ async function parseResponse(content, responseFormat, options = {}) {
             },
             // Strategy 3: Remove leading/trailing text and try parsing
             () => {
-                const jsonMatch = cleanedContent.replace(/^[^{[]*|[^}\]]*$/g, '');
+                const jsonMatch = cleanedContent.replace(/^[^{[]*|[^}\]]*$/g, "");
                 try {
                     return JSON.parse(jsonMatch);
                 }
@@ -1689,7 +1717,7 @@ async function parseResponse(content, responseFormat, options = {}) {
         }
         // Strategy 5: Use AI fixing (only if explicitly enabled)
         if (enableAiFix) {
-            getLumicLogger().warn('Using AI-powered JSON fixing. This adds cost and latency. Consider improving JSON generation instead.');
+            getLumicLogger().warn("Using AI-powered JSON fixing. This adds cost and latency. Consider improving JSON generation instead.");
             try {
                 const aiFixedJson = await fixJsonWithAI(cleanedContent);
                 if (aiFixedJson !== null) {
@@ -1702,7 +1730,7 @@ async function parseResponse(content, responseFormat, options = {}) {
                     catch {
                         // AI returned something that looks like JSON but isn't valid
                         // Increment recursion depth and try parsing the AI response
-                        getLumicLogger().warn('AI fixing returned invalid JSON, attempting recursive parse...');
+                        getLumicLogger().warn("AI fixing returned invalid JSON, attempting recursive parse...");
                         return parseResponse(JSON.stringify(aiFixedJson), responseFormat, {
                             ...options,
                             _recursionDepth: recursionDepth + 1,
@@ -1711,14 +1739,14 @@ async function parseResponse(content, responseFormat, options = {}) {
                 }
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
                 getLumicLogger().error(`AI JSON fixing failed: ${errorMessage}`);
                 // Continue to final error below
             }
         }
         // If all strategies fail, throw an error
         getLumicLogger().error(`Failed to parse JSON from content: ${cleanedContent}. Original JSON: ${content}`);
-        throw new Error('Unable to parse JSON response');
+        throw new Error("Unable to parse JSON response");
     }
     else {
         return content;
@@ -2312,13 +2340,15 @@ const isRetryableLLMError = (error) => {
     if (error instanceof Error) {
         const message = error.message;
         // Retry on rate limits (429)
-        if (message.includes('429') || message.includes('rate limit') || message.includes('Rate limit')) {
+        if (message.includes("429") ||
+            message.includes("rate limit") ||
+            message.includes("Rate limit")) {
             return true;
         }
         // Retry on transient body-corruption 400s. Match the exact OpenAI error
         // string to avoid retrying genuine client-side validation 400s (which
         // would re-fail forever and waste retry budget).
-        if (message.includes('could not parse the JSON body of your request')) {
+        if (message.includes("could not parse the JSON body of your request")) {
             return true;
         }
     }
@@ -2387,23 +2417,26 @@ function isReasoningModel(model) {
  * @throws Error if the response format is invalid or incompatible.
  */
 function getResponseFormatOption(responseFormat, normalizedModel) {
-    if (responseFormat === 'text') {
-        return { type: 'text' };
+    if (responseFormat === "text") {
+        return { type: "text" };
     }
-    if (responseFormat === 'json') {
-        return supportsJsonMode(normalizedModel) ? { type: 'json_object' } : { type: 'text' };
+    if (responseFormat === "json") {
+        return supportsJsonMode(normalizedModel)
+            ? { type: "json_object" }
+            : { type: "text" };
     }
-    if (typeof responseFormat === 'object' && responseFormat.type === 'json_schema') {
+    if (typeof responseFormat === "object" &&
+        responseFormat.type === "json_schema") {
         if (!isStructuredOutputCompatibleModel(normalizedModel)) {
             throw new Error(`${normalizedModel} is not compatible with structured outputs / json object.`);
         }
         return {
-            type: 'json_schema',
+            type: "json_schema",
             json_schema: {
-                type: 'object',
+                type: "object",
                 properties: responseFormat.schema.properties,
                 required: responseFormat.schema.required || [],
-                name: 'Response',
+                name: "Response",
             },
         };
     }
@@ -2462,7 +2495,7 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
     const apiKey = options.apiKey || getSecrets().openai.apiKey;
     if (!apiKey) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
+        throw new Error("OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set");
     }
     const openai = new OpenAI({
         apiKey: apiKey,
@@ -2472,7 +2505,7 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     // Add developer prompt if present
     if (options.developerPrompt && supportsDeveloperPrompt(normalizedModel)) {
         messages.push({
-            role: 'developer',
+            role: "developer",
             content: options.developerPrompt,
         });
     }
@@ -2481,15 +2514,15 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
         messages.push(...options.context);
     }
     // Add user content
-    if (typeof content === 'string') {
+    if (typeof content === "string") {
         messages.push({
-            role: 'user',
+            role: "user",
             content,
         });
     }
     else {
         messages.push({
-            role: 'user',
+            role: "user",
             content,
         });
     }
@@ -2503,7 +2536,8 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
         queryOptions.tools = options.tools;
     }
     // Only include temperature if the model supports it
-    if (options.temperature !== undefined && supportsTemperature(normalizedModel)) {
+    if (options.temperature !== undefined &&
+        supportsTemperature(normalizedModel)) {
         queryOptions.temperature = options.temperature;
     }
     // Only include max_completion_tokens when specified
@@ -2513,7 +2547,7 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     // Only set response_format when it's not the default 'text' type
     // (sending response_format: {type: 'text'} is redundant and may cause issues)
     const responseFormatOption = getResponseFormatOption(responseFormat, normalizedModel);
-    if (responseFormatOption.type !== 'text') {
+    if (responseFormatOption.type !== "text") {
         queryOptions.response_format = responseFormatOption;
     }
     let completion;
@@ -2534,15 +2568,19 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
         // for production prompts containing sensitive context.
         const errorMessage = error instanceof Error ? error.message : String(error);
         const totalContentChars = messages.reduce((sum, msg) => {
-            if (typeof msg.content === 'string')
+            if (typeof msg.content === "string")
                 return sum + msg.content.length;
             if (Array.isArray(msg.content)) {
-                return sum + msg.content.reduce((s, part) => {
-                    if (typeof part === 'object' && part !== null && 'text' in part && typeof part.text === 'string') {
-                        return s + part.text.length;
-                    }
-                    return s;
-                }, 0);
+                return (sum +
+                    msg.content.reduce((s, part) => {
+                        if (typeof part === "object" &&
+                            part !== null &&
+                            "text" in part &&
+                            typeof part.text === "string") {
+                            return s + part.text.length;
+                        }
+                        return s;
+                    }, 0));
             }
             return sum;
         }, 0);
@@ -2569,7 +2607,7 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     const cachedTokens = completion.usage?.prompt_tokens_details?.cached_tokens ?? 0;
     const response = {
         id: completion.id,
-        content: completion.choices[0]?.message?.content || '',
+        content: completion.choices[0]?.message?.content || "",
         tool_calls: completion.choices[0]?.message?.tool_calls,
         usage: {
             prompt_tokens: completion.usage?.prompt_tokens ?? 0,
@@ -2579,7 +2617,7 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
         },
         system_fingerprint: completion.system_fingerprint,
         service_tier: options.service_tier,
-        provider: 'openai',
+        provider: "openai",
         model: normalizedModel,
     };
     return response;
@@ -2592,7 +2630,7 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
  * @param options The options for the LLM call. Defaults to an empty object.
  * @return A promise that resolves to the response from the LLM.
  */
-const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', options = {}) => {
+const makeOpenAIChatCompletionCall = async (content, responseFormat = "text", options = {}) => {
     const mergedOptions = {
         ...DEFAULT_OPTIONS$1,
         ...options,
@@ -2601,7 +2639,7 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
     // Track cost in the global cost tracker. Pass cached tokens through so the
     // tracker applies the discounted cached-input rate (typically ~50% of the
     // standard input rate) instead of billing every input token at full price.
-    getLLMCostTracker().trackUsage('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens);
+    getLLMCostTracker().trackUsage("openai", completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens);
     // Handle tool calls differently
     if (completion.tool_calls && completion.tool_calls.length > 0) {
         const toolCallResponse = {
@@ -2617,10 +2655,10 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
                 prompt_tokens: completion.usage.prompt_tokens,
                 completion_tokens: completion.usage.completion_tokens,
                 reasoning_tokens: 0,
-                provider: 'openai',
+                provider: "openai",
                 model: completion.model,
                 cached_tokens: completion.usage.cached_tokens,
-                cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
+                cost: calculateCost("openai", completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
             },
             tool_calls: completion.tool_calls,
         };
@@ -2628,7 +2666,7 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
     // Handle regular responses
     const parsedResponse = await parseResponse(completion.content, responseFormat);
     if (parsedResponse === null) {
-        throw new Error('Failed to parse response');
+        throw new Error("Failed to parse response");
     }
     return {
         response: parsedResponse,
@@ -2636,10 +2674,10 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
             prompt_tokens: completion.usage.prompt_tokens,
             completion_tokens: completion.usage.completion_tokens,
             reasoning_tokens: 0,
-            provider: 'openai',
+            provider: "openai",
             model: completion.model,
             cached_tokens: completion.usage.cached_tokens,
-            cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
+            cost: calculateCost("openai", completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
         },
         tool_calls: completion.tool_calls,
     };
@@ -2674,7 +2712,7 @@ const makeResponsesAPICall = async (input, options = {}) => {
     const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
     const apiKey = options.apiKey || getSecrets().openai.apiKey;
     if (!apiKey) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
+        throw new Error("OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set");
     }
     const openai = new OpenAI({
         apiKey: apiKey,
@@ -2698,20 +2736,20 @@ const makeResponsesAPICall = async (input, options = {}) => {
     // (the equivalent of Chat Completions' `prompt_tokens_details.cached_tokens`).
     const responsesCachedTokens = response.usage?.input_tokens_details?.cached_tokens || 0;
     // Track cost in the global cost tracker
-    getLLMCostTracker().trackUsage('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens);
+    getLLMCostTracker().trackUsage("openai", normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens);
     // Extract tool calls from the output
     const toolCalls = response.output
-        ?.filter((item) => item.type === 'function_call')
+        ?.filter((item) => item.type === "function_call")
         .map((toolCall) => ({
         id: toolCall.call_id,
-        type: 'function',
+        type: "function",
         function: {
             name: toolCall.name,
             arguments: toolCall.arguments,
         },
     }));
     // Extract code interpreter outputs if present
-    const codeInterpreterCalls = response.output?.filter((item) => item.type === 'code_interpreter_call');
+    const codeInterpreterCalls = response.output?.filter((item) => item.type === "code_interpreter_call");
     let codeInterpreterOutputs = undefined;
     if (codeInterpreterCalls && codeInterpreterCalls.length > 0) {
         // Each code_interpreter_call has an 'outputs' array property
@@ -2737,32 +2775,34 @@ const makeResponsesAPICall = async (input, options = {}) => {
                 prompt_tokens: response.usage?.input_tokens || 0,
                 completion_tokens: response.usage?.output_tokens || 0,
                 reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
-                provider: 'openai',
+                provider: "openai",
                 model: normalizedModel,
                 cached_tokens: responsesCachedTokens,
-                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens),
+                cost: calculateCost("openai", normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens),
             },
             tool_calls: toolCalls,
-            ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
+            ...(codeInterpreterOutputs
+                ? { code_interpreter_outputs: codeInterpreterOutputs }
+                : {}),
         };
     }
     // Extract text content from the response output
     const textContent = response.output
-        ?.filter((item) => item.type === 'message')
+        ?.filter((item) => item.type === "message")
         .map((item) => item.content
-        .filter((content) => content.type === 'output_text')
+        .filter((content) => content.type === "output_text")
         .map((content) => content.text)
-        .join(''))
-        .join('') || '';
+        .join(""))
+        .join("") || "";
     // Determine the format for parsing the response
-    let parsingFormat = 'text';
-    if (requestBody.text?.format?.type === 'json_object') {
-        parsingFormat = 'json';
+    let parsingFormat = "text";
+    if (requestBody.text?.format?.type === "json_object") {
+        parsingFormat = "json";
     }
     // Handle regular responses
     const parsedResponse = await parseResponse(textContent, parsingFormat);
     if (parsedResponse === null) {
-        throw new Error('Failed to parse response from Responses API');
+        throw new Error("Failed to parse response from Responses API");
     }
     return {
         response: parsedResponse,
@@ -2770,13 +2810,15 @@ const makeResponsesAPICall = async (input, options = {}) => {
             prompt_tokens: response.usage?.input_tokens || 0,
             completion_tokens: response.usage?.output_tokens || 0,
             reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
-            provider: 'openai',
+            provider: "openai",
             model: normalizedModel,
             cached_tokens: responsesCachedTokens,
-            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens),
+            cost: calculateCost("openai", normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens),
         },
         tool_calls: toolCalls,
-        ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
+        ...(codeInterpreterOutputs
+            ? { code_interpreter_outputs: codeInterpreterOutputs }
+            : {}),
     };
 };
 
@@ -8086,12 +8128,12 @@ function sanitizeObject(obj, sensitiveFields = ['apiKey', 'token', 'secret', 'pa
 const isRetryableAnthropicError = (error) => {
     if (error instanceof Error) {
         const message = error.message;
-        if (message.includes('429') ||
-            message.includes('500') ||
-            message.includes('503') ||
-            message.includes('529') ||
-            message.includes('rate limit') ||
-            message.includes('overloaded')) {
+        if (message.includes("429") ||
+            message.includes("500") ||
+            message.includes("503") ||
+            message.includes("529") ||
+            message.includes("rate limit") ||
+            message.includes("overloaded")) {
             return true;
         }
     }
@@ -8106,8 +8148,11 @@ const isRetryableAnthropicError = (error) => {
 function translateToolsToAnthropic(tools) {
     return tools.map((tool) => ({
         name: tool.function.name,
-        description: tool.function.description || '',
-        input_schema: (tool.function.parameters || { type: 'object', properties: {} }),
+        description: tool.function.description || "",
+        input_schema: (tool.function.parameters || {
+            type: "object",
+            properties: {},
+        }),
     }));
 }
 /**
@@ -8120,27 +8165,31 @@ function translateContextToAnthropic(context) {
     const systemParts = [];
     const messages = [];
     for (const msg of context) {
-        if (msg.role === 'system' || msg.role === 'developer') {
-            if (typeof msg.content === 'string') {
+        if (msg.role === "system" || msg.role === "developer") {
+            if (typeof msg.content === "string") {
                 systemParts.push(msg.content);
             }
             continue;
         }
-        if (msg.role === 'user') {
-            const content = typeof msg.content === 'string'
+        if (msg.role === "user") {
+            const content = typeof msg.content === "string"
                 ? msg.content
                 : JSON.stringify(msg.content);
-            messages.push({ role: 'user', content });
+            messages.push({ role: "user", content });
             continue;
         }
-        if (msg.role === 'assistant') {
+        if (msg.role === "assistant") {
             const assistantMsg = msg;
             // If the assistant message has tool_calls, translate to Anthropic tool_use blocks
             if (assistantMsg.tool_calls && assistantMsg.tool_calls.length > 0) {
                 const contentBlocks = [];
                 // Include text content if present
-                if (typeof assistantMsg.content === 'string' && assistantMsg.content.trim()) {
-                    contentBlocks.push({ type: 'text', text: assistantMsg.content });
+                if (typeof assistantMsg.content === "string" &&
+                    assistantMsg.content.trim()) {
+                    contentBlocks.push({
+                        type: "text",
+                        text: assistantMsg.content,
+                    });
                 }
                 // Translate each tool_call to a tool_use block
                 for (const tc of assistantMsg.tool_calls) {
@@ -8152,32 +8201,36 @@ function translateContextToAnthropic(context) {
                         input = { raw: tc.function.arguments };
                     }
                     contentBlocks.push({
-                        type: 'tool_use',
+                        type: "tool_use",
                         id: tc.id,
                         name: tc.function.name,
                         input,
                     });
                 }
-                messages.push({ role: 'assistant', content: contentBlocks });
+                messages.push({ role: "assistant", content: contentBlocks });
             }
             else {
-                const content = typeof assistantMsg.content === 'string'
+                const content = typeof assistantMsg.content === "string"
                     ? assistantMsg.content
                     : JSON.stringify(assistantMsg.content);
-                messages.push({ role: 'assistant', content });
+                messages.push({ role: "assistant", content });
             }
             continue;
         }
-        if (msg.role === 'tool') {
+        if (msg.role === "tool") {
             // Anthropic expects tool results as user messages with tool_result content blocks
             const toolMsg = msg;
             messages.push({
-                role: 'user',
-                content: [{
-                        type: 'tool_result',
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
                         tool_use_id: toolMsg.tool_call_id,
-                        content: typeof toolMsg.content === 'string' ? toolMsg.content : JSON.stringify(toolMsg.content),
-                    }],
+                        content: typeof toolMsg.content === "string"
+                            ? toolMsg.content
+                            : JSON.stringify(toolMsg.content),
+                    },
+                ],
             });
             continue;
         }
@@ -8198,13 +8251,13 @@ function translateContextToAnthropic(context) {
             merged.push({ role: msg.role, content: toContentBlocks(msg.content) });
         }
     }
-    return { messages: merged, systemText: systemParts.join('\n\n') };
+    return { messages: merged, systemText: systemParts.join("\n\n") };
 }
 /** Convert string or content block array to a uniform content block array. */
 function toContentBlocks(content) {
-    if (typeof content === 'string') {
+    if (typeof content === "string") {
         const textBlock = {
-            type: 'text',
+            type: "text",
             text: content,
             citations: null,
         };
@@ -8224,11 +8277,11 @@ function toContentBlocks(content) {
  * @param options The options for the LLM call.
  * @return A promise that resolves to the response from the Anthropic API.
  */
-async function makeAnthropicCall(content, responseFormat = 'text', options = {}) {
-    const model = (options.model || 'claude-sonnet-4-6');
+async function makeAnthropicCall(content, responseFormat = "text", options = {}) {
+    const model = (options.model || "claude-sonnet-4-6");
     const apiKey = options.apiKey || getSecrets().anthropic.apiKey;
     if (!apiKey) {
-        throw new Error('Anthropic API key is not provided and ANTHROPIC_API_KEY environment variable is not set');
+        throw new Error("Anthropic API key is not provided and ANTHROPIC_API_KEY environment variable is not set");
     }
     const client = new Anthropic({
         apiKey,
@@ -8240,8 +8293,10 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
         systemParts.push(options.developerPrompt);
     }
     // If JSON response is requested, instruct the model via system prompt
-    if (responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat.type === 'json_schema')) {
-        systemParts.push('You MUST respond with valid JSON only. No markdown, no code blocks, no explanatory text — just the raw JSON object or array.');
+    if (responseFormat === "json" ||
+        (typeof responseFormat === "object" &&
+            responseFormat.type === "json_schema")) {
+        systemParts.push("You MUST respond with valid JSON only. No markdown, no code blocks, no explanatory text — just the raw JSON object or array.");
     }
     // Build messages array
     const messages = [];
@@ -8254,7 +8309,7 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
         messages.push(...translated.messages);
     }
     // Add user content
-    messages.push({ role: 'user', content });
+    messages.push({ role: "user", content });
     // Build request params
     const requestParams = {
         model,
@@ -8263,7 +8318,7 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
     };
     // Add system prompt if present
     if (systemParts.length > 0) {
-        requestParams.system = systemParts.join('\n\n');
+        requestParams.system = systemParts.join("\n\n");
     }
     // Add temperature if specified
     if (options.temperature !== undefined) {
@@ -8286,14 +8341,14 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
         const inputTokens = response.usage.input_tokens;
         const outputTokens = response.usage.output_tokens;
         // Track cost
-        getLLMCostTracker().trackUsage('anthropic', model, inputTokens, outputTokens);
+        getLLMCostTracker().trackUsage("anthropic", model, inputTokens, outputTokens);
         // Extract tool use blocks
-        const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
+        const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
         if (toolUseBlocks.length > 0) {
             // Translate Anthropic tool_use to OpenAI tool_calls format
             const toolCalls = toolUseBlocks.map((block) => ({
                 id: block.id,
-                type: 'function',
+                type: "function",
                 function: {
                     name: block.name,
                     arguments: JSON.stringify(block.input),
@@ -8312,22 +8367,22 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
                     prompt_tokens: inputTokens,
                     completion_tokens: outputTokens,
                     reasoning_tokens: 0,
-                    provider: 'anthropic',
+                    provider: "anthropic",
                     model,
-                    cost: calculateCost('anthropic', model, inputTokens, outputTokens),
+                    cost: calculateCost("anthropic", model, inputTokens, outputTokens),
                 },
                 tool_calls: toolCalls,
             };
         }
         // Extract text content
         const textContent = response.content
-            .filter((block) => block.type === 'text')
+            .filter((block) => block.type === "text")
             .map((block) => block.text)
-            .join('');
+            .join("");
         // Parse response
         const parsedResponse = await parseResponse(textContent, responseFormat);
         if (parsedResponse === null) {
-            throw new Error('Failed to parse Anthropic response');
+            throw new Error("Failed to parse Anthropic response");
         }
         return {
             response: parsedResponse,
@@ -8335,9 +8390,9 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
                 prompt_tokens: inputTokens,
                 completion_tokens: outputTokens,
                 reasoning_tokens: 0,
-                provider: 'anthropic',
+                provider: "anthropic",
                 model,
-                cost: calculateCost('anthropic', model, inputTokens, outputTokens),
+                cost: calculateCost("anthropic", model, inputTokens, outputTokens),
             },
         };
     }
@@ -8359,7 +8414,9 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
 const isRetryableError = (error) => {
     if (error instanceof Error) {
         const message = error.message;
-        if (message.includes('429') || message.includes('rate limit') || message.includes('Rate limit')) {
+        if (message.includes("429") ||
+            message.includes("rate limit") ||
+            message.includes("Rate limit")) {
             return true;
         }
     }
@@ -8373,14 +8430,16 @@ function resolveApiKey(provider, optionsApiKey) {
     if (optionsApiKey)
         return optionsApiKey;
     const secrets = getSecrets();
-    const pathParts = provider.apiKeySecretPath.split('.');
+    const pathParts = provider.apiKeySecretPath.split(".");
     let current = secrets;
     for (const part of pathParts) {
-        if (current === null || current === undefined || typeof current !== 'object')
-            return '';
+        if (current === null ||
+            current === undefined ||
+            typeof current !== "object")
+            return "";
         current = current[part];
     }
-    return (typeof current === 'string' ? current : '') || '';
+    return (typeof current === "string" ? current : "") || "";
 }
 /**
  * Makes a call to an OpenAI-compatible provider (Kimi, Qwen, or any future provider).
@@ -8394,12 +8453,12 @@ function resolveApiKey(provider, optionsApiKey) {
  * @param providerName The provider key in OPENAI_COMPATIBLE_PROVIDERS.
  * @return A promise that resolves to the response from the provider.
  */
-async function makeOpenAICompatibleCall(content, responseFormat = 'text', options = {}, providerName) {
+async function makeOpenAICompatibleCall(content, responseFormat = "text", options = {}, providerName) {
     const providerConfig = OPENAI_COMPATIBLE_PROVIDERS[providerName];
     if (!providerConfig) {
         throw new Error(`Unknown OpenAI-compatible provider: ${providerName}`);
     }
-    const model = normalizeModelName(options.model || '');
+    const model = normalizeModelName(options.model || "");
     const apiKey = resolveApiKey(providerConfig, options.apiKey);
     if (!apiKey) {
         throw new Error(`${providerConfig.name} API key is not provided and ${providerConfig.apiKeyEnvVar} environment variable is not set`);
@@ -8412,31 +8471,36 @@ async function makeOpenAICompatibleCall(content, responseFormat = 'text', option
     const messages = [];
     // Add system message with developer prompt if present
     if (options.developerPrompt) {
-        messages.push({ role: 'system', content: options.developerPrompt });
+        messages.push({ role: "system", content: options.developerPrompt });
     }
     // Add context if present
     if (options.context) {
         messages.push(...options.context);
     }
     // Add user content
-    if (typeof content === 'string') {
-        messages.push({ role: 'user', content });
+    if (typeof content === "string") {
+        messages.push({ role: "user", content });
     }
     else {
-        messages.push({ role: 'user', content });
+        messages.push({ role: "user", content });
     }
     // Determine if the model supports JSON mode
     const supportsJson = isValidModel(model) && getModelCapabilities(model).supportsJson;
     // If JSON response format, add hint to system prompt
-    if ((responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat.type === 'json_schema')) &&
+    if ((responseFormat === "json" ||
+        (typeof responseFormat === "object" &&
+            responseFormat.type === "json_schema")) &&
         supportsJson) {
-        if (!messages.some((m) => m.role === 'system')) {
-            messages.unshift({ role: 'system', content: 'Please respond in valid JSON format.' });
+        if (!messages.some((m) => m.role === "system")) {
+            messages.unshift({
+                role: "system",
+                content: "Please respond in valid JSON format.",
+            });
         }
         else {
-            const systemMsgIndex = messages.findIndex((m) => m.role === 'system');
+            const systemMsgIndex = messages.findIndex((m) => m.role === "system");
             const systemMsg = messages[systemMsgIndex];
-            if (typeof systemMsg.content === 'string') {
+            if (typeof systemMsg.content === "string") {
                 messages[systemMsgIndex] = {
                     ...systemMsg,
                     content: `${systemMsg.content} Please respond in valid JSON format.`,
@@ -8449,8 +8513,8 @@ async function makeOpenAICompatibleCall(content, responseFormat = 'text', option
         messages,
     };
     // Add response format if JSON is supported
-    if (responseFormat !== 'text' && supportsJson) {
-        queryOptions.response_format = { type: 'json_object' };
+    if (responseFormat !== "text" && supportsJson) {
+        queryOptions.response_format = { type: "json_object" };
     }
     // Temperature
     if (options.temperature !== undefined) {
@@ -8508,7 +8572,7 @@ async function makeOpenAICompatibleCall(content, responseFormat = 'text', option
             };
         }
         // Handle regular responses
-        const textContent = completion.choices[0]?.message?.content || '';
+        const textContent = completion.choices[0]?.message?.content || "";
         const parsedResponse = await parseResponse(textContent, responseFormat);
         if (parsedResponse === null) {
             throw new Error(`Failed to parse ${providerConfig.name} response`);
@@ -8800,7 +8864,9 @@ const isRetryableDeepseekError = (error) => {
     if (error instanceof Error) {
         const message = error.message;
         // Retry only on rate limits (429)
-        if (message.includes('429') || message.includes('rate limit') || message.includes('Rate limit')) {
+        if (message.includes("429") ||
+            message.includes("rate limit") ||
+            message.includes("Rate limit")) {
             return true;
         }
     }
@@ -8810,7 +8876,7 @@ const isRetryableDeepseekError = (error) => {
  * Default options for Deepseek API calls
  */
 const DEFAULT_DEEPSEEK_OPTIONS = {
-    defaultModel: 'deepseek-chat',
+    defaultModel: "deepseek-chat",
 };
 /**
  * Checks if the given model is a supported Deepseek model
@@ -8822,7 +8888,7 @@ const isSupportedDeepseekModel = (model) => {
         return false;
     }
     const capabilities = getModelCapabilities(model);
-    return capabilities.provider === 'deepseek';
+    return capabilities.provider === "deepseek";
 };
 /**
  * Checks if the given Deepseek model supports JSON output format
@@ -8855,17 +8921,19 @@ const supportsToolCalling = (model) => {
  */
 function getDeepseekResponseFormatOption(responseFormat, model) {
     // Check if the model supports JSON output
-    if (responseFormat !== 'text' && !supportsJsonOutput(model)) {
+    if (responseFormat !== "text" && !supportsJsonOutput(model)) {
         getLumicLogger().warn(`Model ${model} does not support JSON output. Using text format instead.`);
-        return { type: 'text' };
+        return { type: "text" };
     }
-    if (responseFormat === 'text') {
-        return { type: 'text' };
+    if (responseFormat === "text") {
+        return { type: "text" };
     }
-    if (responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat.type === 'json_schema')) {
-        return { type: 'json_object' };
+    if (responseFormat === "json" ||
+        (typeof responseFormat === "object" &&
+            responseFormat.type === "json_schema")) {
+        return { type: "json_object" };
     }
-    return { type: 'text' };
+    return { type: "text" };
 }
 /**
  * Creates a completion using the Deepseek API
@@ -8884,24 +8952,26 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
         throw new Error(`Unsupported Deepseek model: ${normalizedModel}. Please use 'deepseek-chat' or 'deepseek-reasoner'.`);
     }
     // Check if tools are requested with a model that doesn't support them
-    if (options.tools && options.tools.length > 0 && !supportsToolCalling(normalizedModel)) {
+    if (options.tools &&
+        options.tools.length > 0 &&
+        !supportsToolCalling(normalizedModel)) {
         throw new Error(`Model ${normalizedModel} does not support tool calling.`);
     }
     const apiKey = options.apiKey || getSecrets().deepseek.apiKey;
     if (!apiKey) {
-        throw new Error('Deepseek API key is not provided and DEEPSEEK_API_KEY environment variable is not set');
+        throw new Error("Deepseek API key is not provided and DEEPSEEK_API_KEY environment variable is not set");
     }
     // Initialize OpenAI client with Deepseek API URL
     const openai = new OpenAI({
         apiKey,
-        baseURL: 'https://api.deepseek.com',
+        baseURL: "https://api.deepseek.com",
         timeout: options.timeout ?? LLM_TIMEOUT_MS,
     });
     const messages = [];
     // Add system message with developer prompt if present
     if (options.developerPrompt) {
         messages.push({
-            role: 'system',
+            role: "system",
             content: options.developerPrompt,
         });
     }
@@ -8910,33 +8980,35 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
         messages.push(...options.context);
     }
     // Add user content
-    if (typeof content === 'string') {
+    if (typeof content === "string") {
         messages.push({
-            role: 'user',
+            role: "user",
             content,
         });
     }
     else {
         messages.push({
-            role: 'user',
+            role: "user",
             content,
         });
     }
     // If JSON response format, include a hint in the system prompt
-    if ((responseFormat === 'json' || (typeof responseFormat === 'object' && responseFormat.type === 'json_schema'))
-        && supportsJsonOutput(normalizedModel)) {
+    if ((responseFormat === "json" ||
+        (typeof responseFormat === "object" &&
+            responseFormat.type === "json_schema")) &&
+        supportsJsonOutput(normalizedModel)) {
         // If there's no system message yet, add one
-        if (!messages.some(m => m.role === 'system')) {
+        if (!messages.some((m) => m.role === "system")) {
             messages.unshift({
-                role: 'system',
-                content: 'Please respond in valid JSON format.',
+                role: "system",
+                content: "Please respond in valid JSON format.",
             });
         }
         else {
             // Append to existing system message
-            const systemMsgIndex = messages.findIndex(m => m.role === 'system');
+            const systemMsgIndex = messages.findIndex((m) => m.role === "system");
             const systemMsg = messages[systemMsgIndex];
-            if (typeof systemMsg.content === 'string') {
+            if (typeof systemMsg.content === "string") {
                 messages[systemMsgIndex] = {
                     ...systemMsg,
                     content: `${systemMsg.content} Please respond in valid JSON format.`,
@@ -8977,7 +9049,7 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
             0;
         return {
             id: completion.id,
-            content: completion.choices[0]?.message?.content || '',
+            content: completion.choices[0]?.message?.content || "",
             tool_calls: completion.choices[0]?.message?.tool_calls,
             usage: {
                 prompt_tokens: completion.usage?.prompt_tokens ?? 0,
@@ -8986,7 +9058,7 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
                 cached_tokens: cachedTokens,
             },
             system_fingerprint: completion.system_fingerprint,
-            provider: 'deepseek',
+            provider: "deepseek",
             model: normalizedModel,
         };
     }
@@ -9003,7 +9075,7 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
  * @param options Configuration options including model ('deepseek-chat' or 'deepseek-reasoner'), tools, and apiKey.
  * @return A promise that resolves to the response from the Deepseek API.
  */
-const makeDeepseekCall = async (content, responseFormat = 'json', options = {}) => {
+const makeDeepseekCall = async (content, responseFormat = "json", options = {}) => {
     // Set default model if not provided
     const mergedOptions = {
         ...options,
@@ -9013,17 +9085,17 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
     }
     const modelName = normalizeModelName(mergedOptions.model);
     // Check if the requested response format is compatible with the model
-    if (responseFormat !== 'text' && !supportsJsonOutput(modelName)) {
+    if (responseFormat !== "text" && !supportsJsonOutput(modelName)) {
         getLumicLogger().warn(`Model ${modelName} does not support JSON output. Will return error in the response.`);
         return {
             response: {
-                error: `Model ${modelName} does not support JSON output format.`
+                error: `Model ${modelName} does not support JSON output format.`,
             },
             usage: {
                 prompt_tokens: 0,
                 completion_tokens: 0,
                 reasoning_tokens: 0,
-                provider: 'deepseek',
+                provider: "deepseek",
                 model: modelName,
                 cached_tokens: 0,
                 cost: 0,
@@ -9032,17 +9104,19 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         };
     }
     // Check if tools are requested with a model that doesn't support them
-    if (mergedOptions.tools && mergedOptions.tools.length > 0 && !supportsToolCalling(modelName)) {
+    if (mergedOptions.tools &&
+        mergedOptions.tools.length > 0 &&
+        !supportsToolCalling(modelName)) {
         getLumicLogger().warn(`Model ${modelName} does not support tool calling. Will return error in the response.`);
         return {
             response: {
-                error: `Model ${modelName} does not support tool calling.`
+                error: `Model ${modelName} does not support tool calling.`,
             },
             usage: {
                 prompt_tokens: 0,
                 completion_tokens: 0,
                 reasoning_tokens: 0,
-                provider: 'deepseek',
+                provider: "deepseek",
                 model: modelName,
                 cached_tokens: 0,
                 cost: 0,
@@ -9054,7 +9128,7 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         const completion = await createDeepseekCompletion(content, responseFormat, mergedOptions);
         // Track cost in the global cost tracker. Pass cached tokens through so the
         // discounted cached-input pricing tier is applied.
-        getLLMCostTracker().trackUsage('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens);
+        getLLMCostTracker().trackUsage("deepseek", completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens);
         // Handle tool calls similarly to OpenAI
         if (completion.tool_calls && completion.tool_calls.length > 0) {
             const toolCallResponse = {
@@ -9070,10 +9144,10 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                     prompt_tokens: completion.usage.prompt_tokens,
                     completion_tokens: completion.usage.completion_tokens,
                     reasoning_tokens: 0, // Deepseek doesn't provide reasoning tokens separately
-                    provider: 'deepseek',
+                    provider: "deepseek",
                     model: completion.model,
                     cached_tokens: completion.usage.cached_tokens,
-                    cost: calculateCost('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
+                    cost: calculateCost("deepseek", completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
                 },
                 tool_calls: completion.tool_calls,
             };
@@ -9081,7 +9155,7 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         // Handle regular responses
         const parsedResponse = await parseResponse(completion.content, responseFormat);
         if (parsedResponse === null) {
-            throw new Error('Failed to parse Deepseek response');
+            throw new Error("Failed to parse Deepseek response");
         }
         return {
             response: parsedResponse,
@@ -9089,10 +9163,10 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                 prompt_tokens: completion.usage.prompt_tokens,
                 completion_tokens: completion.usage.completion_tokens,
                 reasoning_tokens: 0, // Deepseek doesn't provide reasoning tokens separately
-                provider: 'deepseek',
+                provider: "deepseek",
                 model: completion.model,
                 cached_tokens: completion.usage.cached_tokens,
-                cost: calculateCost('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
+                cost: calculateCost("deepseek", completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
             },
             tool_calls: completion.tool_calls,
         };
@@ -9102,13 +9176,13 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         getLumicLogger().error(`Error in Deepseek API call: ${sanitizeError(error)}`);
         return {
             response: {
-                error: sanitizeError(error)
+                error: sanitizeError(error),
             },
             usage: {
                 prompt_tokens: 0,
                 completion_tokens: 0,
                 reasoning_tokens: 0,
-                provider: 'deepseek',
+                provider: "deepseek",
                 model: modelName,
                 cached_tokens: 0,
                 cost: 0,
@@ -9217,15 +9291,15 @@ const generateCacheKey = (auth, envVarsCheck = null) => {
     if (auth) {
         return `${auth.AWS_ACCESS_KEY_ID}:${auth.AWS_SECRET_ACCESS_KEY}:${auth.AWS_REGION}`;
     }
-    if (envVarsCheck?.source === 'lambda') {
+    if (envVarsCheck?.source === "lambda") {
         // In Lambda, use function name as cache key since it uses IAM role
         const secrets = getSecrets();
-        return `lambda:${secrets.aws.lambdaFunctionName || 'default'}`;
+        return `lambda:${secrets.aws.lambdaFunctionName || "default"}`;
     }
     if (envVarsCheck?.vars) {
         return `${envVarsCheck.vars.accessKeyId}:${envVarsCheck.vars.secretAccessKey}:${envVarsCheck.vars.region}`;
     }
-    return 'default';
+    return "default";
 };
 const validateEnvironmentVars = () => {
     const secrets = getSecrets();
@@ -9238,37 +9312,37 @@ const validateEnvironmentVars = () => {
         // We're in a Lambda environment
         return {
             isValid: true,
-            source: 'lambda',
-            vars: { accessKeyId: '', secretAccessKey: '', region: '' } // No need for explicit credentials in Lambda
+            source: "lambda",
+            vars: { accessKeyId: "", secretAccessKey: "", region: "" }, // No need for explicit credentials in Lambda
         };
     }
     else if (areVarsComplete(secrets.aws.myAccessKeyId, secrets.aws.mySecretAccessKey, secrets.aws.myRegion)) {
         return {
             isValid: true,
-            source: 'my_prefix',
+            source: "my_prefix",
             vars: {
-                accessKeyId: secrets.aws.myAccessKeyId,
-                secretAccessKey: secrets.aws.mySecretAccessKey,
-                region: secrets.aws.myRegion
-            }
+                accessKeyId: secrets.aws.myAccessKeyId ?? "",
+                secretAccessKey: secrets.aws.mySecretAccessKey ?? "",
+                region: secrets.aws.myRegion ?? "",
+            },
         };
     }
     else if (areVarsComplete(secrets.aws.accessKeyId, secrets.aws.secretAccessKey, secrets.aws.region)) {
         return {
             isValid: true,
-            source: 'standard',
+            source: "standard",
             vars: {
-                accessKeyId: secrets.aws.accessKeyId,
-                secretAccessKey: secrets.aws.secretAccessKey,
-                region: secrets.aws.region
-            }
+                accessKeyId: secrets.aws.accessKeyId ?? "",
+                secretAccessKey: secrets.aws.secretAccessKey ?? "",
+                region: secrets.aws.region ?? "",
+            },
         };
     }
     // If we get here, no complete set of variables was found
     return {
         isValid: false,
         source: null,
-        missingVars: []
+        missingVars: [],
     };
 };
 const initialiseAWSClient = (ClientClass, auth = null) => {
@@ -9277,48 +9351,52 @@ const initialiseAWSClient = (ClientClass, auth = null) => {
         const requestTimeout = ClientClass === clientS3.S3Client ? AWS_S3_TIMEOUT_MS : AWS_LAMBDA_TIMEOUT_MS;
         // Case 1: Explicit auth provided
         if (auth) {
-            if (typeof auth !== 'object' || auth === null) {
-                throw new Error('Auth parameter must be an object');
+            if (typeof auth !== "object" || auth === null) {
+                throw new Error("Auth parameter must be an object");
             }
-            const requiredAuthFields = ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION'];
-            const missingFields = requiredAuthFields.filter(field => !auth[field]);
+            const requiredAuthFields = [
+                "AWS_ACCESS_KEY_ID",
+                "AWS_SECRET_ACCESS_KEY",
+                "AWS_REGION",
+            ];
+            const missingFields = requiredAuthFields.filter((field) => !auth[field]);
             if (missingFields.length > 0) {
-                throw new Error(`Auth object is missing required fields: ${missingFields.join(', ')}`);
+                throw new Error(`Auth object is missing required fields: ${missingFields.join(", ")}`);
             }
             return new ClientClass({
                 region: auth.AWS_REGION,
                 credentials: {
                     accessKeyId: auth.AWS_ACCESS_KEY_ID,
-                    secretAccessKey: auth.AWS_SECRET_ACCESS_KEY
+                    secretAccessKey: auth.AWS_SECRET_ACCESS_KEY,
                 },
                 requestHandler: {
-                    requestTimeout
-                }
+                    requestTimeout,
+                },
             });
         }
         // Case 2: Check environment variables
         const envVarsCheck = validateEnvironmentVars();
         if (!envVarsCheck.isValid) {
-            throw new Error('No valid AWS credentials found in environment variables');
+            throw new Error("No valid AWS credentials found in environment variables");
         }
         // Case 2a: Lambda execution environment
-        if (envVarsCheck.source === 'lambda') {
+        if (envVarsCheck.source === "lambda") {
             return new ClientClass({
                 requestHandler: {
-                    requestTimeout
-                }
+                    requestTimeout,
+                },
             }); // AWS SDK will automatically use Lambda role credentials
         }
         // Case 2b: MY_ prefixed vars or standard AWS vars
         return new ClientClass({
-            region: envVarsCheck.vars.region,
+            region: envVarsCheck.vars?.region ?? "",
             credentials: {
-                accessKeyId: envVarsCheck.vars.accessKeyId,
-                secretAccessKey: envVarsCheck.vars.secretAccessKey
+                accessKeyId: envVarsCheck.vars?.accessKeyId ?? "",
+                secretAccessKey: envVarsCheck.vars?.secretAccessKey ?? "",
             },
             requestHandler: {
-                requestTimeout
-            }
+                requestTimeout,
+            },
         });
     }
     catch (error) {
@@ -9331,7 +9409,9 @@ const initialiseS3Client = (auth = null) => {
     const envVarsCheck = auth ? null : validateEnvironmentVars();
     const cacheKey = generateCacheKey(auth, envVarsCheck);
     if (s3ClientCache.has(cacheKey)) {
-        return s3ClientCache.get(cacheKey);
+        const cached = s3ClientCache.get(cacheKey);
+        if (cached)
+            return cached;
     }
     // Create new client and cache it
     const client = initialiseAWSClient(clientS3.S3Client, auth);
@@ -9343,7 +9423,9 @@ const initialiseLambdaClient = (auth = null) => {
     const envVarsCheck = auth ? null : validateEnvironmentVars();
     const cacheKey = generateCacheKey(auth, envVarsCheck);
     if (lambdaClientCache.has(cacheKey)) {
-        return lambdaClientCache.get(cacheKey);
+        const cached = lambdaClientCache.get(cacheKey);
+        if (cached)
+            return cached;
     }
     // Create new client and cache it
     const client = initialiseAWSClient(clientLambda.Lambda, auth);
@@ -9843,15 +9925,17 @@ const isRetryableS3Error = (error) => {
     if (error instanceof Error) {
         const message = error.message;
         // Retry on throttling
-        if (message.includes('SlowDown') || message.includes('RequestTimeout')) {
+        if (message.includes("SlowDown") || message.includes("RequestTimeout")) {
             return true;
         }
         // Retry on 5xx server errors
-        if (message.includes('InternalError') || message.includes('ServiceUnavailable')) {
+        if (message.includes("InternalError") ||
+            message.includes("ServiceUnavailable")) {
             return true;
         }
         // Retry on connection errors
-        if (message.includes('RequestTimeTooSkewed') || message.includes('NetworkingError')) {
+        if (message.includes("RequestTimeTooSkewed") ||
+            message.includes("NetworkingError")) {
             return true;
         }
     }
@@ -9865,10 +9949,11 @@ const generateRandomHash = (length) => {
 };
 function generateDateTimeStamp() {
     const now = new Date();
-    return now.toISOString()
-        .replace(/T/, '-')
-        .replace(/\..+/, '')
-        .replace(/:/g, '-');
+    return now
+        .toISOString()
+        .replace(/T/, "-")
+        .replace(/\..+/, "")
+        .replace(/:/g, "-");
 }
 const isValidBucketName = (name) => {
     const regex = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
@@ -9899,7 +9984,7 @@ async function uploadFile(s3Client, bucketName, filePath, destinationPath, isPub
         Bucket: bucketName,
         Key: s3Key,
         Body: fileContent,
-        ACL: isPublic ? 'public-read' : undefined
+        ACL: isPublic ? "public-read" : undefined,
     });
     await withRetry(() => s3Client.send(command), {
         maxRetries: 3,
@@ -9919,7 +10004,7 @@ async function uploadDirectory(s3Client, bucketName, dirPath, destinationPath, i
         Bucket: bucketName,
         Key: s3Key,
         Body: fileContent,
-        ACL: isPublic ? 'public-read' : undefined
+        ACL: isPublic ? "public-read" : undefined,
     });
     await withRetry(() => s3Client.send(command), {
         maxRetries: 3,
@@ -9935,7 +10020,7 @@ async function zipDirectory(sourceDir, outPath) {
     const zip = new AdmZip();
     let fileCount = 0;
     try {
-        async function addFilesToZip(currentPath, relativePath = '') {
+        async function addFilesToZip(currentPath, relativePath = "") {
             const files = await fs$1.readdir(currentPath, { withFileTypes: true });
             for (const file of files) {
                 const filePath = path$1.join(currentPath, file.name);
@@ -9978,27 +10063,33 @@ async function downloadFromS3Helper(s3Client, bucketName, s3Path, localPath) {
             Prefix: s3Path,
             ContinuationToken: continuationToken,
         });
-        const listResponse = await withRetry(() => s3Client.send(listCommand), {
+        const listResponse = (await withRetry(() => s3Client.send(listCommand), {
             maxRetries: 3,
             baseDelayMs: 1000,
             maxDelayMs: 15000,
             retryableErrors: isRetryableS3Error,
-        }, `S3:ListObjects:${bucketName}`);
+        }, `S3:ListObjects:${bucketName}`));
         const objects = listResponse.Contents || [];
         if (objects.length === 0) {
             return { fileCount: 0, folderCount: 0, totalSize: 0, fileList: [] };
         }
-        if (objects.length === 1 && objects[0].Key?.endsWith('.zip')) {
+        if (objects.length === 1 && objects[0].Key?.endsWith(".zip")) {
             // It's a zip file, download and extract it
             const zipPath = path$1.join(localPath, path$1.basename(objects[0].Key));
             await downloadFile(s3Client, bucketName, objects[0].Key, zipPath);
-            const { totalFiles, totalFolders, totalSize: extractedSize, fileList: extractedFileList } = await unzipFile(zipPath, localPath);
+            const { totalFiles, totalFolders, totalSize: extractedSize, fileList: extractedFileList, } = await unzipFile(zipPath, localPath);
             await fs$1.unlink(zipPath);
-            return { fileCount: totalFiles, folderCount: totalFolders, totalSize: extractedSize, fileList: extractedFileList };
+            return {
+                fileCount: totalFiles,
+                folderCount: totalFolders,
+                totalSize: extractedSize,
+                fileList: extractedFileList,
+            };
         }
         else {
             // Non-zip files. Download files in batches.
-            for (let i = 0; i < objects.length; i += 1000) { // AWS allows up to 1000 per request
+            for (let i = 0; i < objects.length; i += 1000) {
+                // AWS allows up to 1000 per request
                 const batch = objects.slice(i, i + 1000);
                 await Promise.all(batch.map(async (obj) => {
                     if (!obj.Key)
@@ -10014,7 +10105,9 @@ async function downloadFromS3Helper(s3Client, bucketName, s3Path, localPath) {
                     }
                     // Count folders
                     const relativePath = path$1.relative(localPath, path$1.dirname(localFilePath));
-                    if (relativePath && !relativePath.startsWith('..') && relativePath !== '.') {
+                    if (relativePath &&
+                        !relativePath.startsWith("..") &&
+                        relativePath !== ".") {
                         folderCount++;
                     }
                 }));
@@ -10035,7 +10128,7 @@ async function downloadFile(s3Client, bucketName, s3Key, localFilePath) {
     await withRetry(async () => {
         const { Body } = await s3Client.send(getCommand);
         if (!Body)
-            throw new Error('No body returned from S3');
+            throw new Error("No body returned from S3");
         const writeStream = fs.createWriteStream(localFilePath);
         await promises.pipeline(Body, writeStream);
     }, {
@@ -10091,17 +10184,19 @@ async function emptyBucket(s3Client, bucketName) {
             Bucket: bucketName,
             ContinuationToken: continuationToken,
         });
-        const response = await withRetry(() => s3Client.send(listCommand), {
+        const response = (await withRetry(() => s3Client.send(listCommand), {
             maxRetries: 3,
             baseDelayMs: 1000,
             maxDelayMs: 15000,
             retryableErrors: isRetryableS3Error,
-        }, `S3:ListObjects:${bucketName}`);
+        }, `S3:ListObjects:${bucketName}`));
         const { Contents, IsTruncated, NextContinuationToken } = response;
         if (Contents && Contents.length > 0) {
             const deleteCommand = new clientS3.DeleteObjectsCommand({
                 Bucket: bucketName,
-                Delete: { Objects: Contents.map(({ Key }) => ({ Key: Key })) },
+                Delete: {
+                    Objects: Contents.filter((c) => c.Key).map((c) => ({ Key: c.Key })),
+                },
             });
             await withRetry(() => s3Client.send(deleteCommand), {
                 maxRetries: 3,
@@ -23009,11 +23104,11 @@ let poolConfig = DEFAULT_POOL_CONFIG;
 async function loadApolloModules() {
     if (typeof window === "undefined" || process.env.AWS_EXECUTION_ENV) {
         // Server-side (or Lambda): load the CommonJS‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.server-BTHAQqYl.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-DB3jLbBx.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-YzlpL7kf.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CyxU1hTu.js'); }));
     }
 }
 /**
@@ -79040,7 +79135,7 @@ const RETRY_CONFIG = {
     BASE_DELAY: 2000, // Increased base delay to 2 seconds
     MAX_DELAY: 64000,
     MAX_RETRIES: 5,
-    MAX_RANDOM_DELAY: 1000
+    MAX_RANDOM_DELAY: 1000,
 };
 /**
  * Determines if an error is related to Google Sheets API quotas or rate limits.
@@ -79066,10 +79161,10 @@ const RETRY_CONFIG = {
  */
 function isQuotaError(error) {
     const message = error.message.toLowerCase();
-    return message.includes('quota exceeded') ||
-        message.includes('rate limit') ||
-        message.includes('429') ||
-        message.includes('too many requests');
+    return (message.includes("quota exceeded") ||
+        message.includes("rate limit") ||
+        message.includes("429") ||
+        message.includes("too many requests"));
 }
 /**
  * Implements exponential backoff retry mechanism for Google Sheets API calls.
@@ -79128,14 +79223,14 @@ async function withExponentialBackoff(operation) {
             const exponentialDelay = Math.min(Math.pow(2, retries) * RETRY_CONFIG.BASE_DELAY + randomDelay, RETRY_CONFIG.MAX_DELAY);
             logIfDebug(`Quota/Rate limit exceeded. Error: ${error.message}`);
             logIfDebug(`Retrying in ${exponentialDelay}ms (attempt ${retries}/${RETRY_CONFIG.MAX_RETRIES})`);
-            await new Promise(resolve => setTimeout(resolve, exponentialDelay));
+            await new Promise((resolve) => setTimeout(resolve, exponentialDelay));
         }
     }
 }
 function checkEnvVars() {
     const secrets = getSecrets();
     if (!secrets.googleSheets.clientEmail || !secrets.googleSheets.privateKey) {
-        throw new Error('GOOGLE_SHEETS_CLIENT_EMAIL or GOOGLE_SHEETS_PRIVATE_KEY is not defined in environment variables.');
+        throw new Error("GOOGLE_SHEETS_CLIENT_EMAIL or GOOGLE_SHEETS_PRIVATE_KEY is not defined in environment variables.");
     }
 }
 /**
@@ -79150,16 +79245,16 @@ async function getAuthClient() {
         const secrets = getSecrets();
         const credentials = {
             client_email: secrets.googleSheets.clientEmail,
-            private_key: secrets.googleSheets.privateKey?.replace(/\\n/g, '\n'),
+            private_key: secrets.googleSheets.privateKey?.replace(/\\n/g, "\n"),
         };
         const auth = new require$$0$6.GoogleAuth({
             credentials,
-            scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+            scopes: ["https://www.googleapis.com/auth/spreadsheets"],
         });
         return auth.getClient();
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         logIfDebug(`Error initializing Google Sheets auth: ${errorMessage}`);
         throw new Error(`Failed to initialize Google Sheets auth: ${errorMessage}`);
     }
@@ -79171,7 +79266,7 @@ async function getSheetsClient() {
     const auth = await getAuthClient();
     return new buildExports.sheets_v4.Sheets({
         auth,
-        timeout: GOOGLE_SHEETS_TIMEOUT_MS
+        timeout: GOOGLE_SHEETS_TIMEOUT_MS,
     });
 }
 /**
@@ -79204,7 +79299,7 @@ function escapeSheetName(sheetName) {
  * @param startColumn Optional starting column (defaults to 'A')
  * @returns Promise resolving to response with success status and row details
  */
-async function addRow(config, values, startColumn = 'A') {
+async function addRow(config, values, startColumn = "A") {
     try {
         const sheets = await getSheetsClient();
         const escapedSheetName = escapeSheetName(config.sheetName);
@@ -79212,7 +79307,7 @@ async function addRow(config, values, startColumn = 'A') {
         const response = await withExponentialBackoff(() => sheets.spreadsheets.values.append({
             spreadsheetId: config.spreadsheetId,
             range,
-            valueInputOption: 'USER_ENTERED',
+            valueInputOption: "USER_ENTERED",
             requestBody: {
                 values: [values],
             },
@@ -79220,9 +79315,9 @@ async function addRow(config, values, startColumn = 'A') {
         //logIfDebug(`Added row to sheet ${config.sheetName}: ${values.join(', ')}`);
         const rowNumber = response.data.updates?.updatedRange
             ? parseInt(response.data.updates.updatedRange
-                .split('!')[1]
-                .split(':')[0]
-                .replace(/[^0-9]/g, ''))
+                .split("!")[1]
+                .split(":")[0]
+                .replace(/[^0-9]/g, ""))
             : 0;
         return {
             success: true,
@@ -79233,7 +79328,7 @@ async function addRow(config, values, startColumn = 'A') {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         logIfDebug(`Error adding row to sheet: ${errorMessage}`);
         return {
             success: false,
@@ -79275,7 +79370,7 @@ async function addSheet(spreadsheetId, sheetTitle) {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         logIfDebug(`Error adding sheet: ${errorMessage}`);
         return {
             success: false,
@@ -79299,7 +79394,7 @@ async function writeCell(config, cell, value) {
         await withExponentialBackoff(() => sheets.spreadsheets.values.update({
             spreadsheetId: config.spreadsheetId,
             range,
-            valueInputOption: 'USER_ENTERED',
+            valueInputOption: "USER_ENTERED",
             requestBody: {
                 values: [[value]],
             },
@@ -79313,7 +79408,7 @@ async function writeCell(config, cell, value) {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         logIfDebug(`Error writing to cell: ${errorMessage}`);
         return {
             success: false,
@@ -79337,8 +79432,11 @@ async function getCell(config, cell) {
             spreadsheetId: config.spreadsheetId,
             range,
         }));
-        const value = response.data.values?.[0]?.[0];
-        logIfDebug(`Read value from cell ${range}: ${value}`);
+        const rawValue = response.data.values?.[0]?.[0];
+        const value = rawValue === undefined || rawValue === null
+            ? null
+            : rawValue;
+        logIfDebug(`Read value from cell ${range}: ${String(value)}`);
         return {
             success: true,
             data: {
@@ -79347,7 +79445,7 @@ async function getCell(config, cell) {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         logIfDebug(`Error reading from cell: ${errorMessage}`);
         return {
             success: false,
@@ -79380,10 +79478,11 @@ function convertA1ToRowCol(a1Notation) {
  * @returns Padded array of arrays
  */
 function padArrays(arrays) {
-    const maxLength = Math.max(...arrays.map(arr => arr.length));
-    return arrays.map(arr => {
+    const maxLength = Math.max(...arrays.map((arr) => arr.length));
+    return arrays.map((arr) => {
         if (arr.length < maxLength) {
-            return [...arr, ...Array(maxLength - arr.length).fill('')];
+            const padding = Array(maxLength - arr.length).fill("");
+            return [...arr, ...padding];
         }
         return arr;
     });
@@ -79395,10 +79494,10 @@ function padArrays(arrays) {
  * @param startCell Optional starting cell in A1 notation (defaults to 'A1')
  * @returns Promise resolving to response with success status and update details
  */
-async function writeArray(config, data, startCell = 'A1') {
+async function writeArray(config, data, startCell = "A1") {
     try {
         if (!data.length) {
-            throw new Error('Data array is empty');
+            throw new Error("Data array is empty");
         }
         const sheets = await getSheetsClient();
         const { row: startRow, column: startCol } = convertA1ToRowCol(startCell);
@@ -79414,7 +79513,7 @@ async function writeArray(config, data, startCell = 'A1') {
         const response = await withExponentialBackoff(() => sheets.spreadsheets.values.update({
             spreadsheetId: config.spreadsheetId,
             range,
-            valueInputOption: 'USER_ENTERED',
+            valueInputOption: "USER_ENTERED",
             requestBody: {
                 values: paddedData,
             },
@@ -79430,7 +79529,7 @@ async function writeArray(config, data, startCell = 'A1') {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         logIfDebug(`Error writing array to sheet: ${errorMessage}`);
         return {
             success: false,
@@ -81724,4 +81823,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-DfuMX-MS.js.map
+//# sourceMappingURL=index-KzQOh2uu.js.map