@adaptic/lumic-utils 1.0.24 → 1.0.26

package/dist/{index-EMQ1uJMh.js → index-z7Y1nTVX.js}

@@ -551,19 +551,10 @@ function getModelProvider(model) {
     return SUPPORTED_MODELS[model].provider;
 }
 /**
- * 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.
+ * Default model tiers per provider for use with LLM_MODEL_MINI/NORMAL/ADVANCED env vars
  */
 const PROVIDER_DEFAULT_MODELS = {
-    openai: { mini: 'gpt-5.4-nano', normal: 'gpt-5.4-mini', advanced: 'gpt-5.4' },
+    openai: { mini: 'gpt-5.4-nano', normal: 'gpt-5.4-mini', advanced: 'gpt-5.5' },
     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' },
@@ -1517,13 +1508,11 @@ 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)' },
     });
 }
 /**
@@ -1541,7 +1530,9 @@ 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;
@@ -1554,18 +1545,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)) {
@@ -1579,32 +1570,23 @@ 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
@@ -1628,9 +1610,7 @@ 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
@@ -1641,15 +1621,24 @@ 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}`);
             }
         }
-        // Multiple JSON parsing strategies
-        // Default pipeline: direct parse -> extract from brackets -> remove leading/trailing text -> fixBrokenJson (string manipulation) -> FAIL
+        // Whether the cleaned content structurally resembles JSON. Used to gate the
+        // lenient fixBrokenJson strategy, which will otherwise coerce arbitrary
+        // prose into a bogus object/array.
+        const inputResemblesJson = cleanedContent.startsWith('{') || cleanedContent.startsWith('[');
+        // Multiple JSON parsing strategies.
+        // Default pipeline: direct parse -> extract from brackets -> remove
+        // leading/trailing text -> GATED fixBrokenJson -> FAIL. fixBrokenJson is
+        // deliberately gated (Strategy 4): its output is accepted only when the
+        // input looked like JSON AND the repaired value round-trips through
+        // JSON.stringify/JSON.parse, so a "successful" repair of non-JSON text is
+        // rejected instead of silently returned as garbage.
         const jsonParsingStrategies = [
             // Strategy 1: Direct parsing
             () => {
@@ -1675,7 +1664,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);
                 }
@@ -1683,55 +1672,175 @@ async function parseResponse(content, responseFormat, options = {}) {
                     return null;
                 }
             },
-            // Strategy 4: Use fixBrokenJson (string manipulation only, no AI)
+            // Strategy 4: Gated fixBrokenJson (string manipulation only, no AI)
             () => {
-                return fixBrokenJson(cleanedContent);
+                if (!inputResemblesJson) {
+                    return null;
+                }
+                const fixed = fixBrokenJson(cleanedContent);
+                if (fixed === null) {
+                    return null;
+                }
+                try {
+                    // Round-trip guard: ensures the repaired value is genuinely
+                    // JSON-serializable before we trust it.
+                    return JSON.parse(JSON.stringify(fixed));
+                }
+                catch {
+                    return null;
+                }
             },
         ];
         // Try each parsing strategy
         for (const strategy of jsonParsingStrategies) {
-            const result = await strategy();
+            const result = strategy();
             if (result !== null) {
-                return result;
+                return finalizeJsonResult(result, responseFormat);
             }
         }
         // 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.');
+            let aiFixedJson = null;
             try {
-                const aiFixedJson = await fixJsonWithAI(cleanedContent);
-                if (aiFixedJson !== null) {
-                    // Validate the AI-fixed JSON by attempting to stringify and re-parse it
-                    // This ensures it's actually valid JSON and not just something that passed fixJsonWithAI
-                    try {
-                        const validated = JSON.parse(JSON.stringify(aiFixedJson));
-                        return validated;
-                    }
-                    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...");
-                        return parseResponse(JSON.stringify(aiFixedJson), responseFormat, {
-                            ...options,
-                            _recursionDepth: recursionDepth + 1,
-                        });
-                    }
-                }
+                aiFixedJson = await fixJsonWithAI(cleanedContent);
             }
             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
+                // Fall through to the final error below.
+            }
+            if (aiFixedJson !== null) {
+                let validated;
+                try {
+                    // Validate the AI-fixed JSON by attempting to stringify and re-parse
+                    // it. This ensures it is actually valid JSON, not just something that
+                    // passed fixJsonWithAI.
+                    validated = JSON.parse(JSON.stringify(aiFixedJson));
+                }
+                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...');
+                    return parseResponse(JSON.stringify(aiFixedJson), responseFormat, {
+                        ...options,
+                        _recursionDepth: recursionDepth + 1,
+                    });
+                }
+                // Schema validation (json_schema format) happens here, OUTSIDE the
+                // JSON.parse try/catch, so a schema mismatch propagates as a thrown
+                // JsonParseError rather than being mistaken for invalid JSON.
+                return finalizeJsonResult(validated, responseFormat);
             }
         }
         // 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;
     }
 }
+/**
+ * Reports the JSON type of a runtime value for schema-validation diagnostics.
+ *
+ * @param value The value whose JSON type should be described.
+ * @returns One of `'null' | 'array' | 'object' | 'string' | 'number' | 'boolean' | 'undefined'`.
+ */
+function jsonTypeOf(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Extracts a declared primitive `type` string from a property schema, if present.
+ *
+ * @param propertySchema The (untyped) per-property JSON-Schema fragment.
+ * @returns The declared type string, or null when none is declared.
+ */
+function extractSchemaType(propertySchema) {
+    if (typeof propertySchema === 'object' && propertySchema !== null && 'type' in propertySchema) {
+        const declared = propertySchema.type;
+        return typeof declared === 'string' ? declared : null;
+    }
+    return null;
+}
+/**
+ * Checks whether a runtime value satisfies a declared JSON-Schema primitive
+ * type. Unknown/unsupported type keywords are treated permissively (they never
+ * cause a rejection), so this validator only ever rejects clear mismatches.
+ *
+ * @param value The runtime value to check.
+ * @param expectedType The declared JSON-Schema type keyword.
+ * @returns True when the value matches (or the keyword is unsupported).
+ */
+function valueMatchesJsonType(value, expectedType) {
+    switch (expectedType) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        case 'null':
+            return value === null;
+        default:
+            return true;
+    }
+}
+/**
+ * Validates a parsed value against a `json_schema` object schema. Enforces that
+ * the value is a plain object, that every `required` property is present, and
+ * that present properties whose schema declares a primitive `type` match it.
+ *
+ * @param value The parsed value to validate.
+ * @param schema The object schema supplied on the response format.
+ * @throws {JsonParseError} When the value violates the schema.
+ */
+function validateJsonSchema(value, schema) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new JsonParseError(`JSON schema validation failed: expected an object but received ${jsonTypeOf(value)}.`);
+    }
+    const record = value;
+    const missing = (schema.required ?? []).filter((key) => !(key in record));
+    if (missing.length > 0) {
+        throw new JsonParseError(`JSON schema validation failed: missing required properties: ${missing.join(', ')}.`);
+    }
+    for (const [key, propertySchema] of Object.entries(schema.properties)) {
+        if (!(key in record))
+            continue;
+        const expectedType = extractSchemaType(propertySchema);
+        if (expectedType !== null && !valueMatchesJsonType(record[key], expectedType)) {
+            throw new JsonParseError(`JSON schema validation failed: property "${key}" expected type "${expectedType}" but received ${jsonTypeOf(record[key])}.`);
+        }
+    }
+}
+/**
+ * Finalizes a successfully-parsed JSON value. When the caller supplied a
+ * `json_schema` response format, the value is validated against that schema
+ * before being returned so schema violations surface as a thrown
+ * {@link JsonParseError} instead of flowing silently downstream. For plain
+ * `json` formats the value is returned unchanged.
+ *
+ * @param value The parsed value produced by a parsing strategy.
+ * @param responseFormat The originally requested response format.
+ * @returns The value narrowed to `T`.
+ * @throws {JsonParseError} When a supplied json_schema is not satisfied.
+ */
+function finalizeJsonResult(value, responseFormat) {
+    if (typeof responseFormat === 'object' && responseFormat?.type === 'json_schema') {
+        validateJsonSchema(value, responseFormat.schema);
+    }
+    return value;
+}
 
 /**
  * Default timeout values (in milliseconds) for external service calls.
@@ -2003,11 +2112,19 @@ const DEFAULT_RETRY_CONFIG = {
  * @throws The last error encountered if all retry attempts fail or if a non-retryable error occurs
  */
 async function withRetry(fn, config = {}, label = 'unknown') {
-    const { maxRetries, baseDelayMs, maxDelayMs, retryableErrors, circuitBreaker } = {
+    const { maxRetries, baseDelayMs, maxDelayMs, retryableErrors, circuitBreaker, signal } = {
         ...DEFAULT_RETRY_CONFIG,
         ...config,
     };
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        // Short-circuit on cancellation BEFORE starting a fresh attempt so
+        // the caller does not pay the cost of issuing a request whose result
+        // they have already discarded.
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error
+                ? signal.reason
+                : new Error('Aborted');
+        }
         try {
             // If a circuit breaker is provided, execute through it
             const result = circuitBreaker
@@ -2020,6 +2137,13 @@ async function withRetry(fn, config = {}, label = 'unknown') {
             if (error instanceof CircuitBreakerOpenError) {
                 throw error;
             }
+            // Do not retry on cooperative cancellation — the caller has
+            // explicitly asked us to stop.
+            if (signal?.aborted) {
+                throw signal.reason instanceof Error
+                    ? signal.reason
+                    : new Error('Aborted');
+            }
             // Don't retry if we've exhausted all attempts
             if (attempt === maxRetries) {
                 throw error;
@@ -2033,7 +2157,26 @@ async function withRetry(fn, config = {}, label = 'unknown') {
             const jitter = Math.random() * 1000;
             const delay = Math.min(exponentialDelay + jitter, maxDelayMs);
             getLumicLogger().warn(`[${label}] Attempt ${attempt + 1} failed, retrying in ${Math.round(delay)}ms`);
-            await new Promise((resolve) => setTimeout(resolve, delay));
+            // Sleep but bail early if signal aborts mid-backoff.
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    if (signal)
+                        signal.removeEventListener('abort', onAbort);
+                    resolve();
+                }, delay);
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(signal?.reason instanceof Error ? signal.reason : new Error('Aborted'));
+                };
+                if (signal) {
+                    if (signal.aborted) {
+                        clearTimeout(timer);
+                        reject(signal.reason instanceof Error ? signal.reason : new Error('Aborted'));
+                        return;
+                    }
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+            });
         }
     }
     // This should never be reached, but TypeScript needs it for type safety
