@adaptic/lumic-utils 1.0.29 → 1.0.31

package/dist/{index-CtY-7qjs.js → index-DlAW691N.js}

@@ -2688,10 +2688,11 @@ function requiresResponsesApiForTools(model) {
 }
 /**
  * OpenAI's `reasoning_effort` ladder, ordered from least to most effort. This is
- * the full 2026 ladder (developers.openai.com); NOTE there is no `'max'` level.
+ * the full 2026 ladder (developers.openai.com), including `'max'` — the OpenAI
+ * SDK v6 `Shared.ReasoningEffort` type accepts this entire set on the wire.
  * Mirrors the widened {@link LLMOptions.reasoning_effort} union.
  */
-const REASONING_EFFORT_LADDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+const REASONING_EFFORT_LADDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
 /**
  * Per-model `reasoning_effort` support window for OpenAI reasoning models,
  * expressed on {@link REASONING_EFFORT_LADDER}. `min`/`max` are the lowest and
@@ -2718,27 +2719,19 @@ const MODEL_REASONING_EFFORT_SUPPORT = {
     // o1-mini is intentionally omitted — it rejects reasoning_effort outright.
 };
 /**
- * Folds a full-ladder effort level onto the nearest value the installed OpenAI
- * SDK can send ({@link SdkReasoningEffort}). Levels below `low` map to `low`,
- * levels above `high` map to `high`. Exhaustive over the ladder so the compiler
- * flags any future ladder addition. Widen this mapping when the SDK's
- * `ReasoningEffort` type gains `none`/`minimal`/`xhigh`.
+ * Identity pass-through from a full-ladder effort level to an SDK-sendable value.
+ * Under OpenAI SDK v6 the wire type ({@link SdkReasoningEffort}) spans the entire
+ * ladder, so every level is sendable as-is; the per-model
+ * {@link MODEL_REASONING_EFFORT_SUPPORT} window (applied in
+ * {@link clampReasoningEffort}) is what keeps a request within a model's range.
+ * Retained as a named seam so a future SDK narrowing has one obvious place to
+ * re-introduce folding.
  *
  * @param level A level on {@link REASONING_EFFORT_LADDER}.
- * @returns The nearest SDK-sendable effort.
+ * @returns The same level, typed as SDK-sendable.
  */
 function toSdkReasoningEffort(level) {
-    switch (level) {
-        case 'none':
-        case 'minimal':
-        case 'low':
-            return 'low';
-        case 'medium':
-            return 'medium';
-        case 'high':
-        case 'xhigh':
-            return 'high';
-    }
+    return level;
 }
 /**
  * Clamps a requested {@link LLMOptions.reasoning_effort} to a value the target
@@ -2985,7 +2978,10 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     const response = {
         id: completion.id,
         content: completion.choices[0]?.message?.content || '',
-        tool_calls: completion.choices[0]?.message?.tool_calls,
+        // OpenAI SDK v6 widened tool calls into a function/custom union; the engine
+        // only emits + parses function calls, so narrow to the function variant to
+        // preserve the byte-identical `{ id, type, function }` shape.
+        tool_calls: completion.choices[0]?.message?.tool_calls?.filter((tc) => tc.type === 'function'),
         usage: {
             prompt_tokens: completion.usage?.prompt_tokens ?? 0,
             completion_tokens: completion.usage?.completion_tokens ?? 0,
@@ -8920,7 +8916,12 @@ const isRetryableAnthropicError = (error) => {
  * Anthropic: { name, description, input_schema }
  */
 function translateToolsToAnthropic(tools) {
-    return tools.map((tool) => ({
+    // OpenAI SDK v6 widened `ChatCompletionTool` into a function/custom union.
+    // lumic-utils only supports function tools, so narrow to the function variant
+    // before reading `.function`. Custom tools (which lumic never emits) are skipped.
+    return tools
+        .filter((tool) => tool.type === 'function')
+        .map((tool) => ({
         name: tool.function.name,
         description: tool.function.description || '',
         input_schema: (tool.function.parameters || { type: 'object', properties: {} }),
@@ -9314,8 +9315,11 @@ async function makeOpenAICompatibleCall(content, responseFormat = 'text', option
         const completionTokens = completion.usage?.completion_tokens || 0;
         // Track cost
         getLLMCostTracker().trackUsage(providerConfig.name, model, promptTokens, completionTokens);
-        // Handle tool calls
-        const toolCalls = completion.choices[0]?.message?.tool_calls;
+        // Handle tool calls. OpenAI SDK v6 widened tool calls into a function/custom
+        // union; these OpenAI-compatible providers only return function calls, so
+        // narrow to the function variant to preserve the byte-identical
+        // `function.{name,arguments}` shape the engine parses.
+        const toolCalls = completion.choices[0]?.message?.tool_calls?.filter((tc) => tc.type === 'function');
         if (toolCalls && toolCalls.length > 0) {
             const toolCallResponse = {
                 tool_calls: toolCalls.map((tc) => ({
@@ -9864,7 +9868,13 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         // Handle tool calls similarly to OpenAI
         if (completion.tool_calls && completion.tool_calls.length > 0) {
             const toolCallResponse = {
-                tool_calls: completion.tool_calls.map((tc) => ({
+                // OpenAI SDK v6 widened tool calls into a function/custom union. DeepSeek
+                // (called via the OpenAI-compatible surface) only returns function calls,
+                // so narrow to the function variant to preserve the byte-identical
+                // `function.{name,arguments}` shape.
+                tool_calls: completion.tool_calls
+                    .filter((tc) => tc.type === 'function')
+                    .map((tc) => ({
                     id: tc.id,
                     name: tc.function.name,
                     arguments: JSON.parse(tc.function.arguments),
@@ -23818,11 +23828,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-DoI6FK_-.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-DMz8cEcx.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-C1dwHT2X.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CNrz3Xod.js'); }));
     }
 }
 /**
@@ -82617,4 +82627,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-CtY-7qjs.js.map
+//# sourceMappingURL=index-DlAW691N.js.map