@juspay/neurolink 11.7.0 → 11.8.0

package/dist/lib/providers/amazonSagemaker.d.ts

@@ -1,9 +1,8 @@
-import type { ZodType } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { StreamOptions } from "../types/index.js";
+import type { LanguageModel } from "../types/index.js";
 /**
  * Amazon SageMaker Provider extending BaseProvider
  */
@@ -21,7 +20,30 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getAISDKModel(): LanguageModel;
-    protected executeStream(_options: StreamOptions, _analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Streaming was previously an `executeStream` override that unconditionally
+     * threw "not yet fully implemented" — while `SageMakerLanguageModel.doStream`
+     * sat one property access away, complete and working, with its own fallback
+     * to a synthetic stream when the endpoint does not support true streaming.
+     *
+     * This adapts that AI-SDK-shaped result to `BaseProvider`'s `doStream` hook,
+     * and the inherited default supplies `executeStream`. The two shapes differ:
+     * the language model emits typed parts (`text-delta`, `finish`) on a
+     * `ReadableStream`, while the hook wants text chunks plus promises for how
+     * the turn ended. Those promises are resolved from the `finish` part by a
+     * detached pump, so they settle whether or not the caller reads a chunk.
+     */
+    protected doStream(options: StreamOptions): Promise<{
+        stream: AsyncIterable<{
+            content: string;
+        }>;
+        finishReason: Promise<string>;
+        usage: Promise<{
+            inputTokens: number;
+            outputTokens: number;
+        }>;
+        warnings?: string[];
+    }>;
     protected formatProviderError(error: unknown): Error;
     /**
      * Get SageMaker-specific provider information

package/dist/lib/providers/amazonSagemaker.js

@@ -1,4 +1,5 @@
 import { BaseProvider } from "../core/baseProvider.js";
+import { createStreamChannel } from "../core/streamChannel.js";
 import { logger } from "../utils/logger.js";
 import { withSpan } from "../telemetry/withSpan.js";
 import { tracers } from "../telemetry/tracers.js";
@@ -20,7 +21,25 @@ export class AmazonSageMakerProvider extends BaseProvider {
         super(modelName, "sagemaker", neurolink);
         try {
             // Load and validate configuration, then overlay per-request credentials
-            const baseConfig = getSageMakerConfig(credentials?.region ?? region);
+            // Credentials are passed in rather than overlaid afterwards, so they
+            // are present when the config is validated.
+            const baseConfig = getSageMakerConfig(credentials?.region ?? region, {
+                ...(credentials?.region !== undefined && {
+                    region: credentials.region,
+                }),
+                ...(credentials?.accessKeyId !== undefined && {
+                    accessKeyId: credentials.accessKeyId,
+                }),
+                ...(credentials?.secretAccessKey !== undefined && {
+                    secretAccessKey: credentials.secretAccessKey,
+                }),
+                ...(credentials?.sessionToken !== undefined && {
+                    sessionToken: credentials.sessionToken,
+                }),
+                ...(credentials?.endpoint !== undefined && {
+                    endpoint: credentials.endpoint,
+                }),
+            });
             this.sagemakerConfig = {
                 ...baseConfig,
                 ...(credentials?.region !== undefined && {
@@ -74,7 +93,20 @@ export class AmazonSageMakerProvider extends BaseProvider {
         const smModel = this.sagemakerModel;
         return smModel;
     }
-    async executeStream(_options, _analysisSchema) {
+    /**
+     * Streaming was previously an `executeStream` override that unconditionally
+     * threw "not yet fully implemented" — while `SageMakerLanguageModel.doStream`
+     * sat one property access away, complete and working, with its own fallback
+     * to a synthetic stream when the endpoint does not support true streaming.
+     *
+     * This adapts that AI-SDK-shaped result to `BaseProvider`'s `doStream` hook,
+     * and the inherited default supplies `executeStream`. The two shapes differ:
+     * the language model emits typed parts (`text-delta`, `finish`) on a
+     * `ReadableStream`, while the hook wants text chunks plus promises for how
+     * the turn ended. Those promises are resolved from the `finish` part by a
+     * detached pump, so they settle whether or not the caller reads a chunk.
+     */
+    async doStream(options) {
         return withSpan({
             name: "neurolink.provider.sagemaker.stream",
             tracer: tracers.stream,
@@ -83,16 +115,81 @@ export class AmazonSageMakerProvider extends BaseProvider {
                 "model.name": this.modelName,
                 "sagemaker.endpoint": this.modelConfig.endpointName,
                 "sagemaker.region": this.sagemakerConfig.region,
-                "sagemaker.not_implemented": true,
             },
         }, async () => {
             try {
-                // For now, throw an error indicating this is not yet implemented
-                throw new SageMakerError("SageMaker streaming not yet fully implemented. Coming in next phase.", {
-                    code: "MODEL_ERROR",
-                    statusCode: 501,
-                    endpoint: this.modelConfig.endpointName,
+                const messages = await this.buildMessagesForStream(options);
+                const result = await this.sagemakerModel.doStream({
+                    prompt: messages,
+                    maxTokens: options.maxTokens,
+                    temperature: options.temperature,
+                });
+                // Settled from the `finish` part below. A turn that ends without one
+                // — a truncated or errored stream — still settles, so a caller
+                // awaiting either promise cannot hang.
+                let settleFinishReason;
+                let settleUsage;
+                const finishReason = new Promise((resolve) => {
+                    settleFinishReason = resolve;
+                });
+                const usage = new Promise((resolve) => {
+                    settleUsage = resolve;
                 });
+                // The source is drained by a detached pump rather than lazily by the
+                // consumer. Resolving `finishReason`/`usage` from inside a generator
+                // ties them to somebody iterating it, and the inherited
+                // `executeStream` chains analytics off exactly those promises — so a
+                // caller that awaits `result.analytics` without consuming the stream
+                // would wait forever. Pumping here means the turn completes, and
+                // both promises settle, whether or not anyone reads a chunk.
+                const channel = createStreamChannel();
+                void (async () => {
+                    const reader = result.stream.getReader();
+                    let sawFinish = false;
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                break;
+                            }
+                            const part = value;
+                            if (part.type === "text-delta" && part.textDelta) {
+                                channel.push({ content: part.textDelta });
+                                continue;
+                            }
+                            if (part.type === "finish") {
+                                sawFinish = true;
+                                settleFinishReason(part.finishReason ?? "stop");
+                                settleUsage({
+                                    inputTokens: part.usage?.inputTokens ?? part.usage?.promptTokens ?? 0,
+                                    outputTokens: part.usage?.outputTokens ??
+                                        part.usage?.completionTokens ??
+                                        0,
+                                });
+                            }
+                        }
+                        channel.close();
+                    }
+                    catch (error) {
+                        channel.error(error);
+                    }
+                    finally {
+                        reader.releaseLock();
+                        // A stream that ended without a finish part — truncated or
+                        // errored — must still settle both promises, or the same hang
+                        // returns by a different route.
+                        if (!sawFinish) {
+                            settleFinishReason("unknown");
+                            settleUsage({ inputTokens: 0, outputTokens: 0 });
+                        }
+                    }
+                })();
+                return {
+                    stream: channel.iterable,
+                    finishReason,
+                    usage,
+                    warnings: (result.warnings ?? []).map((warning) => warning.message ?? String(warning)),
+                };
             }
             catch (error) {
                 throw this.handleProviderError(error);

package/dist/lib/providers/sagemaker/config.d.ts

@@ -18,7 +18,19 @@ import type { SageMakerConfig, SageMakerModelConfig } from "../../types/index.js
  * @returns Validated SageMaker configuration
  * @throws {Error} When required configuration is missing or invalid
  */
-export declare function getSageMakerConfig(region?: string): SageMakerConfig;
+export declare function getSageMakerConfig(region?: string, 
+/**
+ * Per-request credentials, applied BEFORE validation.
+ *
+ * They have to participate in validation rather than be overlaid onto an
+ * already-validated result: this function throws when accessKeyId or
+ * secretAccessKey is empty, so a caller passing credentials explicitly
+ * still had to have AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY set in the
+ * environment or construction failed before their values were ever looked
+ * at. That made `credentials.sagemaker` unusable on its own, which is the
+ * entire point of per-request credentials.
+ */
+overrides?: Partial<Pick<SageMakerConfig, "region" | "accessKeyId" | "secretAccessKey" | "sessionToken" | "endpoint">>): SageMakerConfig;
 /**
  * Load and validate SageMaker model configuration
  *

package/dist/lib/providers/sagemaker/config.js

@@ -55,28 +55,65 @@ const modelConfigCache = new Map();
  * @returns Validated SageMaker configuration
  * @throws {Error} When required configuration is missing or invalid
  */
-export function getSageMakerConfig(region) {
-    // Return cached config if available
-    if (configCache) {
+export function getSageMakerConfig(region, 
+/**
+ * Per-request credentials, applied BEFORE validation.
+ *
+ * They have to participate in validation rather than be overlaid onto an
+ * already-validated result: this function throws when accessKeyId or
+ * secretAccessKey is empty, so a caller passing credentials explicitly
+ * still had to have AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY set in the
+ * environment or construction failed before their values were ever looked
+ * at. That made `credentials.sagemaker` unusable on its own, which is the
+ * entire point of per-request credentials.
+ */
+overrides) {
+    // The cache holds the environment-derived config, so it can only be used
+    // when this call adds nothing of its own. Emptiness is decided by whether
+    // any field is actually set, not by whether an object was passed: the
+    // provider always passes an object literal, which is `{}` — and truthy —
+    // when the caller supplied no credentials. Testing the object itself would
+    // bypass the cache on every ordinary call and discard configuration loaded
+    // from file along with it.
+    // The `region` ARGUMENT counts as request-specific too, not just the
+    // overrides object. The provider passes its constructor region through it,
+    // so treating such a call as environment-derived would let it return a
+    // cached config carrying a different region — or cache its own explicit
+    // region and hand that to every later caller.
+    const hasRequestSpecificInput = region !== undefined ||
+        (overrides !== undefined &&
+            Object.values(overrides).some((value) => value !== undefined));
+    if (configCache && !hasRequestSpecificInput) {
         return configCache;
     }
+    const explicitRegion = overrides?.region ?? region;
     const config = {
-        region: region ||
-            process.env.SAGEMAKER_REGION ||
-            process.env.AWS_REGION ||
-            "us-east-1",
-        accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
-        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "",
-        sessionToken: process.env.AWS_SESSION_TOKEN,
+        // An explicitly supplied region is preserved even when empty, so the
+        // schema's min(1) rejects it rather than it being silently replaced by
+        // the environment. Only an absent one falls through.
+        region: explicitRegion !== undefined
+            ? explicitRegion
+            : process.env.SAGEMAKER_REGION || process.env.AWS_REGION || "us-east-1",
+        // `??`, not `||`: an explicitly supplied empty credential must reach
+        // validation and be rejected there. With `||` it reads as absent and the
+        // request silently runs on whatever ambient AWS credentials the machine
+        // happens to have — which is precisely the per-request isolation this
+        // parameter exists to provide.
+        accessKeyId: overrides?.accessKeyId ?? process.env.AWS_ACCESS_KEY_ID ?? "",
+        secretAccessKey: overrides?.secretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY ?? "",
+        sessionToken: overrides?.sessionToken ?? process.env.AWS_SESSION_TOKEN,
         timeout: parseInt(process.env.SAGEMAKER_TIMEOUT || "30000"),
         maxRetries: parseInt(process.env.SAGEMAKER_MAX_RETRIES || "3"),
-        endpoint: process.env.SAGEMAKER_ENDPOINT,
+        endpoint: overrides?.endpoint ?? process.env.SAGEMAKER_ENDPOINT,
     };
     // Validate configuration using Zod schema
     try {
         const validatedConfig = SageMakerConfigSchema.parse(config);
-        // Cache the validated configuration
-        configCache = validatedConfig;
+        // Only the environment-derived config is cacheable; a per-request result
+        // must not become the answer for every later caller.
+        if (!hasRequestSpecificInput) {
+            configCache = validatedConfig;
+        }
         return validatedConfig;
     }
     catch (error) {

package/dist/lib/utils/providerRetry.js

@@ -59,6 +59,22 @@ export function duckTypedStatusCode(error) {
     if (typeof err.status === "number") {
         return err.status;
     }
+    // AWS SDK v3 puts the HTTP status on `$metadata.httpStatusCode` and nowhere
+    // else, so without this branch no AWS error carries a status code as far as
+    // anything here is concerned. That is not only a retry question: this
+    // function also feeds `classifyProviderError` and the retry telemetry, so a
+    // Bedrock or SageMaker 429 was not recognisable as a rate limit, and a 5xx
+    // not recognisable as transient, by any status-based path. Name-based
+    // classification (ThrottlingException, AccessDeniedException) still worked,
+    // which is why this stayed hidden.
+    const metadata = err.$metadata;
+    if (typeof metadata === "object" && metadata !== null) {
+        const httpStatusCode = metadata
+            .httpStatusCode;
+        if (typeof httpStatusCode === "number") {
+            return httpStatusCode;
+        }
+    }
     return undefined;
 }
 /**

package/dist/providers/amazonSagemaker.d.ts

@@ -1,9 +1,8 @@
-import type { ZodType } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { StreamOptions } from "../types/index.js";
+import type { LanguageModel } from "../types/index.js";
 /**
  * Amazon SageMaker Provider extending BaseProvider
  */
@@ -21,7 +20,30 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getAISDKModel(): LanguageModel;
-    protected executeStream(_options: StreamOptions, _analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Streaming was previously an `executeStream` override that unconditionally
+     * threw "not yet fully implemented" — while `SageMakerLanguageModel.doStream`
+     * sat one property access away, complete and working, with its own fallback
+     * to a synthetic stream when the endpoint does not support true streaming.
+     *
+     * This adapts that AI-SDK-shaped result to `BaseProvider`'s `doStream` hook,
+     * and the inherited default supplies `executeStream`. The two shapes differ:
+     * the language model emits typed parts (`text-delta`, `finish`) on a
+     * `ReadableStream`, while the hook wants text chunks plus promises for how
+     * the turn ended. Those promises are resolved from the `finish` part by a
+     * detached pump, so they settle whether or not the caller reads a chunk.
+     */
+    protected doStream(options: StreamOptions): Promise<{
+        stream: AsyncIterable<{
+            content: string;
+        }>;
+        finishReason: Promise<string>;
+        usage: Promise<{
+            inputTokens: number;
+            outputTokens: number;
+        }>;
+        warnings?: string[];
+    }>;
     protected formatProviderError(error: unknown): Error;
     /**
      * Get SageMaker-specific provider information

package/dist/providers/amazonSagemaker.js

@@ -1,4 +1,5 @@
 import { BaseProvider } from "../core/baseProvider.js";
+import { createStreamChannel } from "../core/streamChannel.js";
 import { logger } from "../utils/logger.js";
 import { withSpan } from "../telemetry/withSpan.js";
 import { tracers } from "../telemetry/tracers.js";
@@ -20,7 +21,25 @@ export class AmazonSageMakerProvider extends BaseProvider {
         super(modelName, "sagemaker", neurolink);
         try {
             // Load and validate configuration, then overlay per-request credentials
-            const baseConfig = getSageMakerConfig(credentials?.region ?? region);
+            // Credentials are passed in rather than overlaid afterwards, so they
+            // are present when the config is validated.
+            const baseConfig = getSageMakerConfig(credentials?.region ?? region, {
+                ...(credentials?.region !== undefined && {
+                    region: credentials.region,
+                }),
+                ...(credentials?.accessKeyId !== undefined && {
+                    accessKeyId: credentials.accessKeyId,
+                }),
+                ...(credentials?.secretAccessKey !== undefined && {
+                    secretAccessKey: credentials.secretAccessKey,
+                }),
+                ...(credentials?.sessionToken !== undefined && {
+                    sessionToken: credentials.sessionToken,
+                }),
+                ...(credentials?.endpoint !== undefined && {
+                    endpoint: credentials.endpoint,
+                }),
+            });
             this.sagemakerConfig = {
                 ...baseConfig,
                 ...(credentials?.region !== undefined && {
@@ -74,7 +93,20 @@ export class AmazonSageMakerProvider extends BaseProvider {
         const smModel = this.sagemakerModel;
         return smModel;
     }
-    async executeStream(_options, _analysisSchema) {
+    /**
+     * Streaming was previously an `executeStream` override that unconditionally
+     * threw "not yet fully implemented" — while `SageMakerLanguageModel.doStream`
+     * sat one property access away, complete and working, with its own fallback
+     * to a synthetic stream when the endpoint does not support true streaming.
+     *
+     * This adapts that AI-SDK-shaped result to `BaseProvider`'s `doStream` hook,
+     * and the inherited default supplies `executeStream`. The two shapes differ:
+     * the language model emits typed parts (`text-delta`, `finish`) on a
+     * `ReadableStream`, while the hook wants text chunks plus promises for how
+     * the turn ended. Those promises are resolved from the `finish` part by a
+     * detached pump, so they settle whether or not the caller reads a chunk.
+     */
+    async doStream(options) {
         return withSpan({
             name: "neurolink.provider.sagemaker.stream",
             tracer: tracers.stream,
@@ -83,16 +115,81 @@ export class AmazonSageMakerProvider extends BaseProvider {
                 "model.name": this.modelName,
                 "sagemaker.endpoint": this.modelConfig.endpointName,
                 "sagemaker.region": this.sagemakerConfig.region,
-                "sagemaker.not_implemented": true,
             },
         }, async () => {
             try {
-                // For now, throw an error indicating this is not yet implemented
-                throw new SageMakerError("SageMaker streaming not yet fully implemented. Coming in next phase.", {
-                    code: "MODEL_ERROR",
-                    statusCode: 501,
-                    endpoint: this.modelConfig.endpointName,
+                const messages = await this.buildMessagesForStream(options);
+                const result = await this.sagemakerModel.doStream({
+                    prompt: messages,
+                    maxTokens: options.maxTokens,
+                    temperature: options.temperature,
+                });
+                // Settled from the `finish` part below. A turn that ends without one
+                // — a truncated or errored stream — still settles, so a caller
+                // awaiting either promise cannot hang.
+                let settleFinishReason;
+                let settleUsage;
+                const finishReason = new Promise((resolve) => {
+                    settleFinishReason = resolve;
+                });
+                const usage = new Promise((resolve) => {
+                    settleUsage = resolve;
                 });
+                // The source is drained by a detached pump rather than lazily by the
+                // consumer. Resolving `finishReason`/`usage` from inside a generator
+                // ties them to somebody iterating it, and the inherited
+                // `executeStream` chains analytics off exactly those promises — so a
+                // caller that awaits `result.analytics` without consuming the stream
+                // would wait forever. Pumping here means the turn completes, and
+                // both promises settle, whether or not anyone reads a chunk.
+                const channel = createStreamChannel();
+                void (async () => {
+                    const reader = result.stream.getReader();
+                    let sawFinish = false;
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                break;
+                            }
+                            const part = value;
+                            if (part.type === "text-delta" && part.textDelta) {
+                                channel.push({ content: part.textDelta });
+                                continue;
+                            }
+                            if (part.type === "finish") {
+                                sawFinish = true;
+                                settleFinishReason(part.finishReason ?? "stop");
+                                settleUsage({
+                                    inputTokens: part.usage?.inputTokens ?? part.usage?.promptTokens ?? 0,
+                                    outputTokens: part.usage?.outputTokens ??
+                                        part.usage?.completionTokens ??
+                                        0,
+                                });
+                            }
+                        }
+                        channel.close();
+                    }
+                    catch (error) {
+                        channel.error(error);
+                    }
+                    finally {
+                        reader.releaseLock();
+                        // A stream that ended without a finish part — truncated or
+                        // errored — must still settle both promises, or the same hang
+                        // returns by a different route.
+                        if (!sawFinish) {
+                            settleFinishReason("unknown");
+                            settleUsage({ inputTokens: 0, outputTokens: 0 });
+                        }
+                    }
+                })();
+                return {
+                    stream: channel.iterable,
+                    finishReason,
+                    usage,
+                    warnings: (result.warnings ?? []).map((warning) => warning.message ?? String(warning)),
+                };
             }
             catch (error) {
                 throw this.handleProviderError(error);

package/dist/providers/sagemaker/config.d.ts

@@ -18,7 +18,19 @@ import type { SageMakerConfig, SageMakerModelConfig } from "../../types/index.js
  * @returns Validated SageMaker configuration
  * @throws {Error} When required configuration is missing or invalid
  */
-export declare function getSageMakerConfig(region?: string): SageMakerConfig;
+export declare function getSageMakerConfig(region?: string, 
+/**
+ * Per-request credentials, applied BEFORE validation.
+ *
+ * They have to participate in validation rather than be overlaid onto an
+ * already-validated result: this function throws when accessKeyId or
+ * secretAccessKey is empty, so a caller passing credentials explicitly
+ * still had to have AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY set in the
+ * environment or construction failed before their values were ever looked
+ * at. That made `credentials.sagemaker` unusable on its own, which is the
+ * entire point of per-request credentials.
+ */
+overrides?: Partial<Pick<SageMakerConfig, "region" | "accessKeyId" | "secretAccessKey" | "sessionToken" | "endpoint">>): SageMakerConfig;
 /**
  * Load and validate SageMaker model configuration
  *

package/dist/providers/sagemaker/config.js

@@ -55,28 +55,65 @@ const modelConfigCache = new Map();
  * @returns Validated SageMaker configuration
  * @throws {Error} When required configuration is missing or invalid
  */
-export function getSageMakerConfig(region) {
-    // Return cached config if available
-    if (configCache) {
+export function getSageMakerConfig(region, 
+/**
+ * Per-request credentials, applied BEFORE validation.
+ *
+ * They have to participate in validation rather than be overlaid onto an
+ * already-validated result: this function throws when accessKeyId or
+ * secretAccessKey is empty, so a caller passing credentials explicitly
+ * still had to have AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY set in the
+ * environment or construction failed before their values were ever looked
+ * at. That made `credentials.sagemaker` unusable on its own, which is the
+ * entire point of per-request credentials.
+ */
+overrides) {
+    // The cache holds the environment-derived config, so it can only be used
+    // when this call adds nothing of its own. Emptiness is decided by whether
+    // any field is actually set, not by whether an object was passed: the
+    // provider always passes an object literal, which is `{}` — and truthy —
+    // when the caller supplied no credentials. Testing the object itself would
+    // bypass the cache on every ordinary call and discard configuration loaded
+    // from file along with it.
+    // The `region` ARGUMENT counts as request-specific too, not just the
+    // overrides object. The provider passes its constructor region through it,
+    // so treating such a call as environment-derived would let it return a
+    // cached config carrying a different region — or cache its own explicit
+    // region and hand that to every later caller.
+    const hasRequestSpecificInput = region !== undefined ||
+        (overrides !== undefined &&
+            Object.values(overrides).some((value) => value !== undefined));
+    if (configCache && !hasRequestSpecificInput) {
         return configCache;
     }
+    const explicitRegion = overrides?.region ?? region;
     const config = {
-        region: region ||
-            process.env.SAGEMAKER_REGION ||
-            process.env.AWS_REGION ||
-            "us-east-1",
-        accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
-        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "",
-        sessionToken: process.env.AWS_SESSION_TOKEN,
+        // An explicitly supplied region is preserved even when empty, so the
+        // schema's min(1) rejects it rather than it being silently replaced by
+        // the environment. Only an absent one falls through.
+        region: explicitRegion !== undefined
+            ? explicitRegion
+            : process.env.SAGEMAKER_REGION || process.env.AWS_REGION || "us-east-1",
+        // `??`, not `||`: an explicitly supplied empty credential must reach
+        // validation and be rejected there. With `||` it reads as absent and the
+        // request silently runs on whatever ambient AWS credentials the machine
+        // happens to have — which is precisely the per-request isolation this
+        // parameter exists to provide.
+        accessKeyId: overrides?.accessKeyId ?? process.env.AWS_ACCESS_KEY_ID ?? "",
+        secretAccessKey: overrides?.secretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY ?? "",
+        sessionToken: overrides?.sessionToken ?? process.env.AWS_SESSION_TOKEN,
         timeout: parseInt(process.env.SAGEMAKER_TIMEOUT || "30000"),
         maxRetries: parseInt(process.env.SAGEMAKER_MAX_RETRIES || "3"),
-        endpoint: process.env.SAGEMAKER_ENDPOINT,
+        endpoint: overrides?.endpoint ?? process.env.SAGEMAKER_ENDPOINT,
     };
     // Validate configuration using Zod schema
     try {
         const validatedConfig = SageMakerConfigSchema.parse(config);
-        // Cache the validated configuration
-        configCache = validatedConfig;
+        // Only the environment-derived config is cacheable; a per-request result
+        // must not become the answer for every later caller.
+        if (!hasRequestSpecificInput) {
+            configCache = validatedConfig;
+        }
         return validatedConfig;
     }
     catch (error) {

package/dist/utils/providerRetry.js

@@ -58,6 +58,22 @@ export function duckTypedStatusCode(error) {
     if (typeof err.status === "number") {
         return err.status;
     }
+    // AWS SDK v3 puts the HTTP status on `$metadata.httpStatusCode` and nowhere
+    // else, so without this branch no AWS error carries a status code as far as
+    // anything here is concerned. That is not only a retry question: this
+    // function also feeds `classifyProviderError` and the retry telemetry, so a
+    // Bedrock or SageMaker 429 was not recognisable as a rate limit, and a 5xx
+    // not recognisable as transient, by any status-based path. Name-based
+    // classification (ThrottlingException, AccessDeniedException) still worked,
+    // which is why this stayed hidden.
+    const metadata = err.$metadata;
+    if (typeof metadata === "object" && metadata !== null) {
+        const httpStatusCode = metadata
+            .httpStatusCode;
+        if (typeof httpStatusCode === "number") {
+            return httpStatusCode;
+        }
+    }
     return undefined;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.7.0",
+  "version": "11.8.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -212,7 +212,8 @@
     "test:vector-chroma": "npx tsx test/continuous-test-suite-vector-chroma.ts",
     "test:vector-pgvector": "npx tsx test/continuous-test-suite-vector-pgvector.ts",
     "test:vector-pinecone": "npx tsx test/continuous-test-suite-vector-pinecone.ts",
-    "test:bedrock-loop-characterization": "tsx test/continuous-test-suite-bedrock-loop-characterization.ts"
+    "test:bedrock-loop-characterization": "tsx test/continuous-test-suite-bedrock-loop-characterization.ts",
+    "test:sagemaker-streaming": "tsx test/continuous-test-suite-sagemaker-streaming.ts"
   },
   "files": [
     "dist",