@juspay/neurolink 9.64.0 → 9.65.0

package/dist/lib/providers/amazonBedrock.js

@@ -22,10 +22,38 @@ export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
     conversationHistory = [];
     region;
+    /**
+     * Parse the region segment from a Bedrock ARN.
+     * Returns null when the input is not an ARN.
+     *
+     * Supports all AWS partitions:
+     * - `arn:aws:bedrock:…`        (commercial)
+     * - `arn:aws-cn:bedrock:…`     (China)
+     * - `arn:aws-us-gov:bedrock:…` (GovCloud)
+     */
+    static extractRegionFromArn(modelId) {
+        if (!modelId) {
+            return null;
+        }
+        const match = modelId.match(/^arn:aws[a-z0-9-]*:bedrock:([^:]+):/);
+        return match?.[1] ?? null;
+    }
     constructor(modelName, neurolink, region, credentials) {
         super(modelName, "bedrock", neurolink);
+        // When the model is given as a Bedrock ARN (e.g. an inference profile
+        // like `arn:aws:bedrock:us-east-1:123:inference-profile/foo`), Bedrock
+        // requires the runtime client's region to match the region embedded
+        // in the ARN — otherwise it returns "The provided model identifier is
+        // invalid." Auto-extract so users don't have to keep AWS_REGION in
+        // sync with their model ARN.
+        const resolvedModel = modelName || process.env.BEDROCK_MODEL || this.modelName;
+        const arnRegion = AmazonBedrockProvider.extractRegionFromArn(resolvedModel);
         this.region =
-            credentials?.region || region || process.env.AWS_REGION || "us-east-1";
+            credentials?.region ||
+                region ||
+                arnRegion ||
+                process.env.AWS_REGION ||
+                "us-east-1";
         logger.debug("[AmazonBedrockProvider] Starting constructor with extensive logging for debugging");
         // Log environment variables for debugging
         logger.debug(`[AmazonBedrockProvider] Environment check: AWS_REGION=${process.env.AWS_REGION || "undefined"}, AWS_ACCESS_KEY_ID=${process.env.AWS_ACCESS_KEY_ID ? "SET" : "undefined"}, AWS_SECRET_ACCESS_KEY=${process.env.AWS_SECRET_ACCESS_KEY ? "SET" : "undefined"}`);
@@ -274,7 +302,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 "gen_ai.operation.name": "chat",
             },
         }, async (generateSpan) => {
-            logger.info(`🚀 [AmazonBedrockProvider] Starting Bedrock API call at ${new Date().toISOString()}`);
+            logger.info(`[AmazonBedrockProvider] Starting Bedrock API call at ${new Date().toISOString()}`);
             try {
                 // Pre-call validation and logging
                 let region = "unknown";
@@ -287,9 +315,9 @@ export class AmazonBedrockProvider extends BaseProvider {
                 catch {
                     // Region lookup failed — not critical, only used for logging
                 }
-                logger.info(`🔧 [AmazonBedrockProvider] Client region: ${region}`);
-                logger.info(`🔧 [AmazonBedrockProvider] Model: ${this.modelName || this.getDefaultModel()}`);
-                logger.info(`🔧 [AmazonBedrockProvider] Conversation history length: ${this.conversationHistory.length}`);
+                logger.info(`[AmazonBedrockProvider] Client region: ${region}`);
+                logger.info(`[AmazonBedrockProvider] Model: ${this.modelName || this.getDefaultModel()}`);
+                logger.info(`[AmazonBedrockProvider] Conversation history length: ${this.conversationHistory.length}`);
                 // Get all available tools
                 const aiTools = await this.getAllTools();
                 const allTools = this.convertAISDKToolsToToolDefinitions(aiTools);
@@ -310,10 +338,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                 };
                 if (toolConfig) {
                     commandInput.toolConfig = toolConfig;
-                    logger.info(`🛠️ [AmazonBedrockProvider] Tools configured: ${toolConfig.tools?.length || 0}`);
+                    logger.info(`[AmazonBedrockProvider] Tools configured: ${toolConfig.tools?.length || 0}`);
                 }
                 // Log command details for debugging
-                logger.info(`📋 [AmazonBedrockProvider] Command input summary:`);
+                logger.info(`[AmazonBedrockProvider] Command input summary:`);
                 logger.info(`  - Model ID: ${commandInput.modelId}`);
                 logger.info(`  - Messages count: ${commandInput.messages?.length || 0}`);
                 logger.info(`  - System prompts: ${commandInput.system?.length || 0}`);
@@ -821,8 +849,8 @@ export class AmazonBedrockProvider extends BaseProvider {
         return this.bedrockClient;
     }
     async executeStream(options) {
-        logger.debug("🟢 [TRACE] executeStream ENTRY - starting streaming attempt");
-        logger.info("🚀 [AmazonBedrockProvider] Attempting real streaming with ConverseStreamCommand");
+        logger.debug("[TRACE] executeStream ENTRY - starting streaming attempt");
+        logger.info("[AmazonBedrockProvider] Attempting real streaming with ConverseStreamCommand");
         return bedrockTracer.startActiveSpan("bedrock.stream", {
             kind: SpanKind.CLIENT,
             attributes: {
@@ -832,7 +860,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             },
         }, async (streamSpan) => {
             try {
-                logger.debug("🟢 [TRACE] executeStream TRY block - about to call streamingConversationLoop");
+                logger.debug("[TRACE] executeStream TRY block - about to call streamingConversationLoop");
                 // Clear conversation history for new streaming session
                 this.conversationHistory = [];
                 // Check for multimodal input (images, PDFs, CSVs, files)
@@ -871,15 +899,15 @@ export class AmazonBedrockProvider extends BaseProvider {
                 }
                 logger.debug(`[AmazonBedrockProvider] Starting streaming conversation with ${this.conversationHistory.length} message(s)`);
                 // Call the actual streaming implementation that already exists
-                logger.debug("🟢 [TRACE] executeStream - calling streamingConversationLoop NOW");
+                logger.debug("[TRACE] executeStream - calling streamingConversationLoop NOW");
                 const result = await this.streamingConversationLoop(options, streamSpan);
-                logger.debug("🟢 [TRACE] executeStream - streamingConversationLoop SUCCESS, returning result");
+                logger.debug("[TRACE] executeStream - streamingConversationLoop SUCCESS, returning result");
                 streamSpan.setStatus({ code: SpanStatusCode.OK });
                 streamSpan.end();
                 return result;
             }
             catch (error) {
-                logger.debug("🔴 [TRACE] executeStream CATCH - error caught from streamingConversationLoop");
+                logger.debug("[TRACE] executeStream CATCH - error caught from streamingConversationLoop");
                 const errorObj = error;
                 // Check if error is related to streaming permissions
                 const isPermissionError = errorObj?.name ===
@@ -889,10 +917,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                     errorObj?.message?.includes("bedrock:InvokeModelWithResponseStream") ||
                     errorObj?.message?.includes("streaming") ||
                     errorObj?.message?.includes("ConverseStream");
-                logger.debug("🔴 [TRACE] executeStream CATCH - checking if permission error");
-                logger.debug(`🔴 [TRACE] executeStream CATCH - isPermissionError=${isPermissionError}`);
+                logger.debug("[TRACE] executeStream CATCH - checking if permission error");
+                logger.debug(`[TRACE] executeStream CATCH - isPermissionError=${isPermissionError}`);
                 if (isPermissionError) {
-                    logger.debug("🟡 [TRACE] executeStream CATCH - PERMISSION ERROR DETECTED, starting fallback");
+                    logger.debug("[TRACE] executeStream CATCH - PERMISSION ERROR DETECTED, starting fallback");
                     logger.warn(`[AmazonBedrockProvider] Streaming permissions not available, falling back to generate method: ${errorObj.message}`);
                     streamSpan.addEvent("stream.fallback_to_generate", {
                         reason: errorObj.message,
@@ -917,16 +945,28 @@ export class AmazonBedrockProvider extends BaseProvider {
                     streamSpan.setAttribute("gen_ai.response.stop_reason", "fallback_end_turn");
                     streamSpan.setStatus({ code: SpanStatusCode.OK });
                     streamSpan.end();
-                    // Convert generate result to streaming format
+                    // Convert generate result to streaming format.
+                    // Use whitespace-preserving split (matches BaseProvider's
+                    // executeFakeStreaming) so newlines, tabs, indentation, code
+                    // blocks, and markdown tables aren't collapsed to single spaces.
                     const stream = new ReadableStream({
                         start(controller) {
-                            // Split the response into chunks for pseudo-streaming
                             const responseText = generateResult.content || "";
-                            const chunks = responseText.split(" ");
-                            chunks.forEach((word, _index) => {
-                                controller.enqueue({ content: word + " " });
-                            });
-                            controller.enqueue({ content: "" });
+                            const tokens = responseText.split(/(\s+)/);
+                            let buffer = "";
+                            for (let i = 0; i < tokens.length; i++) {
+                                buffer += tokens[i];
+                                const shouldYield = i === tokens.length - 1 ||
+                                    buffer.length > 50 ||
+                                    /[.!?;,]\s*$/.test(buffer);
+                                if (shouldYield && buffer.length > 0) {
+                                    controller.enqueue({ content: buffer });
+                                    buffer = "";
+                                }
+                            }
+                            if (buffer.length > 0) {
+                                controller.enqueue({ content: buffer });
+                            }
                             controller.close();
                         },
                     });
@@ -970,7 +1010,7 @@ export class AmazonBedrockProvider extends BaseProvider {
         });
     }
     async streamingConversationLoop(options, streamSpan) {
-        logger.debug("🟦 [TRACE] streamingConversationLoop ENTRY");
+        logger.debug("[TRACE] streamingConversationLoop ENTRY");
         const startTime = Date.now();
         const maxIterations = options.maxSteps || DEFAULT_MAX_STEPS;
         let iteration = 0;
@@ -983,7 +1023,7 @@ export class AmazonBedrockProvider extends BaseProvider {
         // The REAL issue: ReadableStream errors don't bubble up to the caller
         // So we need to make the first streaming call synchronously to test permissions
         try {
-            logger.debug("🟦 [TRACE] streamingConversationLoop - testing first streaming call");
+            logger.debug("[TRACE] streamingConversationLoop - testing first streaming call");
             const commandInput = await this.prepareStreamCommand(options);
             const command = new ConverseStreamCommand(commandInput);
             logger.debug("[Observability] Bedrock streaming API request", {
@@ -1005,7 +1045,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             // Process the first response immediately to avoid waste
             const stream = new ReadableStream({
                 start: async (controller) => {
-                    logger.debug("🟦 [TRACE] streamingConversationLoop - ReadableStream start() called");
+                    logger.debug("[TRACE] streamingConversationLoop - ReadableStream start() called");
                     try {
                         // Process the first response we already have, tracking all event types
                         let firstStopReason = "";
@@ -1114,6 +1154,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                             const shouldContinue = await this.handleStreamStopReason(firstStopReason, firstAssistantMessage, controller, options);
                             if (!shouldContinue) {
                                 streamSpan.setAttribute("gen_ai.response.stop_reason", firstStopReason);
+                                // Close the controller so downstream `for await` exits;
+                                // see the close() comment near the bottom of this start()
+                                // function for the spec rationale.
+                                controller.close();
                                 return;
                             }
                         }
@@ -1153,10 +1197,21 @@ export class AmazonBedrockProvider extends BaseProvider {
                         if (iteration >= maxIterations) {
                             streamSpan.setAttribute("gen_ai.response.stop_reason", "max_iterations");
                             controller.error(new Error("Streaming conversation exceeded maximum iterations"));
+                            return;
                         }
+                        // CRITICAL: ReadableStream's start() returning does NOT auto-close
+                        // the controller per the WHATWG Streams spec. Without this, the
+                        // downstream `for await (const chunk of stream)` in
+                        // convertToAsyncIterable never sees `done: true` and the
+                        // consumer hangs forever — manifested as a 240s harness
+                        // PER_TEST_TIMEOUT_SKIP for `[bedrock] stream tokens`. The first-
+                        // iteration `return` path and the while-loop natural `break`
+                        // path both reach here, so closing once at the bottom covers
+                        // every non-error exit.
+                        controller.close();
                     }
                     catch (error) {
-                        logger.debug("🔴 [TRACE] streamingConversationLoop - CATCH block hit in ReadableStream");
+                        logger.debug("[TRACE] streamingConversationLoop - CATCH block hit in ReadableStream");
                         controller.error(error);
                     }
                 },
@@ -1226,7 +1281,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             };
         }
         catch (error) {
-            logger.debug("🔴 [TRACE] streamingConversationLoop - first streaming call FAILED, throwing");
+            logger.debug("[TRACE] streamingConversationLoop - first streaming call FAILED, throwing");
             throw error; // This will be caught by executeStream
         }
     }
@@ -1426,7 +1481,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             return false;
         }
         else if (stopReason === "tool_use") {
-            logger.debug(`🛠️ [AmazonBedrockProvider] Tool use detected in streaming - executing tools`);
+            logger.debug(`[AmazonBedrockProvider] Tool use detected in streaming - executing tools`);
             await this.executeStreamTools(assistantMessage.content, options);
             return true; // Continue conversation loop
         }
@@ -1455,10 +1510,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                 toolUseCount++;
             }
         }
-        logger.debug(`🔍 [AmazonBedrockProvider] Found ${toolUseCount} toolUse blocks in assistant message`);
+        logger.debug(`[AmazonBedrockProvider] Found ${toolUseCount} toolUse blocks in assistant message`);
         for (const contentItem of messageContent) {
             if (contentItem.toolUse) {
-                logger.debug(`🔧 [AmazonBedrockProvider] Executing tool: ${contentItem.toolUse.name}`);
+                logger.debug(`[AmazonBedrockProvider] Executing tool: ${contentItem.toolUse.name}`);
                 // Track tool call
                 toolCalls.push({
                     type: "tool-call",
@@ -1468,7 +1523,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 });
                 try {
                     const toolResult = await this.executeSingleTool(contentItem.toolUse.name, contentItem.toolUse.input || {}, contentItem.toolUse.toolUseId);
-                    logger.debug(`✅ [AmazonBedrockProvider] Tool execution successful: ${contentItem.toolUse.name}`);
+                    logger.debug(`[AmazonBedrockProvider] Tool execution successful: ${contentItem.toolUse.name}`);
                     // Track tool result for storage
                     toolResultsForStorage.push({
                         type: "tool-result",
@@ -1486,7 +1541,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                     });
                 }
                 catch (error) {
-                    logger.error(`❌ [AmazonBedrockProvider] Tool execution failed: ${contentItem.toolUse.name}`, error);
+                    logger.error(`[AmazonBedrockProvider] Tool execution failed: ${contentItem.toolUse.name}`, error);
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     // Track failed tool result
                     toolResultsForStorage.push({
@@ -1509,10 +1564,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                 }
             }
         }
-        logger.debug(`📊 [AmazonBedrockProvider] Created ${toolResults.length} toolResult blocks for ${toolUseCount} toolUse blocks`);
+        logger.debug(`[AmazonBedrockProvider] Created ${toolResults.length} toolResult blocks for ${toolUseCount} toolUse blocks`);
         // Validate 1:1 mapping before adding to conversation
         if (toolResults.length !== toolUseCount) {
-            logger.error(`❌ [AmazonBedrockProvider] Mismatch: ${toolResults.length} toolResults vs ${toolUseCount} toolUse blocks`);
+            logger.error(`[AmazonBedrockProvider] Mismatch: ${toolResults.length} toolResults vs ${toolUseCount} toolUse blocks`);
             throw new Error(`Tool mapping mismatch: ${toolResults.length} toolResults for ${toolUseCount} toolUse blocks`);
         }
         // Add tool results as user message - exact structure like Bedrock-MCP-Connector
@@ -1522,7 +1577,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 content: toolResults,
             };
             this.conversationHistory.push(userMessageWithToolResults);
-            logger.debug(`📤 [AmazonBedrockProvider] Added ${toolResults.length} tool results to conversation (1:1 mapping validated)`);
+            logger.debug(`[AmazonBedrockProvider] Added ${toolResults.length} tool results to conversation (1:1 mapping validated)`);
             // Emit tool:end for each completed tool result so Pipeline B
             // captures telemetry for Bedrock-driven tool calls (gap S2).
             emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResultsForStorage.map((tr) => {
@@ -1558,14 +1613,14 @@ export class AmazonBedrockProvider extends BaseProvider {
             region: process.env.AWS_REGION || "us-east-1",
         });
         try {
-            logger.debug("🔍 [AmazonBedrockProvider] Starting health check...");
+            logger.debug("[AmazonBedrockProvider] Starting health check...");
             const command = new ListFoundationModelsCommand({});
             const response = await healthCheckClient.send(command, {
                 abortSignal: controller.signal,
             });
             const models = response.modelSummaries || [];
             const activeModels = models.filter((model) => model.modelLifecycle?.status === "ACTIVE");
-            logger.debug(`✅ [AmazonBedrockProvider] Health check passed - Found ${activeModels.length} active models out of ${models.length} total models`);
+            logger.debug(`[AmazonBedrockProvider] Health check passed - Found ${activeModels.length} active models out of ${models.length} total models`);
             if (activeModels.length === 0) {
                 throw new Error("No active foundation models available in the region");
             }
@@ -1586,7 +1641,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             if (errorObj.code === "ECONNREFUSED" || errorObj.code === "ENOTFOUND") {
                 throw new Error("Unable to connect to Bedrock service. Check your network connectivity and AWS region configuration", { cause: error });
             }
-            logger.error("❌ [AmazonBedrockProvider] Health check failed:", error);
+            logger.error("[AmazonBedrockProvider] Health check failed:", error);
             throw new Error(`Bedrock health check failed: ${errorMessage || "Unknown error"}`, { cause: error });
         }
         finally {

package/dist/lib/providers/anthropic.js

@@ -323,12 +323,39 @@ export class AnthropicProvider extends BaseProvider {
         else {
             // Traditional API key authentication
             const apiKeyToUse = credentials?.apiKey ?? config?.apiKey ?? getAnthropicApiKey();
+            // The Vercel AI SDK builds `${baseURL}/messages` (no version prefix).
+            // Anthropic's REST API lives under `/v1/messages`, so a user-supplied
+            // bare host like `http://localhost:55669` 404s. Normalize: if the
+            // baseURL doesn't already end with `/vN`, append `/v1`.
+            //
+            // CAVEAT: this heuristic assumes the proxy exposes Anthropic-compatible
+            // endpoints rooted at `/vN/...`. Path-rooted proxies like
+            // `https://proxy.example.com/anthropic` will be silently rewritten to
+            // `…/anthropic/v1` and 404 if the proxy doesn't expose that path. To
+            // disable auto-append, set `ANTHROPIC_BASE_URL` explicitly ending in a
+            // version segment (e.g. `https://api.anthropic.com/v1`).
+            const normalizedBaseURL = (() => {
+                const raw = process.env.ANTHROPIC_BASE_URL;
+                if (!raw) {
+                    return undefined;
+                }
+                const trimmed = raw.replace(/\/+$/, "");
+                if (/\/v\d+$/.test(trimmed)) {
+                    return trimmed;
+                }
+                logger.warn("[AnthropicProvider] ANTHROPIC_BASE_URL does not end with /vN; " +
+                    "appending /v1 so the Vercel AI SDK can build /messages correctly. " +
+                    "To silence this warning, set ANTHROPIC_BASE_URL with an explicit " +
+                    "version segment (e.g. https://api.anthropic.com/v1). " +
+                    "If your proxy exposes Anthropic at a custom path that doesn't " +
+                    "expose /v1/messages, the auto-append will produce a 404 — pass " +
+                    "the full path including the version explicitly.", { baseURL: raw, rewrittenTo: `${trimmed}/v1` });
+                return `${trimmed}/v1`;
+            })();
             anthropic = createAnthropic({
                 apiKey: apiKeyToUse,
                 headers,
-                ...(process.env.ANTHROPIC_BASE_URL && {
-                    baseURL: process.env.ANTHROPIC_BASE_URL,
-                }),
+                ...(normalizedBaseURL && { baseURL: normalizedBaseURL }),
                 fetch: createProxyFetch(),
             });
             logger.debug("Anthropic Provider initialized with API key", {
@@ -379,13 +406,23 @@ export class AnthropicProvider extends BaseProvider {
         const usingProxy = !!process.env.ANTHROPIC_BASE_URL;
         if (this.enableBetaFeatures) {
             if (usingProxy) {
-                headers["anthropic-beta"] = [
+                // The 1M-context beta requires a plan upgrade on most accounts;
+                // surfacing it by default forces a "The long context beta is not
+                // yet available for this subscription." failure for everyone else.
+                // Gate behind ANTHROPIC_ENABLE_LONG_CONTEXT_BETA=1 so default-tier
+                // accounts (and CI) can use the proxy without the gated feature.
+                const longContextOptIn = process.env.ANTHROPIC_ENABLE_LONG_CONTEXT_BETA === "1" ||
+                    process.env.ANTHROPIC_ENABLE_LONG_CONTEXT_BETA === "true";
+                const betas = [
                     ...CLAUDE_CODE_OAUTH_BETAS,
                     "fine-grained-tool-streaming-2025-05-14",
-                    "context-1m-2025-08-07",
                     "interleaved-thinking-2025-05-14",
                     "redact-thinking-2026-02-12",
-                ].join(",");
+                ];
+                if (longContextOptIn) {
+                    betas.push("context-1m-2025-08-07");
+                }
+                headers["anthropic-beta"] = betas.join(",");
             }
             else {
                 headers["anthropic-beta"] = ANTHROPIC_BETA_HEADERS["anthropic-beta"];
@@ -414,8 +451,11 @@ export class AnthropicProvider extends BaseProvider {
      * ```
      */
     validateModelAccess(model) {
-        // Proxy mode: bypass tier validation entirely — the proxy handles model access
+        // Proxy mode: bypass tier validation entirely — the proxy handles model
+        // access. Log at debug level so users can tell why an unknown model name
+        // "validated" when their proxy may not actually expose it.
         if (process.env.ANTHROPIC_BASE_URL) {
+            logger.debug("[validateModelAccess] Bypassing tier check (ANTHROPIC_BASE_URL set — proxy enforces access)", { model });
             return true;
         }
         // API tier has access to all models
@@ -539,6 +579,14 @@ export class AnthropicProvider extends BaseProvider {
             const REFRESH_TIMEOUT_MS = 30_000;
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), REFRESH_TIMEOUT_MS);
+            // User-Agent is set to CLAUDE_CLI_USER_AGENT so the refresh request
+            // matches what the official Claude CLI / CLIProxyAPI sends. Anthropic
+            // gates parts of the OAuth flow on this UA (the same `client_id` is
+            // rejected by `ANTHROPIC_TOKEN_URL` if the UA looks like a generic
+            // SDK), so this is required for OAuth refresh to succeed — not a
+            // cosmetic choice. If Anthropic ever publishes a separate UA for
+            // third-party OAuth clients, switch to that. See `auth/anthropicOAuth.ts`
+            // for the source of `CLAUDE_CLI_USER_AGENT` / `CLAUDE_CODE_CLIENT_ID`.
             const response = await fetch(ANTHROPIC_TOKEN_URL, {
                 method: "POST",
                 headers: {

package/dist/lib/providers/anthropicBaseProvider.js

@@ -90,7 +90,7 @@ export class AnthropicProviderV2 extends BaseProvider {
             try {
                 result = streamText({
                     model,
-                    prompt: options.input.text,
+                    prompt: options.input.text ?? "",
                     system: options.systemPrompt,
                     temperature: options.temperature,
                     maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified

package/dist/lib/providers/azureOpenai.js

@@ -5,6 +5,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
+import { AuthenticationError, NetworkError, ProviderError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { createAzureAPIKeyConfig, createAzureEndpointConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -19,12 +20,48 @@ export class AzureOpenAIProvider extends BaseProvider {
         super(modelName, "azure", sdk);
         this.apiKey = credentials?.apiKey || process.env.AZURE_OPENAI_API_KEY || "";
         const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "";
-        const envResourceName = endpoint
-            .replace("https://", "")
-            .replace(/\/+$/, "") // Remove trailing slashes
-            .replace(".openai.azure.com", "")
-            .replace(".cognitiveservices.azure.com", "");
+        // Use URL parsing instead of string-replace so endpoints that already
+        // carry a path segment (e.g. "https://<host>/openai" — a valid Azure AI
+        // Foundry shape) don't end up duplicating it as "<host>/openai/openai".
+        // Tolerate missing scheme by prefixing https:// before parsing.
+        let endpointUrl;
+        if (endpoint) {
+            try {
+                endpointUrl = new URL(endpoint.includes("://") ? endpoint : `https://${endpoint}`);
+            }
+            catch {
+                endpointUrl = undefined;
+            }
+        }
+        const endpointHost = endpointUrl?.hostname ?? "";
+        const endpointPath = endpointUrl?.pathname && endpointUrl.pathname !== "/"
+            ? endpointUrl.pathname.replace(/\/+$/, "")
+            : "";
+        // Classic Azure OpenAI ("*.openai.azure.com") and Cognitive Services
+        // ("*.cognitiveservices.azure.com") endpoints encode the resource name as
+        // a subdomain that @ai-sdk/azure expects to receive verbatim. The newer
+        // Azure AI Foundry endpoint format ("*.services.ai.azure.com") does not
+        // round-trip through that subdomain rewrite, so passing the resource name
+        // would yield e.g. "<host>.services.ai.azure.com.openai.azure.com". For
+        // those hosts we hand the full URL back via baseURL instead.
+        const isClassicAzureHost = /\.(openai|cognitiveservices)\.azure\.com$/.test(endpointHost);
+        const envResourceName = isClassicAzureHost
+            ? endpointHost
+                .replace(".openai.azure.com", "")
+                .replace(".cognitiveservices.azure.com", "")
+            : "";
         this.resourceName = credentials?.resourceName || envResourceName;
+        // For Azure AI Foundry the SDK still routes to the OpenAI-compatible API
+        // (deployments/{deployment}/chat/completions); the `/openai` path suffix
+        // mirrors what the SDK derives in classic mode
+        // (`https://${resource}.openai.azure.com/openai`). Reuse the path the
+        // operator already supplied if it already terminates in `/openai` *or*
+        // a versioned form like `/openai/v1`; otherwise append `/openai`. Never
+        // duplicate.
+        const hasOpenAIPathSuffix = /\/openai(?:\/v\d+)?$/.test(endpointPath);
+        const baseURLForFoundry = !this.resourceName && endpointUrl
+            ? `${endpointUrl.origin}${hasOpenAIPathSuffix ? endpointPath : `${endpointPath}/openai`}`
+            : undefined;
         this.deployment =
             credentials?.deploymentName ||
                 modelName ||
@@ -40,20 +77,32 @@ export class AzureOpenAIProvider extends BaseProvider {
         if (!this.apiKey) {
             validateApiKey(createAzureAPIKeyConfig());
         }
-        if (!this.resourceName) {
+        if (!this.resourceName && !baseURLForFoundry) {
             validateApiKey(createAzureEndpointConfig());
         }
-        // Create the Azure provider instance with proxy support
+        // Create the Azure provider instance with proxy support.
+        // For classic *.openai.azure.com / *.cognitiveservices.azure.com hosts we
+        // pass `resourceName`, which @ai-sdk/azure rewrites into the canonical
+        // subdomain. For Azure AI Foundry hosts ("*.services.ai.azure.com") we
+        // pass the full URL via `baseURL` so no rewrite happens.
         // useDeploymentBasedUrls is required because @ai-sdk/azure v3+ defaults to
         // the /v1/ URL format, but most Azure deployments still require the legacy
         // /deployments/{deployment}/ URL pattern.
-        this.azureProvider = createAzure({
-            resourceName: this.resourceName,
-            apiKey: this.apiKey,
-            apiVersion: this.apiVersion,
-            useDeploymentBasedUrls: true,
-            fetch: createProxyFetch(),
-        });
+        this.azureProvider = baseURLForFoundry
+            ? createAzure({
+                baseURL: baseURLForFoundry,
+                apiKey: this.apiKey,
+                apiVersion: this.apiVersion,
+                useDeploymentBasedUrls: true,
+                fetch: createProxyFetch(),
+            })
+            : createAzure({
+                resourceName: this.resourceName,
+                apiKey: this.apiKey,
+                apiVersion: this.apiVersion,
+                useDeploymentBasedUrls: true,
+                fetch: createProxyFetch(),
+            });
         logger.debug("Azure Vercel Provider initialized", {
             deployment: this.deployment,
             resourceName: this.resourceName,
@@ -77,18 +126,18 @@ export class AzureOpenAIProvider extends BaseProvider {
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`Azure OpenAI request timed out: ${error.message}`);
+            return new NetworkError(`Request timed out: ${error.message}`, "azure");
         }
         const errorObj = error;
         if (errorObj?.message &&
             typeof errorObj.message === "string" &&
             errorObj.message.includes("401")) {
-            return new Error("Invalid Azure OpenAI API key or endpoint.");
+            return new AuthenticationError("Invalid Azure OpenAI API key or endpoint.", "azure");
         }
         const message = errorObj?.message && typeof errorObj.message === "string"
             ? errorObj.message
             : "Unknown error";
-        return new Error(`Azure OpenAI error: ${message}`);
+        return new ProviderError(`Azure OpenAI error: ${message}`, "azure");
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, _analysisSchema) {

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

@@ -0,0 +1,35 @@
+import { type LanguageModel } from "ai";
+import type { AIProviderName } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+/**
+ * Cloudflare Workers AI Provider
+ *
+ * Edge-served open models (Llama / Mistral / Qwen / Gemma) at
+ * `https://api.cloudflare.com/client/v4/accounts/{accountId}/ai/v1`
+ * (OpenAI-compatible). Cheapest tier for high-volume usage.
+ *
+ * Required env: `CLOUDFLARE_API_KEY` + `CLOUDFLARE_ACCOUNT_ID`.
+ *
+ * @see https://developers.cloudflare.com/workers-ai/configuration/open-ai-compatibility/
+ */
+export declare class CloudflareProvider extends BaseProvider {
+    private model;
+    private apiKey;
+    private baseURL;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["cloudflare"]);
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    private executeStreamInner;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected getAISDKModel(): LanguageModel;
+    protected formatProviderError(error: unknown): Error;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default CloudflareProvider;