@juspay/neurolink 12.59.0 → 13.0.0

package/dist/observability/otlpEncoding.d.ts

@@ -0,0 +1,20 @@
+import type { LangfuseAttributePolicy, OtlpKeyValue, OtlpSpan, SpanAttributes, SpanData } from "../types/index.js";
+/**
+ * @description Encodes attributes as OTLP/JSON key-values, dropping `undefined` and `null` entries.
+ * @param attributes {SpanAttributes} - Attribute record to encode.
+ * @returns {OtlpKeyValue[]} One typed key-value per kept attribute.
+ */
+export declare function toOtlpAttributes(attributes: SpanAttributes): OtlpKeyValue[];
+/**
+ * @description Encodes one span as OTLP/JSON, applying the exporter's attribute policy to its attributes.
+ * @param span {SpanData} - Span to encode.
+ * @param policy {LangfuseAttributePolicy} - Environment, release, redaction and mask settings.
+ * @returns {OtlpSpan} The span in the shape Langfuse's ingestion endpoint reads.
+ */
+export declare function toOtlpSpan(span: SpanData, policy: LangfuseAttributePolicy): OtlpSpan;
+/**
+ * @description Splits encoded spans into request-sized batches, bounded by span count and serialized bytes.
+ * @param spans {OtlpSpan[]} - Encoded spans, in export order.
+ * @returns {OtlpSpan[][]} Batches that each fit one export request; a single oversized span still gets its own batch.
+ */
+export declare function chunkOtlpSpans(spans: OtlpSpan[]): OtlpSpan[][];

package/dist/observability/otlpEncoding.js