@@ -2320,15 +2463,13 @@ 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;
         }
     }
@@ -2397,26 +2538,23 @@ 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',
             },
         };
     }
@@ -2475,7 +2613,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,
@@ -2485,7 +2623,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,
         });
     }
@@ -2494,15 +2632,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,
         });
     }
@@ -2516,8 +2654,7 @@ 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
@@ -2527,16 +2664,25 @@ 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;
     try {
-        completion = await withRetry(() => openai.chat.completions.create(queryOptions), {
+        completion = await withRetry(
+        // Pass the AbortSignal into the OpenAI SDK request-options object.
+        // The OpenAI SDK honours `signal` to cancel the in-flight fetch
+        // immediately when it fires — this is what makes caller-driven
+        // cancel-and-restart (e.g. signal-monitoring's materiality
+        // re-trigger path in the engine) actually release the HTTP
+        // connection and response-body buffer rather than just discarding
+        // the resolved value at the engine boundary.
+        () => openai.chat.completions.create(queryOptions, options.signal ? { signal: options.signal } : undefined), {
             maxRetries: 3,
             baseDelayMs: 2000,
             maxDelayMs: 30000,
             retryableErrors: isRetryableLLMError,
+            signal: options.signal,
         }, `OpenAI:${normalizedModel}`);
     }
     catch (error) {
@@ -2548,19 +2694,15 @@ 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);
@@ -2587,7 +2729,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,
@@ -2597,7 +2739,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;
@@ -2610,7 +2752,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,
@@ -2619,7 +2761,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 = {
@@ -2635,10 +2777,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,
         };
@@ -2646,7 +2788,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,
@@ -2654,10 +2796,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,
     };
@@ -2692,44 +2834,45 @@ 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,
         timeout: options.timeout ?? LLM_TIMEOUT_MS,
     });
