@juspay/neurolink 9.63.0 → 9.64.0

package/dist/lib/utils/modelDetection.js

@@ -1,6 +1,7 @@
 /**
  * Model detection utilities for capability checking
  */
+import { IMAGE_GENERATION_MODELS } from "../core/constants.js";
 /**
  * Check if model name is valid for detection functions
  */
@@ -78,4 +79,30 @@ export function getModelFamily(modelName) {
     }
     return "unknown";
 }
+// Compiled once at module load — hasRestrictedOutputLimit() is called per
+// request and previously rebuilt this array on every call.
+const IMAGE_MODEL_PATTERNS = IMAGE_GENERATION_MODELS.map((m) => new RegExp(`^${m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i"));
+/**
+ * Check if a model has restricted output token limit (32768 max)
+ * This applies to:
+ * - All Gemini 3 models (gemini-3-flash, gemini-3-pro, etc.)
+ * - Image generation models (gemini-2.5-flash-image, gemini-3-pro-image-preview)
+ */
+export function hasRestrictedOutputLimit(modelName) {
+    if (!isValidModelName(modelName)) {
+        return false;
+    }
+    // Check for Gemini 3 models (anchored regex for consistency)
+    if (/^gemini-3/i.test(modelName)) {
+        return true;
+    }
+    if (IMAGE_MODEL_PATTERNS.some((pattern) => pattern.test(modelName))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get the max output tokens for a model (32768 for restricted models)
+ */
+export const RESTRICTED_OUTPUT_TOKEN_LIMIT = 32768;
 //# sourceMappingURL=modelDetection.js.map

package/dist/lib/utils/providerHealth.js

@@ -349,7 +349,7 @@ export class ProviderHealthChecker {
                     `    • claude-sonnet-4@20250514, claude-opus-4@20250514\n` +
                     `    • claude-3-5-sonnet-20241022, claude-3-5-haiku-20241022\n` +
                     `    • claude-3-sonnet-20240229, claude-3-haiku-20240307, claude-3-opus-20240229\n` +
-                    `  Implementation: Uses @ai-sdk/google-vertex with dual provider setup\n` +
+                    `  Implementation: Uses native SDKs (@google/genai for Gemini, @anthropic-ai/vertex-sdk for Claude)\n` +
                     `  Authentication: Requires Google Cloud project with Vertex AI API enabled\n` +
                     `  Note: Anthropic models require Anthropic integration in your Google Cloud project`);
             }
@@ -969,13 +969,13 @@ export class ProviderHealthChecker {
         logger.debug("Starting comprehensive Vertex Anthropic support verification");
         try {
             // 1. Check SDK module availability
-            logger.debug("Checking @ai-sdk/google-vertex/anthropic module availability");
-            const anthropicModule = await import("@ai-sdk/google-vertex/anthropic");
+            logger.debug("Checking @anthropic-ai/vertex-sdk module availability");
+            const anthropicModule = await import("@anthropic-ai/vertex-sdk");
             result.hasCreateVertexAnthropic =
-                typeof anthropicModule.createVertexAnthropic === "function";
-            result.hasCorrectTypes = true; // Types are bundled with the function
+                typeof anthropicModule.AnthropicVertex === "function";
+            result.hasCorrectTypes = true; // Types are bundled with the class
             if (!result.hasCreateVertexAnthropic) {
-                result.troubleshooting.push("📦 Update @ai-sdk/google-vertex to latest version with Anthropic support", "🔄 Run: npm install @ai-sdk/google-vertex@latest", "📖 See: https://sdk.vercel.ai/providers/ai-sdk-providers/google-vertex#anthropic-models");
+                result.troubleshooting.push("📦 Install @anthropic-ai/vertex-sdk for Claude on Vertex AI support", "🔄 Run: npm install @anthropic-ai/vertex-sdk", "📖 See: https://docs.anthropic.com/en/api/claude-on-vertex-ai");
                 return result;
             }
             logger.debug("SDK module verified successfully");
@@ -1065,7 +1065,7 @@ export class ProviderHealthChecker {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : undefined,
             });
-            result.recommendations.push("❌ Comprehensive Anthropic support check failed", `🐛 Error: ${error instanceof Error ? error.message : String(error)}`, "", "🔧 Troubleshooting steps:", "1. Update @ai-sdk/google-vertex to latest version", "2. Verify Google Cloud authentication setup", "3. Check project ID and region configuration", "4. Enable Vertex AI API in Google Cloud Console", "5. Enable Anthropic integration in Vertex AI Model Garden");
+            result.recommendations.push("❌ Comprehensive Anthropic support check failed", `🐛 Error: ${error instanceof Error ? error.message : String(error)}`, "", "🔧 Troubleshooting steps:", "1. Verify @google-cloud/vertexai and @anthropic-ai/vertex-sdk are properly installed", "2. Verify Google Cloud authentication setup", "3. Check project ID and region configuration", "4. Enable Vertex AI API in Google Cloud Console", "5. Enable Anthropic integration in Vertex AI Model Garden");
         }
         return result;
     }

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

@@ -27,7 +27,7 @@ export declare function ensureNestedSchemaTypes(schema: Record<string, unknown>)
  * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) -- extracted directly
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) -- returned as-is
  */
-export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema, target?: "jsonSchema7" | "openApi3"): object;
 export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;
 /**
  * Check if a value is a Zod schema

package/dist/lib/utils/schemaConversion.js

@@ -1,7 +1,25 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { jsonSchemaToZod } from "json-schema-to-zod";
+import * as zodModule from "zod";
 import { z } from "zod";
 import { logger } from "./logger.js";
+// Zod 4 ships a built-in `z.toJSONSchema(...)`. Zod 3 does not — it returned
+// nothing of the sort and we relied entirely on `zod-to-json-schema`. The
+// `zod-to-json-schema` package only understands Zod 3's internal `_def`
+// shape, so feeding it a Zod 4 schema yields an empty `{}` (it silently
+// produces `definitions: { ToolParameters: {} }`). When this happens
+// downstream callers send an empty `responseSchema` to the model and get
+// back arbitrary JSON, which is exactly how the Vertex Structured-Output
+// regressions surfaced. Detect the Zod 4 helper at module load and prefer
+// it for actual Zod schemas.
+// Zod 4 spells the OpenAPI target as "openapi-3.0" (with a dot) while the
+// third-party zod-to-json-schema package uses "openApi3". Internally we use
+// the latter for backwards compatibility with existing call sites; this map
+// translates to the dialect Zod 4 actually accepts. The Zod4Native* types
+// live in src/lib/types/aliases.ts per project rule 2.
+const zodToJsonSchemaV4 = typeof zodModule.toJSONSchema === "function"
+    ? zodModule.toJSONSchema
+    : undefined;
 /**
  * Resolve a deep JSON pointer path within a schema.
  * Handles paths like "#/definitions/ToolParameters/properties/foo/properties/bar"
@@ -96,7 +114,12 @@ export function inlineJsonSchema(schema, definitions, visited = new Set(), rootS
             visited.delete(refPath);
             return inlined;
         }
-        logger.debug(`[SCHEMA-INLINE] Could not resolve $ref: ${refPath}`);
+        // Unresolved $ref: warn and preserve the original node verbatim. Falling
+        // through to the copy loop below would strip the $ref key and silently
+        // turn a ref-only node into an empty {}, which broadens validation
+        // instead of failing closed.
+        logger.warn(`[SCHEMA-INLINE] Could not resolve $ref: ${refPath}`);
+        return { ...schema };
     }
     // Create result without $ref and definitions
     const result = {};
@@ -279,7 +302,12 @@ export function ensureNestedSchemaTypes(schema) {
  * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) -- extracted directly
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) -- returned as-is
  */
-export function convertZodToJsonSchema(zodSchema) {
+export function convertZodToJsonSchema(zodSchema, 
+// Default to JSON Schema draft-07 so non-Vertex consumers (Bedrock, MCP
+// tool registration, etc.) keep their pre-migration dialect. Vertex/Gemini
+// callers opt into "openApi3" explicitly to get `nullable: true` instead
+// of `anyOf: [..., {type: "null"}]`.
+target = "jsonSchema7") {
     const schema = zodSchema;
     if (!schema || typeof schema !== "object") {
         return { type: "object", properties: {} };
@@ -295,14 +323,41 @@ export function convertZodToJsonSchema(zodSchema) {
     if (!isZodSchema(schema)) {
         return ensureNestedSchemaTypes(ensureTypeField(schema));
     }
-    // Actual Zod schema — convert via zod-to-json-schema
+    // Actual Zod schema — prefer Zod 4's native `z.toJSONSchema` when
+    // available (the runtime version of `zod` here is Zod 4), then fall
+    // back to `zod-to-json-schema` for Zod 3 schemas that external callers
+    // might still pass in.
+    //
+    // Translate our `target` to Zod 4's native dialect identifier so the
+    // openApi3 path emits the OpenAPI 3 schema shape Vertex/Gemini expect
+    // (and not the default draft-07 anyOf/null union).
+    if (zodToJsonSchemaV4) {
+        const nativeTarget = target === "openApi3" ? "openapi-3.0" : "draft-07";
+        try {
+            const native = zodToJsonSchemaV4(zodSchema, {
+                target: nativeTarget,
+            });
+            // Drop the $schema metadata Vertex/Gemini doesn't need, then walk to
+            // backfill any missing nested types (Zod 4's output is already flat
+            // — no $defs/$ref by default — but the helper is cheap and matches
+            // the Zod 3 path's contract).
+            const flat = { ...native };
+            delete flat.$schema;
+            const inlined = inlineJsonSchema(flat);
+            return ensureNestedSchemaTypes(ensureTypeField(inlined));
+        }
+        catch (error) {
+            logger.warn("Native z.toJSONSchema failed; falling back to zod-to-json-schema", { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    // Zod 3 fallback path
     try {
         // Zod 4→3 boundary: zodToJsonSchema types reference Zod 3's ZodSchema via zod/v3.
         // Runtime compatible — cast through unknown at this third-party boundary only.
         const zodV3Schema = zodSchema;
         const jsonSchema = zodToJsonSchema(zodV3Schema, {
             name: "ToolParameters",
-            target: "openApi3", // Use OpenAPI 3.0 for nullable: true instead of anyOf with null (required for Vertex AI)
+            target,
             errorMessages: true,
         });
         // zodToJsonSchema with 'name' produces { $ref: "#/definitions/ToolParameters", definitions: {...} }

package/dist/lib/utils/tokenLimits.js

@@ -2,30 +2,14 @@
  * Provider-specific token limit utilities
  * Provides safe maxTokens values based on provider and model capabilities
  */
-import { PROVIDER_MAX_TOKENS, IMAGE_GENERATION_MODELS, } from "../core/constants.js";
+import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
 import { logger } from "./logger.js";
-// Gemini 3 models and Gemini 2.5 image models have a hard limit of 32768 output tokens
-const GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS = 32768;
-/**
- * Check if a model has the restricted 32768 output token limit
- * This applies to:
- * - All Gemini 3 models (gemini-3-flash, gemini-3-pro, etc.)
- * - All Gemini 2.5 image generation models (gemini-2.5-flash-image)
- */
-function hasRestrictedOutputLimit(model) {
-    if (!model) {
-        return false;
-    }
-    // Check for Gemini 3 models
-    if (model.includes("gemini-3")) {
-        return true;
-    }
-    // Check for image generation models (includes gemini-2.5-flash-image)
-    if (IMAGE_GENERATION_MODELS.some((m) => model.includes(m))) {
-        return true;
-    }
-    return false;
-}
+import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, } from "./modelDetection.js";
+// Restricted-model detection (Gemini 3.x + image-gen models capped at 32768
+// output tokens) lives in modelDetection.ts. Importing the canonical helper
+// keeps both call sites on one definition; the previous local copy used
+// case-sensitive substring matches and could miss identifiers like
+// "Gemini-3-Pro" which the canonical anchored, case-insensitive regex matches.
 /**
  * Get the safe maximum tokens for a provider and model
  */
@@ -33,19 +17,19 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     // CRITICAL: Gemini 3 models AND image generation models have a hard limit of 32768 output tokens
     // This check must happen FIRST, before any other logic, because these models
     // will reject requests with maxOutputTokens > 32768
-    const isRestrictedModel = hasRestrictedOutputLimit(model);
+    const isRestrictedModel = model ? hasRestrictedOutputLimit(model) : false;
     if (isRestrictedModel) {
         // Explicit undefined/null check so a caller-supplied 0 is preserved
-        // (truthy checks would treat 0 as "unset" and silently fall back to the cap).
+        // (truthy guards would treat 0 as "unset" and silently fall back to the cap).
         if (requestedMaxTokens !== undefined &&
             requestedMaxTokens !== null &&
-            requestedMaxTokens > GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS) {
-            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds ${model} limit of ${GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS}. Using ${GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS} instead.`);
-            return GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS;
+            requestedMaxTokens > RESTRICTED_OUTPUT_TOKEN_LIMIT) {
+            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds ${model} limit of ${RESTRICTED_OUTPUT_TOKEN_LIMIT}. Using ${RESTRICTED_OUTPUT_TOKEN_LIMIT} instead.`);
+            return RESTRICTED_OUTPUT_TOKEN_LIMIT;
         }
         // If no maxTokens specified, use the restricted limit as default
         if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
-            return GEMINI_RESTRICTED_MAX_OUTPUT_TOKENS;
+            return RESTRICTED_OUTPUT_TOKEN_LIMIT;
         }
         // Otherwise, use the requested value (it's within limits, including 0)
         return requestedMaxTokens;
@@ -54,7 +38,12 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     const providerLimits = PROVIDER_MAX_TOKENS[provider];
     if (!providerLimits) {
         logger.warn(`Unknown provider ${provider}, no token limits enforced`);
-        return requestedMaxTokens || undefined; // No default limit for unknown providers
+        // Explicit undefined/null check so a caller-supplied 0 is preserved
+        // (truthy guard would silently drop 0 here as it does in the restricted branch).
+        if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
+            return undefined;
+        }
+        return requestedMaxTokens;
     }
     // Get model-specific limit or provider default
     let maxLimit;
@@ -73,8 +62,10 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     else {
         maxLimit = PROVIDER_MAX_TOKENS.default;
     }
-    // If no specific maxTokens requested, return the provider limit
-    if (!requestedMaxTokens) {
+    // If no specific maxTokens requested, return the provider limit.
+    // Use explicit undefined/null so a caller-supplied 0 is preserved
+    // (matches the restricted-model branch above).
+    if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
         return maxLimit;
     }
     // If requested maxTokens exceeds the limit, use the limit and warn

package/dist/memory/hippocampusInitializer.d.ts

@@ -1,2 +1,2 @@
-import { Hippocampus, type HippocampusConfig } from "@juspay/hippocampus";
-export declare function initializeHippocampus(config: HippocampusConfig): Hippocampus | null;
+import type { HippocampusConfig, HippocampusLike } from "../types/index.js";
+export declare function initializeHippocampus(config: HippocampusConfig): HippocampusLike | null;

package/dist/memory/hippocampusInitializer.js

@@ -1,8 +1,38 @@
-import { Hippocampus } from "@juspay/hippocampus";
+import { createRequire } from "node:module";
 import { logger } from "../utils/logger.js";
+// Lazy require so importing NeuroLink core does not fail when the optional
+// peer @juspay/hippocampus is not installed. The package was previously a
+// hard runtime dependency, but Hippocampus declares a peer on
+// @juspay/neurolink which made pnpm pull a registry NeuroLink that
+// transitively required @ai-sdk/google + @ai-sdk/google-vertex into the
+// production graph. Making memory optional breaks that cycle while keeping
+// the same runtime behavior whenever the package is installed.
+const lazyRequire = createRequire(import.meta.url);
+let cachedModule;
+function loadHippocampusModule() {
+    if (cachedModule !== undefined) {
+        return cachedModule;
+    }
+    try {
+        cachedModule = lazyRequire("@juspay/hippocampus");
+        return cachedModule;
+    }
+    catch (error) {
+        cachedModule = null;
+        logger.debug("[memoryInitializer] @juspay/hippocampus is not installed; memory features disabled.", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
 export function initializeHippocampus(config) {
+    const mod = loadHippocampusModule();
+    if (!mod) {
+        logger.warn("[memoryInitializer] Memory configuration provided but @juspay/hippocampus is not installed. Run `pnpm add @juspay/hippocampus` (or your package manager equivalent) to enable memory.");
+        return null;
+    }
     try {
-        const instance = new Hippocampus(config);
+        const instance = new mod.Hippocampus(config);
         logger.info("[memoryInitializer] Memory initialized successfully", {
             storageType: config.storage?.type || "sqlite",
             maxWords: config.maxWords || 50,

package/dist/middleware/builtin/lifecycle.js

@@ -9,6 +9,7 @@
  */
 import { logger } from "../../utils/logger.js";
 import { isRecoverableError } from "../../utils/errorHandling.js";
+import { fireOnErrorOnce } from "../../utils/lifecycleCallbacks.js";
 export function createLifecycleMiddleware(config = {}) {
     const metadata = {
         id: "lifecycle",
@@ -50,22 +51,12 @@ export function createLifecycleMiddleware(config = {}) {
                 return result;
             }
             catch (error) {
-                if (config.onError) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    try {
-                        const callbackResult = config.onError({
-                            error: err,
-                            duration: Date.now() - startTime,
-                            recoverable: isRecoverableError(err),
-                        });
-                        Promise.resolve(callbackResult).catch((e) => {
-                            logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                        });
-                    }
-                    catch (e) {
-                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                    }
-                }
+                const err = error instanceof Error ? error : new Error(String(error));
+                fireOnErrorOnce(config.onError, error, {
+                    error: err,
+                    duration: Date.now() - startTime,
+                    recoverable: isRecoverableError(err),
+                });
                 throw error;
             }
         },
@@ -102,22 +93,12 @@ export function createLifecycleMiddleware(config = {}) {
                             controller.enqueue(chunk);
                         }
                         catch (error) {
-                            if (config.onError) {
-                                const err = error instanceof Error ? error : new Error(String(error));
-                                try {
-                                    const callbackResult = config.onError({
-                                        error: err,
-                                        duration: Date.now() - startTime,
-                                        recoverable: isRecoverableError(err),
-                                    });
-                                    Promise.resolve(callbackResult).catch((e) => {
-                                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                                    });
-                                }
-                                catch (e) {
-                                    logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                                }
-                            }
+                            const err = error instanceof Error ? error : new Error(String(error));
+                            fireOnErrorOnce(config.onError, error, {
+                                error: err,
+                                duration: Date.now() - startTime,
+                                recoverable: isRecoverableError(err),
+                            });
                             throw error;
                         }
                     },
@@ -144,22 +125,12 @@ export function createLifecycleMiddleware(config = {}) {
                 };
             }
             catch (error) {
-                if (config.onError) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    try {
-                        const callbackResult = config.onError({
-                            error: err,
-                            duration: Date.now() - startTime,
-                            recoverable: isRecoverableError(err),
-                        });
-                        Promise.resolve(callbackResult).catch((e) => {
-                            logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                        });
-                    }
-                    catch (e) {
-                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                    }
-                }
+                const err = error instanceof Error ? error : new Error(String(error));
+                fireOnErrorOnce(config.onError, error, {
+                    error: err,
+                    duration: Date.now() - startTime,
+                    recoverable: isRecoverableError(err),
+                });
                 throw error;
             }
         },

package/dist/neurolink.js

@@ -64,6 +64,7 @@ import { getConversationMessages, storeConversationTurn, } from "./utils/convers
 import { CircuitBreaker, ERROR_CODES, ErrorFactory, isAbortError, isRetriableError, logStructuredError, NeuroLinkError, withRetry, withTimeout, } from "./utils/errorHandling.js";
 // Factory processing imports
 import { createCleanStreamOptions, enhanceTextGenerationOptions, processFactoryOptions, processStreamingFactoryOptions, validateFactoryConfig, } from "./utils/factoryProcessing.js";
+import { fireOnErrorOnce } from "./utils/lifecycleCallbacks.js";
 import { logger, mcpLogger } from "./utils/logger.js";
 import { extractMcpErrorText } from "./utils/mcpErrorText.js";
 import { createCustomToolServerInfo, detectCategory, } from "./utils/mcpDefaults.js";
@@ -2753,7 +2754,29 @@ Current user's request: ${currentInput}`;
      * @since 1.0.0
      */
     async generate(optionsOrPrompt) {
-        return this.runWithFallbackOrchestration(optionsOrPrompt, "generate", (opts) => tracers.sdk.startActiveSpan("neurolink.generate", { kind: SpanKind.INTERNAL }, (generateSpan) => this.executeGenerateWithMetricsContext(opts, generateSpan)));
+        const startTime = Date.now();
+        try {
+            return await this.runWithFallbackOrchestration(optionsOrPrompt, "generate", (opts) => tracers.sdk.startActiveSpan("neurolink.generate", { kind: SpanKind.INTERNAL }, (generateSpan) => this.executeGenerateWithMetricsContext(opts, generateSpan)));
+        }
+        catch (error) {
+            // Fire `onError` lifecycle callback for ANY thrown error — including
+            // ones raised before the provider is even instantiated (invalid
+            // provider name, missing credentials, etc.). The downstream
+            // LifecycleMiddleware only fires `onError` once it has wrapped the
+            // AI SDK doGenerate, which is too late for early-resolution failures.
+            // `fireOnErrorOnce` dedupes against the middleware path so the
+            // consumer callback fires at most once per logical failure.
+            const onError = typeof optionsOrPrompt === "object" && optionsOrPrompt !== null
+                ? optionsOrPrompt.onError
+                : undefined;
+            const err = error instanceof Error ? error : new Error(String(error));
+            fireOnErrorOnce(onError, error, {
+                error: err,
+                duration: Date.now() - startTime,
+                recoverable: false,
+            });
+            throw error;
+        }
     }
     /**
      * Curator P2-3: wraps a generate/stream call with the fallback
@@ -3167,6 +3190,12 @@ Current user's request: ${currentInput}`;
             middleware: options.middleware,
             conversationMessages: options.conversationMessages,
             credentials: options.credentials,
+            // Lifecycle callbacks must reach the provider so non-AI-SDK paths
+            // (Vertex's native @google/genai, native Bedrock, Ollama, etc.) can
+            // invoke them directly. Pipeline A also still receives them via the
+            // wrapped middleware config set by applyGenerateLifecycleMiddleware.
+            onFinish: options.onFinish,
+            onError: options.onError,
         };
         const extraContext = options;
         if (extraContext.sessionId || extraContext.userId) {
@@ -5032,7 +5061,25 @@ Current user's request: ${currentInput}`;
                 : [],
             optionKeys: Object.keys(options),
         });
-        return this.streamWithIterationFallback(options);
+        const startTime = Date.now();
+        try {
+            return await this.streamWithIterationFallback(options);
+        }
+        catch (error) {
+            // Fire `onError` for early-resolution failures (invalid provider,
+            // missing credentials, etc.) that surface before the per-chunk
+            // wrapper installed by GoogleVertex / LifecycleMiddleware can run.
+            // `fireOnErrorOnce` dedupes against the middleware path so the
+            // consumer callback fires at most once per logical failure.
+            const onError = options.onError;
+            const err = error instanceof Error ? error : new Error(String(error));
+            fireOnErrorOnce(onError, error, {
+                error: err,
+                duration: Date.now() - startTime,
+                recoverable: false,
+            });
+            throw error;
+        }
     }
     /**
      * Curator P2-3 / Reviewer Finding #2: stream-fallback that also covers

package/dist/providers/googleAiStudio.d.ts

@@ -41,7 +41,8 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     getProviderName(): AIProviderName;
     getDefaultModel(): string;
     /**
-     * 🔧 PHASE 2: Return AI SDK model instance for tool calling
+     * AI SDK model instance — no longer used.
+     * All models are routed through native @google/genai SDK directly.
      */
     getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
@@ -62,8 +63,8 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     private estimateTokenCount;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
-     * Execute stream using native @google/genai SDK for Gemini 3 models
-     * This bypasses @ai-sdk/google to properly handle thought_signature
+     * Execute stream using native @google/genai SDK
+     * Uses @google/genai directly for all Gemini models (2.0, 2.5, 3.x)
      */
     private executeNativeGemini3Stream;
     /**
@@ -75,6 +76,13 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      * Override generate to route Gemini 3 models with tools to native SDK
      */
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Emit `generation:end` so the Pipeline B observability listener creates
+     * a `model.generation` span for native Google AI Studio generate calls.
+     * Without this hand-off the native path silently disappears from
+     * Pipeline B exporters (Langfuse, custom OTEL collectors).
+     */
+    private emitPipelineBGenerationEvent;
     private executeAudioStreamViaGeminiLive;
     protected getDefaultEmbeddingModel(): string;
     /**