@adaptic/lumic-utils 1.0.18 → 1.0.20

package/dist/{index-UQOI_SLD.js → index-CSOg0U0R.js}

@@ -2086,15 +2086,33 @@ function resetLLMCostTracker() {
 // llm-openai.ts
 /**
  * Determines if an LLM error should be retried.
- * Only retries on rate limit errors (429).
+ *
+ * Retries on:
+ * - 429 / rate limit errors (transient capacity)
+ * - "could not parse the JSON body" 400s — observed once in production for a
+ *   single symbol on the very first conversation turn (Wave 86, 2026-04-11).
+ *   The exact same call site succeeds millions of times before and after, and
+ *   the prior fix commit `6eaef52` in this repo already eliminated the only
+ *   known SDK-v5 cause (passing `tools: undefined/null`). The remaining cases
+ *   are virtually always proxy/network corruption of the request body in
+ *   flight (request truncated mid-flight, TLS renegotiation, edge proxy
+ *   buffer reset). Retrying once with a fresh connection has a high
+ *   probability of recovering, and a deterministic SDK-side defect would
+ *   re-fail on retry (so we still surface it).
  */
 const isRetryableLLMError = (error) => {
     if (error instanceof Error) {
         const message = error.message;
-        // Retry only on rate limits (429)
+        // Retry on rate limits (429)
         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')) {
+            return true;
+        }
     }
     return false;
 };
@@ -2290,20 +2308,66 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     if (responseFormatOption.type !== 'text') {
         queryOptions.response_format = responseFormatOption;
     }
-    const completion = await withRetry(() => openai.chat.completions.create(queryOptions), {
-        maxRetries: 3,
-        baseDelayMs: 2000,
-        maxDelayMs: 30000,
-        retryableErrors: isRetryableLLMError,
-    }, `OpenAI:${normalizedModel}`);
+    let completion;
+    try {
+        completion = await withRetry(() => openai.chat.completions.create(queryOptions), {
+            maxRetries: 3,
+            baseDelayMs: 2000,
+            maxDelayMs: 30000,
+            retryableErrors: isRetryableLLMError,
+        }, `OpenAI:${normalizedModel}`);
+    }
+    catch (error) {
+        // Defensive observability: when the OpenAI SDK rejects our request,
+        // emit a structured snapshot of the queryOptions shape (NOT content) so
+        // a future recurrence of the rare "could not parse JSON body" 400 can be
+        // diagnosed without having to reproduce locally. We deliberately log
+        // metadata only — no message content, no API key — so this is safe even
+        // 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')
+                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;
+        }, 0);
+        getLumicLogger().error(`OpenAI ChatCompletion call failed for model ${normalizedModel}`, {
+            model: normalizedModel,
+            errorMessage,
+            messageCount: messages.length,
+            roleBreakdown: messages.reduce((acc, msg) => {
+                acc[msg.role] = (acc[msg.role] ?? 0) + 1;
+                return acc;
+            }, {}),
+            totalContentChars,
+            toolCount: queryOptions.tools?.length ?? 0,
+            hasTemperature: queryOptions.temperature !== undefined,
+            hasResponseFormat: queryOptions.response_format !== undefined,
+            hasMaxCompletionTokens: queryOptions.max_completion_tokens !== undefined,
+        });
+        throw error;
+    }
+    // OpenAI returns cached input tokens under `prompt_tokens_details.cached_tokens`
+    // when prompts >1024 tokens hit the automatic prompt cache. We surface this
+    // as a first-class field so cost tracking and dashboards reflect the real
+    // (discounted) input cost rather than billing every input token at full rate.
+    const cachedTokens = completion.usage?.prompt_tokens_details?.cached_tokens ?? 0;
     const response = {
         id: completion.id,
         content: completion.choices[0]?.message?.content || '',
         tool_calls: completion.choices[0]?.message?.tool_calls,
-        usage: completion.usage || {
-            prompt_tokens: 0,
-            completion_tokens: 0,
-            total_tokens: 0,
+        usage: {
+            prompt_tokens: completion.usage?.prompt_tokens ?? 0,
+            completion_tokens: completion.usage?.completion_tokens ?? 0,
+            total_tokens: completion.usage?.total_tokens ?? 0,
+            cached_tokens: cachedTokens,
         },
         system_fingerprint: completion.system_fingerprint,
         service_tier: options.service_tier,
@@ -2326,8 +2390,10 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
         ...options,
     };
     const completion = await createCompletion(content, responseFormat, mergedOptions);
-    // Track cost in the global cost tracker
-    getLLMCostTracker().trackUsage('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens);
+    // 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);
     // Handle tool calls differently
     if (completion.tool_calls && completion.tool_calls.length > 0) {
         const toolCallResponse = {
@@ -2345,7 +2411,8 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
                 reasoning_tokens: 0,
                 provider: 'openai',
                 model: completion.model,
-                cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0),
+                cached_tokens: 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,
         };
@@ -2363,7 +2430,8 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
             reasoning_tokens: 0,
             provider: 'openai',
             model: completion.model,
-            cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0),
+            cached_tokens: 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,
     };