-    // Remove apiKey, model, and timeout from options before creating request body
-    const { apiKey: _, model: __, timeout: ___, ...cleanOptions } = options;
+    // Remove apiKey, model, timeout, and signal from options before creating request body
+    const { apiKey: _, model: __, timeout: ___, signal: ____, ...cleanOptions } = options;
     const requestBody = {
         model: normalizedModel,
         input,
         ...cleanOptions,
     };
     // Make the API call to the Responses endpoint
-    const response = await withRetry(() => openai.responses.create(requestBody), {
+    const response = await withRetry(() => openai.responses.create(requestBody, options.signal ? { signal: options.signal } : undefined), {
         maxRetries: 3,
         baseDelayMs: 2000,
         maxDelayMs: 30000,
         retryableErrors: isRetryableLLMError,
+        signal: options.signal,
     }, `OpenAI-Responses:${normalizedModel}`);
     // Responses API exposes cached input tokens under `input_tokens_details.cached_tokens`
     // (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
@@ -2755,34 +2898,32 @@ 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,
@@ -2790,15 +2931,13 @@ 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 } : {}),
     };
 };
 
@@ -8108,12 +8247,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;
         }
     }
@@ -8128,11 +8267,8 @@ 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: {} }),
     }));
 }
 /**
@@ -8145,31 +8281,27 @@ 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) {
@@ -8181,36 +8313,32 @@ 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;
         }
@@ -8231,13 +8359,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,
         };
@@ -8257,11 +8385,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,
@@ -8273,10 +8401,8 @@ 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 = [];
@@ -8289,7 +8415,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,
@@ -8298,37 +8424,46 @@ async function makeAnthropicCall(content, responseFormat = "text", options = {})
     };
     // Add system prompt if present
     if (systemParts.length > 0) {
-        requestParams.system = systemParts.join("\n\n");
-    }
-    // Add temperature if specified
-    if (options.temperature !== undefined) {
-        requestParams.temperature = options.temperature;
-    }
-    if (options.top_p !== undefined) {
-        requestParams.top_p = options.top_p;
-    }
+        requestParams.system = systemParts.join('\n\n');
+    }
+    // Sampling controls are intentionally disabled for the Anthropic provider.
+    //
+    // The claude-*-4.x model family rejects any request that specifies BOTH
+    // `temperature` and `top_p` ("`temperature` and `top_p` cannot both be
+    // specified for this model. Please use only one." — HTTP 400), which aborts
+    // the entire caller flow (e.g. the engine's account decision session).
+    // Callers across the org pass both knobs generically, so rather than make
+    // each one provider-aware we drop both here and let Anthropic use its model
+    // defaults. `options.temperature` / `options.top_p` are intentionally not
+    // forwarded. This is the Anthropic adapter only — the OpenAI, DeepSeek, and
+    // OpenAI-compatible adapters still honor `temperature` and `top_p`.
     // Translate and add tools if present
     if (options.tools && options.tools.length > 0) {
         requestParams.tools = translateToolsToAnthropic(options.tools);
     }
     try {
-        const response = await withRetry(() => client.messages.create(requestParams), {
+        const response = await withRetry(
+        // Pass AbortSignal into the Anthropic SDK request-options object
+        // so caller-driven cancellation interrupts the in-flight HTTP
+        // request immediately. See LLMOptions.signal JSDoc for context.
+        () => client.messages.create(requestParams, options.signal ? { signal: options.signal } : undefined), {
             maxRetries: 3,
             baseDelayMs: 2000,
             maxDelayMs: 30000,
             retryableErrors: isRetryableAnthropicError,
+            signal: options.signal,
         }, `Anthropic:${model}`);
         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),
@@ -8347,22 +8482,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,
@@ -8370,9 +8505,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),
             },
         };
     }
@@ -8394,9 +8529,7 @@ 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;
         }
     }
@@ -8410,16 +8543,14 @@ 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).
@@ -8433,12 +8564,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`);
@@ -8451,36 +8582,31 @@ 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.`,
@@ -8493,8 +8619,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) {
@@ -8518,11 +8644,16 @@ async function makeOpenAICompatibleCall(content, responseFormat = "text", option
         queryOptions.tools = options.tools;
     }
     try {
-        const completion = await withRetry(() => openai.chat.completions.create(queryOptions), {
+        const completion = await withRetry(
+        // Pass AbortSignal into the SDK request-options object so
+        // caller-driven cancellation interrupts the in-flight HTTP
+        // request immediately. See LLMOptions.signal JSDoc for context.
+        () => openai.chat.completions.create(queryOptions, options.signal ? { signal: options.signal } : undefined), {
             maxRetries: 3,
             baseDelayMs: 2000,
             maxDelayMs: 30000,
             retryableErrors: isRetryableError,
+            signal: options.signal,
         }, `${providerConfig.name}:${model}`);
         const promptTokens = completion.usage?.prompt_tokens || 0;
         const completionTokens = completion.usage?.completion_tokens || 0;
@@ -8552,7 +8683,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`);
@@ -8844,9 +8975,7 @@ 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;
         }
     }
@@ -8856,7 +8985,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
@@ -8868,7 +8997,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
@@ -8901,19 +9030,17 @@ 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
@@ -8932,26 +9059,24 @@ 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,
         });
     }
@@ -8960,35 +9085,33 @@ 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.`,
@@ -9029,7 +9152,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,
@@ -9038,7 +9161,7 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
                 cached_tokens: cachedTokens,
             },
             system_fingerprint: completion.system_fingerprint,
-            provider: "deepseek",
+            provider: 'deepseek',
             model: normalizedModel,
         };
     }
@@ -9054,8 +9177,12 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
  * @param responseFormat The format of the response. Defaults to 'json'.
  * @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.
+ * @throws {Error} If the requested capability (JSON output / tool calling) is
+ *   unsupported by the model, or if the underlying API call fails. This matches
+ *   the OpenAI and Anthropic providers, which surface failures by throwing
+ *   rather than returning a success-shaped response carrying an error payload.
  */