@@ -0,0 +1,85 @@
+import { MAX_BYTES_PER_REQUEST, MAX_SPANS_PER_REQUEST, OTLP_STATUS_CODES, } from "../constants/langfuse.js";
+import { SpanStatus } from "../types/index.js";
+import { protectAttributes } from "./langfuseMasking.js";
+const SPAN_KIND_INTERNAL = 1;
+function toNanos(iso) {
+    return (BigInt(Date.parse(iso)) * 1000000n).toString();
+}
+function toOtlpValue(value) {
+    if (typeof value === "boolean") {
+        return { boolValue: value };
+    }
+    if (typeof value === "number") {
+        return Number.isInteger(value)
+            ? { intValue: String(value) }
+            : { doubleValue: value };
+    }
+    if (Array.isArray(value)) {
+        return { arrayValue: { values: value.map(toOtlpValue) } };
+    }
+    return { stringValue: String(value) };
+}
+/**
+ * @description Encodes attributes as OTLP/JSON key-values, dropping `undefined` and `null` entries.
+ * @param attributes {SpanAttributes} - Attribute record to encode.
+ * @returns {OtlpKeyValue[]} One typed key-value per kept attribute.
+ */
+export function toOtlpAttributes(attributes) {
+    return Object.entries(attributes)
+        .filter(([, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => ({ key, value: toOtlpValue(value) }));
+}
+/**
+ * @description Encodes one span as OTLP/JSON, applying the exporter's attribute policy to its attributes.
+ * @param span {SpanData} - Span to encode.
+ * @param policy {LangfuseAttributePolicy} - Environment, release, redaction and mask settings.
+ * @returns {OtlpSpan} The span in the shape Langfuse's ingestion endpoint reads.
+ */
+export function toOtlpSpan(span, policy) {
+    const failed = span.status === SpanStatus.ERROR;
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        ...(span.parentSpanId && { parentSpanId: span.parentSpanId }),
+        name: span.name,
+        kind: SPAN_KIND_INTERNAL,
+        startTimeUnixNano: toNanos(span.startTime),
+        endTimeUnixNano: toNanos(span.endTime ?? span.startTime),
+        attributes: toOtlpAttributes(protectAttributes(span.attributes, policy)),
+        events: span.events.map((event) => ({
+            name: event.name,
+            timeUnixNano: toNanos(event.timestamp),
+            attributes: toOtlpAttributes(event.attributes ?? {}),
+        })),
+        status: {
+            code: OTLP_STATUS_CODES[span.status],
+            ...(failed && span.statusMessage && { message: span.statusMessage }),
+        },
+    };
+}
+/**
+ * @description Splits encoded spans into request-sized batches, bounded by span count and serialized bytes.
+ * @param spans {OtlpSpan[]} - Encoded spans, in export order.
+ * @returns {OtlpSpan[][]} Batches that each fit one export request; a single oversized span still gets its own batch.
+ */
+export function chunkOtlpSpans(spans) {
+    const chunks = [];
+    let current = [];
+    let bytes = 0;
+    for (const span of spans) {
+        const size = Buffer.byteLength(JSON.stringify(span));
+        if (current.length > 0 &&
+            (current.length >= MAX_SPANS_PER_REQUEST ||
+                bytes + size > MAX_BYTES_PER_REQUEST)) {
+            chunks.push(current);
+            current = [];
+            bytes = 0;
+        }
+        current.push(span);
+        bytes += size;
+    }
+    if (current.length > 0) {
+        chunks.push(current);
+    }
+    return chunks;
+}

package/dist/providers/amazonBedrock/client.js

@@ -601,10 +601,7 @@ export class AmazonBedrockProvider extends BaseProvider {
     async executeSingleTool(tools, toolName, args, _toolUseId) {
         return bedrockTracer.startActiveSpan("bedrock.tool.execute", {
             kind: SpanKind.CLIENT,
-            attributes: {
-                "gen_ai.tool.name": toolName,
-                "gen_ai.system": "aws.bedrock",
-            },
+            attributes: { "tool.name": toolName },
         }, async (span) => {
             try {
                 logger.debug(`[AmazonBedrockProvider] Executing single tool: ${toolName}`, {
@@ -711,8 +708,9 @@ export class AmazonBedrockProvider extends BaseProvider {
         if (disableTools) {
             return {};
         }
-        const aiTools = optionTools ??
-            (await this.getAllTools());
+        const aiTools = optionTools
+            ? this.toolsManager.wrapExternalToolsWithEvents(optionTools)
+            : await this.getAllTools();
         return this.convertAISDKToolsToToolDefinitions(aiTools);
     }
     /**
@@ -896,177 +894,149 @@ export class AmazonBedrockProvider extends BaseProvider {
     async executeStream(options) {
         logger.debug("[TRACE] executeStream ENTRY - starting streaming attempt");
         logger.info("[AmazonBedrockProvider] Attempting real streaming with ConverseStreamCommand");
-        return bedrockTracer.startActiveSpan("bedrock.stream", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-                "gen_ai.system": "aws.bedrock",
-                "gen_ai.request.model": this.modelName || this.getDefaultModel(),
-                "gen_ai.operation.name": "stream",
-            },
-        }, async (streamSpan) => {
-            try {
-                logger.debug("[TRACE] executeStream TRY block - about to call streamingConversationLoop");
-                // Clear conversation history for new streaming session
-                this.conversationHistory = [];
-                // Check for multimodal input (images, PDFs, CSVs, files)
-                const hasMultimodalInput = !!(options.input?.images?.length ||
-                    options.input?.content?.length ||
-                    options.input?.files?.length ||
-                    options.input?.csvFiles?.length ||
-                    options.input?.pdfFiles?.length);
-                if (hasMultimodalInput) {
-                    logger.debug(`[AmazonBedrockProvider] Detected multimodal input, using multimodal message builder`, {
-                        hasImages: !!options.input?.images?.length,
-                        imageCount: options.input?.images?.length || 0,
-                        hasContent: !!options.input?.content?.length,
-                        contentCount: options.input?.content?.length || 0,
-                        hasFiles: !!options.input?.files?.length,
-                        fileCount: options.input?.files?.length || 0,
-                        hasCSVFiles: !!options.input?.csvFiles?.length,
-                        csvFileCount: options.input?.csvFiles?.length || 0,
-                        hasPDFFiles: !!options.input?.pdfFiles?.length,
-                        pdfFileCount: options.input?.pdfFiles?.length || 0,
-                    });
-                    // Same instance-default fold as the generate() path above.
-                    this.applyToolReplayDefault(options);
-                    const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-                    const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                    // Convert to Bedrock format
-                    this.conversationHistory =
-                        this.convertToBedrockMessages(multimodalMessages);
-                }
-                else {
-                    logger.debug(`[AmazonBedrockProvider] Text-only input, using simple message builder`);
-                    // Add user message to conversation - simple text-only case
-                    const userMessage = {
-                        role: "user",
-                        content: [{ text: options.input.text }],
-                    };
-                    this.conversationHistory.push(userMessage);
-                }
-                logger.debug(`[AmazonBedrockProvider] Starting streaming conversation with ${this.conversationHistory.length} message(s)`);
-                // Call the actual streaming implementation that already exists
-                logger.debug("[TRACE] executeStream - calling streamingConversationLoop NOW");
-                const result = await this.streamingConversationLoop(options, streamSpan);
-                logger.debug("[TRACE] executeStream - streamingConversationLoop SUCCESS, returning result");
-                streamSpan.setStatus({ code: SpanStatusCode.OK });
-                streamSpan.end();
-                return result;
+        try {
+            logger.debug("[TRACE] executeStream TRY block - about to call streamingConversationLoop");
+            // Clear conversation history for new streaming session
+            this.conversationHistory = [];
+            // Check for multimodal input (images, PDFs, CSVs, files)
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
+            if (hasMultimodalInput) {
+                logger.debug(`[AmazonBedrockProvider] Detected multimodal input, using multimodal message builder`, {
+                    hasImages: !!options.input?.images?.length,
+                    imageCount: options.input?.images?.length || 0,
+                    hasContent: !!options.input?.content?.length,
+                    contentCount: options.input?.content?.length || 0,
+                    hasFiles: !!options.input?.files?.length,
+                    fileCount: options.input?.files?.length || 0,
+                    hasCSVFiles: !!options.input?.csvFiles?.length,
+                    csvFileCount: options.input?.csvFiles?.length || 0,
+                    hasPDFFiles: !!options.input?.pdfFiles?.length,
+                    pdfFileCount: options.input?.pdfFiles?.length || 0,
+                });
+                // Same instance-default fold as the generate() path above.
+                this.applyToolReplayDefault(options);
+                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
+                const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                // Convert to Bedrock format
+                this.conversationHistory =
+                    this.convertToBedrockMessages(multimodalMessages);
             }
-            catch (error) {
-                logger.debug("[TRACE] executeStream CATCH - error caught from streamingConversationLoop");
-                const errorObj = error;
-                // Check if error is related to streaming permissions. Gated on the
-                // real AWS SDK service-exception shape ($metadata) first: a
-                // middleware's wrapStream/transformParams can throw an arbitrary
-                // Error whose message happens to contain "streaming" or whose name
-                // happens to collide with an AWS exception name, and without this
-                // guard that error was silently swallowed and retried as if AWS
-                // itself had rejected the streaming call (see
-                // BedrockRuntimeServiceException in the AWS SDK, which carries
-                // $fault/$metadata on every genuine service exception).
-                const hasAwsServiceExceptionShape = typeof errorObj === "object" &&
-                    errorObj !== null &&
-                    "$metadata" in errorObj;
-                const isPermissionError = hasAwsServiceExceptionShape &&
-                    (errorObj?.name === "AccessDeniedException" ||
-                        errorObj?.name === "UnauthorizedOperation" ||
-                        errorObj?.message?.includes("bedrock:InvokeModelWithResponseStream") ||
-                        errorObj?.message?.includes("streaming") ||
-                        errorObj?.message?.includes("ConverseStream"));
-                logger.debug("[TRACE] executeStream CATCH - checking if permission error");
-                logger.debug(`[TRACE] executeStream CATCH - isPermissionError=${isPermissionError}`);
-                if (isPermissionError) {
-                    logger.debug("[TRACE] executeStream CATCH - PERMISSION ERROR DETECTED, starting fallback");
-                    logger.warn(`[AmazonBedrockProvider] Streaming permissions not available, falling back to generate method: ${errorObj.message}`);
-                    streamSpan.addEvent("stream.fallback_to_generate", {
-                        reason: errorObj.message,
-                    });
-                    // Fallback to generate method and convert to streaming format
-                    const generateResult = await this.generate({
-                        prompt: options.input.text,
-                        input: options.input,
-                        maxTokens: options.maxTokens,
-                        temperature: options.temperature,
-                        systemPrompt: options.systemPrompt,
-                    });
-                    if (!generateResult) {
-                        streamSpan.setStatus({
-                            code: SpanStatusCode.ERROR,
-                            message: "Generate method returned null result",
-                        });
-                        streamSpan.end();
-                        // eslint-disable-next-line preserve-caught-error
-                        throw new Error("Generate method returned null result");
-                    }
-                    streamSpan.setAttribute("gen_ai.response.stop_reason", "fallback_end_turn");
-                    streamSpan.setStatus({ code: SpanStatusCode.OK });
-                    streamSpan.end();
-                    // Convert generate result to streaming format.
-                    // Use whitespace-preserving split (matches BaseProvider's
-                    // executeFakeStreaming) so newlines, tabs, indentation, code
-                    // blocks, and markdown tables aren't collapsed to single spaces.
-                    const stream = new ReadableStream({
-                        start(controller) {
-                            const responseText = generateResult.content || "";
-                            const tokens = responseText.split(/(\s+)/);
-                            let buffer = "";
-                            for (let i = 0; i < tokens.length; i++) {
-                                buffer += tokens[i];
-                                const shouldYield = i === tokens.length - 1 ||
-                                    buffer.length > 50 ||
-                                    /[.!?;,]\s*$/.test(buffer);
-                                if (shouldYield && buffer.length > 0) {
-                                    controller.enqueue({ content: buffer });
-                                    buffer = "";
-                                }
-                            }
-                            if (buffer.length > 0) {
+            else {
+                logger.debug(`[AmazonBedrockProvider] Text-only input, using simple message builder`);
+                // Add user message to conversation - simple text-only case
+                const userMessage = {
+                    role: "user",
+                    content: [{ text: options.input.text }],
+                };
+                this.conversationHistory.push(userMessage);
+            }
+            logger.debug(`[AmazonBedrockProvider] Starting streaming conversation with ${this.conversationHistory.length} message(s)`);
+            // Call the actual streaming implementation that already exists
+            logger.debug("[TRACE] executeStream - calling streamingConversationLoop NOW");
+            const result = await this.streamingConversationLoop(options);
+            logger.debug("[TRACE] executeStream - streamingConversationLoop SUCCESS, returning result");
+            return result;
+        }
+        catch (error) {
+            logger.debug("[TRACE] executeStream CATCH - error caught from streamingConversationLoop");
+            const errorObj = error;
+            // Check if error is related to streaming permissions. Gated on the
+            // real AWS SDK service-exception shape ($metadata) first: a
+            // middleware's wrapStream/transformParams can throw an arbitrary
+            // Error whose message happens to contain "streaming" or whose name
+            // happens to collide with an AWS exception name, and without this
+            // guard that error was silently swallowed and retried as if AWS
+            // itself had rejected the streaming call (see
+            // BedrockRuntimeServiceException in the AWS SDK, which carries
+            // $fault/$metadata on every genuine service exception).
+            const hasAwsServiceExceptionShape = typeof errorObj === "object" &&
+                errorObj !== null &&
+                "$metadata" in errorObj;
+            const isPermissionError = hasAwsServiceExceptionShape &&
+                (errorObj?.name === "AccessDeniedException" ||
+                    errorObj?.name === "UnauthorizedOperation" ||
+                    errorObj?.message?.includes("bedrock:InvokeModelWithResponseStream") ||
+                    errorObj?.message?.includes("streaming") ||
+                    errorObj?.message?.includes("ConverseStream"));
+            logger.debug("[TRACE] executeStream CATCH - checking if permission error");
+            logger.debug(`[TRACE] executeStream CATCH - isPermissionError=${isPermissionError}`);
+            if (isPermissionError) {
+                logger.debug("[TRACE] executeStream CATCH - PERMISSION ERROR DETECTED, starting fallback");
+                logger.warn(`[AmazonBedrockProvider] Streaming permissions not available, falling back to generate method: ${errorObj.message}`);
+                // Fallback to generate method and convert to streaming format
+                const generateResult = await this.generate({
+                    prompt: options.input.text,
+                    input: options.input,
+                    maxTokens: options.maxTokens,
+                    temperature: options.temperature,
+                    systemPrompt: options.systemPrompt,
+                });
+                if (!generateResult) {
+                    // eslint-disable-next-line preserve-caught-error
+                    throw new Error("Generate method returned null result");
+                }
+                // Convert generate result to streaming format.
+                // Use whitespace-preserving split (matches BaseProvider's
+                // executeFakeStreaming) so newlines, tabs, indentation, code
+                // blocks, and markdown tables aren't collapsed to single spaces.
+                const stream = new ReadableStream({
+                    start(controller) {
+                        const responseText = generateResult.content || "";
+                        const tokens = responseText.split(/(\s+)/);
+                        let buffer = "";
+                        for (let i = 0; i < tokens.length; i++) {
+                            buffer += tokens[i];
+                            const shouldYield = i === tokens.length - 1 ||
+                                buffer.length > 50 ||
+                                /[.!?;,]\s*$/.test(buffer);
+                            if (shouldYield && buffer.length > 0) {
                                 controller.enqueue({ content: buffer });
+                                buffer = "";
                             }
-                            controller.close();
-                        },
-                    });
-                    // Convert ReadableStream to AsyncIterable like streamingConversationLoop does
-                    const asyncIterable = {
-                        async *[Symbol.asyncIterator]() {
-                            const reader = stream.getReader();
-                            try {
-                                while (true) {
-                                    const { done, value } = await reader.read();
-                                    if (done) {
-                                        break;
-                                    }
-                                    yield value;
+                        }
+                        if (buffer.length > 0) {
+                            controller.enqueue({ content: buffer });
+                        }
+                        controller.close();
+                    },
+                });
+                // Convert ReadableStream to AsyncIterable like streamingConversationLoop does
+                const asyncIterable = {
+                    async *[Symbol.asyncIterator]() {
+                        const reader = stream.getReader();
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done) {
+                                    break;
                                 }
+                                yield value;
                             }
-                            finally {
-                                reader.releaseLock();
-                            }
-                        },
-                    };
-                    return {
-                        stream: asyncIterable,
-                        // The generate() fallback already computed real usage — a
-                        // hardcoded zero object here threw it away.
-                        usage: generateResult.usage,
-                        model: this.modelName || this.getDefaultModel(),
-                        provider: this.getProviderName(),
-                        metadata: {
-                            fallback: true,
-                        },
-                    };
-                }
-                // Re-throw non-permission errors
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: errorObj instanceof Error ? errorObj.message : String(errorObj),
-                });
-                streamSpan.recordException(errorObj instanceof Error ? errorObj : new Error(String(errorObj)));
-                streamSpan.end();
-                throw error;
+                        }
+                        finally {
+                            reader.releaseLock();
+                        }
+                    },
+                };
+                return {
+                    stream: asyncIterable,
+                    // The generate() fallback already computed real usage — a
+                    // hardcoded zero object here threw it away.
+                    usage: generateResult.usage,
+                    model: this.modelName || this.getDefaultModel(),
+                    provider: this.getProviderName(),
+                    metadata: {
+                        fallback: true,
+                    },
+                };
             }
-        });
+            // Re-throw non-permission errors
+            throw error;
+        }
     }
     /**
      * A multimodal turn skips model middleware (see modelBridge.ts's header).
@@ -1214,7 +1184,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             ...(cacheWrite > 0 && { cacheCreationTokens: cacheWrite }),
         };
     }
-    async streamingConversationLoop(options, streamSpan) {
+    async streamingConversationLoop(options) {
         const startTime = Date.now();
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
         // Resolved once for the whole turn. Bedrock has no mid-turn tool
@@ -1290,9 +1260,6 @@ export class AmazonBedrockProvider extends BaseProvider {
                     return stepResult;
                 },
             };
-            streamSpan.addEvent("stream.api_call", {
-                "bedrock.tool_count": toolConfig?.tools?.length ?? 0,
-            });
             return runAgenticLoop(adapter, conversation, {
                 tools: this.toEngineTools(tools),
                 abortSignal: signal,
@@ -1397,7 +1364,6 @@ export class AmazonBedrockProvider extends BaseProvider {
                         // Read after drain by the facade's fallbackOnMaxSteps gate. Keep
                         // the engine's own outcome; raw tool_use alone is not a step cap.
                         metadata.stopReason = outcome.result.stopReason;
-                        streamSpan.setAttribute("gen_ai.response.stop_reason", outcome.result.rawStopReason ?? "unknown");
                     }
                     // Analytics is resolved off `settled` above, so it lands whether or
                     // not anyone drains the stream.

package/dist/providers/amazonBedrock/loopAdapter.js

@@ -211,7 +211,20 @@ export function createBedrockLoopAdapter(config) {
         // No toolFailureBreaker: Bedrock has never had strike counting — a failing
         // tool becomes one error tool-result with no cross-step memory. Preserved.
         buildStepRequest(conversation, step) {
-            return { raw: config.buildCommandInput(conversation, step) };
+            const input = config.buildCommandInput(conversation, step);
+            return {
+                raw: input,
+                generation: {
+                    provider: "bedrock",
+                    model: input.modelId,
+                    modelParameters: {
+                        temperature: input.inferenceConfig?.temperature,
+                        maxTokens: input.inferenceConfig?.maxTokens,
+                        topP: input.inferenceConfig?.topP,
+                    },
+                    input: { system: input.system, messages: input.messages },
+                },
+            };
         },
         async executeStep(request, channel, signal) {
             const commandInput = request.raw;