@juspay/neurolink 12.22.0 → 12.23.0

package/dist/cli/factories/commandFactory.js

@@ -10,6 +10,7 @@ import { ContextFactory, } from "../../types/index.js";
 import { checkRedisAvailability } from "../../utils/conversationMemory.js";
 import { normalizeEvaluationData } from "../../utils/evaluationUtils.js";
 import { logger } from "../../utils/logger.js";
+import { sniffImageMimeType } from "../../utils/imageDetection.js";
 import { createThinkingConfigFromRecord } from "../../utils/thinkingConfig.js";
 import { buildToolRoutingConfigFromCli } from "../utils/toolRoutingFlags.js";
 import { buildClassifierRouterConfigFromCli } from "../utils/classifierRouterFlags.js";
@@ -233,7 +234,7 @@ export class CLICommandFactory {
         },
         imageOutput: {
             type: "string",
-            description: "Custom path for generated image (default: generated-images/image-<timestamp>.png)",
+            description: "Custom path for generated image (default: generated-images/image-<timestamp>.<ext>, where the extension follows the format the provider actually returned)",
             alias: "image-output",
         },
         // Behavior control options
@@ -1060,7 +1061,8 @@ export class CLICommandFactory {
                         else {
                             const imageDir = "generated-images";
                             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-                            imagePath = path.join(imageDir, `image-${timestamp}.png`);
+                            const ext = imageExtensionFor(generateResult.imageOutput.mimeType, generateResult.imageOutput.base64);
+                            imagePath = path.join(imageDir, `image-${timestamp}.${ext}`);
                             // Create directory if it doesn't exist
                             if (!fs.existsSync(imageDir)) {
                                 fs.mkdirSync(imageDir, { recursive: true });
@@ -3055,7 +3057,8 @@ export class CLICommandFactory {
                 else {
                     const imageDir = "generated-images";
                     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-                    imagePath = path.join(imageDir, `image-${timestamp}.png`);
+                    const ext = imageExtensionFor(undefined, streamResult.imageBase64);
+                    imagePath = path.join(imageDir, `image-${timestamp}.${ext}`);
                     if (!fs.existsSync(imageDir)) {
                         fs.mkdirSync(imageDir, { recursive: true });
                     }
@@ -4545,4 +4548,24 @@ export class CLICommandFactory {
 }
 /** Re-export of CLICommandFactory's static option definitions for direct import by tests/tooling. */
 export const commonOptions = CLICommandFactory.commonOptions;
+/**
+ * File extension for generated image bytes. The provider now labels what it
+ * returned, so a WebP no longer gets written to a `.png` filename — which is
+ * the same wrong-label problem one layer up from the provider.
+ */
+function imageExtensionFor(mimeType, base64) {
+    const known = {
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/webp": "webp",
+        "image/gif": "gif",
+    };
+    if (mimeType && known[mimeType]) {
+        return known[mimeType];
+    }
+    // No label from the provider: sniff the leading bytes rather than assume.
+    const head = Buffer.from(base64.slice(0, 64), "base64");
+    const sniffed = sniffImageMimeType(head);
+    return sniffed ? known[sniffed] : "png";
+}
 //# sourceMappingURL=commandFactory.js.map

package/dist/constants/enums.d.ts

@@ -23,6 +23,7 @@ export declare enum AIProviderName {
     CEREBRAS = "cerebras",
     CLOUDFLARE = "cloudflare",
     FIREWORKS = "fireworks",
+    FRIENDLI = "friendli",
     GMICLOUD = "gmicloud",
     GROQ = "groq",
     INCEPTION_LABS = "inception-labs",
@@ -876,6 +877,15 @@ export declare enum FireworksModels {
     LLAMA_V3P2_11B_VISION_INSTRUCT = "accounts/fireworks/models/llama-v3p2-11b-vision-instruct",
     PHI_3_VISION_128K_INSTRUCT = "accounts/fireworks/models/phi-3-vision-128k-instruct"
 }
+export declare enum FriendliModels {
+    ZAI_ORG_GLM_5_3 = "zai-org/GLM-5.3",
+    ZAI_ORG_GLM_5_3_FLASH = "zai-org/GLM-5.3-Flash",
+    ZAI_ORG_GLM_5_2 = "zai-org/GLM-5.2",
+    ZAI_ORG_GLM_5_1 = "zai-org/GLM-5.1",
+    GOOGLE_GEMMA_4_31B_IT = "google/gemma-4-31B-it",
+    DEEPSEEK_AI_DEEPSEEK_V3_2 = "deepseek-ai/DeepSeek-V3.2",
+    MINIMAXAI_MINIMAX_M2_5 = "MiniMaxAI/MiniMax-M2.5"
+}
 export declare enum GmicloudModels {
     MINIMAXAI_MINIMAX_M3 = "MiniMaxAI/MiniMax-M3"
 }

package/dist/constants/enums.js

@@ -28,6 +28,7 @@ export var AIProviderName;
     AIProviderName["CEREBRAS"] = "cerebras";
     AIProviderName["CLOUDFLARE"] = "cloudflare";
     AIProviderName["FIREWORKS"] = "fireworks";
+    AIProviderName["FRIENDLI"] = "friendli";
     AIProviderName["GMICLOUD"] = "gmicloud";
     AIProviderName["GROQ"] = "groq";
     AIProviderName["INCEPTION_LABS"] = "inception-labs";
@@ -1135,6 +1136,16 @@ export var FireworksModels;
     FireworksModels["LLAMA_V3P2_11B_VISION_INSTRUCT"] = "accounts/fireworks/models/llama-v3p2-11b-vision-instruct";
     FireworksModels["PHI_3_VISION_128K_INSTRUCT"] = "accounts/fireworks/models/phi-3-vision-128k-instruct";
 })(FireworksModels || (FireworksModels = {}));
+export var FriendliModels;
+(function (FriendliModels) {
+    FriendliModels["ZAI_ORG_GLM_5_3"] = "zai-org/GLM-5.3";
+    FriendliModels["ZAI_ORG_GLM_5_3_FLASH"] = "zai-org/GLM-5.3-Flash";
+    FriendliModels["ZAI_ORG_GLM_5_2"] = "zai-org/GLM-5.2";
+    FriendliModels["ZAI_ORG_GLM_5_1"] = "zai-org/GLM-5.1";
+    FriendliModels["GOOGLE_GEMMA_4_31B_IT"] = "google/gemma-4-31B-it";
+    FriendliModels["DEEPSEEK_AI_DEEPSEEK_V3_2"] = "deepseek-ai/DeepSeek-V3.2";
+    FriendliModels["MINIMAXAI_MINIMAX_M2_5"] = "MiniMaxAI/MiniMax-M2.5";
+})(FriendliModels || (FriendliModels = {}));
 export var GmicloudModels;
 (function (GmicloudModels) {
     GmicloudModels["MINIMAXAI_MINIMAX_M3"] = "MiniMaxAI/MiniMax-M3";

package/dist/core/constants.js

@@ -311,7 +311,7 @@ export const PDF_LIMITS = {
     DEFAULT_MAX_CANVAS_PIXELS: 16_777_216,
     // Floor for the downscaled render scale (#260 follow-up). A crafted/malformed
     // MediaBox can drive the estimated pixel count toward Infinity, which would
-    // otherwise collapse `effectiveScale` to 0 and hand `pdf-to-img` a degenerate
+    // otherwise collapse `effectiveScale` to 0 and hand the renderer a degenerate
     // viewport. Never let the downscale branch go below this.
     MIN_EFFECTIVE_SCALE: 0.1,
 };

package/dist/factories/providerDescriptors.d.ts

@@ -3,7 +3,7 @@ import type { ProviderDescriptor } from "../types/index.js";
 /**
  * Single source of truth for provider identity, credentials, defaults, and
  * runtime behavior classification — the hand-maintained providers plus the
- * 8 JSON-catalog providers derived above.
+ * 15 JSON-catalog providers derived above.
  */
 export declare const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[];
 /** O(1) canonical-name → descriptor lookup. */

package/dist/factories/providerDescriptors.js

@@ -5,10 +5,10 @@ import { getCatalogJsonEntries, catalogCredentialsKey, catalogEnvVar, } from "..
 import { DEFAULT_INFERENCE_KINDS } from "../types/index.js";
 /**
  * Hand-maintained provider identity, credentials, defaults, and runtime
- * behavior classification for every provider EXCEPT the 8 JSON-catalog
+ * behavior classification for every provider EXCEPT the 15 JSON-catalog
  * providers derived by buildCatalogDescriptors() below (see
- * PROVIDER_DESCRIPTORS's own doc for why Mistral, a 9th catalog provider,
- * stays here too). Pure data — no provider-class imports, no dynamic
+ * PROVIDER_DESCRIPTORS's own doc for why Mistral, the remaining catalog
+ * provider, stays here too). Pure data — no provider-class imports, no dynamic
  * import(), no side effects beyond building the two derived lookup maps
  * below. Order follows the AIProviderName enum declaration order
  * (enums.ts:8-40) so this file stays easy to diff against it.
@@ -496,13 +496,14 @@ const HAND_DESCRIPTORS = [
     },
 ];
 /**
- * Builds ProviderDescriptor entries for 8 of the 9 JSON-catalog providers —
- * cerebras, cloudflare, fireworks, groq, perplexity, sambanova, together-ai,
- * xai. Every field is derived from the catalog JSON
+ * Builds ProviderDescriptor entries for 15 of the 16 JSON-catalog providers —
+ * api-route, baseten, cerebras, cloudflare, fireworks, gmicloud, groq,
+ * inception-labs, io-intelligence, mancer, perplexity, sambanova,
+ * together-ai, upstage, xai. Every field is derived from the catalog JSON
  * (src/lib/providers/catalog/<id>.json), never hand-typed.
  *
- * Mistral is the 9th catalog provider but is deliberately excluded here and
- * stays in HAND_DESCRIPTORS above: its JSON setup.url
+ * Mistral is the remaining catalog provider but is deliberately excluded
+ * here and stays in HAND_DESCRIPTORS above: its JSON setup.url
  * ("https://console.mistral.ai/") diverges from the long-shipped descriptor
  * setupUrl ("https://console.mistral.ai/api-keys" — a real value conflict,
  * not missing enrichment), its envVars has no `model` key the JSON would
@@ -539,11 +540,12 @@ function buildCatalogDescriptor(entry) {
         credentialsKey: catalogCredentialsKey(entry),
         envVars,
         defaultModel: entry.models.default,
-        // All 9 catalog providers currently have capabilities.tools: true, so
-        // this is runtime-identical today either way. "none" (not an invented
-        // literal — it's the union's own no-tool-support member, the same one
+        // 15 of the 16 catalog providers have capabilities.tools: true; Mancer
+        // ships tools: false, so this ternary's false branch is live, not
+        // hypothetical. "none" (not an invented literal — it's the union's own
+        // no-tool-support member, the same one
         // REPLICATE/VOYAGE/JINA/STABILITY/IDEOGRAM/RECRAFT use above) is the
-        // correct false-branch if a future catalog provider ships tools: false.
+        // correct false-branch here.
         toolSupport: entry.capabilities.tools ? "native" : "none",
         localRuntime: false,
         healthCheck: "env-only",
@@ -561,7 +563,7 @@ function buildCatalogDescriptors() {
 /**
  * Single source of truth for provider identity, credentials, defaults, and
  * runtime behavior classification — the hand-maintained providers plus the
- * 8 JSON-catalog providers derived above.
+ * 15 JSON-catalog providers derived above.
  */
 export const PROVIDER_DESCRIPTORS = [
     ...HAND_DESCRIPTORS,

package/dist/image-gen/ImageGenService.js

@@ -27,6 +27,7 @@
  */
 import { withTimeout } from "../utils/errorHandling.js";
 import { DEFAULT_IMAGE_GEN_CONFIG } from "../types/index.js";
+import { detectImageMimeType, sniffImageMimeType, } from "../utils/imageDetection.js";
 /**
  * NeuroLink instance type (avoiding circular dependencies)
  */
@@ -233,9 +234,14 @@ export class ImageGenService {
             const img = imageOutput;
             if (typeof img.base64 === "string") {
                 const base64 = img.base64;
-                const mimeType = img.mimeType ?? "image/png";
+                const imageBuffer = Buffer.from(base64, "base64");
+                // Providers that do not label the format get it sniffed from the
+                // bytes rather than assumed to be PNG (Recraft, for one, returns WebP).
+                const mimeType = typeof img.mimeType === "string"
+                    ? img.mimeType
+                    : detectImageMimeType(imageBuffer);
                 return {
-                    imageBuffer: Buffer.from(base64, "base64"),
+                    imageBuffer,
                     base64,
                     mimeType,
                 };
@@ -247,7 +253,7 @@ export class ImageGenService {
             return {
                 imageBuffer: imageOutput,
                 base64,
-                mimeType: "image/png",
+                mimeType: detectImageMimeType(imageOutput),
             };
         }
         // Check for data URI format in content
@@ -269,20 +275,16 @@ export class ImageGenService {
             // Try to detect if it's base64 encoded image data
             try {
                 const buffer = Buffer.from(content, "base64");
-                // Check for PNG magic bytes
-                if (buffer[0] === 0x89 && buffer[1] === 0x50) {
-                    return {
-                        imageBuffer: buffer,
-                        base64: content,
-                        mimeType: "image/png",
-                    };
-                }
-                // Check for JPEG magic bytes
-                if (buffer[0] === 0xff && buffer[1] === 0xd8) {
+                // Only treat the content as an image when it carries a known
+                // signature. `detectImageMimeType` answers `image/png` for bytes it
+                // does not recognise, so asking it here would turn arbitrary text into
+                // an image result; `sniffImageMimeType` says "no" instead.
+                const sniffed = sniffImageMimeType(buffer);
+                if (sniffed !== null) {
                     return {
                         imageBuffer: buffer,
                         base64: content,
-                        mimeType: "image/jpeg",
+                        mimeType: sniffed,
                     };
                 }
             }

package/dist/index.d.ts

@@ -73,6 +73,7 @@ export { BeatovenMusic, BeatovenMusicHandler, ElevenLabsMusic, ElevenLabsMusicHa
 export { DIDAvatar, DIDAvatarHandler, HeyGenAvatar, HeyGenAvatarHandler, registerDefaultAvatarHandlers, ReplicateAvatar, ReplicateAvatarHandler, } from "./avatar/index.js";
 export { isVertexVideoConfigured, KlingVideoHandler, registerDefaultVideoHandlers, ReplicateVideoHandler, RunwayVideoHandler, VertexVideoHandler, } from "./adapters/video/index.js";
 export { ImageGenService } from "./image-gen/ImageGenService.js";
+export { detectImageMimeType, sniffImageMimeType, } from "./utils/imageDetection.js";
 export { HITLManager } from "./hitl/hitlManager.js";
 export { ProviderRegistry } from "./factories/providerRegistry.js";
 import { NeuroLink } from "./neurolink.js";

package/dist/index.js

@@ -147,6 +147,7 @@ export { DIDAvatar, DIDAvatarHandler, HeyGenAvatar, HeyGenAvatarHandler, registe
 export { isVertexVideoConfigured, KlingVideoHandler, registerDefaultVideoHandlers, ReplicateVideoHandler, RunwayVideoHandler, VertexVideoHandler, } from "./adapters/video/index.js";
 // Image generation + HITL — surfaced from their dedicated barrels
 export { ImageGenService } from "./image-gen/ImageGenService.js";
+export { detectImageMimeType, sniffImageMimeType, } from "./utils/imageDetection.js";
 export { HITLManager } from "./hitl/hitlManager.js";
 // Provider registry (for tests, advanced consumers, and tools that need to
 // invoke registerAllProviders() outside of constructing a NeuroLink instance)

package/dist/mcp/externalServerManager.d.ts

@@ -92,6 +92,15 @@ export declare class ExternalServerManager extends EventEmitter {
      * Start an external MCP server
      */
     private startServer;
+    /**
+     * Close a live client/transport pair, clearing the lifecycle hooks first
+     * so the `onclose` they would otherwise trigger cannot schedule a restart
+     * of a connection being torn down deliberately. Shared by `stopServer` and
+     * the minTools readiness gate in `startServer`, which rejects a server
+     * before it is ever registered as connected. Leaves status untouched —
+     * callers set whatever status fits their case.
+     */
+    private closeInstanceConnection;
     /**
      * Stop an external MCP server
      */

package/dist/mcp/externalServerManager.js

@@ -61,6 +61,29 @@ function isConnectionLostError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return CONNECTION_LOST_PATTERN.test(message);
 }
+/**
+ * Thrown by `startServer` when a server's discovered tool count falls below
+ * its configured `minTools` floor. Deliberately thrown *inside* the same
+ * try/catch that already handles every other start failure, so the existing
+ * machinery (status -> "failed", `lastError`, span exception recording,
+ * rethrow to `addServer`'s own catch) applies unchanged; `addServer`
+ * recognizes this specific error via `instanceof` to attach the
+ * `readiness: "insufficient_tools"` + `toolsDiscovered` metadata that a
+ * generic start failure does not carry.
+ */
+class InsufficientToolsError extends Error {
+    serverId;
+    toolsDiscovered;
+    minTools;
+    readiness = "insufficient_tools";
+    constructor(serverId, toolsDiscovered, minTools) {
+        super(`Server '${serverId}' discovered ${toolsDiscovered} tool(s), below the configured minTools=${minTools}`);
+        this.serverId = serverId;
+        this.toolsDiscovered = toolsDiscovered;
+        this.minTools = minTools;
+        this.name = "InsufficientToolsError";
+    }
+}
 /**
  * Consecutive idle health checks a server may fail to answer before it is
  * treated as hung and restarted. Two, not one: a single missed ping right
@@ -639,6 +662,7 @@ export class ExternalServerManager extends EventEmitter {
             retries: config.retries,
             healthCheckInterval: config.healthCheckInterval,
             autoRestart: config.autoRestart,
+            minTools: config.minTools,
             cwd: config.cwd,
             url: config.url,
             metadata: {
@@ -680,6 +704,7 @@ export class ExternalServerManager extends EventEmitter {
                 retries: serverInfo.retries,
                 healthCheckInterval: serverInfo.healthCheckInterval,
                 autoRestart: serverInfo.autoRestart,
+                minTools: serverInfo.minTools,
                 cwd: serverInfo.cwd,
                 url: serverInfo.url,
                 blockedTools: serverInfo.blockedTools,
@@ -768,6 +793,7 @@ export class ExternalServerManager extends EventEmitter {
                 metadata: {
                     timestamp: Date.now(),
                     operation: "addServer",
+                    readiness: "ready",
                     toolsDiscovered: finalInstance.tools.length,
                 },
             };
@@ -778,6 +804,23 @@ export class ExternalServerManager extends EventEmitter {
             mcpLogger.debug(`[ExternalServerManager] Failed to add server ${serverId}:`, error);
             // Clean up if instance was created
             this.servers.delete(serverId);
+            // The minTools readiness gate carries structured metadata a generic
+            // start failure does not: how many tools were actually discovered, so
+            // a caller can distinguish "too few tools" from "could not connect".
+            if (error instanceof InsufficientToolsError) {
+                return {
+                    success: false,
+                    error: error.message,
+                    serverId,
+                    duration: Date.now() - startTime,
+                    metadata: {
+                        timestamp: Date.now(),
+                        operation: "addServer",
+                        readiness: error.readiness,
+                        toolsDiscovered: error.toolsDiscovered,
+                    },
+                };
+            }
             return {
                 success: false,
                 error: error instanceof Error ? error.message : String(error),
@@ -885,6 +928,22 @@ export class ExternalServerManager extends EventEmitter {
             this.updateServerStatus(serverId, "connected");
             // Discover tools from the server
             await this.discoverServerTools(serverId);
+            // Readiness gate: a server whose discovered tool count falls below
+            // its configured minTools (default 0 — no minimum, so resource/prompt
+            // -only servers stay valid) is torn back down instead of being marked
+            // connected/healthy. Thrown here — before tools are registered with
+            // the main registry and before health monitoring starts — so a
+            // rejected server is never marked ready even transiently, and the
+            // throw is caught by this method's own catch below, which sets status
+            // "failed" and rethrows to addServer's catch the same way any other
+            // start failure does.
+            const minTools = config.minTools ?? 0;
+            if (instance.toolsMap.size < minTools) {
+                const toolsDiscovered = instance.toolsMap.size;
+                mcpLogger.warn(`[ExternalServerManager] Server '${serverId}' discovered ${toolsDiscovered} tool(s), below the configured minTools=${minTools}; tearing the connection back down`);
+                await this.closeInstanceConnection(serverId, instance);
+                throw new InsufficientToolsError(serverId, toolsDiscovered, minTools);
+            }
             // Register tools with main registry if integration is enabled
             if (this.enableMainRegistryIntegration) {
                 await this.registerServerToolsWithMainRegistry(serverId);
@@ -920,6 +979,31 @@ export class ExternalServerManager extends EventEmitter {
             span.end();
         }
     }
+    /**
+     * Close a live client/transport pair, clearing the lifecycle hooks first
+     * so the `onclose` they would otherwise trigger cannot schedule a restart
+     * of a connection being torn down deliberately. Shared by `stopServer` and
+     * the minTools readiness gate in `startServer`, which rejects a server
+     * before it is ever registered as connected. Leaves status untouched —
+     * callers set whatever status fits their case.
+     */
+    async closeInstanceConnection(serverId, instance) {
+        if (!instance.client || !instance.transportInstance) {
+            return;
+        }
+        instance.client.onclose = undefined;
+        instance.client.onerror = undefined;
+        try {
+            await MCPClientFactory.closeClient(instance.client, instance.transportInstance);
+        }
+        catch (error) {
+            mcpLogger.debug(`[ExternalServerManager] Error closing client for ${serverId}:`, error);
+        }
+        instance.client = null;
+        instance.transportInstance = null;
+        instance.process = null;
+        instance.pid = undefined;
+    }
     /**
      * Stop an external MCP server
      */
@@ -951,22 +1035,10 @@ export class ExternalServerManager extends EventEmitter {
             // Clear server tools from discovery service
             this.toolDiscovery.clearServerTools(serverId);
             // Close MCP client using factory cleanup. This close is ours, not a
-            // crash: drop the lifecycle hooks first so the onclose it triggers
-            // cannot schedule a restart of a server we are deliberately stopping.
-            if (instance.client && instance.transportInstance) {
-                instance.client.onclose = undefined;
-                instance.client.onerror = undefined;
-                try {
-                    await MCPClientFactory.closeClient(instance.client, instance.transportInstance);
-                }
-                catch (error) {
-                    mcpLogger.debug(`[ExternalServerManager] Error closing client for ${serverId}:`, error);
-                }
-                instance.client = null;
-                instance.transportInstance = null;
-                instance.process = null;
-                instance.pid = undefined;
-            }
+            // crash: closeInstanceConnection drops the lifecycle hooks first so
+            // the onclose it triggers cannot schedule a restart of a server we
+            // are deliberately stopping.
+            await this.closeInstanceConnection(serverId, instance);
             this.updateServerStatus(serverId, "stopped");
             span.setStatus({ code: SpanStatusCode.OK });
             mcpLogger.info(`[ExternalServerManager] Server stopped: ${serverId}`);

package/dist/neurolink.js

@@ -7696,6 +7696,24 @@ Current user's request: ${currentInput}`;
                 factoryResult,
                 sessionId: enhancedOptions.context?.sessionId,
             });
+            // Curator P2-4 dedup (concurrency-safe): native provider stream paths
+            // emit `generation:end` themselves. We attach a per-stream mutable
+            // flag to `enhancedOptions._streamDedupContext`; the provider flips it
+            // before its own emit and the finally block below reads the same
+            // closed-over reference, so the orchestration does not emit a second
+            // event for the same stream. Concurrent streams have different option
+            // objects and therefore different contexts, so they cannot interfere.
+            //
+            // #1741: this MUST be attached before `createMCPStream`. That call
+            // reaches `provider.stream({ ...options })`, which copies the options
+            // — so a context attached afterwards never reaches the provider, and
+            // every native stream path silently emitted twice. The flag looked
+            // present on `enhancedOptions` and was simply absent from the object
+            // the provider actually held.
+            const dedupContext = {
+                providerEmitted: false,
+            };
+            enhancedOptions._streamDedupContext = dedupContext;
             // Kept whole (not just destructured) so its toolsUsed/toolExecutions
             // descriptors can be re-applied onto the final StreamResult near the
             // bottom of this method, without ever reading — and thereby freezing —
@@ -7733,17 +7751,6 @@ Current user's request: ${currentInput}`;
             const streamStartTime = Date.now();
             const sessionId = enhancedOptions.context
                 ?.sessionId;
-            // Curator P2-4 dedup (concurrency-safe): native provider stream paths
-            // (Gemini 3 on Vertex / Google AI Studio) emit `generation:end`
-            // themselves. We attach a per-stream mutable flag directly to
-            // `enhancedOptions._streamDedupContext` — native providers receive
-            // these options and flip the flag before their emit; this finally
-            // block reads the same closed-over reference. Concurrent streams
-            // have different option objects so the contexts don't interfere.
-            const dedupContext = {
-                providerEmitted: false,
-            };
-            enhancedOptions._streamDedupContext = dedupContext;
             const processedStream = (async function* () {
                 let streamError;
                 // Curator P2-4: hoist `resolvedUsage` so the finally block can emit a

package/dist/providers/amazonBedrock/client.js

@@ -261,6 +261,15 @@ export class AmazonBedrockProvider extends BaseProvider {
                     success: false,
                     error: error instanceof Error ? error.message : String(error),
                 });
+                // #1741: the SDK emits its own `generation:end` unless the native
+                // path marks that it already did. The failure branch has no result
+                // to carry the mark, so it goes on the error — the same shape the
+                // AI Studio path uses. Without it one failed Bedrock generate is
+                // counted twice in analytics and as two Pipeline B spans.
+                if (error && typeof error === "object") {
+                    error._generationEndEmitted =
+                        true;
+                }
             }
             throw error;
         }
@@ -288,7 +297,7 @@ export class AmazonBedrockProvider extends BaseProvider {
         // `baseProvider` fell back to `result.toolsUsed || []` and every turn
         // reported zero tools while running them correctly — leaving analytics,
         // cost attribution and audit blind on this path.
-        return {
+        const generateResult = {
             content: text, // CLI expects 'content' not 'text'
             usage,
             model: this.modelName || this.getDefaultModel(),
@@ -320,6 +329,16 @@ export class AmazonBedrockProvider extends BaseProvider {
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutions)),
             enhancedWithTools: toolExecutions.some((execution) => execution.error === undefined),
         };
+        // #1741: the SDK's `finalizeGenerateRequestResult` emits its own
+        // `generation:end` unless the result carries this mark, so every
+        // SUCCESSFUL Bedrock generate was counted twice — an extra Langfuse
+        // `model.generation` observation and an extra analytics record per call,
+        // which inflates Bedrock's cost against every other provider. Vertex and
+        // AI Studio have always set it; Bedrock emitted without marking. Set
+        // after construction, like those two, because the field is deliberately
+        // not part of the public `EnhancedGenerateResult` surface.
+        generateResult._generationEndEmitted = true;
+        return generateResult;
     }
     async conversationLoop(options) {
         // The step cap is now the same `maxSteps || DEFAULT_MAX_STEPS` the
@@ -1072,6 +1091,16 @@ export class AmazonBedrockProvider extends BaseProvider {
                     // never injected and generation:end is emitted by hand for
                     // Pipeline B (Langfuse).
                     if (streamEmitter) {
+                        // #1741: tell the orchestration's finally block this stream's
+                        // `generation:end` has already been emitted here, exactly as the
+                        // other native stream paths do. The context object is attached to
+                        // the caller's options by `NeuroLink.stream()`; BaseProvider
+                        // spreads the options but carries the same context reference, so
+                        // mutating it is what the orchestration reads back.
+                        const dedupContext = options._streamDedupContext;
+                        if (dedupContext) {
+                            dedupContext.providerEmitted = true;
+                        }
                         streamEmitter.emit("generation:end", {
                             provider: self.providerName,
                             responseTime: Date.now() - startTime,