-const makeDeepseekCall = async (content, responseFormat = "json", options = {}) => {
+const makeDeepseekCall = async (content, responseFormat = 'json', options = {}) => {
     // Set default model if not provided
     const mergedOptions = {
         ...options,
@@ -9064,51 +9191,21 @@ const makeDeepseekCall = async (content, responseFormat = "json", options = {})
         mergedOptions.model = DEFAULT_DEEPSEEK_OPTIONS.defaultModel;
     }
     const modelName = normalizeModelName(mergedOptions.model);
-    // Check if the requested response format is compatible with the model
-    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.`,
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: "deepseek",
-                model: modelName,
-                cached_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
+    // Check if the requested response format is compatible with the model.
+    // Throw rather than returning a fake-success LLMResponse: a caller that
+    // asked for JSON must not silently receive an { error } payload typed as T.
+    if (responseFormat !== 'text' && !supportsJsonOutput(modelName)) {
+        throw new Error(`Model ${modelName} does not support JSON output format.`);
     }
-    // Check if tools are requested with a model that doesn't support them
-    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.`,
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: "deepseek",
-                model: modelName,
-                cached_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
+    // Check if tools are requested with a model that doesn't support them.
+    if (mergedOptions.tools && mergedOptions.tools.length > 0 && !supportsToolCalling(modelName)) {
+        throw new Error(`Model ${modelName} does not support tool calling.`);
     }
     try {
         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 = {
@@ -9124,10 +9221,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,
             };
@@ -9135,7 +9232,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,
@@ -9143,32 +9240,22 @@ 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,
         };
     }
     catch (error) {
-        // If there's an error due to incompatible features, return a structured error
+        // Mirror the OpenAI/Anthropic providers: log with sanitized context and
+        // rethrow so callers observe the failure. Returning a success-shaped
+        // response with an { error } payload here previously let hard failures
+        // (auth, timeout, rate-limit exhaustion, unparseable output) masquerade as
+        // successful completions downstream.
         getLumicLogger().error(`Error in Deepseek API call: ${sanitizeError(error)}`);
-        return {
-            response: {
-                error: sanitizeError(error),
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: "deepseek",
-                model: modelName,
-                cached_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
+        throw error;
     }
 };
 
@@ -9271,15 +9358,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();
@@ -9292,37 +9379,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) => {
@@ -9331,52 +9418,48 @@ const initialiseAWSClient = (ClientClass, auth = null) => {
         const requestTimeout = ClientClass === 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) {
@@ -9389,9 +9472,7 @@ const initialiseS3Client = (auth = null) => {
     const envVarsCheck = auth ? null : validateEnvironmentVars();
     const cacheKey = generateCacheKey(auth, envVarsCheck);
     if (s3ClientCache.has(cacheKey)) {
-        const cached = s3ClientCache.get(cacheKey);
-        if (cached)
-            return cached;
+        return s3ClientCache.get(cacheKey);
     }
     // Create new client and cache it
     const client = initialiseAWSClient(S3Client, auth);
@@ -9403,9 +9484,7 @@ const initialiseLambdaClient = (auth = null) => {
     const envVarsCheck = auth ? null : validateEnvironmentVars();
     const cacheKey = generateCacheKey(auth, envVarsCheck);
     if (lambdaClientCache.has(cacheKey)) {
-        const cached = lambdaClientCache.get(cacheKey);
-        if (cached)
-            return cached;
+        return lambdaClientCache.get(cacheKey);
     }
     // Create new client and cache it
     const client = initialiseAWSClient(Lambda, auth);
@@ -9905,17 +9984,15 @@ 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;
         }
     }
@@ -9929,11 +10006,10 @@ 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]$/;
@@ -9964,7 +10040,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,
@@ -9984,7 +10060,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,
@@ -10000,7 +10076,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__default.join(currentPath, file.name);
@@ -10043,33 +10119,27 @@ 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__default.join(localPath, path__default.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)
@@ -10085,9 +10155,7 @@ async function downloadFromS3Helper(s3Client, bucketName, s3Path, localPath) {
                     }
                     // Count folders
                     const relativePath = path__default.relative(localPath, path__default.dirname(localFilePath));
-                    if (relativePath &&
-                        !relativePath.startsWith("..") &&
-                        relativePath !== ".") {
+                    if (relativePath && !relativePath.startsWith('..') && relativePath !== '.') {
                         folderCount++;
                     }
                 }));
