@jerome-benoit/sap-ai-provider-v2 5.0.2 → 5.1.0

package/dist/index.cjs

@@ -5,8 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -30,6 +35,181 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/sap-ai-provider-options.ts
+function getProviderName(providerIdentifier) {
+  const dotIndex = providerIdentifier.indexOf(".");
+  return dotIndex === -1 ? providerIdentifier : providerIdentifier.slice(0, dotIndex);
+}
+function validateEmbeddingModelParamsSettings(modelParams) {
+  return embeddingModelParamsSchema.parse(modelParams);
+}
+function validateModelParamsSettings(modelParams) {
+  return modelParamsSchema.parse(modelParams);
+}
+function validateModelParamsWithWarnings(params, warnings) {
+  const result = modelParamsSchema.safeParse(params);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const path = issue.path.join(".");
+      const value = path ? params[path] : void 0;
+      warnings.push({
+        message: `${path}=${String(value)} is invalid: ${issue.message}. The API may reject this value.`,
+        type: "other"
+      });
+    }
+  }
+}
+function parseSAPPartProviderOptions(providerOptions, warnings) {
+  if (!providerOptions || typeof providerOptions !== "object") {
+    return void 0;
+  }
+  const block = providerOptions[SAP_AI_PROVIDER_NAME];
+  if (block === void 0) {
+    return void 0;
+  }
+  const parsed = sapAIPartProviderOptionsSchema.safeParse(block);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  if (warnings) {
+    for (const issue of parsed.error.issues) {
+      const path = issue.path.join(".");
+      const message = `providerOptions['sap-ai']${path ? `.${path}` : ""} is invalid: ${issue.message}. The directive was dropped.`;
+      if (!warnings.some((w) => w.message === message)) {
+        warnings.push({ message, type: "other" });
+      }
+    }
+  }
+  return void 0;
+}
+var import_provider_utils, import_zod, SAP_AI_PROVIDER_NAME, modelParamsSchema, embeddingModelParamsSchema, sapAIApiTypeSchema, cacheControlSchema, sapAIPartProviderOptionsSchema, orchestrationReasoningBlockSchema, promptTemplateScopeSchema, promptTemplateRefByIdSchema, promptTemplateRefByScenarioNameVersionSchema, promptTemplateRefSchema, orchestrationConfigRefOverrideSchema, orchestrationConfigRefByIdSchema, orchestrationConfigRefByScenarioNameVersionSchema, orchestrationConfigRefSchema, responsesModelOptionsSchema, dropUnsupportedParamsSchema, sapAILanguageModelProviderOptions, sapAIEmbeddingProviderOptions;
+var init_sap_ai_provider_options = __esm({
+  "src/sap-ai-provider-options.ts"() {
+    "use strict";
+    import_provider_utils = require("@ai-sdk/provider-utils");
+    import_zod = require("zod");
+    SAP_AI_PROVIDER_NAME = "sap-ai";
+    modelParamsSchema = import_zod.z.object({
+      frequencyPenalty: import_zod.z.number().min(-2).max(2).optional(),
+      maxTokens: import_zod.z.number().int().positive().optional(),
+      n: import_zod.z.number().int().positive().optional(),
+      parallel_tool_calls: import_zod.z.boolean().optional(),
+      presencePenalty: import_zod.z.number().min(-2).max(2).optional(),
+      temperature: import_zod.z.number().min(0).max(2).optional(),
+      topP: import_zod.z.number().min(0).max(1).optional()
+    }).catchall(import_zod.z.unknown());
+    embeddingModelParamsSchema = import_zod.z.object({
+      dimensions: import_zod.z.number().int().positive().optional(),
+      encoding_format: import_zod.z.enum(["base64", "binary", "float"]).optional(),
+      normalize: import_zod.z.boolean().optional()
+    }).catchall(import_zod.z.unknown());
+    sapAIApiTypeSchema = import_zod.z.enum(["orchestration", "foundation-models", "responses"]);
+    cacheControlSchema = import_zod.z.object({
+      ttl: import_zod.z.enum(["5m", "1h"]).optional(),
+      type: import_zod.z.literal("ephemeral")
+    });
+    sapAIPartProviderOptionsSchema = import_zod.z.object({
+      cacheControl: cacheControlSchema.optional()
+    });
+    orchestrationReasoningBlockSchema = import_zod.z.object({
+      content: import_zod.z.string().optional(),
+      signature: import_zod.z.string().optional()
+    }).strict();
+    promptTemplateScopeSchema = import_zod.z.enum(["tenant", "resource_group"]);
+    promptTemplateRefByIdSchema = import_zod.z.object({
+      id: import_zod.z.string().min(1, "Template ID cannot be empty"),
+      scope: promptTemplateScopeSchema.optional()
+    });
+    promptTemplateRefByScenarioNameVersionSchema = import_zod.z.object({
+      name: import_zod.z.string().min(1, "Template name cannot be empty"),
+      scenario: import_zod.z.string().min(1, "Scenario cannot be empty"),
+      scope: promptTemplateScopeSchema.optional(),
+      version: import_zod.z.string().min(1, "Version cannot be empty")
+    });
+    promptTemplateRefSchema = import_zod.z.union([
+      promptTemplateRefByIdSchema,
+      promptTemplateRefByScenarioNameVersionSchema
+    ]);
+    orchestrationConfigRefOverrideSchema = import_zod.z.custom(
+      (value) => typeof value === "object" && value !== null && !Array.isArray(value),
+      { message: "overrideConfig must be an object" }
+    ).refine(
+      (value) => {
+        let stream;
+        try {
+          stream = value.stream;
+        } catch {
+          return false;
+        }
+        return stream === void 0 || Boolean(stream) && typeof stream === "object" && !Array.isArray(stream);
+      },
+      { message: "overrideConfig.stream must be an object" }
+    ).refine(
+      (value) => {
+        let stream;
+        try {
+          stream = value.stream;
+        } catch {
+          return true;
+        }
+        if (stream === void 0 || stream === null || typeof stream !== "object") {
+          return true;
+        }
+        try {
+          return !("enabled" in stream);
+        } catch {
+          return false;
+        }
+      },
+      {
+        message: "stream.enabled is not allowed in overrideConfig: it is controlled by the call site (stream() or chatCompletion())"
+      }
+    );
+    orchestrationConfigRefByIdSchema = import_zod.z.object({
+      id: import_zod.z.string().min(1, "Config ID cannot be empty"),
+      overrideConfig: orchestrationConfigRefOverrideSchema.optional()
+    });
+    orchestrationConfigRefByScenarioNameVersionSchema = import_zod.z.object({
+      name: import_zod.z.string().min(1, "Config name cannot be empty"),
+      overrideConfig: orchestrationConfigRefOverrideSchema.optional(),
+      scenario: import_zod.z.string().min(1, "Scenario cannot be empty"),
+      version: import_zod.z.string().min(1, "Version cannot be empty")
+    });
+    orchestrationConfigRefSchema = import_zod.z.union([
+      orchestrationConfigRefByIdSchema,
+      orchestrationConfigRefByScenarioNameVersionSchema
+    ]);
+    responsesModelOptionsSchema = import_zod.z.object({
+      metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).nullable().optional()
+    }).catchall(import_zod.z.json());
+    dropUnsupportedParamsSchema = import_zod.z.boolean();
+    sapAILanguageModelProviderOptions = (0, import_provider_utils.lazySchema)(
+      () => (0, import_provider_utils.zodSchema)(
+        import_zod.z.object({
+          api: sapAIApiTypeSchema.optional(),
+          dropUnsupportedParams: dropUnsupportedParamsSchema.optional(),
+          escapeTemplatePlaceholders: import_zod.z.boolean().optional(),
+          includeReasoning: import_zod.z.boolean().optional(),
+          modelParams: modelParamsSchema.optional(),
+          orchestrationConfigRef: orchestrationConfigRefSchema.optional(),
+          placeholderValues: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+          promptTemplateRef: promptTemplateRefSchema.optional(),
+          responses: responsesModelOptionsSchema.optional()
+        })
+      )
+    );
+    sapAIEmbeddingProviderOptions = (0, import_provider_utils.lazySchema)(
+      () => (0, import_provider_utils.zodSchema)(
+        import_zod.z.object({
+          api: sapAIApiTypeSchema.optional(),
+          modelParams: embeddingModelParamsSchema.optional(),
+          type: import_zod.z.enum(["document", "query", "text"]).optional()
+        })
+      )
+    );
+  }
+});
+
 // src/convert-to-sap-messages.ts
 function getURLHref(value) {
   if (typeof value !== "object" || value === null || URL_HREF_DESCRIPTOR?.get === void 0) {
@@ -171,6 +351,7 @@ function convertToSAPMessages(prompt, options = {}) {
         let text = "";
         const textParts = parser ? [] : void 0;
         let anyCacheControl = false;
+        let reasoningContent;
         const toolCalls = [];
         for (const part of message.content) {
           switch (part.type) {
@@ -182,6 +363,21 @@ function convertToSAPMessages(prompt, options = {}) {
               break;
             }
             case "reasoning": {
+              const nativeNamespace = options.nativeReasoningProviderName;
+              const nativeOptions = nativeNamespace === void 0 ? void 0 : part.providerOptions?.[nativeNamespace];
+              if (nativeOptions !== null && typeof nativeOptions === "object" && !Array.isArray(nativeOptions) && Object.hasOwn(nativeOptions, "reasoningContent")) {
+                const parsed = orchestrationReasoningBlockSchema.safeParse(
+                  nativeOptions.reasoningContent
+                );
+                if (!parsed.success) {
+                  throw new import_provider.InvalidPromptError({
+                    message: "Invalid native Orchestration reasoning metadata.",
+                    prompt
+                  });
+                }
+                (reasoningContent ??= []).push(parsed.data);
+                break;
+              }
               if (includeReasoning && part.text) {
                 const reasoning = `<think>${part.text}</think>`;
                 text += reasoning;
@@ -228,11 +424,12 @@ function convertToSAPMessages(prompt, options = {}) {
             }
           }
         }
-        if (text || toolCalls.length > 0) {
+        if (text || toolCalls.length > 0 || reasoningContent?.length) {
           const assistantMessage = {
             content: anyCacheControl && textParts ? textParts.map((p) => wrapAsTextContent(maybeEscape(p.text), p.cacheControl)) : maybeEscape(text),
             role: "assistant",
-            tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+            tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+            ...reasoningContent && { reasoning_content: reasoningContent }
           };
           messages.push(assistantMessage);
         }
@@ -388,6 +585,7 @@ var init_convert_to_sap_messages = __esm({
   "src/convert-to-sap-messages.ts"() {
     "use strict";
     import_provider = require("@ai-sdk/provider");
+    init_sap_ai_provider_options();
     ZERO_WIDTH_SPACE = "\u200B";
     ARRAY_BUFFER_BYTE_LENGTH_DESCRIPTOR = Object.getOwnPropertyDescriptor(
       ArrayBuffer.prototype,
@@ -408,211 +606,15 @@ var init_convert_to_sap_messages = __esm({
   }
 });
 
-// src/sap-ai-provider-options.ts
-function getProviderName(providerIdentifier) {
-  const dotIndex = providerIdentifier.indexOf(".");
-  return dotIndex === -1 ? providerIdentifier : providerIdentifier.slice(0, dotIndex);
-}
-function validateEmbeddingModelParamsSettings(modelParams) {
-  return embeddingModelParamsSchema.parse(modelParams);
-}
-function validateModelParamsSettings(modelParams) {
-  return modelParamsSchema.parse(modelParams);
-}
-function validateModelParamsWithWarnings(params, warnings) {
-  const result = modelParamsSchema.safeParse(params);
-  if (!result.success) {
-    for (const issue of result.error.issues) {
-      const path = issue.path.join(".");
-      const value = path ? params[path] : void 0;
-      warnings.push({
-        message: `${path}=${String(value)} is invalid: ${issue.message}. The API may reject this value.`,
-        type: "other"
-      });
-    }
-  }
-}
-function parseSAPPartProviderOptions(providerOptions, warnings) {
-  if (!providerOptions || typeof providerOptions !== "object") {
-    return void 0;
-  }
-  const block = providerOptions[SAP_AI_PROVIDER_NAME];
-  if (block === void 0) {
-    return void 0;
-  }
-  const parsed = sapAIPartProviderOptionsSchema.safeParse(block);
-  if (parsed.success) {
-    return parsed.data;
-  }
-  if (warnings) {
-    for (const issue of parsed.error.issues) {
-      const path = issue.path.join(".");
-      const message = `providerOptions['sap-ai']${path ? `.${path}` : ""} is invalid: ${issue.message}. The directive was dropped.`;
-      if (!warnings.some((w) => w.message === message)) {
-        warnings.push({ message, type: "other" });
-      }
-    }
-  }
-  return void 0;
-}
-var import_provider_utils, import_zod, SAP_AI_PROVIDER_NAME, modelParamsSchema, embeddingModelParamsSchema, sapAIApiTypeSchema, cacheControlSchema, sapAIPartProviderOptionsSchema, promptTemplateScopeSchema, promptTemplateRefByIdSchema, promptTemplateRefByScenarioNameVersionSchema, promptTemplateRefSchema, orchestrationConfigRefOverrideSchema, orchestrationConfigRefByIdSchema, orchestrationConfigRefByScenarioNameVersionSchema, orchestrationConfigRefSchema, sapAILanguageModelProviderOptions, sapAIEmbeddingProviderOptions;
-var init_sap_ai_provider_options = __esm({
-  "src/sap-ai-provider-options.ts"() {
-    "use strict";
-    import_provider_utils = require("@ai-sdk/provider-utils");
-    import_zod = require("zod");
-    SAP_AI_PROVIDER_NAME = "sap-ai";
-    modelParamsSchema = import_zod.z.object({
-      frequencyPenalty: import_zod.z.number().min(-2).max(2).optional(),
-      maxTokens: import_zod.z.number().int().positive().optional(),
-      n: import_zod.z.number().int().positive().optional(),
-      parallel_tool_calls: import_zod.z.boolean().optional(),
-      presencePenalty: import_zod.z.number().min(-2).max(2).optional(),
-      temperature: import_zod.z.number().min(0).max(2).optional(),
-      topP: import_zod.z.number().min(0).max(1).optional()
-    }).catchall(import_zod.z.unknown());
-    embeddingModelParamsSchema = import_zod.z.object({
-      dimensions: import_zod.z.number().int().positive().optional(),
-      encoding_format: import_zod.z.enum(["base64", "binary", "float"]).optional(),
-      normalize: import_zod.z.boolean().optional()
-    }).catchall(import_zod.z.unknown());
-    sapAIApiTypeSchema = import_zod.z.enum(["orchestration", "foundation-models"]);
-    cacheControlSchema = import_zod.z.object({
-      ttl: import_zod.z.enum(["5m", "1h"]).optional(),
-      type: import_zod.z.literal("ephemeral")
-    });
-    sapAIPartProviderOptionsSchema = import_zod.z.object({
-      cacheControl: cacheControlSchema.optional()
-    });
-    promptTemplateScopeSchema = import_zod.z.enum(["tenant", "resource_group"]);
-    promptTemplateRefByIdSchema = import_zod.z.object({
-      id: import_zod.z.string().min(1, "Template ID cannot be empty"),
-      scope: promptTemplateScopeSchema.optional()
-    });
-    promptTemplateRefByScenarioNameVersionSchema = import_zod.z.object({
-      name: import_zod.z.string().min(1, "Template name cannot be empty"),
-      scenario: import_zod.z.string().min(1, "Scenario cannot be empty"),
-      scope: promptTemplateScopeSchema.optional(),
-      version: import_zod.z.string().min(1, "Version cannot be empty")
-    });
-    promptTemplateRefSchema = import_zod.z.union([
-      promptTemplateRefByIdSchema,
-      promptTemplateRefByScenarioNameVersionSchema
-    ]);
-    orchestrationConfigRefOverrideSchema = import_zod.z.custom(
-      (value) => typeof value === "object" && value !== null && !Array.isArray(value),
-      { message: "overrideConfig must be an object" }
-    ).refine(
-      (value) => {
-        let stream;
-        try {
-          stream = value.stream;
-        } catch {
-          return false;
-        }
-        return stream === void 0 || Boolean(stream) && typeof stream === "object" && !Array.isArray(stream);
-      },
-      { message: "overrideConfig.stream must be an object" }
-    ).refine(
-      (value) => {
-        let stream;
-        try {
-          stream = value.stream;
-        } catch {
-          return true;
-        }
-        if (stream === void 0 || stream === null || typeof stream !== "object") {
-          return true;
-        }
-        try {
-          return !("enabled" in stream);
-        } catch {
-          return false;
-        }
-      },
-      {
-        message: "stream.enabled is not allowed in overrideConfig: it is controlled by the call site (stream() or chatCompletion())"
-      }
-    );
-    orchestrationConfigRefByIdSchema = import_zod.z.object({
-      id: import_zod.z.string().min(1, "Config ID cannot be empty"),
-      overrideConfig: orchestrationConfigRefOverrideSchema.optional()
-    });
-    orchestrationConfigRefByScenarioNameVersionSchema = import_zod.z.object({
-      name: import_zod.z.string().min(1, "Config name cannot be empty"),
-      overrideConfig: orchestrationConfigRefOverrideSchema.optional(),
-      scenario: import_zod.z.string().min(1, "Scenario cannot be empty"),
-      version: import_zod.z.string().min(1, "Version cannot be empty")
-    });
-    orchestrationConfigRefSchema = import_zod.z.union([
-      orchestrationConfigRefByIdSchema,
-      orchestrationConfigRefByScenarioNameVersionSchema
-    ]);
-    sapAILanguageModelProviderOptions = (0, import_provider_utils.lazySchema)(
-      () => (0, import_provider_utils.zodSchema)(
-        import_zod.z.object({
-          api: sapAIApiTypeSchema.optional(),
-          escapeTemplatePlaceholders: import_zod.z.boolean().optional(),
-          includeReasoning: import_zod.z.boolean().optional(),
-          modelParams: modelParamsSchema.optional(),
-          orchestrationConfigRef: orchestrationConfigRefSchema.optional(),
-          placeholderValues: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
-          promptTemplateRef: promptTemplateRefSchema.optional()
-        })
-      )
-    );
-    sapAIEmbeddingProviderOptions = (0, import_provider_utils.lazySchema)(
-      () => (0, import_provider_utils.zodSchema)(
-        import_zod.z.object({
-          api: sapAIApiTypeSchema.optional(),
-          modelParams: embeddingModelParamsSchema.optional(),
-          type: import_zod.z.enum(["document", "query", "text"]).optional()
-        })
-      )
-    );
-  }
-});
-
-// src/deep-merge.ts
-function deepMerge(...sources) {
-  const result = {};
-  for (const source of sources) {
-    if (source != null) mergeInto(result, source, /* @__PURE__ */ new Set(), 0);
-  }
-  return result;
-}
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function mergeInto(target, source, ancestors, depth) {
-  if (depth > MAX_DEPTH) throw new Error("Maximum merge depth exceeded");
-  if (ancestors.has(source)) throw new Error("Circular reference detected during deep merge");
-  ancestors.add(source);
-  for (const key of Object.keys(source)) {
-    const sourceValue = source[key];
-    const targetValue = Object.hasOwn(target, key) ? target[key] : void 0;
-    const value = isPlainObject(sourceValue) ? mergeInto(isPlainObject(targetValue) ? targetValue : {}, sourceValue, ancestors, depth + 1) : sourceValue;
-    Object.defineProperty(target, key, {
-      configurable: true,
-      enumerable: true,
-      value,
-      writable: true
-    });
-  }
-  ancestors.delete(source);
-  return target;
-}
-var MAX_DEPTH;
-var init_deep_merge = __esm({
-  "src/deep-merge.ts"() {
-    "use strict";
-    MAX_DEPTH = 100;
-  }
-});
-
 // src/sap-ai-error.ts
+var sap_ai_error_exports = {};
+__export(sap_ai_error_exports, {
+  ApiSwitchError: () => ApiSwitchError,
+  UnsupportedFeatureError: () => UnsupportedFeatureError,
+  convertSAPErrorToAPICallError: () => convertSAPErrorToAPICallError,
+  convertToAISDKError: () => convertToAISDKError,
+  normalizeHeaders: () => normalizeHeaders
+});
 function convertSAPErrorToAPICallError(errorResponse, context) {
   const { code, location, message, requestId } = extractErrorFields(errorResponse);
   const statusCode = getStatusCodeFromSAPError(code, context?.httpStatusCode);
@@ -631,7 +633,7 @@ function convertSAPErrorToAPICallError(errorResponse, context) {
       enhancedMessage += `
 Request ID: ${requestId}`;
     }
-    return new import_provider2.LoadAPIKeyError({
+    return new import_provider3.LoadAPIKeyError({
       message: enhancedMessage
     });
   }
@@ -642,7 +644,7 @@ Request ID: ${requestId}`;
 Request ID: ${requestId}`;
     }
     const modelId = context?.modelId ?? extractModelIdentifier(message, location);
-    return new import_provider2.NoSuchModelError({
+    return new import_provider3.NoSuchModelError({
       message: enhancedMessage,
       modelId: modelId ?? "unknown",
       modelType: context?.modelType ?? "languageModel"
@@ -661,7 +663,7 @@ Error location: ${location}`;
     enhancedMessage += `
 Request ID: ${requestId}`;
   }
-  return new import_provider2.APICallError({
+  return new import_provider3.APICallError({
     isRetryable: isRetryable(statusCode),
     message: enhancedMessage,
     requestBodyValues: context?.requestBody,
@@ -672,14 +674,21 @@ Request ID: ${requestId}`;
   });
 }
 function convertToAISDKError(error, context) {
-  if (import_provider2.APICallError.isInstance(error) || import_provider2.LoadAPIKeyError.isInstance(error) || import_provider2.NoSuchModelError.isInstance(error) || import_provider2.InvalidPromptError.isInstance(error) || import_provider2.UnsupportedFunctionalityError.isInstance(error)) {
+  if (import_provider3.APICallError.isInstance(error) || import_provider3.LoadAPIKeyError.isInstance(error) || import_provider3.NoSuchModelError.isInstance(error) || import_provider3.InvalidPromptError.isInstance(error) || import_provider3.UnsupportedFunctionalityError.isInstance(error)) {
     return error;
   }
-  const { aborted, response, rootError } = inspectError(error);
+  const { aborted, networkCode, noMatchingDeployment, response, rootError, syntaxError } = inspectError(error);
+  if (noMatchingDeployment && !aborted) {
+    return new import_provider3.NoSuchModelError({
+      message: "SAP AI Core has no running deployment matching the requested model. Check the model ID, model version, resource group, and deployment status in your SAP AI Core instance.",
+      modelId: context?.modelId ?? "unknown",
+      modelType: context?.modelType ?? "languageModel"
+    });
+  }
   const responseHeaders = context?.responseHeaders ?? normalizeHeaders(response?.headers);
   if (!aborted) {
     const errorResponse = findStructuredErrorResponse(
-      rootError instanceof SyntaxError ? void 0 : rootError,
+      syntaxError ? void 0 : rootError,
       response?.data
     );
     if (errorResponse) {
@@ -697,7 +706,8 @@ function convertToAISDKError(error, context) {
   };
   if (aborted) {
     return createAPICallError(
-      error,
+      // Preserve cancellation priority without retaining credential-bearing criteria.
+      noMatchingDeployment ? void 0 : error,
       {
         isRetryable: false,
         message: "Request was aborted by the client",
@@ -706,33 +716,44 @@ function convertToAISDKError(error, context) {
       resolvedContext
     );
   }
-  if (isHttpStatus(response?.status)) {
+  if (isHttpStatus(response?.status) && (networkCode === void 0 || syntaxError !== void 0 || response.status < 200 || response.status >= 300)) {
     return createAPICallError(
       error,
       {
         isRetryable: isRetryable(response.status),
-        message: rootError instanceof SyntaxError && error instanceof Error ? error.message : rootError instanceof Error ? rootError.message : "SAP AI Core request failed",
+        message: syntaxError && error instanceof Error ? error.message : rootError instanceof Error ? rootError.message : "SAP AI Core request failed",
         statusCode: response.status
       },
       resolvedContext
     );
   }
-  if (rootError instanceof SyntaxError) {
+  if (syntaxError) {
     return createAPICallError(
       error,
       {
         isRetryable: false,
-        message: error instanceof Error && error !== rootError ? error.message : "Failed to parse SAP AI Core data.",
+        message: error instanceof Error && error !== syntaxError ? error.message : "Failed to parse SAP AI Core data.",
         statusCode: HTTP_STATUS.INTERNAL_ERROR
       },
       resolvedContext
     );
   }
+  if (networkCode) {
+    return createAPICallError(
+      error,
+      {
+        isRetryable: true,
+        message: `SAP AI Core network error (${networkCode})`,
+        statusCode: HTTP_STATUS.SERVICE_UNAVAILABLE
+      },
+      resolvedContext
+    );
+  }
   if (rootError instanceof Error) {
     const errorMsg = rootError.message.toLowerCase();
     const originalErrorMsg = rootError.message;
     if (AUTHENTICATION_ERROR_KEYWORDS.some((keyword) => errorMsg.includes(keyword))) {
-      return new import_provider2.LoadAPIKeyError({
+      return new import_provider3.LoadAPIKeyError({
         message: `SAP AI Core authentication failed: ${originalErrorMsg}
 
 Make sure your AICORE_SERVICE_KEY environment variable is set correctly.
@@ -741,7 +762,7 @@ See: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-serv
     }
     if (DEPLOYMENT_ERROR_KEYWORDS.some((keyword) => errorMsg.includes(keyword))) {
       const modelId = context?.modelId ?? extractModelIdentifier(originalErrorMsg);
-      return new import_provider2.NoSuchModelError({
+      return new import_provider3.NoSuchModelError({
         message: `SAP AI Core deployment error: ${originalErrorMsg}
 
 Make sure you have a running orchestration deployment in your SAP AI Core instance.
@@ -813,7 +834,7 @@ function normalizeHeaders(headers) {
   return Object.fromEntries(entries);
 }
 function createAPICallError(error, options, context) {
-  return new import_provider2.APICallError({
+  return new import_provider3.APICallError({
     cause: error,
     isRetryable: options.isRetryable,
     message: options.message,
@@ -887,10 +908,18 @@ function inspectError(error) {
   let current = error;
   let response;
   let aborted = false;
+  let networkCode;
+  let noMatchingDeployment = false;
+  let syntaxError;
   while (typeof current === "object" && current !== null && !seen.has(current)) {
     seen.add(current);
     rootError = current;
+    noMatchingDeployment ||= current instanceof Error && current.message.startsWith("No deployment matched the given criteria:");
     aborted ||= isAbortError(current);
+    if (current instanceof SyntaxError) syntaxError ??= current;
+    if (current instanceof Error && "code" in current && typeof current.code === "string") {
+      if (RETRYABLE_NETWORK_CODES.has(current.code)) networkCode ??= current.code;
+    }
     const entry = current;
     if (response === void 0 && entry.isAxiosError === true) response = entry.response;
     const cause = "cause" in entry ? entry.cause : current instanceof Error && (0, import_util.isErrorWithCause)(current) ? current.rootCause : void 0;
@@ -900,7 +929,7 @@ function inspectError(error) {
     rootError = cause;
     current = cause;
   }
-  return { aborted, response, rootError };
+  return { aborted, networkCode, noMatchingDeployment, response, rootError, syntaxError };
 }
 function isAbortError(error) {
   if (error instanceof DOMException && error.name === "AbortError") {
@@ -1009,11 +1038,11 @@ function tryExtractSAPErrorFromMessage(message) {
     return null;
   }
 }
-var import_provider2, import_util, HTTP_STATUS, ERROR_MATCHERS, AUTHENTICATION_ERROR_KEYWORDS, DEPLOYMENT_ERROR_KEYWORDS, ApiSwitchError, UnsupportedFeatureError;
+var import_provider3, import_util, HTTP_STATUS, RETRYABLE_NETWORK_CODES, ERROR_MATCHERS, AUTHENTICATION_ERROR_KEYWORDS, DEPLOYMENT_ERROR_KEYWORDS, ApiSwitchError, UnsupportedFeatureError;
 var init_sap_ai_error = __esm({
   "src/sap-ai-error.ts"() {
     "use strict";
-    import_provider2 = require("@ai-sdk/provider");
+    import_provider3 = require("@ai-sdk/provider");
     import_util = require("@sap-cloud-sdk/util");
     HTTP_STATUS = {
       BAD_REQUEST: 400,
@@ -1027,6 +1056,17 @@ var init_sap_ai_error = __esm({
       SERVICE_UNAVAILABLE: 503,
       UNAUTHORIZED: 401
     };
+    RETRYABLE_NETWORK_CODES = /* @__PURE__ */ new Set([
+      "EAI_AGAIN",
+      "ECONNABORTED",
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "EHOSTUNREACH",
+      "ENETUNREACH",
+      "ENOTFOUND",
+      "EPIPE",
+      "ETIMEDOUT"
+    ]);
     ERROR_MATCHERS = [
       {
         category: "network",
@@ -1160,8 +1200,13 @@ The model's response was blocked by content safety filters. Try a different prom
        * @param suggestedApi - The API that supports this feature.
        */
       constructor(feature, api, suggestedApi) {
-        const apiName = api === "foundation-models" ? "Foundation Models" : "Orchestration";
-        const suggestedApiName = suggestedApi === "foundation-models" ? "Foundation Models" : "Orchestration";
+        const names = {
+          "foundation-models": "Foundation Models",
+          orchestration: "Orchestration",
+          responses: "Responses"
+        };
+        const apiName = names[api];
+        const suggestedApiName = names[suggestedApi];
         super(`${feature} is not supported by ${apiName} API. Use ${suggestedApiName} API instead.`);
         this.feature = feature;
         this.api = api;
@@ -1175,6 +1220,98 @@ The model's response was blocked by content safety filters. Try a different prom
   }
 });
 
+// src/abort-utils.ts
+function createAbortError(reason) {
+  const error = new Error("The operation was aborted.", { cause: reason });
+  error.name = "AbortError";
+  return error;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw createAbortError(signal.reason);
+}
+function waitWithAbort(pending, signal, onAbortedValue) {
+  if (!signal) return pending;
+  return new Promise((resolve, reject) => {
+    let listening = true;
+    const cleanup = () => {
+      if (!listening) return;
+      listening = false;
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(createAbortError(signal.reason));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    void pending.then(
+      (value) => {
+        cleanup();
+        if (signal.aborted) {
+          try {
+            onAbortedValue?.(value);
+          } finally {
+            reject(createAbortError(signal.reason));
+          }
+        } else {
+          resolve(value);
+        }
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    ).catch((error) => {
+      cleanup();
+      reject(error);
+    });
+    if (signal.aborted) onAbort();
+  });
+}
+var init_abort_utils = __esm({
+  "src/abort-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/deep-merge.ts
+function deepMerge(...sources) {
+  const result = {};
+  for (const source of sources) {
+    if (source != null) mergeInto(result, source, /* @__PURE__ */ new Set(), 0);
+  }
+  return result;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function mergeInto(target, source, ancestors, depth) {
+  if (depth > MAX_DEPTH) throw new Error("Maximum merge depth exceeded");
+  if (ancestors.has(source)) throw new Error("Circular reference detected during deep merge");
+  ancestors.add(source);
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = Object.hasOwn(target, key) ? target[key] : void 0;
+    const value = isPlainObject(sourceValue) ? mergeInto(isPlainObject(targetValue) ? targetValue : {}, sourceValue, ancestors, depth + 1) : sourceValue;
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true
+    });
+  }
+  ancestors.delete(source);
+  return target;
+}
+var MAX_DEPTH;
+var init_deep_merge = __esm({
+  "src/deep-merge.ts"() {
+    "use strict";
+    MAX_DEPTH = 100;
+  }
+});
+
 // src/strategy-utils.ts
 function applyParameterOverrides(modelParams, options, sapModelParams, settingsModelParams, mappings) {
   for (const mapping of mappings) {
@@ -1225,9 +1362,23 @@ function buildGenerateResult(config) {
   const content = [];
   const tokenUsage = response.getTokenUsage();
   const finishReasonRaw = response.getFinishReason();
-  const finishReason = mapFinishReason(finishReasonRaw);
+  const providerSpecificFields = parseProviderSpecificFields(
+    response.getProviderSpecificFields?.()
+  );
+  const finishReason = mapFinishReason(
+    finishReasonRaw,
+    getProviderFinishReason(providerSpecificFields)
+  );
   const textContent = response.getContent();
   const toolCalls = response.getToolCalls();
+  for (const block of response.getReasoningBlocks?.() ?? []) {
+    const validatedBlock = orchestrationReasoningBlockSchema.parse(block);
+    content.push({
+      providerMetadata: buildOrchestrationReasoningMetadata(validatedBlock, providerName),
+      text: validatedBlock.content ?? "",
+      type: "reasoning"
+    });
+  }
   if (textContent) content.push({ text: textContent, type: "text" });
   for (const toolCall of toolCalls ?? []) {
     content.push({
@@ -1262,9 +1413,10 @@ function buildGenerateResult(config) {
     providerMetadata: {
       [providerName]: {
         ...buildAnthropicCacheMetadata(tokenUsage),
-        finishReason: finishReasonRaw ?? "unknown",
+        finishReason: finishReason.raw ?? "unknown",
         finishReasonMapped: finishReason,
         ...intermediateFailures?.length ? { intermediateFailures: sanitizeAsJSONArray(intermediateFailures) } : {},
+        ...providerSpecificFields && { providerSpecificFields },
         ...requestId ? { requestId } : {},
         version
       }
@@ -1535,8 +1687,8 @@ function isZodSchema(obj) {
   const record = obj;
   return "_def" in record && "parse" in record && hasCallableParse(record);
 }
-function mapFinishReason(reason) {
-  const raw = reason ?? void 0;
+function mapFinishReason(reason, originalReason) {
+  const raw = originalReason ?? reason ?? void 0;
   if (!reason) {
     return { raw, unified: "other" };
   }
@@ -1631,6 +1783,18 @@ function normalizeEmbedding(embedding) {
   );
   return Array.from(float32Array);
 }
+function buildOrchestrationReasoningMetadata(block, providerName) {
+  return { [providerName]: { reasoningContent: block } };
+}
+function getProviderFinishReason(fields) {
+  const reason = fields?.finish_reason;
+  return typeof reason === "string" && reason.length > 0 ? reason : void 0;
+}
+function parseProviderSpecificFields(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const fields = sanitizeAsJSONObject(value);
+  return fields !== null && typeof fields === "object" && !Array.isArray(fields) ? fields : void 0;
+}
 function sanitizeAsJSONArray(value) {
   try {
     return JSON.parse(JSON.stringify(value, jsonReplacer));
@@ -1662,16 +1826,17 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "5.0.2" : "0.0.0-test";
+    VERSION = true ? "5.1.0" : "0.0.0-test";
   }
 });
 
 // src/base-embedding-model-strategy.ts
-var import_provider3, BaseEmbeddingModelStrategy;
+var import_provider4, BaseEmbeddingModelStrategy;
 var init_base_embedding_model_strategy = __esm({
   "src/base-embedding-model-strategy.ts"() {
     "use strict";
-    import_provider3 = require("@ai-sdk/provider");
+    import_provider4 = require("@ai-sdk/provider");
+    init_abort_utils();
     init_deep_merge();
     init_sap_ai_error();
     init_sap_ai_provider_options();
@@ -1691,25 +1856,30 @@ var init_base_embedding_model_strategy = __esm({
         const { abortSignal, values } = options;
         try {
           if (values.length > maxEmbeddingsPerCall) {
-            throw new import_provider3.TooManyEmbeddingValuesForCallError({
+            throw new import_provider4.TooManyEmbeddingValuesForCallError({
               maxEmbeddingsPerCall,
               modelId: config.modelId,
               provider: config.provider,
               values
             });
           }
+          throwIfAborted(abortSignal);
           const embeddingOptions = config.parsedProviderOptions;
           const providerName = getProviderName(config.provider);
           const embeddingType = embeddingOptions?.type ?? settings.type ?? "text";
           const warnings = [];
           this.resolveWarnings(settings, warnings);
           const client = this.createClient(config, settings, embeddingOptions);
-          const response = await this.executeCall(
-            client,
-            values,
-            embeddingType,
-            mergeRequestConfig(config.requestConfig, abortSignal, options.headers)
+          const response = await waitWithAbort(
+            this.executeCall(
+              client,
+              values,
+              embeddingType,
+              mergeRequestConfig(config.requestConfig, abortSignal, options.headers)
+            ),
+            abortSignal
           );
+          throwIfAborted(abortSignal);
           const embeddings = this.extractEmbeddings(response);
           const totalTokens = this.extractTokenCount(response);
           const { headers: responseHeaders, requestId } = this.extractResponseMetadata(response);
@@ -1724,7 +1894,7 @@ var init_base_embedding_model_strategy = __esm({
             warnings
           });
         } catch (error) {
-          if (error instanceof import_provider3.TooManyEmbeddingValuesForCallError) {
+          if (error instanceof import_provider4.TooManyEmbeddingValuesForCallError) {
             throw error;
           }
           throw convertToAISDKError(error, {
@@ -1825,22 +1995,22 @@ var init_foundation_models_embedding_model_strategy = __esm({
 
 // src/sap-ai-validation.ts
 function validateEscapeTemplatePlaceholders(api, escapeTemplatePlaceholders) {
-  if (api === "foundation-models" && escapeTemplatePlaceholders === true) {
+  if (api !== "orchestration" && escapeTemplatePlaceholders === true) {
     throw new UnsupportedFeatureError(
       ESCAPE_TEMPLATE_PLACEHOLDERS_DESCRIPTION,
-      "foundation-models",
+      api,
       "orchestration"
     );
   }
 }
-function validateFoundationModelsOnlyOptions(settings) {
+function validateFoundationModelsOnlyOptions(api, settings) {
   if (!settings) return;
   const fmSettings = settings;
   for (const feature of FOUNDATION_MODELS_ONLY_FEATURE_KEYS) {
     if (fmSettings[feature] !== void 0) {
       throw new UnsupportedFeatureError(
         FOUNDATION_MODELS_ONLY_FEATURES[feature],
-        "orchestration",
+        api,
         "foundation-models"
       );
     }
@@ -1858,23 +2028,19 @@ function validateOrchestrationOnlyEmbeddingOptions(settings) {
     }
   }
 }
-function validateOrchestrationOnlyOptions(settings) {
+function validateOrchestrationOnlyOptions(api, settings) {
   if (!settings) return;
   const orchSettings = settings;
   for (const feature of ORCHESTRATION_ONLY_FEATURE_KEYS) {
     if (orchSettings[feature] !== void 0) {
-      throw new UnsupportedFeatureError(
-        ORCHESTRATION_ONLY_FEATURES[feature],
-        "foundation-models",
-        "orchestration"
-      );
+      throw new UnsupportedFeatureError(ORCHESTRATION_ONLY_FEATURES[feature], api, "orchestration");
     }
   }
 }
 function validateApiSwitch(fromApi, toApi, modelSettings, embeddingSettings) {
   if (fromApi === toApi) return;
   if (!modelSettings && !embeddingSettings) return;
-  if (fromApi === "orchestration" && toApi === "foundation-models") {
+  if (toApi !== "orchestration") {
     const orchSettings = modelSettings;
     for (const feature of ORCHESTRATION_ONLY_FEATURE_KEYS) {
       if (orchSettings?.[feature] !== void 0) {
@@ -1887,7 +2053,7 @@ function validateApiSwitch(fromApi, toApi, modelSettings, embeddingSettings) {
       }
     }
   }
-  if (fromApi === "foundation-models" && toApi === "orchestration") {
+  if (toApi !== "foundation-models") {
     const fmSettings = modelSettings;
     for (const feature of FOUNDATION_MODELS_ONLY_FEATURE_KEYS) {
       if (fmSettings?.[feature] !== void 0) {
@@ -1895,6 +2061,9 @@ function validateApiSwitch(fromApi, toApi, modelSettings, embeddingSettings) {
       }
     }
   }
+  if (toApi !== "responses" && modelSettings && "responses" in modelSettings && modelSettings.responses !== void 0) {
+    throw new ApiSwitchError(fromApi, toApi, "responses");
+  }
 }
 function mergeSettingsWithApi(defaultSettings, callSettings, fallbackApi) {
   return {
@@ -1945,27 +2114,44 @@ function validateSettings(options) {
       );
     }
   }
-  if (api === "foundation-models") {
-    validateOrchestrationOnlyOptions(modelSettings);
-    validateOrchestrationOnlyInvocationOptions(invocationSettings);
+  if (api === "responses" && embeddingSettings !== void 0) {
+    throw new UnsupportedFeatureError("Embeddings", "responses", "foundation-models");
+  }
+  if (api !== "orchestration") {
+    validateOrchestrationOnlyOptions(api, modelSettings);
+    validateOrchestrationOnlyInvocationOptions(api, invocationSettings);
     validateOrchestrationOnlyEmbeddingOptions(embeddingSettings);
+  }
+  if (api !== "foundation-models") {
+    validateFoundationModelsOnlyOptions(api, modelSettings);
+  }
+  const modelResponses = modelSettings && "responses" in modelSettings ? modelSettings.responses : void 0;
+  const invocationResponses = invocationSettings?.responses;
+  if (api !== "responses") {
+    if (modelResponses !== void 0 || invocationResponses !== void 0) {
+      throw new UnsupportedFeatureError("Responses options (responses)", api, "responses");
+    }
   } else {
-    validateFoundationModelsOnlyOptions(modelSettings);
+    if (modelResponses !== void 0) responsesModelOptionsSchema.parse(modelResponses);
+    if (invocationResponses !== void 0) responsesModelOptionsSchema.parse(invocationResponses);
+  }
+  const modelDropUnsupportedParams = modelSettings?.dropUnsupportedParams;
+  if (modelDropUnsupportedParams !== void 0) {
+    dropUnsupportedParamsSchema.parse(modelDropUnsupportedParams);
+  }
+  if (invocationSettings?.dropUnsupportedParams !== void 0) {
+    dropUnsupportedParamsSchema.parse(invocationSettings.dropUnsupportedParams);
   }
   const modelEscape = modelSettings?.escapeTemplatePlaceholders;
   const invocationEscape = invocationSettings?.escapeTemplatePlaceholders;
   const effectiveEscape = invocationEscape ?? modelEscape;
   validateEscapeTemplatePlaceholders(api, effectiveEscape);
 }
-function validateOrchestrationOnlyInvocationOptions(invocationSettings) {
+function validateOrchestrationOnlyInvocationOptions(api, invocationSettings) {
   if (!invocationSettings) return;
   for (const feature of ORCHESTRATION_ONLY_INVOCATION_FEATURE_KEYS) {
     if (invocationSettings[feature] !== void 0) {
-      throw new UnsupportedFeatureError(
-        ORCHESTRATION_ONLY_FEATURES[feature],
-        "foundation-models",
-        "orchestration"
-      );
+      throw new UnsupportedFeatureError(ORCHESTRATION_ONLY_FEATURES[feature], api, "orchestration");
     }
   }
 }
@@ -1975,7 +2161,9 @@ var init_sap_ai_validation = __esm({
     "use strict";
     init_deep_merge();
     init_sap_ai_error();
+    init_sap_ai_provider_options();
     ORCHESTRATION_ONLY_FEATURE_KEYS = [
+      "dropUnsupportedParams",
       "fallbackModuleConfigs",
       "filtering",
       "grounding",
@@ -1988,6 +2176,7 @@ var init_sap_ai_validation = __esm({
       "translation"
     ];
     ORCHESTRATION_ONLY_FEATURES = {
+      dropUnsupportedParams: "Unsupported parameter handling (dropUnsupportedParams)",
       fallbackModuleConfigs: "Fallback module configurations (fallbackModuleConfigs)",
       filtering: "Content filtering",
       grounding: "Document grounding",
@@ -2004,6 +2193,7 @@ var init_sap_ai_validation = __esm({
       dataSources: "Azure On Your Data (dataSources)"
     };
     ORCHESTRATION_ONLY_INVOCATION_FEATURE_KEYS = [
+      "dropUnsupportedParams",
       "orchestrationConfigRef",
       "placeholderValues",
       "promptTemplateRef"
@@ -2012,75 +2202,1146 @@ var init_sap_ai_validation = __esm({
     ORCHESTRATION_ONLY_EMBEDDING_FEATURES = {
       masking: ORCHESTRATION_ONLY_FEATURES.masking
     };
-    ESCAPE_TEMPLATE_PLACEHOLDERS_DESCRIPTION = "escapeTemplatePlaceholders (Jinja2 template escaping)";
-    VALID_API_TYPES = ["orchestration", "foundation-models"];
+    ESCAPE_TEMPLATE_PLACEHOLDERS_DESCRIPTION = "escapeTemplatePlaceholders (Jinja2 template escaping)";
+    VALID_API_TYPES = [
+      "orchestration",
+      "foundation-models",
+      "responses"
+    ];
+  }
+});
+
+// src/orchestration-embedding-model-strategy.ts
+var orchestration_embedding_model_strategy_exports = {};
+__export(orchestration_embedding_model_strategy_exports, {
+  OrchestrationEmbeddingModelStrategy: () => OrchestrationEmbeddingModelStrategy
+});
+var OrchestrationEmbeddingModelStrategy;
+var init_orchestration_embedding_model_strategy = __esm({
+  "src/orchestration-embedding-model-strategy.ts"() {
+    "use strict";
+    init_base_embedding_model_strategy();
+    init_sap_ai_validation();
+    init_strategy_utils();
+    OrchestrationEmbeddingModelStrategy = class extends BaseEmbeddingModelStrategy {
+      ClientClass;
+      constructor(ClientClass) {
+        super();
+        this.ClientClass = ClientClass;
+      }
+      createClient(config, settings, embeddingOptions) {
+        const mergedParams = this.mergeModelParams(settings, embeddingOptions);
+        const embeddingConfig = {
+          model: {
+            name: config.modelId,
+            ...hasKeys(mergedParams) ? { params: mergedParams } : {},
+            ...settings.modelVersion ? { version: settings.modelVersion } : {}
+          }
+        };
+        const moduleConfig = {
+          embeddings: embeddingConfig,
+          ...settings.masking && hasKeys(settings.masking) ? { masking: settings.masking } : {}
+        };
+        return new this.ClientClass(moduleConfig, config.deploymentConfig, config.destination);
+      }
+      async executeCall(client, values, embeddingType, requestConfig) {
+        return client.embed({ input: values, type: embeddingType }, requestConfig);
+      }
+      extractEmbeddings(response) {
+        const embeddingData = response.getEmbeddings();
+        const sortedEmbeddings = [...embeddingData].sort((a, b) => a.index - b.index);
+        return sortedEmbeddings.map((data) => normalizeEmbedding(data.embedding));
+      }
+      extractResponseMetadata(response) {
+        return extractResponseMetadata(response, "response");
+      }
+      extractTokenCount(response) {
+        const tokenUsage = response.getTokenUsage();
+        return tokenUsage.total_tokens;
+      }
+      getUrl() {
+        return "sap-ai:orchestration/embeddings";
+      }
+      resolveWarnings(settings, warnings) {
+        validateMaskingProvidersDeprecation(settings, warnings);
+      }
+    };
+  }
+});
+
+// src/responses-adapters-v3-to-v4.ts
+function convertResponsesCallToV4(options) {
+  return {
+    ...options,
+    prompt: options.prompt.map((message) => {
+      switch (message.role) {
+        case "assistant":
+          return { ...message, content: message.content.map(convertPromptPart) };
+        case "system":
+          return message;
+        case "tool":
+          return {
+            ...message,
+            content: message.content.map(
+              (part) => part.type === "tool-result" ? convertToolResult(part) : part
+            )
+          };
+        case "user":
+          return {
+            ...message,
+            content: message.content.map(
+              (part) => part.type === "file" ? convertFile(part) : part
+            )
+          };
+      }
+    })
+  };
+}
+function convertFile(part) {
+  const data = part.data;
+  const href = getURLHref(data);
+  if (href !== void 0) {
+    const url = data instanceof URL && data.toString === URL.prototype.toString ? data : new URL(href);
+    return { ...part, data: { type: "url", url } };
+  }
+  return { ...part, data: { data, type: "data" } };
+}
+function convertPromptPart(part) {
+  if (part.type === "file") {
+    throw new import_provider5.UnsupportedFunctionalityError({
+      functionality: "Responses assistant file history is not supported."
+    });
+  }
+  if (part.type === "tool-result") return convertToolResult(part);
+  return part;
+}
+function convertToolItem(item) {
+  switch (item.type) {
+    case "custom":
+    case "text":
+      return item;
+    case "file-data":
+    case "image-data": {
+      const delegateIsImage = (0, import_provider_utils2.getTopLevelMediaType)(item.mediaType) === "image";
+      if (delegateIsImage !== (item.type === "image-data")) {
+        throw new import_provider5.UnsupportedFunctionalityError({
+          functionality: "Responses tool-result media whose legacy category disagrees with its media type."
+        });
+      }
+      return { ...item, data: { data: item.data, type: "data" }, type: "file" };
+    }
+    case "file-id":
+    case "image-file-id":
+      return {
+        data: {
+          reference: typeof item.fileId === "string" ? { openai: item.fileId } : item.fileId,
+          type: "reference"
+        },
+        mediaType: item.type === "image-file-id" ? "image" : "application/octet-stream",
+        providerOptions: item.providerOptions,
+        type: "file"
+      };
+    case "file-url":
+    case "image-url":
+      return {
+        data: { type: "url", url: new URL(item.url) },
+        mediaType: item.type === "image-url" ? "image" : "application/octet-stream",
+        providerOptions: item.providerOptions,
+        type: "file"
+      };
+  }
+}
+function convertToolResult(part) {
+  return part.output.type === "content" ? { ...part, output: { ...part.output, value: part.output.value.map(convertToolItem) } } : { ...part, output: part.output };
+}
+var import_provider5, import_provider_utils2;
+var init_responses_adapters_v3_to_v4 = __esm({
+  "src/responses-adapters-v3-to-v4.ts"() {
+    "use strict";
+    import_provider5 = require("@ai-sdk/provider");
+    import_provider_utils2 = require("@ai-sdk/provider-utils");
+    init_convert_to_sap_messages();
+  }
+});
+
+// src/adapter-metadata.ts
+var ORIGINAL_V4_FINISH_REASON;
+var init_adapter_metadata = __esm({
+  "src/adapter-metadata.ts"() {
+    "use strict";
+    ORIGINAL_V4_FINISH_REASON = /* @__PURE__ */ Symbol.for(
+      "@jerome-benoit/sap-ai-provider/adapter-metadata.originalV4FinishReason"
+    );
+  }
+});
+
+// src/responses-adapters-v4-to-v3.ts
+function convertResponsesResultToV3(result) {
+  return {
+    ...result,
+    content: result.content.map(convertContent),
+    finishReason: convertFinishReason(result.finishReason),
+    warnings: result.warnings.map(convertWarning)
+  };
+}
+function convertResponsesStreamPartToV3(part) {
+  switch (part.type) {
+    case "custom":
+    case "reasoning-file":
+      throw new import_provider6.UnsupportedFunctionalityError({
+        functionality: `Responses '${part.type}' output has no V3 equivalent.`
+      });
+    case "file":
+      return convertGeneratedFile(part);
+    case "finish":
+      return { ...part, finishReason: convertFinishReason(part.finishReason) };
+    case "stream-start":
+      return { ...part, warnings: part.warnings.map(convertWarning) };
+    default:
+      return part;
+  }
+}
+function convertContent(part) {
+  if (part.type === "custom" || part.type === "reasoning-file") {
+    throw new import_provider6.UnsupportedFunctionalityError({
+      functionality: `Responses '${part.type}' output has no V3 equivalent.`
+    });
+  }
+  return part.type === "file" ? convertGeneratedFile(part) : part;
+}
+function convertFinishReason(reason) {
+  if (reason.unified !== "interrupted") return reason;
+  const converted = { ...reason, unified: "other" };
+  return Object.defineProperty(converted, ORIGINAL_V4_FINISH_REASON, { value: reason });
+}
+function convertGeneratedFile(part) {
+  if (part.data.type !== "data") {
+    throw new import_provider6.UnsupportedFunctionalityError({
+      functionality: "Responses generated file URLs have no V3 equivalent and are not fetched."
+    });
+  }
+  return { ...part, data: part.data.data };
+}
+function convertWarning(warning) {
+  return warning.type === "deprecated" ? { message: `${warning.setting}: ${warning.message}`, type: "other" } : warning;
+}
+var import_provider6;
+var init_responses_adapters_v4_to_v3 = __esm({
+  "src/responses-adapters-v4-to-v3.ts"() {
+    "use strict";
+    import_provider6 = require("@ai-sdk/provider");
+    init_adapter_metadata();
+  }
+});
+
+// src/sap-http-stream.ts
+function destroyHttpResponse(response, retainedRequest) {
+  const body = response.data;
+  const request = response.request;
+  try {
+    if (isDestroyableRequest(body)) body.destroy();
+  } finally {
+    if (request !== retainedRequest && isDestroyableRequest(request)) request.destroy();
+  }
+}
+function disposeSapStream(response) {
+  if (disposedStreams.has(response)) return;
+  disposedStreams.add(response);
+  try {
+    response.stream.controller.abort();
+  } finally {
+    if (leasedStreams.has(response)) releaseSapStream(response);
+    else destroyHttpResponse(response.rawResponse);
+  }
+}
+async function executeSapStream(execute, signal, requestConfig) {
+  const responses = [];
+  const cleanups = /* @__PURE__ */ new Set();
+  let closed = false;
+  let transferred = false;
+  let failedRequest;
+  let failedError;
+  const release = () => {
+    closed = true;
+    signal?.removeEventListener("abort", release);
+    for (const response of responses) {
+      if (response.fromTransport && isConsumedHttpBody(response.data)) continue;
+      const consumedRequest = responses.some(
+        (other) => other.fromTransport && other.request === response.request && isConsumedHttpBody(other.data)
+      );
+      try {
+        const dispose = response.disposeTimeout;
+        const retainedRequest = consumedRequest ? response.request : void 0;
+        if (dispose && cleanups.has(dispose)) dispose(retainedRequest);
+        else destroyHttpResponse(response, retainedRequest);
+      } catch {
+      }
+    }
+    responses.length = 0;
+    cleanups.clear();
+  };
+  const ownResponse = (response, request, fromTransport, failed) => {
+    const data = response.data;
+    const nativeRequest = response.request;
+    const owned = responses.find((other) => other.data === data && other.request === nativeRequest);
+    if (owned) {
+      if (failed && !owned.disposeTimeout) {
+        owned.disposeTimeout = preserveResponseBodyTimeout(response, request, cleanups);
+      }
+    } else {
+      responses.push({
+        data,
+        disposeTimeout: failed ? preserveResponseBodyTimeout(response, request, cleanups) : void 0,
+        fromTransport,
+        request: nativeRequest
+      });
+    }
+    if (closed || signal?.aborted) release();
+  };
+  const observeResponse = ({ fn }) => async (request) => {
+    try {
+      const response = await fn(request);
+      ownResponse(response, request, true, false);
+      return response;
+    } catch (error) {
+      const failed = findFailedHttpRequest(error);
+      if (failed) ownResponse(failed.response, request, true, true);
+      throw error;
+    }
+  };
+  const captureFinalFailure = ({ fn }) => async (request) => {
+    try {
+      const response = await fn(request);
+      ownResponse(response, request, false, false);
+      return response;
+    } catch (error) {
+      const failed = findFailedHttpRequest(error);
+      if (!failed) throw error;
+      failedRequest = failed;
+      failedError = error;
+      ownResponse(failed.response, request, false, true);
+      return failed.response;
+    }
+  };
+  try {
+    const response = await waitWithAbort(
+      execute({
+        ...requestConfig,
+        middleware: [captureFinalFailure, ...requestConfig?.middleware ?? [], observeResponse]
+      }),
+      signal,
+      disposeSapStream
+    );
+    if (signal?.aborted) {
+      try {
+        disposeSapStream(response);
+      } finally {
+        throwIfAborted(signal);
+      }
+    }
+    if (failedRequest) {
+      try {
+        await readHttpErrorBody(
+          failedRequest.response,
+          createErrorByteStream(failedRequest.response),
+          signal
+        );
+      } catch {
+        throwIfAborted(signal);
+      }
+      throw failedError;
+    }
+    if (responses.length > 0) {
+      streamLeases.set(response, release);
+      leasedStreams.add(response);
+      signal?.addEventListener("abort", release, { once: true });
+      if (signal?.aborted) {
+        releaseSapStream(response);
+        throwIfAborted(signal);
+      }
+      transferred = true;
+    }
+    return response;
+  } finally {
+    if (!transferred) release();
+  }
+}
+function findFailedHttpRequest(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  for (let depth = 0; depth < 32; depth++) {
+    if (typeof current !== "object" || current === null || seen.has(current)) return void 0;
+    if (import_provider7.AISDKError.isInstance(current)) return void 0;
+    seen.add(current);
+    if (isFailedHttpRequest(current)) return current;
+    current = "cause" in current ? current.cause : current instanceof Error && (0, import_util2.isErrorWithCause)(current) ? current.rootCause : void 0;
+  }
+  return void 0;
+}
+function isDestroyableRequest(request) {
+  return typeof request === "object" && request !== null && "destroy" in request && typeof request.destroy === "function";
+}
+function preserveResponseBodyTimeout(response, requestConfig, cleanups) {
+  const body = response.data;
+  const request = response.request;
+  if (!isHttpResponseEvents(body) || !isHttpResponseEvents(request)) return;
+  const responseConfig = "config" in response ? response.config : void 0;
+  const timeoutConfig = typeof responseConfig === "object" && responseConfig !== null && !Array.isArray(responseConfig) ? responseConfig : requestConfig;
+  let ownsRequest = true;
+  const release = () => {
+    request.removeListener("timeout", onTimeout);
+    body.removeListener("end", release);
+    body.removeListener("error", onFailure);
+    body.removeListener("close", onFailure);
+    cleanups.delete(dispose);
+  };
+  const onFailure = () => {
+    try {
+      if (ownsRequest) request.destroy();
+    } finally {
+      release();
+    }
+  };
+  const dispose = (retainedRequest) => {
+    ownsRequest = request !== retainedRequest;
+    request.removeListener("timeout", onTimeout);
+    try {
+      body.destroy();
+    } finally {
+      if (ownsRequest) request.destroy();
+    }
+  };
+  const onTimeout = () => {
+    const nativeResponse = "res" in request ? request.res : void 0;
+    if (typeof nativeResponse === "object" && nativeResponse !== null && "complete" in nativeResponse && nativeResponse.complete === true) {
+      release();
+      return;
+    }
+    const timeout = timeoutConfig.timeout;
+    const timeoutErrorMessage = timeoutConfig.timeoutErrorMessage;
+    const transitional = timeoutConfig.transitional;
+    const clarifyTimeoutError = typeof transitional === "object" && transitional !== null && "clarifyTimeoutError" in transitional && transitional.clarifyTimeoutError === true;
+    const message = typeof timeoutErrorMessage === "string" && timeoutErrorMessage ? timeoutErrorMessage : (typeof timeout === "number" || typeof timeout === "string") && timeout ? `timeout of ${String(timeout)}ms exceeded` : "timeout exceeded";
+    body.destroy(
+      Object.assign(new Error(message), {
+        code: clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED"
+      })
+    );
+    request.destroy();
+  };
+  request.once("timeout", onTimeout);
+  body.once("end", release);
+  body.once("error", onFailure);
+  body.once("close", onFailure);
+  cleanups.add(dispose);
+  return dispose;
+}
+async function readHttpErrorBody(response, stream, signal) {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  let retainedBytes = 0;
+  let text = "";
+  let truncated = false;
+  let readFailure;
+  try {
+    for (; ; ) {
+      const chunk = await waitWithAbort(reader.read(), signal);
+      if (chunk.done) {
+        text += decoder.decode();
+        break;
+      }
+      const remaining = MAX_ERROR_BODY_BYTES - retainedBytes;
+      text += decoder.decode(chunk.value.subarray(0, remaining), { stream: true });
+      retainedBytes += Math.min(chunk.value.byteLength, remaining);
+      if (chunk.value.byteLength > remaining) {
+        truncated = true;
+        await reader.cancel("HTTP error diagnostic limit exceeded");
+        break;
+      }
+    }
+  } catch (error) {
+    readFailure = error;
+    if (!truncated) text += decoder.decode();
+    void reader.cancel(error).catch(() => {
+    });
+  } finally {
+    if (signal?.aborted) {
+      destroyHttpResponse(response);
+      void reader.cancel(signal.reason).catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+  response.data = truncated ? text + ERROR_BODY_TRUNCATION : text;
+  if (!truncated && readFailure === void 0) {
+    try {
+      response.data = JSON.parse(text);
+    } catch {
+      response.data = text;
+    }
+  }
+  throwIfAborted(signal);
+  return readFailure;
+}
+function withSapStreamCleanup(response, stream) {
+  if (!streamLeases.has(response)) return stream;
+  return iterate();
+  async function* iterate() {
+    try {
+      yield* stream;
+    } finally {
+      releaseSapStream(response);
+    }
+  }
+}
+function createErrorByteStream(response) {
+  const body = response.data;
+  if (typeof body !== "object" || body === null || !(Symbol.asyncIterator in body) || typeof body[Symbol.asyncIterator] !== "function") {
+    throw new TypeError("SAP did not return a readable HTTP error body.");
+  }
+  const iterator = body[Symbol.asyncIterator]();
+  const encoder = new TextEncoder();
+  return new ReadableStream(
+    {
+      cancel() {
+        destroyHttpResponse(response);
+      },
+      async pull(controller) {
+        try {
+          const chunk = await iterator.next();
+          if (chunk.done) controller.close();
+          else if (typeof chunk.value === "string") controller.enqueue(encoder.encode(chunk.value));
+          else if (chunk.value instanceof Uint8Array) controller.enqueue(chunk.value);
+          else throw new TypeError("SAP returned a non-byte HTTP error chunk.");
+        } catch (error) {
+          try {
+            destroyHttpResponse(response);
+          } catch {
+          } finally {
+            controller.error(error);
+          }
+        }
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+function isConsumedHttpBody(body) {
+  return typeof body === "object" && body !== null && "readableEnded" in body && body.readableEnded === true;
+}
+function isFailedHttpRequest(error) {
+  return error instanceof Error && "isAxiosError" in error && error.isAxiosError === true && "response" in error && typeof error.response === "object" && error.response !== null;
+}
+function isHttpResponseEvents(value) {
+  return isDestroyableRequest(value) && "once" in value && typeof value.once === "function" && "removeListener" in value && typeof value.removeListener === "function";
+}
+function releaseSapStream(response) {
+  const release = streamLeases.get(response);
+  streamLeases.delete(response);
+  release?.();
+}
+var import_provider7, import_util2, ERROR_BODY_TRUNCATION, MAX_ERROR_BODY_BYTES, ERROR_BODY_READ_FAILURE, disposedStreams, leasedStreams, streamLeases;
+var init_sap_http_stream = __esm({
+  "src/sap-http-stream.ts"() {
+    "use strict";
+    import_provider7 = require("@ai-sdk/provider");
+    import_util2 = require("@sap-cloud-sdk/util");
+    init_abort_utils();
+    ERROR_BODY_TRUNCATION = "...[truncated]";
+    MAX_ERROR_BODY_BYTES = 2e3 - ERROR_BODY_TRUNCATION.length;
+    ERROR_BODY_READ_FAILURE = /* @__PURE__ */ Symbol("sap-ai.httpErrorBodyReadFailure");
+    disposedStreams = /* @__PURE__ */ new WeakSet();
+    leasedStreams = /* @__PURE__ */ new WeakSet();
+    streamLeases = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/responses-http-transport.ts
+async function createResponsesTransport(config, settings, options) {
+  throwIfAborted(options.abortSignal);
+  const deployment = buildModelDeployment(config, settings.modelVersion);
+  const [deploymentId, destination] = await waitWithAbort(
+    Promise.all([
+      (0, import_internal.getFoundationModelDeploymentId)(deployment, "azure-openai", config.destination),
+      (0, import_core.getAiCoreDestination)(config.destination)
+    ]),
+    options.abortSignal
+  );
+  throwIfAborted(options.abortSignal);
+  const deploymentPath = `/inference/deployments/${encodeURIComponent(deploymentId)}`;
+  const baseURL = (0, import_internal2.getTargetUrl)(destination.url, deploymentPath);
+  const endpoint = new URL(`${baseURL}/responses`);
+  const requestConfig = mergeRequestConfig(
+    config.requestConfig,
+    options.abortSignal,
+    options.headers
+  );
+  const activeRequests = /* @__PURE__ */ new Set();
+  let disposed = false;
+  let disposalReason;
+  const dispose = (reason) => {
+    if (disposed) return;
+    disposed = true;
+    disposalReason = reason;
+    for (const release of activeRequests) {
+      try {
+        release(reason);
+      } catch {
+      }
+    }
+    activeRequests.clear();
+  };
+  const fetch = async (input, init) => {
+    if (disposed) throw createAbortError(disposalReason);
+    const url = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+    if (url.origin !== endpoint.origin || url.pathname !== endpoint.pathname) {
+      throw new TypeError("SAP Responses requests must target the configured deployment.");
+    }
+    if (init?.method !== "POST" || typeof init.body !== "string") {
+      throw new TypeError("SAP Responses requires a POST request with a JSON body.");
+    }
+    const body = JSON.parse(init.body);
+    const operation = typeof body === "object" && body !== null && "stream" in body && body.stream === true ? "doStream" : "doGenerate";
+    const controller = new AbortController();
+    const signal = options.abortSignal ?? init.signal;
+    const bodyTimeoutCleanups = /* @__PURE__ */ new Set();
+    let abortFailedRequest;
+    let activeResponse;
+    const onAbort = () => {
+      controller.abort(signal?.reason);
+    };
+    const cleanup = () => {
+      activeRequests.delete(disposeRequest);
+      signal?.removeEventListener("abort", onAbort);
+      if (abortFailedRequest) controller.signal.removeEventListener("abort", abortFailedRequest);
+      for (const dispose2 of bodyTimeoutCleanups) dispose2();
+      activeResponse = void 0;
+    };
+    const disposeRequest = (reason) => {
+      try {
+        controller.abort(reason);
+      } finally {
+        try {
+          if (activeResponse) destroyHttpResponse(activeResponse);
+        } finally {
+          cleanup();
+        }
+      }
+    };
+    throwIfAborted(signal ?? void 0);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    activeRequests.add(disposeRequest);
+    const headers = new Headers(init.headers);
+    headers.delete("authorization");
+    const configuredHeaders = Object.fromEntries(
+      Object.entries(requestConfig?.headers ?? {}).map(([key, value]) => [
+        key.toLowerCase(),
+        value
+      ])
+    );
+    let failedRequest;
+    let failedError;
+    const watchResponse = (response, request) => {
+      activeResponse = response;
+      if (controller.signal.aborted) destroyHttpResponse(response);
+      else preserveResponseBodyTimeout(response, request, bodyTimeoutCleanups);
+      return response;
+    };
+    const preserveBodyTimeout = ({ fn }) => async (request) => {
+      try {
+        return watchResponse(await fn(request), request);
+      } catch (error) {
+        const failed = findFailedHttpRequest(error);
+        if (failed) watchResponse(failed.response, request);
+        throw error;
+      }
+    };
+    const preserveErrorResponse = ({ fn }) => async (request) => {
+      try {
+        return await fn(request);
+      } catch (error) {
+        const failed = findFailedHttpRequest(error);
+        if (!failed) throw error;
+        failedRequest = failed;
+        failedError = error;
+        const request2 = failed.response.request;
+        if (isDestroyableRequest(request2)) {
+          abortFailedRequest = () => {
+            request2.destroy();
+          };
+          if (controller.signal.aborted) abortFailedRequest();
+          else controller.signal.addEventListener("abort", abortFailedRequest, { once: true });
+        }
+        return failed.response;
+      }
+    };
+    try {
+      const pendingResponse = (0, import_core.executeRequest)(
+        {
+          apiVersion: "2024-10-21",
+          resourceGroup: (0, import_internal.getResourceGroup)(deployment),
+          url: `${deploymentPath}/responses`
+        },
+        body,
+        {
+          ...requestConfig,
+          headers: { ...Object.fromEntries(headers), ...configuredHeaders },
+          middleware: [
+            preserveErrorResponse,
+            ...requestConfig?.middleware ?? [],
+            preserveBodyTimeout
+          ],
+          responseType: "stream",
+          signal: controller.signal
+        },
+        config.destination
+      );
+      const response = await waitWithAbort(pendingResponse, controller.signal, destroyHttpResponse);
+      activeResponse = response;
+      if (controller.signal.aborted) {
+        destroyHttpResponse(response);
+        throw createAbortError(controller.signal.reason);
+      }
+      const responseBody = response.data;
+      const responseStream = createByteStream(
+        responseBody,
+        controller,
+        cleanup,
+        config,
+        options,
+        operation
+      );
+      if (failedRequest) {
+        const readFailure = await readHttpErrorBody(
+          failedRequest.response,
+          responseStream,
+          signal ?? void 0
+        );
+        const failure = convertToAISDKError(failedError, {
+          modelId: config.modelId,
+          modelType: "languageModel",
+          operation,
+          requestBody: createAISDKRequestBodySummary(options),
+          url: "sap-ai:responses"
+        });
+        if (readFailure !== void 0 && import_provider8.APICallError.isInstance(failure)) {
+          Object.defineProperty(failure, ERROR_BODY_READ_FAILURE, { value: readFailure });
+        }
+        throw failure;
+      }
+      return new Response(responseStream, {
+        headers: normalizeHeaders(response.headers),
+        status: response.status
+      });
+    } catch (error) {
+      dispose(error);
+      throw error;
+    }
+  };
+  return { baseURL, dispose, fetch };
+}
+function createByteStream(body, requestController, cleanup, config, options, operation) {
+  if (typeof body !== "object" || body === null || !(Symbol.asyncIterator in body) || typeof body[Symbol.asyncIterator] !== "function") {
+    requestController.abort();
+    cleanup();
+    throw new TypeError("SAP Responses did not return a readable response body.");
+  }
+  const source = body;
+  const iterator = source[Symbol.asyncIterator]();
+  const encoder = new TextEncoder();
+  const onAbort = () => source.destroy?.();
+  const cleanupStream = () => {
+    requestController.signal.removeEventListener("abort", onAbort);
+    cleanup();
+  };
+  requestController.signal.addEventListener("abort", onAbort, { once: true });
+  if (requestController.signal.aborted) onAbort();
+  return new ReadableStream(
+    {
+      async cancel(reason) {
+        requestController.abort(reason);
+        cleanupStream();
+        if (source.destroy) {
+          source.destroy();
+        } else {
+          await iterator.return?.();
+        }
+      },
+      async pull(controller) {
+        try {
+          throwIfAborted(requestController.signal);
+          const chunk = await iterator.next();
+          throwIfAborted(requestController.signal);
+          if (chunk.done) {
+            cleanupStream();
+            controller.close();
+          } else if (typeof chunk.value === "string") {
+            controller.enqueue(encoder.encode(chunk.value));
+          } else if (chunk.value instanceof Uint8Array) {
+            controller.enqueue(chunk.value);
+          } else {
+            throw new TypeError("SAP Responses returned a non-byte response chunk.");
+          }
+        } catch (error) {
+          const failure = requestController.signal.aborted ? createAbortError(requestController.signal.reason) : error;
+          requestController.abort(error);
+          cleanupStream();
+          source.destroy?.();
+          controller.error(
+            convertToAISDKError(failure, {
+              modelId: config.modelId,
+              modelType: "languageModel",
+              operation,
+              requestBody: createAISDKRequestBodySummary(options),
+              url: "sap-ai:responses"
+            })
+          );
+        }
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+var import_provider8, import_internal, import_core, import_internal2;
+var init_responses_http_transport = __esm({
+  "src/responses-http-transport.ts"() {
+    "use strict";
+    import_provider8 = require("@ai-sdk/provider");
+    import_internal = require("@sap-ai-sdk/ai-api/internal.js");
+    import_core = require("@sap-ai-sdk/core");
+    import_internal2 = require("@sap-ai-sdk/core/internal.js");
+    init_abort_utils();
+    init_sap_ai_error();
+    init_sap_http_stream();
+    init_strategy_utils();
   }
 });
 
-// src/orchestration-embedding-model-strategy.ts
-var orchestration_embedding_model_strategy_exports = {};
-__export(orchestration_embedding_model_strategy_exports, {
-  OrchestrationEmbeddingModelStrategy: () => OrchestrationEmbeddingModelStrategy
+// src/responses-language-model-strategy.ts
+var responses_language_model_strategy_exports = {};
+__export(responses_language_model_strategy_exports, {
+  ResponsesLanguageModelStrategy: () => ResponsesLanguageModelStrategy
 });
-var OrchestrationEmbeddingModelStrategy;
-var init_orchestration_embedding_model_strategy = __esm({
-  "src/orchestration-embedding-model-strategy.ts"() {
-    "use strict";
-    init_base_embedding_model_strategy();
-    init_sap_ai_validation();
-    init_strategy_utils();
-    OrchestrationEmbeddingModelStrategy = class extends BaseEmbeddingModelStrategy {
-      ClientClass;
-      constructor(ClientClass) {
-        super();
-        this.ClientClass = ClientClass;
-      }
-      createClient(config, settings, embeddingOptions) {
-        const mergedParams = this.mergeModelParams(settings, embeddingOptions);
-        const embeddingConfig = {
-          model: {
-            name: config.modelId,
-            ...hasKeys(mergedParams) ? { params: mergedParams } : {},
-            ...settings.modelVersion ? { version: settings.modelVersion } : {}
-          }
+function convertError(error, config, options, operation) {
+  if (import_provider9.APICallError.isInstance(error) && error.message === "Failed to process successful response" && error.statusCode !== void 0 && error.statusCode >= 200 && error.statusCode < 300 && import_provider9.APICallError.isInstance(error.cause)) {
+    return error.cause;
+  }
+  if (operation === "doStream" && !import_provider9.APICallError.isInstance(error)) {
+    const parsed = OPENAI_STREAM_ERROR_SCHEMA.safeParse(error);
+    if (parsed.success) {
+      return new import_provider9.APICallError({
+        cause: error,
+        data: parsed.data.data,
+        isRetryable: parsed.data.isRetryable,
+        message: parsed.data.message,
+        requestBodyValues: createAISDKRequestBodySummary(options),
+        statusCode: parsed.data.statusCode,
+        url: "sap-ai:responses"
+      });
+    }
+  }
+  return convertToAISDKError(error, {
+    modelId: config.modelId,
+    modelType: "languageModel",
+    operation,
+    requestBody: createAISDKRequestBodySummary(options),
+    url: "sap-ai:responses"
+  });
+}
+function fromOpenAI(metadata, providerName) {
+  if (providerName === "openai" || !metadata?.openai) return metadata;
+  const { openai, ...rest } = metadata;
+  return { ...rest, [providerName]: { ...rest[providerName], ...openai } };
+}
+function fromOpenAICitations(citations, providerName) {
+  if (providerName === "openai" || !citations) return citations;
+  let mapped;
+  let index = 0;
+  for (const citation of citations) {
+    const providerMetadata = fromOpenAI(citation.source.providerMetadata, providerName);
+    if (providerMetadata !== citation.source.providerMetadata) {
+      mapped ??= citations.slice();
+      mapped[index] = {
+        ...citation,
+        source: { ...citation.source, providerMetadata }
+      };
+    }
+    index++;
+  }
+  return mapped ?? citations;
+}
+function fromOpenAIContent(part, providerName) {
+  const providerMetadata = fromOpenAI(part.providerMetadata, providerName);
+  const citations = fromOpenAICitations(part.citations, providerName);
+  if (providerMetadata === part.providerMetadata && citations === part.citations) return part;
+  if (providerMetadata === part.providerMetadata) return { ...part, citations };
+  return citations === part.citations ? { ...part, providerMetadata } : { ...part, citations, providerMetadata };
+}
+function modelResponseFormat(settings) {
+  const format = settings.responseFormat;
+  if (!format || format.type === "text") return format;
+  if (format.type === "json_object") return { type: "json" };
+  const schema = format.json_schema;
+  return {
+    description: schema.description,
+    name: schema.name,
+    schema: schema.schema === void 0 ? void 0 : import_zod3.z.record(import_zod3.z.string(), import_zod3.z.json()).parse(schema.schema),
+    type: "json"
+  };
+}
+async function prepareModel(config, settings, options) {
+  if (options.abortSignal?.aborted) {
+    throw createAbortError(options.abortSignal.reason);
+  }
+  const providerName = getProviderName(config.provider);
+  const sapOptions = config.parsedProviderOptions;
+  const parameters = { ...settings.modelParams, ...sapOptions?.modelParams };
+  const warnings = Object.keys(parameters).filter((key) => !MODEL_PARAMETERS.has(key)).map((key) => ({
+    details: "Use the responses option for Responses-specific parameters.",
+    feature: `modelParams.${key}`,
+    type: "unsupported"
+  }));
+  if (sapOptions?.includeReasoning ?? settings.includeReasoning) {
+    warnings.push({
+      details: "Responses preserves native reasoning history instead of converting it to text.",
+      feature: "includeReasoning",
+      type: "unsupported"
+    });
+  }
+  const responseOptions = {
+    ...parameters.parallel_tool_calls !== void 0 ? { parallelToolCalls: parameters.parallel_tool_calls } : {},
+    ...settings.responseFormat?.type === "json_schema" ? { strictJsonSchema: settings.responseFormat.json_schema.strict } : {},
+    store: false,
+    ...settings.responses,
+    ...sapOptions?.responses
+  };
+  const reasoning = "reasoning" in options ? options.reasoning : void 0;
+  if (typeof reasoning === "string" && reasoning !== "provider-default") {
+    responseOptions.reasoningEffort = reasoning;
+  }
+  const input = {
+    ...options,
+    frequencyPenalty: options.frequencyPenalty ?? parameters.frequencyPenalty,
+    maxOutputTokens: options.maxOutputTokens ?? parameters.maxTokens,
+    presencePenalty: options.presencePenalty ?? parameters.presencePenalty,
+    prompt: toOpenAIPrompt(options.prompt, providerName),
+    providerOptions: {
+      ...options.providerOptions,
+      openai: responseOptions
+    },
+    responseFormat: options.responseFormat ?? modelResponseFormat(settings),
+    temperature: options.temperature ?? parameters.temperature,
+    tools: options.tools?.map(
+      (tool) => tool.type === "function" ? {
+        ...tool,
+        providerOptions: toOpenAI(tool.providerOptions, providerName),
+        strict: tool.strict ?? false
+      } : tool
+    ),
+    topP: options.topP ?? parameters.topP
+  };
+  const convertedInput = convertResponsesCallToV4(input);
+  const transport = await createResponsesTransport(config, settings, options);
+  const model = (0, import_openai.createOpenAI)({
+    // Authentication is supplied by SAP's transport, not an OpenAI API key.
+    apiKey: "sap-ai-core",
+    baseURL: transport.baseURL,
+    fetch: transport.fetch
+  }).responses(config.modelId);
+  return { dispose: transport.dispose, input: convertedInput, model, providerName, warnings };
+}
+function responseMetadata(metadata, providerName) {
+  const mapped = fromOpenAI(metadata, providerName);
+  return {
+    ...mapped,
+    [providerName]: { ...mapped?.[providerName], api: "responses", version: VERSION }
+  };
+}
+function toOpenAI(options, providerName) {
+  if (providerName === "openai" || !options?.[providerName]) return options;
+  return { ...options, openai: { ...options.openai, ...options[providerName] } };
+}
+function toOpenAIOutput(output, providerName) {
+  const mappedOutput = {
+    ...output,
+    providerOptions: toOpenAI(output.providerOptions, providerName)
+  };
+  if (mappedOutput.type !== "content") return mappedOutput;
+  return {
+    ...mappedOutput,
+    value: mappedOutput.value.map((part) => ({
+      ...part,
+      ...(part.type === "file-id" || part.type === "image-file-id") && typeof part.fileId !== "string" && part.fileId[providerName] ? { fileId: { ...part.fileId, openai: part.fileId[providerName] } } : {},
+      ..."providerOptions" in part ? { providerOptions: toOpenAI(part.providerOptions, providerName) } : {}
+    }))
+  };
+}
+function toOpenAIPart(part, providerName) {
+  return {
+    ...part,
+    ...part.type === "tool-result" ? { output: toOpenAIOutput(part.output, providerName) } : {},
+    providerOptions: toOpenAI(part.providerOptions, providerName)
+  };
+}
+function toOpenAIPrompt(prompt, providerName) {
+  return prompt.map((message) => {
+    const providerOptions = toOpenAI(message.providerOptions, providerName);
+    switch (message.role) {
+      case "assistant":
+        return {
+          ...message,
+          content: message.content.map((part) => toOpenAIPart(part, providerName)),
+          providerOptions
         };
-        const moduleConfig = {
-          embeddings: embeddingConfig,
-          ...settings.masking && hasKeys(settings.masking) ? { masking: settings.masking } : {}
+      case "system":
+        return { ...message, providerOptions };
+      case "tool":
+        return {
+          ...message,
+          content: message.content.map((part) => toOpenAIPart(part, providerName)),
+          providerOptions
         };
-        return new this.ClientClass(moduleConfig, config.deploymentConfig, config.destination);
-      }
-      async executeCall(client, values, embeddingType, requestConfig) {
-        return client.embed({ input: values, type: embeddingType }, requestConfig);
-      }
-      extractEmbeddings(response) {
-        const embeddingData = response.getEmbeddings();
-        const sortedEmbeddings = [...embeddingData].sort((a, b) => a.index - b.index);
-        return sortedEmbeddings.map((data) => normalizeEmbedding(data.embedding));
-      }
-      extractResponseMetadata(response) {
-        return extractResponseMetadata(response, "response");
-      }
-      extractTokenCount(response) {
-        const tokenUsage = response.getTokenUsage();
-        return tokenUsage.total_tokens;
-      }
-      getUrl() {
-        return "sap-ai:orchestration/embeddings";
+      case "user":
+        return {
+          ...message,
+          content: message.content.map((part) => toOpenAIPart(part, providerName)),
+          providerOptions
+        };
+    }
+  });
+}
+var import_openai, import_provider9, import_zod3, MODEL_PARAMETERS, OPENAI_STREAM_ERROR_SCHEMA, ResponsesLanguageModelStrategy;
+var init_responses_language_model_strategy = __esm({
+  "src/responses-language-model-strategy.ts"() {
+    "use strict";
+    import_openai = require("@ai-sdk/openai");
+    import_provider9 = require("@ai-sdk/provider");
+    import_zod3 = require("zod");
+    init_abort_utils();
+    init_responses_adapters_v3_to_v4();
+    init_responses_adapters_v4_to_v3();
+    init_responses_http_transport();
+    init_sap_ai_error();
+    init_sap_ai_provider_options();
+    init_strategy_utils();
+    init_version();
+    MODEL_PARAMETERS = /* @__PURE__ */ new Set([
+      "frequencyPenalty",
+      "maxTokens",
+      "parallel_tool_calls",
+      "presencePenalty",
+      "temperature",
+      "topP"
+    ]);
+    OPENAI_STREAM_ERROR_SCHEMA = import_zod3.z.object({
+      data: import_zod3.z.object({ type: import_zod3.z.enum(["error", "response.failed"]) }).loose(),
+      isRetryable: import_zod3.z.boolean(),
+      message: import_zod3.z.string(),
+      statusCode: import_zod3.z.number().int().min(400).max(599)
+    });
+    ResponsesLanguageModelStrategy = class {
+      async doGenerate(config, settings, options) {
+        let dispose;
+        try {
+          const prepared = await prepareModel(config, settings, options);
+          dispose = prepared.dispose;
+          const { input, model, providerName, warnings } = prepared;
+          const result = convertResponsesResultToV3(await model.doGenerate(input));
+          return {
+            ...result,
+            content: result.content.map((part) => fromOpenAIContent(part, providerName)),
+            providerMetadata: responseMetadata(result.providerMetadata, providerName),
+            warnings: [...warnings, ...result.warnings]
+          };
+        } catch (error) {
+          const failure = convertError(error, config, options, "doGenerate");
+          dispose?.(failure);
+          throw failure;
+        }
       }
-      resolveWarnings(settings, warnings) {
-        validateMaskingProvidersDeprecation(settings, warnings);
+      async doStream(config, settings, options) {
+        let dispose;
+        try {
+          const prepared = await prepareModel(config, settings, options);
+          dispose = prepared.dispose;
+          const { input, model, providerName, warnings } = prepared;
+          const result = await model.doStream(input);
+          const reader = result.stream.getReader();
+          let cancelled = false;
+          const isCancelled = () => cancelled;
+          return {
+            ...result,
+            stream: new ReadableStream(
+              {
+                async cancel(reason) {
+                  cancelled = true;
+                  dispose?.(reason);
+                  try {
+                    await reader.cancel(reason);
+                  } finally {
+                    reader.releaseLock();
+                  }
+                },
+                async pull(controller) {
+                  try {
+                    if (options.abortSignal?.aborted)
+                      throw createAbortError(options.abortSignal.reason);
+                    const next = await reader.read();
+                    if (isCancelled()) return;
+                    if (options.abortSignal?.aborted)
+                      throw createAbortError(options.abortSignal.reason);
+                    if (next.done) {
+                      reader.releaseLock();
+                      controller.close();
+                      return;
+                    }
+                    const part = convertResponsesStreamPartToV3(next.value);
+                    if (part.type === "stream-start") {
+                      controller.enqueue({ ...part, warnings: [...warnings, ...part.warnings] });
+                    } else if (part.type === "finish") {
+                      controller.enqueue({
+                        ...part,
+                        providerMetadata: responseMetadata(part.providerMetadata, providerName)
+                      });
+                    } else if (part.type === "error") {
+                      controller.enqueue({
+                        ...part,
+                        error: convertError(part.error, config, options, "doStream")
+                      });
+                    } else if ("providerMetadata" in part || part.type === "text-end") {
+                      controller.enqueue(fromOpenAIContent(part, providerName));
+                    } else {
+                      controller.enqueue(part);
+                    }
+                  } catch (error) {
+                    if (isCancelled()) return;
+                    const failure = convertError(error, config, options, "doStream");
+                    dispose?.(failure);
+                    await reader.cancel(error).catch(() => void 0);
+                    if (isCancelled()) return;
+                    reader.releaseLock();
+                    controller.enqueue({
+                      error: failure,
+                      type: "error"
+                    });
+                    controller.close();
+                  }
+                }
+              },
+              { highWaterMark: 0 }
+            )
+          };
+        } catch (error) {
+          const failure = convertError(error, config, options, "doStream");
+          dispose?.(failure);
+          throw failure;
+        }
       }
     };
   }
 });
 
 // src/stream-transformer.ts
-function createAbortError(reason) {
-  const error = new Error("The operation was aborted.", { cause: reason });
-  error.name = "AbortError";
-  return error;
-}
 function createInitialStreamState() {
   return {
     activeText: false,
@@ -2109,13 +3370,15 @@ function createStreamTransformer(config) {
     cancel,
     convertToAISDKError: convertToAISDKError2,
     extractChunkMetadata,
+    extractProviderSpecificFields,
+    extractReasoningBlocks,
     idGenerator,
     includeRawChunks,
     modelId,
     options,
     providerName,
     requestId,
-    responseMetadata,
+    responseMetadata: responseMetadata2,
     sdkStream,
     streamResponseGetCitations,
     streamResponseGetFinishReason,
@@ -2127,10 +3390,51 @@ function createStreamTransformer(config) {
   let textBlockId = null;
   const streamState = createInitialStreamState();
   const toolCallsInProgress = /* @__PURE__ */ new Map();
-  const resolvedResponseMetadata = { ...responseMetadata };
+  const resolvedResponseMetadata = { ...responseMetadata2 };
   let resolvedRequestId = requestId;
   let tokenUsage;
   let citations;
+  let providerSpecificFields;
+  let providerFinishReason;
+  let reasoningBlocks;
+  function collectReasoningBlocks(incoming, controller) {
+    if (incoming === void 0) return true;
+    if (!Array.isArray(incoming)) {
+      handleStreamError(
+        new TypeError("Invalid Orchestration reasoning_content: expected an array."),
+        controller,
+        convertToAISDKError2,
+        options,
+        modelId,
+        url
+      );
+      return false;
+    }
+    const blocks = incoming;
+    if (blocks.length === 0) return true;
+    reasoningBlocks ??= [];
+    for (const [index, value] of blocks.entries()) {
+      const parsed = orchestrationReasoningBlockSchema.safeParse(value);
+      if (!parsed.success) {
+        handleStreamError(parsed.error, controller, convertToAISDKError2, options, modelId, url);
+        return false;
+      }
+      const block = parsed.data;
+      let state = reasoningBlocks[index];
+      if (state) {
+        state.block.content = (state.block.content ?? "") + (block.content ?? "");
+        if (block.signature) state.block.signature = block.signature;
+      } else {
+        state = { block, id: idGenerator.generateReasoningBlockId() };
+        reasoningBlocks.push(state);
+        controller.enqueue({ id: state.id, type: "reasoning-start" });
+      }
+      if (block.content) {
+        controller.enqueue({ delta: block.content, id: state.id, type: "reasoning-delta" });
+      }
+    }
+    return true;
+  }
   function collectCitations(incoming) {
     if (!incoming?.length) return;
     citations ??= /* @__PURE__ */ new Map();
@@ -2207,6 +3511,13 @@ function createStreamTransformer(config) {
           );
           return;
         }
+        for (const state of reasoningBlocks ?? []) {
+          controller.enqueue({
+            id: state.id,
+            providerMetadata: buildOrchestrationReasoningMetadata(state.block, providerName),
+            type: "reasoning-end"
+          });
+        }
         const didEmitAnyToolCalls = finalizeToolCalls(
           controller,
           toolCallsInProgress,
@@ -2218,13 +3529,16 @@ function createStreamTransformer(config) {
         }
         const finalFinishReason = streamResponseGetFinishReason();
         if (finalFinishReason) {
-          streamState.finishReason = mapFinishReason(finalFinishReason);
+          streamState.finishReason = mapFinishReason(finalFinishReason, providerFinishReason);
         } else if (didEmitAnyToolCalls) {
           streamState.finishReason = {
-            raw: void 0,
+            raw: providerFinishReason,
             unified: "tool-calls"
           };
         }
+        if (providerFinishReason !== void 0) {
+          streamState.finishReason = { ...streamState.finishReason, raw: providerFinishReason };
+        }
         streamState.usage = mapTokenUsage(tokenUsage);
         collectCitations(streamResponseGetCitations?.());
         if (citations) {
@@ -2246,6 +3560,7 @@ function createStreamTransformer(config) {
               ...buildAnthropicCacheMetadata(tokenUsage),
               finishReason: streamState.finishReason.raw ?? "unknown",
               finishReasonMapped: streamState.finishReason,
+              ...providerSpecificFields && { providerSpecificFields },
               ...streamIntermediateFailures?.length ? {
                 intermediateFailures: sanitizeAsJSONArray(streamIntermediateFailures)
               } : {},
@@ -2285,6 +3600,14 @@ function createStreamTransformer(config) {
         Object.assign(resolvedResponseMetadata, incomingMetadata);
         collectUsage(chunk.getTokenUsage?.());
         collectCitations(chunk.getCitations?.());
+        const incomingProviderFields = parseProviderSpecificFields(
+          extractProviderSpecificFields?.(chunk)
+        );
+        if (incomingProviderFields) {
+          providerSpecificFields = { ...providerSpecificFields, ...incomingProviderFields };
+          providerFinishReason = getProviderFinishReason(incomingProviderFields) ?? providerFinishReason;
+        }
+        if (!collectReasoningBlocks(extractReasoningBlocks?.(chunk), controller)) return;
         if (streamState.isFirstChunk || metadataChanged) {
           streamState.isFirstChunk = false;
           controller.enqueue({
@@ -2314,7 +3637,7 @@ function createStreamTransformer(config) {
         }
         const chunkFinishReason = chunk.getFinishReason();
         if (chunkFinishReason) {
-          streamState.finishReason = mapFinishReason(chunkFinishReason);
+          streamState.finishReason = mapFinishReason(chunkFinishReason, providerFinishReason);
           if (streamState.finishReason.unified === "tool-calls") {
             finalizeToolCalls(controller, toolCallsInProgress, idGenerator, emitToolInputStart);
             if (streamState.activeText && textBlockId) {
@@ -2437,8 +3760,16 @@ var StreamIdGenerator;
 var init_stream_transformer = __esm({
   "src/stream-transformer.ts"() {
     "use strict";
+    init_abort_utils();
+    init_sap_ai_provider_options();
     init_strategy_utils();
     StreamIdGenerator = class {
+      /**
+       * @returns A UUID string for identifying a native reasoning block.
+       */
+      generateReasoningBlockId() {
+        return crypto.randomUUID();
+      }
       /**
        * @returns A UUID string for identifying the response.
        */
@@ -2466,6 +3797,7 @@ var BaseLanguageModelStrategy;
 var init_base_language_model_strategy = __esm({
   "src/base-language-model-strategy.ts"() {
     "use strict";
+    init_abort_utils();
     init_convert_to_sap_messages();
     init_sap_ai_error();
     init_sap_ai_provider_options();
@@ -2497,15 +3829,19 @@ var init_base_language_model_strategy = __esm({
       ];
       async doGenerate(config, settings, options) {
         try {
-          if (options.abortSignal?.aborted) throw createAbortError(options.abortSignal.reason);
+          throwIfAborted(options.abortSignal);
           const commonParts = this.buildCommonParts(config, settings, options);
           const { request, warnings } = this.buildRequest(config, settings, options, commonParts);
           const client = this.createClient(config, settings, commonParts);
-          const response = await this.executeApiCall(
-            client,
-            request,
-            mergeRequestConfig(config.requestConfig, options.abortSignal, options.headers)
+          const response = await waitWithAbort(
+            this.executeApiCall(
+              client,
+              request,
+              mergeRequestConfig(config.requestConfig, options.abortSignal, options.headers)
+            ),
+            options.abortSignal
           );
+          throwIfAborted(options.abortSignal);
           return buildGenerateResult({
             providerName: commonParts.providerName,
             requestBody: request,
@@ -2527,7 +3863,7 @@ var init_base_language_model_strategy = __esm({
       }
       async doStream(config, settings, options) {
         try {
-          if (options.abortSignal?.aborted) throw createAbortError(options.abortSignal.reason);
+          throwIfAborted(options.abortSignal);
           const commonParts = this.buildCommonParts(config, settings, options);
           const { request, warnings } = this.buildRequest(config, settings, options, commonParts);
           const client = this.createClient(config, settings, commonParts);
@@ -2536,14 +3872,24 @@ var init_base_language_model_strategy = __esm({
             request,
             options.abortSignal ?? void 0,
             settings,
-            mergeRequestConfig(config.requestConfig, void 0, options.headers)
+            mergeRequestConfig(config.requestConfig, void 0, options.headers),
+            commonParts
           );
+          if (options.abortSignal?.aborted) {
+            try {
+              streamResponse.cancel();
+            } finally {
+              throwIfAborted(options.abortSignal);
+            }
+          }
           const idGenerator = new StreamIdGenerator();
           const streamWarnings = this.collectStreamWarnings(settings, commonParts.sapOptions);
           const transformedStream = createStreamTransformer({
             cancel: streamResponse.cancel,
             convertToAISDKError,
             extractChunkMetadata: (chunk) => this.extractMetadata(chunk),
+            extractProviderSpecificFields: streamResponse.extractProviderSpecificFields,
+            extractReasoningBlocks: streamResponse.extractReasoningBlocks,
             idGenerator,
             includeRawChunks: options.includeRawChunks ?? false,
             modelId: config.modelId,
@@ -2603,6 +3949,7 @@ var init_base_language_model_strategy = __esm({
         const messages = convertToSAPMessages(options.prompt, {
           escapeTemplatePlaceholders: this.getEscapeTemplatePlaceholders(sapOptions, settings),
           includeReasoning: this.getIncludeReasoning(sapOptions, settings),
+          nativeReasoningProviderName: this.getNativeReasoningProviderName(providerName),
           parsePartProviderOptions: this.getPartProviderOptionsParser(),
           warnings
         });
@@ -2642,12 +3989,12 @@ var init_base_language_model_strategy = __esm({
        * @internal
        */
       extractMetadata(response) {
-        const responseMetadata = extractCompletionMetadata(
+        const responseMetadata2 = extractCompletionMetadata(
           response,
           this.getCompletionDataPath()
         );
         const { headers, requestId } = extractResponseMetadata(response, "rawResponse");
-        return { requestId, responseHeaders: headers, responseMetadata };
+        return { requestId, responseHeaders: headers, responseMetadata: responseMetadata2 };
       }
       /**
        * Returns whether to escape template placeholders for this API.
@@ -2667,7 +4014,16 @@ var init_base_language_model_strategy = __esm({
        * @internal
        */
       getIncludeReasoning(sapOptions, settings) {
-        return sapOptions?.includeReasoning ?? settings.includeReasoning ?? false;
+        return sapOptions?.includeReasoning ?? ("includeReasoning" in settings ? settings.includeReasoning : false) ?? false;
+      }
+      /**
+       * Enables native reasoning history only for strategies supporting the Orchestration wire format.
+       * @param _providerName - Configured provider namespace.
+       * @returns The native reasoning namespace, or undefined for legacy text-only history.
+       * @internal
+       */
+      getNativeReasoningProviderName(_providerName) {
+        return void 0;
       }
       /**
        * Returns a parser for per-message-part `providerOptions['sap-ai']`.
@@ -2710,6 +4066,7 @@ var init_foundation_models_language_model_strategy = __esm({
   "src/foundation-models-language-model-strategy.ts"() {
     "use strict";
     init_base_language_model_strategy();
+    init_sap_http_stream();
     init_strategy_utils();
     FOUNDATION_MODELS_PARAM_MAPPINGS = [
       ...BaseLanguageModelStrategy.COMMON_PARAM_MAPPINGS,
@@ -2755,7 +4112,7 @@ var init_foundation_models_language_model_strategy = __esm({
       }
       async executeApiCall(client, request, requestConfig) {
         const response = await client.run(request, requestConfig);
-        const { requestId, responseMetadata } = this.extractMetadata(response);
+        const { requestId, responseMetadata: responseMetadata2 } = this.extractMetadata(response);
         return {
           getContent: () => response.getContent(),
           getFinishReason: () => response.getFinishReason(),
@@ -2764,21 +4121,28 @@ var init_foundation_models_language_model_strategy = __esm({
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- SAP SDK types headers as any
           rawResponse: { headers: response.rawResponse.headers },
           requestId,
-          responseMetadata
+          responseMetadata: responseMetadata2
         };
       }
-      async executeStreamCall(client, request, abortSignal, _settings, requestConfig) {
-        const streamResponse = await client.stream(request, abortSignal, requestConfig);
-        const { requestId, responseHeaders, responseMetadata } = this.extractMetadata(streamResponse);
+      async executeStreamCall(client, request, abortSignal, _settings, requestConfig, _commonParts) {
+        const streamResponse = await executeSapStream(
+          (streamRequestConfig) => client.stream(request, abortSignal, streamRequestConfig),
+          abortSignal,
+          requestConfig
+        );
+        const { requestId, responseHeaders, responseMetadata: responseMetadata2 } = this.extractMetadata(streamResponse);
         return {
           cancel: () => {
-            streamResponse.stream.controller.abort();
+            disposeSapStream(streamResponse);
           },
           getFinishReason: () => streamResponse.getFinishReason(),
           requestId,
           responseHeaders,
-          responseMetadata,
-          stream: streamResponse.stream
+          responseMetadata: responseMetadata2,
+          stream: withSapStreamCleanup(
+            streamResponse,
+            streamResponse.stream
+          )
         };
       }
       getCompletionDataPath() {
@@ -2839,10 +4203,12 @@ var init_orchestration_language_model_strategy = __esm({
     init_deep_merge();
     init_sap_ai_provider_options();
     init_sap_ai_validation();
+    init_sap_http_stream();
     init_strategy_utils();
     ORCHESTRATION_MODULE_KEYS = ["masking", "filtering", "grounding", "translation"];
     CONFIG_REF_IGNORED_MODULES = [
       ...ORCHESTRATION_MODULE_KEYS,
+      "dropUnsupportedParams",
       "fallbackModuleConfigs",
       "promptTemplateRef",
       "responseFormat",
@@ -2850,7 +4216,11 @@ var init_orchestration_language_model_strategy = __esm({
       "modelParams",
       "modelVersion"
     ];
-    CONFIG_REF_IGNORED_PROVIDER_OPTIONS = ["promptTemplateRef", "modelParams"];
+    CONFIG_REF_IGNORED_PROVIDER_OPTIONS = [
+      "dropUnsupportedParams",
+      "promptTemplateRef",
+      "modelParams"
+    ];
     ORCHESTRATION_PARAM_MAPPINGS = [
       ...BaseLanguageModelStrategy.COMMON_PARAM_MAPPINGS,
       { camelCaseKey: "topK", optionKey: "topK", outputKey: "top_k" }
@@ -2880,6 +4250,12 @@ var init_orchestration_language_model_strategy = __esm({
         const warnings = [];
         const configRefCandidate = sapOptions?.orchestrationConfigRef ?? settings.orchestrationConfigRef;
         if (configRefCandidate && isOrchestrationConfigRef(configRefCandidate)) {
+          if (settings.streamOptions && hasKeys(settings.streamOptions)) {
+            warnings.push({
+              message: "orchestrationConfigRef is set; local streamOptions are ignored. Configure streaming in the referenced configuration or its overrideConfig.",
+              type: "other"
+            });
+          }
           return warnings;
         }
         if (settings.translation && hasKeys(settings.translation)) {
@@ -2893,11 +4269,12 @@ var init_orchestration_language_model_strategy = __esm({
         return warnings;
       }
       createClient(config, settings, commonParts) {
-        const { configRef, promptTemplateRef, responseFormat, tools } = commonParts.resolvedState;
+        const { configRef, dropUnsupportedParams, promptTemplateRef, responseFormat, tools } = commonParts.resolvedState;
         if (configRef) {
           return new this.ClientClass(configRef, config.deploymentConfig, config.destination);
         }
         const clientConfig = this.buildOrchestrationModuleConfig(config, settings, {
+          dropUnsupportedParams,
           modelParams: commonParts.modelParams,
           promptTemplateRef,
           responseFormat,
@@ -2915,40 +4292,47 @@ var init_orchestration_language_model_strategy = __esm({
       }
       async executeApiCall(client, request, requestConfig) {
         const response = await client.chatCompletion(request, requestConfig);
-        const { requestId, responseMetadata } = this.extractMetadata(response);
+        const { requestId, responseMetadata: responseMetadata2 } = this.extractMetadata(response);
         return {
           getCitations: () => response.getCitations(),
           getContent: () => response.getContent(),
           getFinishReason: () => response.getFinishReason(),
           getIntermediateFailures: () => response.getIntermediateFailures(),
+          getProviderSpecificFields: () => response.findChoiceByIndex(0)?.provider_specific_fields,
+          getReasoningBlocks: () => response.getAssistantMessage()?.reasoning_content,
           getTokenUsage: () => response.getTokenUsage(),
           getToolCalls: () => response.getToolCalls(),
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- SAP SDK types headers as any
           rawResponse: { headers: response.rawResponse.headers },
           requestId,
-          responseMetadata
+          responseMetadata: responseMetadata2
         };
       }
-      async executeStreamCall(client, request, abortSignal, settings, requestConfig) {
-        const sdkStreamOptions = this.buildSdkStreamOptions(settings.streamOptions);
-        const streamResponse = await client.stream(
-          request,
+      async executeStreamCall(client, request, abortSignal, settings, requestConfig, commonParts) {
+        const { configRef } = commonParts.resolvedState;
+        const sdkStreamOptions = configRef ? void 0 : this.buildSdkStreamOptions(settings.streamOptions);
+        const streamResponse = await executeSapStream(
+          (streamRequestConfig) => client.stream(request, abortSignal, sdkStreamOptions, streamRequestConfig),
           abortSignal,
-          sdkStreamOptions,
           requestConfig
         );
-        const { requestId, responseHeaders, responseMetadata } = this.extractMetadata(streamResponse);
+        const { requestId, responseHeaders, responseMetadata: responseMetadata2 } = this.extractMetadata(streamResponse);
         return {
           cancel: () => {
-            streamResponse.stream.controller.abort();
+            disposeSapStream(streamResponse);
           },
+          extractProviderSpecificFields: (chunk) => chunk.findChoiceByIndex(0)?.provider_specific_fields,
+          extractReasoningBlocks: (chunk) => chunk.findChoiceByIndex(0)?.delta.reasoning_content,
           getCitations: () => streamResponse.getCitations(),
           getFinishReason: () => streamResponse.getFinishReason(),
           getIntermediateFailures: () => streamResponse.getIntermediateFailures(),
           requestId,
           responseHeaders,
-          responseMetadata,
-          stream: streamResponse.stream
+          responseMetadata: responseMetadata2,
+          stream: withSapStreamCleanup(
+            streamResponse,
+            streamResponse.stream
+          )
         };
       }
       getCompletionDataPath() {
@@ -2957,6 +4341,9 @@ var init_orchestration_language_model_strategy = __esm({
       getEscapeTemplatePlaceholders(sapOptions, settings) {
         return sapOptions?.escapeTemplatePlaceholders ?? settings.escapeTemplatePlaceholders ?? true;
       }
+      getNativeReasoningProviderName(providerName) {
+        return providerName;
+      }
       getParamMappings() {
         return ORCHESTRATION_PARAM_MAPPINGS;
       }
@@ -2990,7 +4377,8 @@ var init_orchestration_language_model_strategy = __esm({
           if (converted.warning) warnings.push(converted.warning);
         }
         const tools = this.resolveTools(settings, options, warnings);
-        return { configRef, promptTemplateRef, responseFormat, tools };
+        const dropUnsupportedParams = sapOptions?.dropUnsupportedParams ?? settings.dropUnsupportedParams;
+        return { configRef, dropUnsupportedParams, promptTemplateRef, responseFormat, tools };
       }
       /**
        * Builds request for orchestrationConfigRef mode.
@@ -3035,6 +4423,7 @@ var init_orchestration_language_model_strategy = __esm({
        * @param config - Strategy configuration.
        * @param settings - Model settings.
        * @param params - Build parameters.
+       * @param params.dropUnsupportedParams - Optional unsupported-parameter policy for the primary model.
        * @param params.modelParams - LLM model parameters.
        * @param params.promptTemplateRef - Optional prompt template reference.
        * @param params.responseFormat - Optional response format specification.
@@ -3044,7 +4433,14 @@ var init_orchestration_language_model_strategy = __esm({
        * @internal
        */
       buildOrchestrationModuleConfig(config, settings, params) {
-        const { modelParams, promptTemplateRef, responseFormat, toolChoice, tools } = params;
+        const {
+          dropUnsupportedParams,
+          modelParams,
+          promptTemplateRef,
+          responseFormat,
+          toolChoice,
+          tools
+        } = params;
         const promptConfig = promptTemplateRef ? this.buildTemplateRefPromptConfig(promptTemplateRef, tools, responseFormat) : this.buildInlineTemplateConfig(tools, responseFormat);
         const effectiveModelParams = toolChoice ? { ...modelParams, tool_choice: toolChoice } : modelParams;
         const moduleConfig = {
@@ -3052,7 +4448,8 @@ var init_orchestration_language_model_strategy = __esm({
             model: {
               name: config.modelId,
               params: effectiveModelParams,
-              ...settings.modelVersion ? { version: settings.modelVersion } : {}
+              ...settings.modelVersion ? { version: settings.modelVersion } : {},
+              ...dropUnsupportedParams !== void 0 ? { drop_unsupported_params: dropUnsupportedParams } : {}
             },
             prompt: promptConfig
           }
@@ -3141,7 +4538,7 @@ var init_orchestration_language_model_strategy = __esm({
           }
         }
         for (const key of CONFIG_REF_IGNORED_PROVIDER_OPTIONS) {
-          if (sapOptions?.[key] && !settings[key]) {
+          if (sapOptions?.[key] !== void 0 && settings[key] === void 0) {
             ignoredSettings.push(`providerOptions.${key}`);
           }
         }
@@ -3282,6 +4679,52 @@ __export(index_v2_exports, {
 module.exports = __toCommonJS(index_v2_exports);
 init_convert_to_sap_messages();
 
+// src/sap-ai-adapters-v3-to-v2.ts
+var import_provider2 = require("@ai-sdk/provider");
+
+// src/map-readable-stream.ts
+function mapReadableStream(source, convert) {
+  const reader = source.getReader();
+  let cancelled = false;
+  return new ReadableStream(
+    {
+      async cancel(reason) {
+        cancelled = true;
+        try {
+          await reader.cancel(reason);
+        } finally {
+          reader.releaseLock();
+        }
+      },
+      async pull(controller) {
+        try {
+          for (; ; ) {
+            const next = await reader.read();
+            if (cancelled) return;
+            if (next.done) {
+              reader.releaseLock();
+              controller.close();
+              return;
+            }
+            const converted = convert(next.value);
+            if (converted !== null) {
+              controller.enqueue(converted);
+              return;
+            }
+          }
+        } catch (error) {
+          if (cancelled) return;
+          await reader.cancel(error).catch(() => void 0);
+          if (cancelled) return;
+          reader.releaseLock();
+          controller.error(error);
+        }
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+
 // src/sap-ai-adapters-v3-to-v2.ts
 function convertStreamPartToV2(internalPart) {
   const compatiblePart = internalPart;
@@ -3299,7 +4742,7 @@ function convertStreamPartToV2(internalPart) {
     case "stream-start":
       return { ...compatiblePart, warnings: convertWarningsToV2(compatiblePart.warnings) };
     case "tool-approval-request":
-      return null;
+      throw createV2ToolApprovalError();
     case "tool-call": {
       const { dynamic: _dynamic, ...part } = compatiblePart;
       return part;
@@ -3337,19 +4780,17 @@ function convertWarningToV2(internalWarning) {
   };
 }
 function createV2StreamFromInternal(internalStream) {
-  return internalStream.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        const converted = convertStreamPartToV2(chunk);
-        if (converted !== null) controller.enqueue(converted);
-      }
-    })
-  );
+  return mapReadableStream(internalStream, convertStreamPartToV2);
+}
+function createV2ToolApprovalError() {
+  return new import_provider2.UnsupportedFunctionalityError({
+    functionality: "Tool approvals are unavailable through the V2 provider. Use /v3 with AI SDK 6 or /v4 with AI SDK 7."
+  });
 }
 
 // src/sap-ai-embedding-model.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_zod4 = require("zod");
 init_sap_ai_provider_options();
 
 // src/sap-ai-strategy.ts
@@ -3380,6 +4821,10 @@ function getOrCreateLanguageModelStrategy(api) {
   return strategyPromise;
 }
 async function createEmbeddingModelStrategy(api) {
+  if (api === "responses") {
+    const { UnsupportedFeatureError: UnsupportedFeatureError2 } = await Promise.resolve().then(() => (init_sap_ai_error(), sap_ai_error_exports));
+    throw new UnsupportedFeatureError2("Embeddings", "responses", "foundation-models");
+  }
   if (api === "foundation-models") {
     const { AzureOpenAiEmbeddingClient } = await import("@sap-ai-sdk/foundation-models");
     const { FoundationModelsEmbeddingModelStrategy: FoundationModelsEmbeddingModelStrategy2 } = await Promise.resolve().then(() => (init_foundation_models_embedding_model_strategy(), foundation_models_embedding_model_strategy_exports));
@@ -3390,6 +4835,10 @@ async function createEmbeddingModelStrategy(api) {
   return new OrchestrationEmbeddingModelStrategy2(OrchestrationEmbeddingClient2);
 }
 async function createLanguageModelStrategy(api) {
+  if (api === "responses") {
+    const { ResponsesLanguageModelStrategy: ResponsesLanguageModelStrategy2 } = await Promise.resolve().then(() => (init_responses_language_model_strategy(), responses_language_model_strategy_exports));
+    return new ResponsesLanguageModelStrategy2();
+  }
   if (api === "foundation-models") {
     const { AzureOpenAiChatClient } = await import("@sap-ai-sdk/foundation-models");
     const { FoundationModelsLanguageModelStrategy: FoundationModelsLanguageModelStrategy2 } = await Promise.resolve().then(() => (init_foundation_models_language_model_strategy(), foundation_models_language_model_strategy_exports));
@@ -3403,7 +4852,7 @@ async function createLanguageModelStrategy(api) {
 // src/sap-ai-embedding-model.ts
 init_sap_ai_validation();
 var DEFAULT_MAX_EMBEDDINGS_PER_CALL = 2048;
-var maxEmbeddingsPerCallSchema = import_zod3.z.number().int().positive().or(import_zod3.z.literal(Infinity));
+var maxEmbeddingsPerCallSchema = import_zod4.z.number().int().positive().or(import_zod4.z.literal(Infinity));
 var SAPAIEmbeddingModel = class {
   maxEmbeddingsPerCall;
   modelId;
@@ -3432,7 +4881,7 @@ var SAPAIEmbeddingModel = class {
   }
   async doEmbed(options) {
     const providerName = getProviderName(this.config.provider);
-    const sapOptions = await (0, import_provider_utils2.parseProviderOptions)({
+    const sapOptions = await (0, import_provider_utils3.parseProviderOptions)({
       provider: providerName,
       providerOptions: options.providerOptions,
       schema: sapAIEmbeddingProviderOptions
@@ -3453,7 +4902,12 @@ var SAPAIEmbeddingModel = class {
       provider: this.config.provider,
       requestConfig: this.config.requestConfig
     };
-    return strategy.doEmbed(strategyConfig, this.settings, options, this.maxEmbeddingsPerCall);
+    return strategy.doEmbed(
+      strategyConfig,
+      this.settings,
+      options,
+      this.maxEmbeddingsPerCall
+    );
   }
 };
 
@@ -3508,8 +4962,57 @@ var SAPAIEmbeddingModelV2 = class {
 // src/index-v2.ts
 init_sap_ai_error();
 
+// src/sap-ai-adapters-v2-to-v3.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+function normalizeV2PromptToV3(prompt) {
+  return prompt.map((message) => {
+    switch (message.role) {
+      case "assistant":
+        return {
+          ...message,
+          content: message.content.map(
+            (part) => part.type === "tool-result" ? normalizeToolResultPart(part) : part
+          )
+        };
+      case "tool":
+        return {
+          ...message,
+          content: message.content.map(
+            (part) => part.type === "tool-result" ? normalizeToolResultPart(part) : part
+          )
+        };
+      default:
+        return message;
+    }
+  });
+}
+function normalizeToolOutput(output) {
+  if (output.type !== "content") return output;
+  return {
+    ...output,
+    value: output.value.map((item) => {
+      if (item.type !== "media") return item;
+      const mediaType = (0, import_provider_utils4.resolveFullMediaType)({
+        part: {
+          data: { data: item.data, type: "data" },
+          mediaType: item.mediaType.toLowerCase(),
+          type: "file"
+        }
+      });
+      return {
+        ...item,
+        mediaType,
+        type: mediaType.startsWith("image/") ? "image-data" : "file-data"
+      };
+    })
+  };
+}
+function normalizeToolResultPart(part) {
+  return { ...part, output: normalizeToolOutput(part.output) };
+}
+
 // src/sap-ai-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 init_sap_ai_provider_options();
 init_sap_ai_validation();
 var SAPAILanguageModel = class {
@@ -3543,11 +5046,13 @@ var SAPAILanguageModel = class {
   }
   async doGenerate(options) {
     const { strategy, strategyConfig } = await this.prepareInvocation(options);
-    return strategy.doGenerate(strategyConfig, this.settings, options);
+    const result = strategy.doGenerate(strategyConfig, this.settings, options);
+    return result;
   }
   async doStream(options) {
     const { strategy, strategyConfig } = await this.prepareInvocation(options);
-    return strategy.doStream(strategyConfig, this.settings, options);
+    const result = strategy.doStream(strategyConfig, this.settings, options);
+    return result;
   }
   supportsUrl(url) {
     if (url.protocol === "https:") return true;
@@ -3564,7 +5069,7 @@ var SAPAILanguageModel = class {
    */
   async prepareInvocation(options) {
     const providerName = getProviderName(this.config.provider);
-    const sapOptions = await (0, import_provider_utils3.parseProviderOptions)({
+    const sapOptions = await (0, import_provider_utils5.parseProviderOptions)({
       provider: providerName,
       providerOptions: options.providerOptions,
       schema: sapAILanguageModelProviderOptions
@@ -3574,10 +5079,12 @@ var SAPAILanguageModel = class {
       api: effectiveApi,
       invocationSettings: sapOptions ? {
         api: sapOptions.api,
+        dropUnsupportedParams: sapOptions.dropUnsupportedParams,
         escapeTemplatePlaceholders: sapOptions.escapeTemplatePlaceholders,
         orchestrationConfigRef: sapOptions.orchestrationConfigRef,
         placeholderValues: sapOptions.placeholderValues,
-        promptTemplateRef: sapOptions.promptTemplateRef
+        promptTemplateRef: sapOptions.promptTemplateRef,
+        responses: sapOptions.responses
       } : void 0,
       modelApi: this.settings.api,
       modelSettings: this.settings
@@ -3618,7 +5125,10 @@ var SAPAILanguageModelV2 = class {
     this.internalModel = new SAPAILanguageModel(modelId, settings, config);
   }
   async doGenerate(options) {
-    const result = await this.internalModel.doGenerate(options);
+    const result = await this.internalModel.doGenerate(normalizeCallOptions(options));
+    if (result.content.some((part) => part.type === "tool-approval-request")) {
+      throw createV2ToolApprovalError();
+    }
     return {
       content: result.content,
       finishReason: result.finishReason.unified,
@@ -3630,7 +5140,7 @@ var SAPAILanguageModelV2 = class {
     };
   }
   async doStream(options) {
-    const result = await this.internalModel.doStream(options);
+    const result = await this.internalModel.doStream(normalizeCallOptions(options));
     return {
       request: result.request,
       response: result.response ? {
@@ -3640,13 +5150,22 @@ var SAPAILanguageModelV2 = class {
     };
   }
 };
+function normalizeCallOptions(options) {
+  const normalized = {
+    ...options,
+    prompt: normalizeV2PromptToV3(options.prompt),
+    // Legacy provider-defined tools keep their unsupported warning/skip behavior.
+    tools: options.tools
+  };
+  return normalized;
+}
 
 // src/index-v2.ts
 init_sap_ai_provider_options();
 
 // src/sap-ai-provider-v2.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_util2 = require("@sap-cloud-sdk/util");
+var import_provider10 = require("@ai-sdk/provider");
+var import_util3 = require("@sap-cloud-sdk/util");
 init_sap_ai_provider_options();
 init_sap_ai_validation();
 function createSAPAIProvider(options = {}) {
@@ -3663,7 +5182,7 @@ function createSAPAIProvider(options = {}) {
   }
   if (typeof process === "undefined" || !process.env.SAP_CLOUD_SDK_LOG_LEVEL) {
     const logLevel = options.logLevel ?? "warn";
-    (0, import_util2.setGlobalLogLevel)(logLevel);
+    (0, import_util3.setGlobalLogLevel)(logLevel);
   }
   const deploymentConfig = options.deploymentId ? { deploymentId: options.deploymentId } : { resourceGroup };
   const providerApi = options.api ?? "orchestration";
@@ -3705,7 +5224,7 @@ function createSAPAIProvider(options = {}) {
   provider.languageModel = createModel;
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.imageModel = (modelId) => {
-    throw new import_provider4.NoSuchModelError({
+    throw new import_provider10.NoSuchModelError({
       message: `SAP AI Core does not support image generation. Model '${modelId}' is not available.`,
       modelId,
       modelType: "imageModel"