@adaptic/lumic-utils 1.0.23 → 1.0.25

package/dist/{index-WGzi__C5.js → index-ChygDqeG.js}

@@ -2003,11 +2003,19 @@ const DEFAULT_RETRY_CONFIG = {
  * @throws The last error encountered if all retry attempts fail or if a non-retryable error occurs
  */
 async function withRetry(fn, config = {}, label = 'unknown') {
-    const { maxRetries, baseDelayMs, maxDelayMs, retryableErrors, circuitBreaker } = {
+    const { maxRetries, baseDelayMs, maxDelayMs, retryableErrors, circuitBreaker, signal } = {
         ...DEFAULT_RETRY_CONFIG,
         ...config,
     };
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        // Short-circuit on cancellation BEFORE starting a fresh attempt so
+        // the caller does not pay the cost of issuing a request whose result
+        // they have already discarded.
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error
+                ? signal.reason
+                : new Error('Aborted');
+        }
         try {
             // If a circuit breaker is provided, execute through it
             const result = circuitBreaker
@@ -2020,6 +2028,13 @@ async function withRetry(fn, config = {}, label = 'unknown') {
             if (error instanceof CircuitBreakerOpenError) {
                 throw error;
             }
+            // Do not retry on cooperative cancellation — the caller has
+            // explicitly asked us to stop.
+            if (signal?.aborted) {
+                throw signal.reason instanceof Error
+                    ? signal.reason
+                    : new Error('Aborted');
+            }
             // Don't retry if we've exhausted all attempts
             if (attempt === maxRetries) {
                 throw error;
@@ -2033,7 +2048,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
@@ -2526,11 +2560,20 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     }
     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) {
@@ -2688,19 +2731,20 @@ const makeResponsesAPICall = async (input, options = {}) => {
         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`).
@@ -8273,23 +8317,32 @@ async function makeAnthropicCall(content, responseFormat = 'text', options = {})
     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;
-    }
+    // 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;
@@ -8482,11 +8535,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;
@@ -23017,11 +23075,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-BEGHAF48.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-Cx30LaNh.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-FeVPHV0i.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-D6jG5B1n.js'); }));
     }
 }
 /**
@@ -81732,4 +81790,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-WGzi__C5.js.map
+//# sourceMappingURL=index-ChygDqeG.js.map