@@ -10108,7 +10176,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 = createWriteStream(localFilePath);
         await pipeline(Body, writeStream);
     }, {
@@ -10121,14 +10189,27 @@ async function downloadFile(s3Client, bucketName, s3Key, localFilePath) {
 async function unzipFile(zipPath, destPath) {
     const zip = new AdmZip(zipPath);
     try {
-        zip.extractAllToAsync(destPath, true);
-        const stats = await getDirectoryStats(destPath);
-        return stats;
+        // extractAllToAsync is fire-and-forget: it returns void and reports
+        // failures through its callback. The previous call neither awaited it nor
+        // observed the callback, so getDirectoryStats raced an in-flight (or
+        // failed) extraction and any extraction error was silently dropped. Wrap
+        // it in a Promise so the extraction is fully awaited and errors surface.
+        await new Promise((resolve, reject) => {
+            zip.extractAllToAsync(destPath, true, false, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        return await getDirectoryStats(destPath);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         getLumicLogger().error(`Error unzipping file: ${errorMessage}`);
-        throw error;
+        throw new ZipError(`Failed to extract archive "${zipPath}" to "${destPath}": ${errorMessage}`, error);
     }
 }
 async function getDirectoryStats(dirPath) {
@@ -10164,19 +10245,17 @@ 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 DeleteObjectsCommand({
                 Bucket: bucketName,
-                Delete: {
-                    Objects: Contents.filter((c) => c.Key).map((c) => ({ Key: c.Key })),
-                },
+                Delete: { Objects: Contents.map(({ Key }) => ({ Key: Key })) },
             });
             await withRetry(() => s3Client.send(deleteCommand), {
                 maxRetries: 3,
@@ -23084,11 +23163,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 import('./apollo-client.server-CbagxkmK.js'));
+        return (await import('./apollo-client.server-DaXmxoBl.js'));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await import('./apollo-client.client-9wJcufhf.js'));
+        return (await import('./apollo-client.client-Uv0-ZrFd.js'));
     }
 }
 /**
@@ -79115,7 +79194,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.
@@ -79141,10 +79220,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.
@@ -79203,14 +79282,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.');
     }
 }
 /**
@@ -79225,16 +79304,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 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}`);
     }
@@ -79246,7 +79325,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
     });
 }
 /**
@@ -79279,7 +79358,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);
@@ -79287,7 +79366,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],
             },
@@ -79295,9 +79374,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,
@@ -79308,7 +79387,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,
@@ -79350,7 +79429,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,
@@ -79374,7 +79453,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]],
             },
@@ -79388,7 +79467,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,
@@ -79412,11 +79491,8 @@ async function getCell(config, cell) {
             spreadsheetId: config.spreadsheetId,
             range,
         }));
-        const rawValue = response.data.values?.[0]?.[0];
-        const value = rawValue === undefined || rawValue === null
-            ? null
-            : rawValue;
-        logIfDebug(`Read value from cell ${range}: ${String(value)}`);
+        const value = response.data.values?.[0]?.[0];
+        logIfDebug(`Read value from cell ${range}: ${value}`);
         return {
             success: true,
             data: {
@@ -79425,7 +79501,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,
@@ -79458,11 +79534,10 @@ 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) {
-            const padding = Array(maxLength - arr.length).fill("");
-            return [...arr, ...padding];
+            return [...arr, ...Array(maxLength - arr.length).fill('')];
         }
         return arr;
     });
@@ -79474,10 +79549,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);
@@ -79493,7 +79568,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,
             },
@@ -79509,7 +79584,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,
@@ -81616,4 +81691,4 @@ const lumic = {
 };
 
 export { GraphQLInterfaceType as $, print as A, getNamedType as B, isInputType as C, isRequiredArgument as D, isNamedType as E, GraphQLError as F, GraphQLNonNull as G, isOutputType as H, isRequiredInputField as I, isCompositeType as J, Kind as K, getNullableType as L, getEnterLeaveForKind as M, isNode as N, OperationTypeNode as O, didYouMean as P, naturalCompare as Q, suggestionList as R, specifiedScalarTypes as S, keyMap as T, isType as U, isNullableType as V, visit as W, visitInParallel as X, keyValMap as Y, assertObjectType as Z, GraphQLScalarType as _, isListType as a, validateGoogleSheetsRange as a$, GraphQLUnionType as a0, GraphQLInputObjectType as a1, assertNullableType as a2, assertInterfaceType as a3, mapValue as a4, isSpecifiedScalarType as a5, isPrintableAsBlockString as a6, printBlockString as a7, BREAK as a8, GRAPHQL_MAX_INT as a9, printSourceLocation as aA, resolveObjMapThunk as aB, resolveReadonlyArrayThunk as aC, valueFromASTUntyped as aD, version$4 as aE, versionInfo as aF, getAugmentedNamespace as aG, isDigit$1 as aH, isNameStart as aI, dedentBlockStringLines as aJ, isNameContinue as aK, setLumicLogger as aL, getLumicLogger as aM, sanitizeForLog as aN, sanitizeError as aO, sanitizeAWSAuth as aP, sanitizeObject as aQ, getSecrets as aR, resetSecrets as aS, requireSecret as aT, withRetry as aU, CircuitBreaker as aV, CircuitBreakerState as aW, CircuitBreakerOpenError as aX, DEFAULT_CIRCUIT_BREAKER_CONFIG as aY, validateSlackChannel as aZ, validateS3Key as a_, GRAPHQL_MIN_INT as aa, GraphQLFloat as ab, GraphQLInt as ac, Location as ad, Token as ae, assertAbstractType as af, assertCompositeType as ag, assertEnumType as ah, assertEnumValueName as ai, assertInputObjectType as aj, assertInputType as ak, assertLeafType as al, assertListType as am, assertNamedType as an, assertNonNullType as ao, assertOutputType as ap, assertScalarType as aq, assertType as ar, assertUnionType as as, assertWrappingType as at, formatError as au, getLocation as av, getVisitFn as aw, isWrappingType as ax, printError as ay, printLocation as az, isAbstractType as b, PDFError as b$, LLMCostTracker as b0, getLLMCostTracker as b1, setLLMCostTracker as b2, resetLLMCostTracker as b3, setMetricsCollector as b4, getMetricsCollector as b5, resetMetricsCollector as b6, withMetrics as b7, generateCorrelationId as b8, getCorrelationId as b9, openAIChatCompletionSchema as bA, openAIImageResponseSchema as bB, validateOpenAIChatCompletion as bC, safeValidateOpenAIChatCompletion as bD, perplexityResponseSchema as bE, validatePerplexityResponse as bF, safeValidatePerplexityResponse as bG, googleSheetsValueRangeSchema as bH, validateGoogleSheetsResponse as bI, safeValidateGoogleSheetsResponse as bJ, s3ListObjectsSchema as bK, s3GetObjectSchema as bL, lambdaInvokeResponseSchema as bM, validateS3ListObjects as bN, safeValidateS3ListObjects as bO, validateLambdaResponse as bP, safeValidateLambdaResponse as bQ, createValidator as bR, createSafeValidator as bS, LumicError as bT, SlackError as bU, LLMError as bV, AWSLambdaError as bW, AWSS3Error as bX, GoogleSheetsError as bY, PerplexityError as bZ, JsonParseError as b_, getCorrelationContext as ba, withCorrelationId as bb, getCorrelationHeaders as bc, TokenBucketRateLimiter as bd, RATE_LIMIT_PROFILES as be, getRateLimiter as bf, resetAllRateLimiters as bg, withRateLimit as bh, checkIntegrationHealth as bi, SUPPORTED_MODELS as bj, isValidModel as bk, getModelCapabilities as bl, getModelProvider as bm, MODEL_ALIASES as bn, OPENAI_COMPATIBLE_PROVIDERS as bo, PROVIDER_DEFAULT_MODELS as bp, LLM_DEFAULT_PROVIDER as bq, LLM_MINI_PROVIDER as br, LLM_NORMAL_PROVIDER as bs, LLM_ADVANCED_PROVIDER as bt, LLM_PROVIDER as bu, LLM_MODEL_MINI as bv, LLM_MODEL_NORMAL as bw, LLM_MODEL_ADVANCED as bx, makeAnthropicCall as by, makeOpenAICompatibleCall as bz, isInterfaceType as c, ZipError as c0, SLACK_TIMEOUT_MS as c1, PERPLEXITY_TIMEOUT_MS as c2, GOOGLE_SHEETS_TIMEOUT_MS as c3, LLM_TIMEOUT_MS as c4, AWS_LAMBDA_TIMEOUT_MS as c5, AWS_S3_TIMEOUT_MS as c6, OPENWEATHER_TIMEOUT_MS as c7, GENERIC_FETCH_TIMEOUT_MS as c8, isObjectType as d, assertName as e, devAssert as f, isObjectLike as g, defineArguments as h, isNonNullType as i, argsToArgsConfig as j, GraphQLBoolean as k, lumic as l, GraphQLString as m, instanceOf as n, inspect as o, isInputObjectType as p, isLeafType as q, isEnumType as r, GraphQLID as s, toObjMap as t, invariant as u, GraphQLObjectType as v, GraphQLEnumType as w, GraphQLList as x, isScalarType as y, isUnionType as z };
-//# sourceMappingURL=index-EMQ1uJMh.js.map
+//# sourceMappingURL=index-z7Y1nTVX.js.map