@adaptic/lumic-utils 1.0.17 → 1.0.19

package/dist/{index-Y9dzs7p_.js → index-Dr85zRZC.js}

@@ -2106,15 +2106,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;
 };
@@ -2310,12 +2328,52 @@ 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;
+    }
     const response = {
         id: completion.id,
         content: completion.choices[0]?.message?.content || '',
@@ -7921,7 +7979,35 @@ function translateContextToAnthropic(context) {
             continue;
         }
     }
-    return { messages, systemText: systemParts.join('\n\n') };
+    // Anthropic requires alternating user/assistant roles — merge consecutive
+    // same-role messages into a single message with combined content blocks.
+    const merged = [];
+    for (const msg of messages) {
+        const prev = merged[merged.length - 1];
+        if (prev && prev.role === msg.role) {
+            // Merge into the previous message by combining content blocks
+            const prevBlocks = toContentBlocks(prev.content);
+            const curBlocks = toContentBlocks(msg.content);
+            prev.content = [...prevBlocks, ...curBlocks];
+        }
+        else {
+            // Ensure content is in block form for consistency (string → TextBlock)
+            merged.push({ role: msg.role, content: toContentBlocks(msg.content) });
+        }
+    }
+    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') {
+        const textBlock = {
+            type: 'text',
+            text: content,
+            citations: null,
+        };
+        return [textBlock];
+    }
+    return content;
 }
 /**
  * Makes a call to the Anthropic Messages API.
@@ -22710,11 +22796,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-CS3TcmzK.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-HwHIFnVk.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-NpMY129A.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-guxMwplM.js'); }));
     }
 }
 /**
@@ -81425,4 +81511,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-Y9dzs7p_.js.map
+//# sourceMappingURL=index-Dr85zRZC.js.map