@juspay/neurolink 12.14.16 → 12.14.18

package/dist/providers/amazonBedrock/client.js

@@ -264,14 +264,30 @@ export class AmazonBedrockProvider extends BaseProvider {
             provider: this.getProviderName(),
             ...(finishReason !== undefined && { finishReason }),
             ...(rawFinishReason !== undefined && { rawFinishReason }),
-            toolsUsed: toolExecutions.map((execution) => execution.name),
+            // `toolsUsed` means RAN, not "was asked for". `runAgenticLoop` records
+            // every dispatch it performed, including the ones that never reached a
+            // tool: a name the model invented (TOOL_NOT_FOUND), one the breaker had
+            // already given up on (TOOL_PERMANENTLY_FAILED), and one that threw.
+            // Exactly those carry `error`; a call that reached the tool and got a
+            // value back does not. That is the same line `nativeGenerateLoop` draws
+            // — its `toolsUsed.push(name)` sits inside the try, after the guarded
+            // call returns — so filtering here makes Bedrock's generate path report
+            // what every other generate path reports, instead of inflating
+            // analytics, cost attribution and audit with calls that never ran.
+            //
+            // `toolCalls` and `toolExecutions` stay complete on purpose: they are
+            // the record of what the turn ATTEMPTED, and a failed attempt is
+            // precisely what a caller debugging a turn needs to see.
+            toolsUsed: toolExecutions
+                .filter((execution) => execution.error === undefined)
+                .map((execution) => execution.name),
             toolCalls: toolExecutions.map((execution) => ({
                 toolCallId: execution.id,
                 toolName: execution.name,
                 args: execution.input,
             })),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutions)),
-            enhancedWithTools: toolExecutions.length > 0,
+            enhancedWithTools: toolExecutions.some((execution) => execution.error === undefined),
         };
     }
     async conversationLoop(options) {
@@ -983,7 +999,15 @@ export class AmazonBedrockProvider extends BaseProvider {
                 // alone left every streamed Bedrock turn reporting no tool calls,
                 // however many it made.
                 toolExecutions: outcome.result?.toolExecutions ?? [],
-                toolsUsed: (outcome.result?.toolExecutions ?? []).map((execution) => execution.name),
+                // Same "ran, not asked for" rule as the generate path above.
+                // `toolCallCount` still derives from the unfiltered
+                // `toolExecutions`, which is correct — a dispatch that failed was
+                // still a call — so this list is a fallback today rather than an
+                // observable surface. It is filtered anyway so that the moment
+                // anything does surface it, it is not surfacing the same lie.
+                toolsUsed: (outcome.result?.toolExecutions ?? [])
+                    .filter((execution) => execution.error === undefined)
+                    .map((execution) => execution.name),
             }, Date.now() - startTime, {
                 requestId: `bedrock-stream-${Date.now()}`,
                 streamingMode: true,

package/dist/proxy/codexFallback.js

@@ -25,17 +25,40 @@ function asNonEmptyString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 function buildSystemInstructions(body) {
+    const instructions = [];
     if (typeof body.system === "string") {
-        return body.system || undefined;
+        if (body.system) {
+            instructions.push(body.system);
+        }
     }
-    if (Array.isArray(body.system)) {
+    else if (Array.isArray(body.system)) {
         const text = body.system
             .map((block) => (typeof block.text === "string" ? block.text : ""))
             .filter(Boolean)
             .join("\n\n");
-        return text || undefined;
+        if (text) {
+            instructions.push(text);
+        }
     }
-    return undefined;
+    for (const message of body.messages) {
+        // Claude's public Messages type restricts message roles to user/assistant,
+        // but Claude Code can emit an inline system message for context-management
+        // edits. Preserve its text as instructions instead of sending a non-leading
+        // system item to the Codex conversation input.
+        if (message.role !== "system") {
+            continue;
+        }
+        const text = typeof message.content === "string"
+            ? message.content
+            : message.content
+                .map((block) => (block.type === "text" ? block.text : ""))
+                .filter(Boolean)
+                .join("\n");
+        if (text) {
+            instructions.push(text);
+        }
+    }
+    return instructions.length > 0 ? instructions.join("\n\n") : undefined;
 }
 function imageUrlForBlock(block) {
     if (block.source.type === "url" && block.source.url) {
@@ -126,14 +149,26 @@ function convertClaudeMessage(role, content) {
             });
             continue;
         }
-        messageContent.push(toCodexContentPart(block, role));
+        // Claude Code context-management messages can contain `tool_addition`
+        // blocks. The live tool definitions are already carried by `body.tools`;
+        // these history markers must not become undefined array entries because
+        // JSON encodes array undefined values as null and Codex rejects them.
+        if (block.type === "tool_addition") {
+            continue;
+        }
+        const contentPart = toCodexContentPart(block, role);
+        if (contentPart) {
+            messageContent.push(contentPart);
+        }
     }
     flushMessage();
     return input;
 }
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
 export function convertClaudeRequestToCodex(body, model, reasoningEffort) {
-    const input = body.messages.flatMap((message) => convertClaudeMessage(message.role, message.content));
+    const input = body.messages.flatMap((message) => message.role === "system"
+        ? []
+        : convertClaudeMessage(message.role, message.content));
     const request = {
         model,
         input,

package/dist/types/config.d.ts

@@ -510,11 +510,16 @@ export type CreateThinkingConfigOptions = {
  * Native SDK thinkingConfig structure for Gemini native SDK.
  *
  * `thinkingLevel` and `thinkingBudget` are mutually exclusive on the wire:
- * Gemini 3 models accept `thinkingLevel`; Gemini 2.5 (and earlier) models
- * reject it outright with INVALID_ARGUMENT "thinking_level not supported by
- * this model" and require the numeric `thinkingBudget` instead. Both fields
- * are optional here so a single type can represent either shape — callers
- * building the request pick whichever field the target model accepts.
+ * Gemini 3 models accept `thinkingLevel`; Gemini 2.5 models reject it outright
+ * with INVALID_ARGUMENT "thinking_level not supported by this model" and
+ * require the numeric `thinkingBudget` instead. Gemini 2.5 is also the only
+ * family `createNativeThinkingConfig` emits a budget for:
+ * `getGemini25ThinkingBudgetRange` has no verified range for anything earlier,
+ * so those models get no `thinkingConfig` at all — and a one-time WARN —
+ * rather than a guessed shape that might itself 400.
+ *
+ * Both fields are optional here so a single type can represent either shape —
+ * callers building the request pick whichever field the target model accepts.
  */
 export type NativeThinkingConfig = {
     includeThoughts: boolean;