@adaptic/lumic-utils 1.0.24 → 1.0.26

package/dist/{index-KzQOh2uu.js → index-DgFDhFuO.js}

@@ -571,19 +571,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' },
@@ -1537,13 +1528,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)' },
     });
 }
 /**
@@ -1561,7 +1550,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;
@@ -1574,18 +1565,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)) {
@@ -1599,32 +1590,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
@@ -1648,9 +1630,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
@@ -1661,15 +1641,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
             () => {
@@ -1695,7 +1684,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);
                 }
@@ -1703,55 +1692,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.
@@ -2023,11 +2132,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
@@ -2040,6 +2157,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;
@@ -2053,7 +2177,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
@@ -2340,15 +2483,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;
         }
     }
@@ -2417,26 +2558,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',
             },
         };
     }
@@ -2495,7 +2633,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,
@@ -2505,7 +2643,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,
         });
     }
@@ -2514,15 +2652,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,
         });
     }
@@ -2536,8 +2674,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
@@ -2547,16 +2684,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) {
@@ -2568,19 +2714,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);
@@ -2607,7 +2749,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,
@@ -2617,7 +2759,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;
@@ -2630,7 +2772,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,
@@ -2639,7 +2781,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 = {
@@ -2655,10 +2797,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,
         };
@@ -2666,7 +2808,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,
@@ -2674,10 +2816,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,
     };
@@ -2712,44 +2854,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
@@ -2775,34 +2918,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,
@@ -2810,15 +2951,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 } : {}),
     };
 };
 
@@ -8128,12 +8267,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;
         }
     }
@@ -8148,11 +8287,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: {} }),
     }));
 }
 /**
@@ -8165,31 +8301,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) {
@@ -8201,36 +8333,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;
         }
@@ -8251,13 +8379,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,
         };
@@ -8277,11 +8405,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,
@@ -8293,10 +8421,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 = [];
@@ -8309,7 +8435,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,
@@ -8318,37 +8444,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),
@@ -8367,22 +8502,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,
@@ -8390,9 +8525,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),
             },
         };
     }
@@ -8414,9 +8549,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;
         }
     }
@@ -8430,16 +8563,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).
@@ -8453,12 +8584,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`);
@@ -8471,36 +8602,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.`,
@@ -8513,8 +8639,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) {
@@ -8538,11 +8664,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;
@@ -8572,7 +8703,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`);
@@ -8864,9 +8995,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;
         }
     }
@@ -8876,7 +9005,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
@@ -8888,7 +9017,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
@@ -8921,19 +9050,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
@@ -8952,26 +9079,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,
         });
     }
@@ -8980,35 +9105,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.`,
@@ -9049,7 +9172,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,
@@ -9058,7 +9181,7 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
                 cached_tokens: cachedTokens,
             },
             system_fingerprint: completion.system_fingerprint,
-            provider: "deepseek",
+            provider: 'deepseek',
             model: normalizedModel,
         };
     }
@@ -9074,8 +9197,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,
@@ -9084,51 +9211,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 = {
@@ -9144,10 +9241,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,
             };
@@ -9155,7 +9252,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,
@@ -9163,32 +9260,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;
     }
 };
 
@@ -9291,15 +9378,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();
@@ -9312,37 +9399,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) => {
@@ -9351,52 +9438,48 @@ const initialiseAWSClient = (ClientClass, auth = null) => {
         const requestTimeout = ClientClass === clientS3.S3Client ? AWS_S3_TIMEOUT_MS : AWS_LAMBDA_TIMEOUT_MS;
         // Case 1: Explicit auth provided
         if (auth) {
-            if (typeof auth !== "object" || auth === null) {
-                throw new Error("Auth parameter must be an object");
+            if (typeof auth !== 'object' || auth === null) {
+                throw new Error('Auth parameter must be an object');
             }
-            const requiredAuthFields = [
-                "AWS_ACCESS_KEY_ID",
-                "AWS_SECRET_ACCESS_KEY",
-                "AWS_REGION",
-            ];
-            const missingFields = requiredAuthFields.filter((field) => !auth[field]);
+            const requiredAuthFields = ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION'];
+            const missingFields = requiredAuthFields.filter(field => !auth[field]);
             if (missingFields.length > 0) {
-                throw new Error(`Auth object is missing required fields: ${missingFields.join(", ")}`);
+                throw new Error(`Auth object is missing required fields: ${missingFields.join(', ')}`);
             }
             return new ClientClass({
                 region: auth.AWS_REGION,
                 credentials: {
                     accessKeyId: auth.AWS_ACCESS_KEY_ID,
-                    secretAccessKey: auth.AWS_SECRET_ACCESS_KEY,
+                    secretAccessKey: auth.AWS_SECRET_ACCESS_KEY
                 },
                 requestHandler: {
-                    requestTimeout,
-                },
+                    requestTimeout
+                }
             });
         }
         // Case 2: Check environment variables
         const envVarsCheck = validateEnvironmentVars();
         if (!envVarsCheck.isValid) {
-            throw new Error("No valid AWS credentials found in environment variables");
+            throw new Error('No valid AWS credentials found in environment variables');
         }
         // Case 2a: Lambda execution environment
-        if (envVarsCheck.source === "lambda") {
+        if (envVarsCheck.source === 'lambda') {
             return new ClientClass({
                 requestHandler: {
-                    requestTimeout,
-                },
+                    requestTimeout
+                }
             }); // AWS SDK will automatically use Lambda role credentials
         }
         // Case 2b: MY_ prefixed vars or standard AWS vars
         return new ClientClass({
-            region: envVarsCheck.vars?.region ?? "",
+            region: envVarsCheck.vars.region,
             credentials: {
-                accessKeyId: envVarsCheck.vars?.accessKeyId ?? "",
-                secretAccessKey: envVarsCheck.vars?.secretAccessKey ?? "",
+                accessKeyId: envVarsCheck.vars.accessKeyId,
+                secretAccessKey: envVarsCheck.vars.secretAccessKey
             },
             requestHandler: {
-                requestTimeout,
-            },
+                requestTimeout
+            }
         });
     }
     catch (error) {
@@ -9409,9 +9492,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(clientS3.S3Client, auth);
@@ -9423,9 +9504,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(clientLambda.Lambda, auth);
@@ -9925,17 +10004,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;
         }
     }
@@ -9949,11 +10026,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]$/;
@@ -9984,7 +10060,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,
@@ -10004,7 +10080,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,
@@ -10020,7 +10096,7 @@ async function zipDirectory(sourceDir, outPath) {
     const zip = new AdmZip();
     let fileCount = 0;
     try {
-        async function addFilesToZip(currentPath, relativePath = "") {
+        async function addFilesToZip(currentPath, relativePath = '') {
             const files = await fs$1.readdir(currentPath, { withFileTypes: true });
             for (const file of files) {
                 const filePath = path$1.join(currentPath, file.name);
@@ -10063,33 +10139,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$1.join(localPath, path$1.basename(objects[0].Key));
             await downloadFile(s3Client, bucketName, objects[0].Key, zipPath);
-            const { totalFiles, totalFolders, totalSize: extractedSize, fileList: extractedFileList, } = await unzipFile(zipPath, localPath);
+            const { totalFiles, totalFolders, totalSize: extractedSize, fileList: extractedFileList } = await unzipFile(zipPath, localPath);
             await fs$1.unlink(zipPath);
-            return {
-                fileCount: totalFiles,
-                folderCount: totalFolders,
-                totalSize: extractedSize,
-                fileList: extractedFileList,
-            };
+            return { fileCount: totalFiles, folderCount: totalFolders, totalSize: extractedSize, fileList: extractedFileList };
         }
         else {
             // Non-zip files. Download files in batches.
-            for (let i = 0; i < objects.length; i += 1000) {
-                // AWS allows up to 1000 per request
+            for (let i = 0; i < objects.length; i += 1000) { // AWS allows up to 1000 per request
                 const batch = objects.slice(i, i + 1000);
                 await Promise.all(batch.map(async (obj) => {
                     if (!obj.Key)
@@ -10105,9 +10175,7 @@ async function downloadFromS3Helper(s3Client, bucketName, s3Path, localPath) {
                     }
                     // Count folders
                     const relativePath = path$1.relative(localPath, path$1.dirname(localFilePath));
-                    if (relativePath &&
-                        !relativePath.startsWith("..") &&
-                        relativePath !== ".") {
+                    if (relativePath && !relativePath.startsWith('..') && relativePath !== '.') {
                         folderCount++;
                     }
                 }));
@@ -10128,7 +10196,7 @@ async function downloadFile(s3Client, bucketName, s3Key, localFilePath) {
     await withRetry(async () => {
         const { Body } = await s3Client.send(getCommand);
         if (!Body)
-            throw new Error("No body returned from S3");
+            throw new Error('No body returned from S3');
         const writeStream = fs.createWriteStream(localFilePath);
         await promises.pipeline(Body, writeStream);
     }, {
@@ -10141,14 +10209,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) {
@@ -10184,19 +10265,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 clientS3.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,
@@ -23104,11 +23183,11 @@ let poolConfig = DEFAULT_POOL_CONFIG;
 async function loadApolloModules() {
     if (typeof window === "undefined" || process.env.AWS_EXECUTION_ENV) {
         // Server-side (or Lambda): load the CommonJS‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.server-DB3jLbBx.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-JYHXy9ib.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CyxU1hTu.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CtjgIfRT.js'); }));
     }
 }
 /**
@@ -79135,7 +79214,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.
@@ -79161,10 +79240,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.
@@ -79223,14 +79302,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.');
     }
 }
 /**
@@ -79245,16 +79324,16 @@ async function getAuthClient() {
         const secrets = getSecrets();
         const credentials = {
             client_email: secrets.googleSheets.clientEmail,
-            private_key: secrets.googleSheets.privateKey?.replace(/\\n/g, "\n"),
+            private_key: secrets.googleSheets.privateKey?.replace(/\\n/g, '\n'),
         };
         const auth = new require$$0$6.GoogleAuth({
             credentials,
-            scopes: ["https://www.googleapis.com/auth/spreadsheets"],
+            scopes: ['https://www.googleapis.com/auth/spreadsheets'],
         });
         return auth.getClient();
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
         logIfDebug(`Error initializing Google Sheets auth: ${errorMessage}`);
         throw new Error(`Failed to initialize Google Sheets auth: ${errorMessage}`);
     }
@@ -79266,7 +79345,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
     });
 }
 /**
@@ -79299,7 +79378,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);
@@ -79307,7 +79386,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],
             },
@@ -79315,9 +79394,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,
@@ -79328,7 +79407,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,
@@ -79370,7 +79449,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,
@@ -79394,7 +79473,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]],
             },
@@ -79408,7 +79487,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,
@@ -79432,11 +79511,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: {
@@ -79445,7 +79521,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,
@@ -79478,11 +79554,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;
     });
@@ -79494,10 +79569,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);
@@ -79513,7 +79588,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,
             },
@@ -79529,7 +79604,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,
@@ -81823,4 +81898,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-KzQOh2uu.js.map
+//# sourceMappingURL=index-DgFDhFuO.js.map