@juspay/neurolink 9.54.9 → 9.55.1

package/dist/lib/utils/conversationMemory.js

@@ -170,6 +170,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
                         cacheWriteTokens: result.usage.cacheCreationTokens,
                     }
                     : undefined,
+                thoughtSignature: result.thoughtSignature,
             });
             logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
                 requestId,

package/dist/neurolink.js

@@ -1472,7 +1472,11 @@ Current user's request: ${currentInput}`;
                     message: "Starting Langfuse observability initialization",
                 });
                 // Initialize OpenTelemetry (sets defaults from config)
-                initializeOpenTelemetry(langfuseConfig);
+                void initializeOpenTelemetry(langfuseConfig).catch((err) => {
+                    logger.error("[NeuroLink] OpenTelemetry initialization failed", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
                 const healthStatus = getLangfuseHealthStatus();
                 const langfuseInitDurationNs = process.hrtime.bigint() - langfuseInitStartTime;
                 if (healthStatus.initialized &&
@@ -2234,7 +2238,11 @@ Current user's request: ${currentInput}`;
         try {
             const langfuseConfig = this.observabilityConfig?.langfuse;
             if (langfuseConfig?.enabled) {
-                initializeOpenTelemetry(langfuseConfig);
+                void initializeOpenTelemetry(langfuseConfig).catch((err) => {
+                    logger.error("[NeuroLink] OpenTelemetry initialization failed", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
                 logger.debug("[NeuroLink] Langfuse observability initialized via public method");
             }
             else {

package/dist/providers/googleNativeGemini3.d.ts

@@ -92,6 +92,11 @@ export declare function collectStreamChunksIncremental(stream: AsyncIterable<{
     functionCalls?: NativeFunctionCall[];
     [key: string]: unknown;
 }>, channel: TextChannel): Promise<CollectedChunkResult>;
+/**
+ * Extract the thoughtSignature token from raw response parts.
+ * Returns the last thoughtSignature found (each step may produce one).
+ */
+export declare function extractThoughtSignature(rawResponseParts: unknown[]): string | undefined;
 /**
  * Extract text from raw response parts, filtering out non-text parts
  * (thoughtSignature, functionCall) to avoid SDK warnings.

package/dist/providers/googleNativeGemini3.js

@@ -437,6 +437,24 @@ export async function collectStreamChunksIncremental(stream, channel) {
     }
     return { rawResponseParts, stepFunctionCalls, inputTokens, outputTokens };
 }
+/**
+ * Extract the thoughtSignature token from raw response parts.
+ * Returns the last thoughtSignature found (each step may produce one).
+ */
+export function extractThoughtSignature(rawResponseParts) {
+    for (let i = rawResponseParts.length - 1; i >= 0; i--) {
+        const part = rawResponseParts[i];
+        if (part !== null &&
+            part !== undefined &&
+            typeof part === "object" &&
+            "thoughtSignature" in part &&
+            typeof part.thoughtSignature ===
+                "string") {
+            return part.thoughtSignature;
+        }
+    }
+    return undefined;
+}
 /**
  * Extract text from raw response parts, filtering out non-text parts
  * (thoughtSignature, functionCall) to avoid SDK warnings.

package/dist/providers/googleVertex.js

@@ -24,7 +24,7 @@ import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
-import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
+import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { getModelId } from "./providerTypeUtils.js";
 // Import proper types for multimodal message handling
 // Keep-alive note: Node.js native fetch and undici (used by createProxyFetch)
@@ -1310,10 +1310,63 @@ export class GoogleVertexProvider extends BaseProvider {
             return currentContents;
         }
         const history = [];
+        // Composite key: "<turnCounter>:<stepIndex>" ensures step 1 of
+        // conversational turn 1 never collides with step 1 of turn 2.
+        const stepMap = new Map();
+        const segments = [];
+        // Incremented each time a regular user/assistant message is encountered,
+        // acting as a logical turn boundary between agentic loop iterations.
+        let turnCounter = 0;
+        const makeKey = (stepIndex) => `${turnCounter}:${stepIndex ?? "undefined"}`;
+        const getOrCreateStep = (stepIndex) => {
+            const key = makeKey(stepIndex);
+            if (stepMap.has(key)) {
+                return stepMap.get(key);
+            }
+            const step = {
+                type: "tool_step",
+                callParts: [],
+                resultParts: [],
+            };
+            stepMap.set(key, step);
+            segments.push(step);
+            return step;
+        };
         for (const msg of conversationMessages) {
-            // @google/genai only accepts "user" and "model" roles in contents.
-            // Skip system messages (handled via config.systemInstruction).
-            // Map "assistant" → "model" (Gemini convention).
+            if (msg.role === "tool_call") {
+                const step = getOrCreateStep(msg.metadata?.stepIndex);
+                const fcPart = {
+                    functionCall: {
+                        name: msg.tool || "unknown",
+                        args: msg.args || {},
+                    },
+                };
+                if (msg.metadata?.thoughtSignature) {
+                    fcPart.thoughtSignature = msg.metadata.thoughtSignature;
+                }
+                step.callParts.push(fcPart);
+                continue;
+            }
+            if (msg.role === "tool_result") {
+                const step = getOrCreateStep(msg.metadata?.stepIndex);
+                let responsePayload;
+                try {
+                    responsePayload = msg.content
+                        ? { result: JSON.parse(msg.content) }
+                        : { result: "success" };
+                }
+                catch {
+                    responsePayload = { result: msg.content || "success" };
+                }
+                step.resultParts.push({
+                    functionResponse: {
+                        name: msg.tool || "unknown",
+                        response: responsePayload,
+                    },
+                });
+                continue;
+            }
+            // Regular (user / assistant) message — acts as a turn boundary.
             const role = msg.role === "assistant" ? "model" : msg.role;
             if (role !== "user" && role !== "model") {
                 continue;
@@ -1321,9 +1374,29 @@ export class GoogleVertexProvider extends BaseProvider {
             if (!msg.content || msg.content.trim().length === 0) {
                 continue;
             }
-            history.push({ role, parts: [{ text: msg.content }] });
+            // Increment turn counter BEFORE pushing the segment so that any
+            // tool_calls that follow this message get a fresh namespace.
+            turnCounter++;
+            const textPart = { text: msg.content };
+            if (msg.metadata?.thoughtSignature) {
+                textPart.thoughtSignature = msg.metadata.thoughtSignature;
+            }
+            segments.push({ type: "regular", role, parts: [textPart] });
+        }
+        // Emit in order: each ToolStep → model turn (calls) + user turn (results)
+        for (const seg of segments) {
+            if (seg.type === "regular") {
+                history.push({ role: seg.role, parts: seg.parts });
+            }
+            else {
+                if (seg.callParts.length > 0) {
+                    history.push({ role: "model", parts: seg.callParts });
+                }
+                if (seg.resultParts.length > 0) {
+                    history.push({ role: "user", parts: seg.resultParts });
+                }
+            }
         }
-        // Prepend history before current user message
         return [...history, ...currentContents];
     }
     // ── Shared Gemini 3 helpers are now in ./googleNativeGemini3.ts ──
@@ -1425,6 +1498,7 @@ export class GoogleVertexProvider extends BaseProvider {
             timeoutController,
             composedSignal,
             maxSteps,
+            options,
         });
         loopPromise.catch(() => undefined);
         return {
@@ -1438,11 +1512,13 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     async runNativeGemini3StreamLoop(params) {
         let lastStepText = "";
+        let lastThoughtSignature;
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
         let step = 0;
         let completedWithFinalAnswer = false;
         const failedTools = new Map();
+        const toolExecutions = [];
         try {
             while (step < params.maxSteps) {
                 if (params.composedSignal?.aborted) {
@@ -1465,6 +1541,10 @@ export class GoogleVertexProvider extends BaseProvider {
                     totalInputTokens += chunkResult.inputTokens;
                     totalOutputTokens += chunkResult.outputTokens;
                     const stepText = extractTextFromParts(chunkResult.rawResponseParts);
+                    const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                    if (stepThoughtSig) {
+                        lastThoughtSignature = stepThoughtSig;
+                    }
                     if (chunkResult.stepFunctionCalls.length === 0) {
                         completedWithFinalAnswer = true;
                         break;
@@ -1478,7 +1558,36 @@ export class GoogleVertexProvider extends BaseProvider {
                     }
                     logger.debug(`[GoogleVertex] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
                     pushModelResponseToHistory(params.currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                    const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, params.executeMap, failedTools, params.allToolCalls, { abortSignal: params.composedSignal });
+                    // Track array lengths before execution to extract this step's additions
+                    const toolCallsBefore = params.allToolCalls.length;
+                    const toolExecsBefore = toolExecutions.length;
+                    const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, params.executeMap, failedTools, params.allToolCalls, { toolExecutions, abortSignal: params.composedSignal });
+                    // Store this step's tool calls/results in conversation memory
+                    // (mirrors onStepFinish in the standard GenerationHandler path)
+                    const stepToolCalls = params.allToolCalls.slice(toolCallsBefore);
+                    const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                    // Tag each tool call with the step's thoughtSignature and stepIndex
+                    // so they can be stored on the tool_call ChatMessage metadata in Redis
+                    // and reconstructed correctly in prependConversationHistory.
+                    const taggedToolCalls = stepToolCalls.map((tc, i) => ({
+                        ...tc,
+                        ...(i === 0 && stepThoughtSig
+                            ? { thoughtSignature: stepThoughtSig }
+                            : {}),
+                        stepIndex: step,
+                    }));
+                    const taggedToolResults = stepToolExecs.map((te) => ({
+                        toolName: te.name,
+                        result: te.output,
+                        stepIndex: step,
+                    }));
+                    if (taggedToolCalls.length > 0 || taggedToolResults.length > 0) {
+                        this.handleToolExecutionStorage(taggedToolCalls, taggedToolResults, params.options, new Date()).catch((error) => {
+                            logger.warn("[GoogleVertex] Failed to store native stream tool executions", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        });
+                    }
                     params.currentContents.push({
                         role: "user",
                         parts: functionResponses,
@@ -1498,6 +1607,10 @@ export class GoogleVertexProvider extends BaseProvider {
             const responseTime = Date.now() - params.startTime;
             params.metadata.responseTime = responseTime;
             params.metadata.totalToolExecutions = params.allToolCalls.length;
+            if (lastThoughtSignature) {
+                params.metadata.thoughtSignature =
+                    lastThoughtSignature;
+            }
             params.span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
             params.span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
             params.span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= params.maxSteps && !completedWithFinalAnswer
@@ -1603,10 +1716,8 @@ export class GoogleVertexProvider extends BaseProvider {
             // Build config — systemInstruction stays in config for Gemini 3.x.
             // See stream path comment for rationale.
             const config = buildNativeConfig(options, toolsConfig);
-            // Note: Schema/JSON output for Gemini 3 native SDK is complex due to $ref resolution issues
-            // For now, schemas are handled via the AI SDK fallback path, not native SDK
-            // TODO: Implement proper $ref resolution for complex nested schemas
             const startTime = Date.now();
+            // 5-min default: timeout covers ALL agentic steps, 30s is too short.
             const timeout = this.getTimeout(options);
             const timeoutController = createTimeoutController(timeout, this.providerName, "generate");
             const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
@@ -1615,6 +1726,7 @@ export class GoogleVertexProvider extends BaseProvider {
             const currentContents = this.prependConversationHistory([...contents], options.conversationMessages);
             let finalText = "";
             let lastStepText = "";
+            let lastThoughtSignature;
             let totalInputTokens = 0;
             let totalOutputTokens = 0;
             const allToolCalls = [];
@@ -1642,11 +1754,24 @@ export class GoogleVertexProvider extends BaseProvider {
                                 : {}),
                         });
                         const chunkResult = await collectStreamChunks(stream);
+                        // Silent timeout: abort signal may terminate the stream without
+                        // throwing, yielding zero parts. Surface error explicitly.
+                        if (composedSignal?.aborted &&
+                            chunkResult.rawResponseParts.length === 0) {
+                            throw composedSignal.reason instanceof Error
+                                ? composedSignal.reason
+                                : new Error("Request timed out (no response parts received)");
+                        }
                         totalInputTokens += chunkResult.inputTokens;
                         totalOutputTokens += chunkResult.outputTokens;
+                        const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                        if (stepThoughtSig) {
+                            lastThoughtSignature = stepThoughtSig;
+                        }
                         const stepText = extractTextFromParts(chunkResult.rawResponseParts);
                         if (chunkResult.stepFunctionCalls.length === 0) {
-                            finalText = stepText;
+                            // Fall back to lastStepText when final step has no text parts
+                            finalText = stepText || lastStepText;
                             break;
                         }
                         lastStepText = stepText;
@@ -1659,7 +1784,36 @@ export class GoogleVertexProvider extends BaseProvider {
                         }
                         logger.debug(`[GoogleVertex] Generate executing ${chunkResult.stepFunctionCalls.length} function calls`);
                         pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                        // Track array lengths before execution to extract this step's additions
+                        const toolCallsBefore = allToolCalls.length;
+                        const toolExecsBefore = toolExecutions.length;
                         const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
+                        // Store this step's tool calls/results in conversation memory
+                        // (mirrors onStepFinish in the standard GenerationHandler path)
+                        const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                        const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                        // Tag each tool call with the step's thoughtSignature and stepIndex
+                        // so they can be stored on the tool_call ChatMessage metadata in Redis
+                        // and reconstructed correctly in prependConversationHistory.
+                        const taggedToolCalls = stepToolCalls.map((tc, i) => ({
+                            ...tc,
+                            ...(i === 0 && stepThoughtSig
+                                ? { thoughtSignature: stepThoughtSig }
+                                : {}),
+                            stepIndex: step,
+                        }));
+                        const taggedToolResults = stepToolExecs.map((te) => ({
+                            toolName: te.name,
+                            result: te.output,
+                            stepIndex: step,
+                        }));
+                        if (taggedToolCalls.length > 0 || taggedToolResults.length > 0) {
+                            this.handleToolExecutionStorage(taggedToolCalls, taggedToolResults, options, new Date()).catch((error) => {
+                                logger.warn("[GoogleVertex] Failed to store native tool executions", {
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                            });
+                        }
                         // Function/tool responses must use role: "user" — the
                         // @google/genai SDK's validateHistory() only accepts "user"
                         // and "model" roles (matching automaticFunctionCalling).
@@ -1720,6 +1874,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 toolsUsed: allToolCalls.map((tc) => tc.toolName),
                 toolExecutions: toolExecutions,
                 enhancedWithTools: allToolCalls.length > 0,
+                ...(lastThoughtSignature && {
+                    thoughtSignature: lastThoughtSignature,
+                }),
             };
         });
     }

package/dist/services/server/ai/observability/instrumentation.d.ts

@@ -6,7 +6,6 @@
  *
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
-import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { trace } from "@opentelemetry/api";
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
 import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
@@ -26,7 +25,7 @@ import type { LangfuseConfig, LangfuseContext } from "../../../../types/index.js
  *
  * @param config - Langfuse configuration passed from parent application
  */
-export declare function initializeOpenTelemetry(config: LangfuseConfig): void;
+export declare function initializeOpenTelemetry(config: LangfuseConfig): Promise<void>;
 /**
  * Flush all pending spans to Langfuse
  */
@@ -38,7 +37,7 @@ export declare function shutdownOpenTelemetry(): Promise<void>;
 /**
  * Get the Langfuse span processor
  */
-export declare function getLangfuseSpanProcessor(): LangfuseSpanProcessor | null;
+export declare function getLangfuseSpanProcessor(): SpanProcessor | null;
 /**
  * Get the tracer provider
  */

package/dist/services/server/ai/observability/instrumentation.js

@@ -6,7 +6,6 @@
  *
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
-import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { metrics, SpanStatusCode, trace } from "@opentelemetry/api";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
@@ -503,8 +502,19 @@ class ContextEnricher {
         return Promise.resolve();
     }
 }
-function createLangfuseProcessor(config) {
-    return new LangfuseSpanProcessor({
+async function createLangfuseProcessor(config) {
+    let mod;
+    try {
+        mod = await import(/* @vite-ignore */ "@langfuse/otel");
+    }
+    catch (err) {
+        const e = err instanceof Error ? err : null;
+        if (e?.code === "ERR_MODULE_NOT_FOUND" && e.message.includes("langfuse")) {
+            throw new Error('Langfuse observability requires "@langfuse/otel". Install it with:\n  pnpm add @langfuse/otel', { cause: err });
+        }
+        throw err;
+    }
+    return new mod.LangfuseSpanProcessor({
         publicKey: config.publicKey,
         secretKey: config.secretKey,
         baseUrl: config.baseUrl || "https://cloud.langfuse.com",
@@ -513,7 +523,7 @@ function createLangfuseProcessor(config) {
         shouldExportSpan: () => true,
     });
 }
-function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds) {
+async function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds) {
     if (langfuseRequested && !hasLangfuseCreds) {
         if (!otlpEndpoint) {
             logger.warn(`${LOG_PREFIX} External provider mode requested Langfuse but credentials are missing, and no OTLP endpoint is configured; skipping initialization`, {
@@ -535,7 +545,7 @@ function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, ser
         isCredentialsValid = hasLangfuseCreds;
         langfuseProcessor =
             langfuseRequested && hasLangfuseCreds
-                ? createLangfuseProcessor(config)
+                ? await createLangfuseProcessor(config)
                 : null;
         usingExternalProvider = true;
         isInitialized = true;
@@ -548,11 +558,9 @@ function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, ser
                 // Auto-detect: skip if consumer already registered a LangfuseSpanProcessor.
                 //
                 // Detection strategy (ordered by robustness):
-                // 1. `instanceof LangfuseSpanProcessor` — reliable when both sides use
-                //    the same @langfuse/otel package instance (same module identity).
-                // 2. Duck-type check for Langfuse-specific public member
+                // 1. Duck-type check for Langfuse-specific public member
                 //    (`langfuseClient` property) — survives minification.
-                // 3. `constructor.name === "LangfuseSpanProcessor"` — last resort,
+                // 2. `constructor.name === "LangfuseSpanProcessor"` — last resort,
                 //    brittle under minification or bundler renaming.
                 //
                 // NOTE: `_registeredSpanProcessors` is an internal OpenTelemetry field.
@@ -566,10 +574,6 @@ function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, ser
                     if (p === null || p === undefined || typeof p !== "object") {
                         return false;
                     }
-                    // Prefer instanceof — works when same @langfuse/otel package is shared
-                    if (p instanceof LangfuseSpanProcessor) {
-                        return true;
-                    }
                     // Duck-type: Langfuse processor exposes a langfuseClient property
                     if ("langfuseClient" in p) {
                         return true;
@@ -626,7 +630,7 @@ function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, ser
         isInitialized = true;
     }
 }
-function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds) {
+async function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds) {
     if ((!langfuseRequested || !hasLangfuseCreds) && !otlpEndpoint) {
         if (langfuseRequested && !hasLangfuseCreds) {
             logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing, and no OTLP endpoint is configured; skipping initialization`, {
@@ -652,7 +656,7 @@ function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, s
         isCredentialsValid = hasLangfuseCreds;
         langfuseProcessor =
             langfuseRequested && hasLangfuseCreds
-                ? createLangfuseProcessor(config)
+                ? await createLangfuseProcessor(config)
                 : null;
         logger.debug(`${LOG_PREFIX} Standalone observability mode`, {
             langfuseEnabled: !!langfuseProcessor,
@@ -741,7 +745,7 @@ function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, s
  *
  * @param config - Langfuse configuration passed from parent application
  */
-export function initializeOpenTelemetry(config) {
+export async function initializeOpenTelemetry(config) {
     // Guard against multiple initializations — but always update config
     // so that later NeuroLink instances can change traceNameFormat,
     // autoDetectOperationName, and other configuration preferences
@@ -771,10 +775,10 @@ export function initializeOpenTelemetry(config) {
     const serviceName = process.env.OTEL_SERVICE_NAME || "neurolink";
     const resource = createOtelResource(config, serviceName);
     if (shouldUseExternal) {
-        initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
+        await initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
         return;
     }
-    initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
+    await initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
 }
 /**
  * Flush all pending spans to Langfuse

package/dist/types/conversation.d.ts

@@ -224,6 +224,8 @@ export type ChatMessageMetadata = {
     thoughtHash?: string;
     /** Whether extended thinking was used for this message */
     thinkingExpanded?: boolean;
+    /** Step index for reconstructing parallel vs sequential tool calls */
+    stepIndex?: number;
     /**
      * Head/tail preview of a large tool output.
      * Only present on tool_result messages where the output exceeded truncation limits.
@@ -371,6 +373,8 @@ export type StoreConversationTurnOptions = {
         cacheReadTokens?: number;
         cacheWriteTokens?: number;
     };
+    /** Gemini 3 thought signature for reasoning continuity across turns */
+    thoughtSignature?: string;
 };
 /**
  * Lightweight session metadata for efficient session listing

package/dist/types/generate.d.ts

@@ -999,6 +999,8 @@ export type TextGenerationResult = {
     imageOutput?: {
         base64: string;
     } | null;
+    /** Gemini 3 thought signature for reasoning continuity across turns */
+    thoughtSignature?: string;
     retries?: {
         count: number;
         errors: Array<{

package/dist/types/providers.d.ts

@@ -1577,3 +1577,18 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Internal helpers used by the conversation-history builder in
+ * providers/googleVertex.ts to merge interleaved tool call / result turns.
+ */
+export type VertexToolStep = {
+    type: "tool_step";
+    callParts: unknown[];
+    resultParts: unknown[];
+};
+export type VertexRegularSegment = {
+    type: "regular";
+    role: string;
+    parts: unknown[];
+};
+export type VertexSegment = VertexToolStep | VertexRegularSegment;

package/dist/types/tools.d.ts

@@ -432,13 +432,17 @@ export type PendingToolExecution = {
         toolName?: string;
         args?: Record<string, unknown>;
         timestamp?: Date;
+        thoughtSignature?: string;
+        stepIndex?: number;
         [key: string]: unknown;
     }>;
     toolResults: Array<{
         toolCallId?: string;
+        toolName?: string;
         result?: unknown;
         error?: string;
         timestamp?: Date;
+        stepIndex?: number;
         [key: string]: unknown;
     }>;
     timestamp: number;

package/dist/utils/conversationMemory.js

@@ -170,6 +170,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
                         cacheWriteTokens: result.usage.cacheCreationTokens,
                     }
                     : undefined,
+                thoughtSignature: result.thoughtSignature,
             });
             logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
                 requestId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.54.9",
+  "version": "9.55.1",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
@@ -212,7 +212,6 @@
     "@google/genai": "^1.43.0",
     "@huggingface/inference": "^4.13.14",
     "@juspay/hippocampus": "^0.1.4",
-    "@langfuse/otel": "^5.0.1",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@openrouter/ai-sdk-provider": "^2.2.3",
     "@opentelemetry/api-logs": "^0.214.0",
@@ -275,6 +274,7 @@
     }
   },
   "optionalDependencies": {
+    "@langfuse/otel": "^5.0.1",
     "@fastify/cors": "^11.2.0",
     "@fastify/rate-limit": "^10.3.0",
     "@hono/node-server": "^1.19.9",

package/dist/lib/utils/imageCompressor.d.ts

@@ -1,25 +0,0 @@
-import type { CompressionOptions, CompressionResult, ProviderName } from "../types/index.js";
-/**
- * Provider-specific image size limits in bytes
- */
-export declare const PROVIDER_IMAGE_LIMITS: Record<ProviderName, number>;
-/**
- * Compress an image to meet provider-specific size limits
- * @param imageBuffer - Input image buffer
- * @param options - Compression options including provider name
- * @returns Compressed image buffer with metadata
- */
-export declare function compressImage(imageBuffer: Buffer, options: CompressionOptions): Promise<CompressionResult>;
-/**
- * Check if an image needs compression for a specific provider
- * @param imageBuffer - Input image buffer
- * @param provider - AI provider name
- * @returns True if compression is needed
- */
-export declare function needsCompression(imageBuffer: Buffer, provider: ProviderName): boolean;
-/**
- * Get the size limit for a specific provider
- * @param provider - AI provider name
- * @returns Size limit in bytes
- */
-export declare function getProviderSizeLimit(provider: ProviderName): number;