@@ -2418,8 +2486,11 @@ const makeResponsesAPICall = async (input, options = {}) => {
         maxDelayMs: 30000,
         retryableErrors: isRetryableLLMError,
     }, `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);
+    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')
@@ -2460,7 +2531,8 @@ const makeResponsesAPICall = async (input, options = {}) => {
                 reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
                 provider: 'openai',
                 model: normalizedModel,
-                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0),
+                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),
             },
             tool_calls: toolCalls,
             ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
@@ -2492,7 +2564,8 @@ const makeResponsesAPICall = async (input, options = {}) => {
             reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
             provider: 'openai',
             model: normalizedModel,
-            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0),
+            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),
         },
         tool_calls: toolCalls,
         ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
@@ -7922,7 +7995,12 @@ function translateContextToAnthropic(context) {
 /** Convert string or content block array to a uniform content block array. */
 function toContentBlocks(content) {
     if (typeof content === 'string') {
-        return [{ type: 'text', text: content }];
+        const textBlock = {
+            type: 'text',
+            text: content,
+            citations: null,
+        };
+        return [textBlock];
     }
     return content;
 }
@@ -8679,14 +8757,25 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
             maxDelayMs: 30000,
             retryableErrors: isRetryableDeepseekError,
         }, `Deepseek:${normalizedModel}`);
+        // DeepSeek surfaces cached input tokens in two places on the usage object:
+        //   - `prompt_cache_hit_tokens` (DeepSeek-native field, see
+        //     https://api-docs.deepseek.com/guides/kv_cache)
+        //   - `prompt_tokens_details.cached_tokens` (OpenAI-compatible alias)
+        // Prefer the OpenAI-compatible name so a single canonical field works for
+        // both providers; fall back to the DeepSeek-native name if absent.
+        const usageRaw = completion.usage;
+        const cachedTokens = usageRaw?.prompt_tokens_details?.cached_tokens ??
+            usageRaw?.prompt_cache_hit_tokens ??
+            0;
         return {
             id: completion.id,
             content: completion.choices[0]?.message?.content || '',
             tool_calls: completion.choices[0]?.message?.tool_calls,
-            usage: completion.usage || {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0,
+            usage: {
+                prompt_tokens: completion.usage?.prompt_tokens ?? 0,
+                completion_tokens: completion.usage?.completion_tokens ?? 0,
+                total_tokens: completion.usage?.total_tokens ?? 0,
+                cached_tokens: cachedTokens,
             },
             system_fingerprint: completion.system_fingerprint,
             provider: 'deepseek',
@@ -8728,7 +8817,7 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                 reasoning_tokens: 0,
                 provider: 'deepseek',
                 model: modelName,
-                cache_hit_tokens: 0,
+                cached_tokens: 0,
                 cost: 0,
             },
             tool_calls: undefined,
@@ -8747,7 +8836,7 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                 reasoning_tokens: 0,
                 provider: 'deepseek',
                 model: modelName,
-                cache_hit_tokens: 0,
+                cached_tokens: 0,
                 cost: 0,
             },
             tool_calls: undefined,
@@ -8755,8 +8844,9 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
     }
     try {
         const completion = await createDeepseekCompletion(content, responseFormat, mergedOptions);
-        // Track cost in the global cost tracker
-        getLLMCostTracker().trackUsage('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens);
+        // 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);
         // Handle tool calls similarly to OpenAI
         if (completion.tool_calls && completion.tool_calls.length > 0) {
             const toolCallResponse = {
@@ -8774,9 +8864,8 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                     reasoning_tokens: 0, // Deepseek doesn't provide reasoning tokens separately
                     provider: 'deepseek',
                     model: completion.model,
-                    cache_hit_tokens: 0, // Not provided directly in API response
-                    cost: calculateCost('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, 0 // Cache hit tokens (not provided in the response)
-                    ),
+                    cached_tokens: 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,
             };
@@ -8794,9 +8883,8 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                 reasoning_tokens: 0, // Deepseek doesn't provide reasoning tokens separately
                 provider: 'deepseek',
                 model: completion.model,
-                cache_hit_tokens: 0, // Not provided directly in API response
-                cost: calculateCost('deepseek', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, 0 // Cache hit tokens (not provided in the response)
-                ),
+                cached_tokens: 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,
         };
@@ -8814,7 +8902,7 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
                 reasoning_tokens: 0,
                 provider: 'deepseek',
                 model: modelName,
-                cache_hit_tokens: 0,
+                cached_tokens: 0,
                 cost: 0,
             },
             tool_calls: undefined,
@@ -22713,11 +22801,11 @@ let poolConfig = DEFAULT_POOL_CONFIG;
 async function loadApolloModules() {
     if (typeof window === "undefined" || process.env.AWS_EXECUTION_ENV) {
         // Server-side (or Lambda): load the CommonJS‑based implementation.
-        return (await import('./apollo-client.server-C2gZgUkR.js'));
+        return (await import('./apollo-client.server-L8JR2ko_.js'));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await import('./apollo-client.client-kEvzgHxw.js'));
+        return (await import('./apollo-client.client-DRk6kygw.js'));
     }
 }
 /**
@@ -81241,4 +81329,4 @@ const lumic = {
 };
 
 export { GraphQLInterfaceType as $, print as A, getNamedType as B, isInputType as C, isRequiredArgument as D, isNamedType as E, GraphQLError as F, GraphQLNonNull as G, isOutputType as H, isRequiredInputField as I, isCompositeType as J, Kind as K, getNullableType as L, getEnterLeaveForKind as M, isNode as N, OperationTypeNode as O, didYouMean as P, naturalCompare as Q, suggestionList as R, specifiedScalarTypes as S, keyMap as T, isType as U, isNullableType as V, visit as W, visitInParallel as X, keyValMap as Y, assertObjectType as Z, GraphQLScalarType as _, isListType as a, validateGoogleSheetsRange as a$, GraphQLUnionType as a0, GraphQLInputObjectType as a1, assertNullableType as a2, assertInterfaceType as a3, mapValue as a4, isSpecifiedScalarType as a5, isPrintableAsBlockString as a6, printBlockString as a7, BREAK as a8, GRAPHQL_MAX_INT as a9, printSourceLocation as aA, resolveObjMapThunk as aB, resolveReadonlyArrayThunk as aC, valueFromASTUntyped as aD, version$4 as aE, versionInfo as aF, getAugmentedNamespace as aG, isDigit$1 as aH, isNameStart as aI, dedentBlockStringLines as aJ, isNameContinue as aK, setLumicLogger as aL, getLumicLogger as aM, sanitizeForLog as aN, sanitizeError as aO, sanitizeAWSAuth as aP, sanitizeObject as aQ, getSecrets as aR, resetSecrets as aS, requireSecret as aT, withRetry as aU, CircuitBreaker as aV, CircuitBreakerState as aW, CircuitBreakerOpenError as aX, DEFAULT_CIRCUIT_BREAKER_CONFIG as aY, validateSlackChannel as aZ, validateS3Key as a_, GRAPHQL_MIN_INT as aa, GraphQLFloat as ab, GraphQLInt as ac, Location as ad, Token as ae, assertAbstractType as af, assertCompositeType as ag, assertEnumType as ah, assertEnumValueName as ai, assertInputObjectType as aj, assertInputType as ak, assertLeafType as al, assertListType as am, assertNamedType as an, assertNonNullType as ao, assertOutputType as ap, assertScalarType as aq, assertType as ar, assertUnionType as as, assertWrappingType as at, formatError as au, getLocation as av, getVisitFn as aw, isWrappingType as ax, printError as ay, printLocation as az, isAbstractType as b, PDFError as b$, LLMCostTracker as b0, getLLMCostTracker as b1, setLLMCostTracker as b2, resetLLMCostTracker as b3, setMetricsCollector as b4, getMetricsCollector as b5, resetMetricsCollector as b6, withMetrics as b7, generateCorrelationId as b8, getCorrelationId as b9, openAIChatCompletionSchema as bA, openAIImageResponseSchema as bB, validateOpenAIChatCompletion as bC, safeValidateOpenAIChatCompletion as bD, perplexityResponseSchema as bE, validatePerplexityResponse as bF, safeValidatePerplexityResponse as bG, googleSheetsValueRangeSchema as bH, validateGoogleSheetsResponse as bI, safeValidateGoogleSheetsResponse as bJ, s3ListObjectsSchema as bK, s3GetObjectSchema as bL, lambdaInvokeResponseSchema as bM, validateS3ListObjects as bN, safeValidateS3ListObjects as bO, validateLambdaResponse as bP, safeValidateLambdaResponse as bQ, createValidator as bR, createSafeValidator as bS, LumicError as bT, SlackError as bU, LLMError as bV, AWSLambdaError as bW, AWSS3Error as bX, GoogleSheetsError as bY, PerplexityError as bZ, JsonParseError as b_, getCorrelationContext as ba, withCorrelationId as bb, getCorrelationHeaders as bc, TokenBucketRateLimiter as bd, RATE_LIMIT_PROFILES as be, getRateLimiter as bf, resetAllRateLimiters as bg, withRateLimit as bh, checkIntegrationHealth as bi, SUPPORTED_MODELS as bj, isValidModel as bk, getModelCapabilities as bl, getModelProvider as bm, MODEL_ALIASES as bn, OPENAI_COMPATIBLE_PROVIDERS as bo, PROVIDER_DEFAULT_MODELS as bp, LLM_DEFAULT_PROVIDER as bq, LLM_MINI_PROVIDER as br, LLM_NORMAL_PROVIDER as bs, LLM_ADVANCED_PROVIDER as bt, LLM_PROVIDER as bu, LLM_MODEL_MINI as bv, LLM_MODEL_NORMAL as bw, LLM_MODEL_ADVANCED as bx, makeAnthropicCall as by, makeOpenAICompatibleCall as bz, isInterfaceType as c, ZipError as c0, SLACK_TIMEOUT_MS as c1, PERPLEXITY_TIMEOUT_MS as c2, GOOGLE_SHEETS_TIMEOUT_MS as c3, LLM_TIMEOUT_MS as c4, AWS_LAMBDA_TIMEOUT_MS as c5, AWS_S3_TIMEOUT_MS as c6, OPENWEATHER_TIMEOUT_MS as c7, GENERIC_FETCH_TIMEOUT_MS as c8, isObjectType as d, assertName as e, devAssert as f, isObjectLike as g, defineArguments as h, isNonNullType as i, argsToArgsConfig as j, GraphQLBoolean as k, lumic as l, GraphQLString as m, instanceOf as n, inspect as o, isInputObjectType as p, isLeafType as q, isEnumType as r, GraphQLID as s, toObjMap as t, invariant as u, GraphQLObjectType as v, GraphQLEnumType as w, GraphQLList as x, isScalarType as y, isUnionType as z };
-//# sourceMappingURL=index-UQOI_SLD.js.map
+//# sourceMappingURL=index-CSOg0U0R.js.map