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

package/dist/chunk-77JSAAPE.js

@@ -0,0 +1,778 @@
+import {createRequire as __createRequire} from 'module';var require=__createRequire(import.meta.url);
+
+// src/sap-ai-provider-options.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+var SAP_AI_PROVIDER_NAME = "sap-ai";
+function getProviderName(providerIdentifier) {
+  const dotIndex = providerIdentifier.indexOf(".");
+  return dotIndex === -1 ? providerIdentifier : providerIdentifier.slice(0, dotIndex);
+}
+var modelParamsSchema = z.object({
+  frequencyPenalty: z.number().min(-2).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+  n: z.number().int().positive().optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  presencePenalty: z.number().min(-2).max(2).optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  topP: z.number().min(0).max(1).optional()
+}).catchall(z.unknown());
+var embeddingModelParamsSchema = z.object({
+  dimensions: z.number().int().positive().optional(),
+  encoding_format: z.enum(["base64", "binary", "float"]).optional(),
+  normalize: z.boolean().optional()
+}).catchall(z.unknown());
+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"
+      });
+    }
+  }
+}
+var sapAIApiTypeSchema = z.enum(["orchestration", "foundation-models"]);
+var cacheControlSchema = z.object({
+  ttl: z.enum(["5m", "1h"]).optional(),
+  type: z.literal("ephemeral")
+});
+var sapAIPartProviderOptionsSchema = z.object({
+  cacheControl: cacheControlSchema.optional()
+});
+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 promptTemplateScopeSchema = z.enum(["tenant", "resource_group"]);
+var promptTemplateRefByIdSchema = z.object({
+  id: z.string().min(1, "Template ID cannot be empty"),
+  scope: promptTemplateScopeSchema.optional()
+});
+var promptTemplateRefByScenarioNameVersionSchema = z.object({
+  name: z.string().min(1, "Template name cannot be empty"),
+  scenario: z.string().min(1, "Scenario cannot be empty"),
+  scope: promptTemplateScopeSchema.optional(),
+  version: z.string().min(1, "Version cannot be empty")
+});
+var promptTemplateRefSchema = z.union([
+  promptTemplateRefByIdSchema,
+  promptTemplateRefByScenarioNameVersionSchema
+]);
+var orchestrationConfigRefOverrideSchema = 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())"
+  }
+);
+var orchestrationConfigRefByIdSchema = z.object({
+  id: z.string().min(1, "Config ID cannot be empty"),
+  overrideConfig: orchestrationConfigRefOverrideSchema.optional()
+});
+var orchestrationConfigRefByScenarioNameVersionSchema = z.object({
+  name: z.string().min(1, "Config name cannot be empty"),
+  overrideConfig: orchestrationConfigRefOverrideSchema.optional(),
+  scenario: z.string().min(1, "Scenario cannot be empty"),
+  version: z.string().min(1, "Version cannot be empty")
+});
+var orchestrationConfigRefSchema = z.union([
+  orchestrationConfigRefByIdSchema,
+  orchestrationConfigRefByScenarioNameVersionSchema
+]);
+var sapAILanguageModelProviderOptions = lazySchema(
+  () => zodSchema(
+    z.object({
+      api: sapAIApiTypeSchema.optional(),
+      escapeTemplatePlaceholders: z.boolean().optional(),
+      includeReasoning: z.boolean().optional(),
+      modelParams: modelParamsSchema.optional(),
+      orchestrationConfigRef: orchestrationConfigRefSchema.optional(),
+      placeholderValues: z.record(z.string(), z.string()).optional(),
+      promptTemplateRef: promptTemplateRefSchema.optional()
+    })
+  )
+);
+var sapAIEmbeddingProviderOptions = lazySchema(
+  () => zodSchema(
+    z.object({
+      api: sapAIApiTypeSchema.optional(),
+      modelParams: embeddingModelParamsSchema.optional(),
+      type: z.enum(["document", "query", "text"]).optional()
+    })
+  )
+);
+
+// src/deep-merge.ts
+var MAX_DEPTH = 100;
+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;
+}
+
+// src/sap-ai-error.ts
+import {
+  APICallError,
+  InvalidPromptError,
+  LoadAPIKeyError,
+  NoSuchModelError,
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { isErrorWithCause } from "@sap-cloud-sdk/util";
+var HTTP_STATUS = {
+  BAD_REQUEST: 400,
+  CLIENT_CLOSED_REQUEST: 499,
+  CONFLICT: 409,
+  FORBIDDEN: 403,
+  INTERNAL_ERROR: 500,
+  NOT_FOUND: 404,
+  RATE_LIMIT: 429,
+  REQUEST_TIMEOUT: 408,
+  SERVICE_UNAVAILABLE: 503,
+  UNAUTHORIZED: 401
+};
+var ERROR_MATCHERS = [
+  {
+    category: "network",
+    isRetryable: true,
+    keywords: ["econnrefused", "enotfound", "network", "timeout"],
+    statusCode: HTTP_STATUS.SERVICE_UNAVAILABLE
+  },
+  {
+    category: "destination",
+    isRetryable: false,
+    keywords: ["could not resolve destination"],
+    message: (original) => `SAP AI Core destination error: ${original}
+
+Check your destination configuration or provide a valid destinationName.`,
+    statusCode: HTTP_STATUS.BAD_REQUEST
+  },
+  {
+    category: "content filtered",
+    isRetryable: false,
+    keywords: ["filtered by the output filter"],
+    message: (original) => `Content was filtered: ${original}
+
+The model's response was blocked by content safety filters. Try a different prompt.`,
+    statusCode: HTTP_STATUS.BAD_REQUEST
+  },
+  {
+    category: "stream consumption",
+    isRetryable: false,
+    keywords: ["consumed stream"],
+    statusCode: HTTP_STATUS.INTERNAL_ERROR
+  },
+  {
+    category: "streaming",
+    isRetryable: true,
+    keywords: [
+      "iterating over",
+      "parse message into json",
+      "received from",
+      "no body",
+      "invalid sse payload"
+    ],
+    statusCode: HTTP_STATUS.INTERNAL_ERROR
+  },
+  {
+    category: "configuration",
+    isRetryable: false,
+    keywords: [
+      "prompt template or messages must be defined",
+      "filtering parameters cannot be empty",
+      "templating yaml string must be non-empty",
+      "could not access response data",
+      "could not parse json",
+      "error parsing yaml",
+      "yaml does not conform",
+      "validation errors"
+    ],
+    statusCode: HTTP_STATUS.BAD_REQUEST
+  },
+  {
+    category: "environment",
+    isRetryable: false,
+    keywords: ["buffer is not available as globals"],
+    statusCode: HTTP_STATUS.INTERNAL_ERROR
+  },
+  {
+    category: "response stream",
+    isRetryable: false,
+    keywords: ["response stream is undefined"],
+    statusCode: HTTP_STATUS.INTERNAL_ERROR
+  },
+  {
+    category: "response processing",
+    isRetryable: true,
+    keywords: [
+      "response is required to process",
+      "stream is still open",
+      "data is not available yet"
+    ],
+    statusCode: HTTP_STATUS.INTERNAL_ERROR
+  },
+  {
+    category: "deployment retrieval",
+    isRetryable: true,
+    keywords: ["failed to fetch the list of deployments"],
+    statusCode: HTTP_STATUS.SERVICE_UNAVAILABLE
+  },
+  {
+    category: "stream buffer",
+    isRetryable: false,
+    keywords: ["received non-uint8array"],
+    statusCode: HTTP_STATUS.INTERNAL_ERROR
+  }
+];
+var AUTHENTICATION_ERROR_KEYWORDS = [
+  "authentication",
+  "unauthorized",
+  "aicore_service_key",
+  "invalid credentials",
+  "service credentials",
+  "service binding"
+];
+var DEPLOYMENT_ERROR_KEYWORDS = [
+  "failed to resolve deployment",
+  "no deployment matched"
+];
+var ApiSwitchError = class extends Error {
+  /**
+   * Creates a new ApiSwitchError.
+   * @param fromApi - The API the model was configured with.
+   * @param toApi - The API being switched to at invocation time.
+   * @param conflictingFeature - The feature that prevents the API switch.
+   */
+  constructor(fromApi, toApi, conflictingFeature) {
+    super(
+      `Cannot switch from ${fromApi} to ${toApi} API at invocation time because ${conflictingFeature} would be ignored. Create a new model instance without ${fromApi}-specific features, or keep using the ${fromApi} API.`
+    );
+    this.fromApi = fromApi;
+    this.toApi = toApi;
+    this.conflictingFeature = conflictingFeature;
+    this.name = "ApiSwitchError";
+  }
+  fromApi;
+  toApi;
+  conflictingFeature;
+};
+var UnsupportedFeatureError = class extends Error {
+  /**
+   * Creates a new UnsupportedFeatureError.
+   * @param feature - The name of the unsupported feature (e.g., "Content filtering").
+   * @param api - The API being used that does not support the feature.
+   * @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";
+    super(`${feature} is not supported by ${apiName} API. Use ${suggestedApiName} API instead.`);
+    this.feature = feature;
+    this.api = api;
+    this.suggestedApi = suggestedApi;
+    this.name = "UnsupportedFeatureError";
+  }
+  feature;
+  api;
+  suggestedApi;
+};
+function convertSAPErrorToAPICallError(errorResponse, context) {
+  const { code, location, message, requestId } = extractErrorFields(errorResponse);
+  const statusCode = getStatusCodeFromSAPError(code, context?.httpStatusCode);
+  const responseBody = JSON.stringify({
+    error: {
+      code,
+      location,
+      message,
+      request_id: requestId
+    }
+  });
+  let enhancedMessage = message;
+  if (statusCode === HTTP_STATUS.UNAUTHORIZED || statusCode === HTTP_STATUS.FORBIDDEN) {
+    enhancedMessage += "\n\nAuthentication failed. Verify your AICORE_SERVICE_KEY environment variable is set correctly.\nSee: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-service-key";
+    if (requestId) {
+      enhancedMessage += `
+Request ID: ${requestId}`;
+    }
+    return new LoadAPIKeyError({
+      message: enhancedMessage
+    });
+  }
+  if (statusCode === HTTP_STATUS.NOT_FOUND) {
+    enhancedMessage += "\n\nResource not found. The model or deployment may not exist in your SAP AI Core instance.\nSee: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-deployment-for-orchestration";
+    if (requestId) {
+      enhancedMessage += `
+Request ID: ${requestId}`;
+    }
+    const modelId = context?.modelId ?? extractModelIdentifier(message, location);
+    return new NoSuchModelError({
+      message: enhancedMessage,
+      modelId: modelId ?? "unknown",
+      modelType: context?.modelType ?? "languageModel"
+    });
+  }
+  if (statusCode === HTTP_STATUS.RATE_LIMIT) {
+    enhancedMessage += "\n\nRate limit exceeded. Please try again later or contact your SAP administrator.\nSee: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/rate-limits";
+  } else if (statusCode >= HTTP_STATUS.INTERNAL_ERROR) {
+    enhancedMessage += "\n\nSAP AI Core service error. This is typically a temporary issue. Retries depend on the caller's retry configuration.\nSee: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/troubleshooting";
+  } else if (location) {
+    enhancedMessage += `
+
+Error location: ${location}`;
+  }
+  if (requestId) {
+    enhancedMessage += `
+Request ID: ${requestId}`;
+  }
+  return new APICallError({
+    isRetryable: isRetryable(statusCode),
+    message: enhancedMessage,
+    requestBodyValues: context?.requestBody,
+    responseBody,
+    responseHeaders: context?.responseHeaders,
+    statusCode,
+    url: context?.url ?? ""
+  });
+}
+function convertToAISDKError(error, context) {
+  if (APICallError.isInstance(error) || LoadAPIKeyError.isInstance(error) || NoSuchModelError.isInstance(error) || InvalidPromptError.isInstance(error) || UnsupportedFunctionalityError.isInstance(error)) {
+    return error;
+  }
+  const { aborted, response, rootError } = inspectError(error);
+  const responseHeaders = context?.responseHeaders ?? normalizeHeaders(response?.headers);
+  if (!aborted) {
+    const errorResponse = findStructuredErrorResponse(
+      rootError instanceof SyntaxError ? void 0 : rootError,
+      response?.data
+    );
+    if (errorResponse) {
+      return convertSAPErrorToAPICallError(errorResponse, {
+        ...context,
+        httpStatusCode: response?.status ?? context?.httpStatusCode,
+        responseHeaders
+      });
+    }
+  }
+  const resolvedContext = {
+    ...context,
+    responseBody: serializeAxiosResponseData(response?.data),
+    responseHeaders
+  };
+  if (aborted) {
+    return createAPICallError(
+      error,
+      {
+        isRetryable: false,
+        message: "Request was aborted by the client",
+        statusCode: HTTP_STATUS.CLIENT_CLOSED_REQUEST
+      },
+      resolvedContext
+    );
+  }
+  if (isHttpStatus(response?.status)) {
+    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",
+        statusCode: response.status
+      },
+      resolvedContext
+    );
+  }
+  if (rootError instanceof SyntaxError) {
+    return createAPICallError(
+      error,
+      {
+        isRetryable: false,
+        message: error instanceof Error && error !== rootError ? error.message : "Failed to parse SAP AI Core data.",
+        statusCode: HTTP_STATUS.INTERNAL_ERROR
+      },
+      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 LoadAPIKeyError({
+        message: `SAP AI Core authentication failed: ${originalErrorMsg}
+
+Make sure your AICORE_SERVICE_KEY environment variable is set correctly.
+See: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-service-key`
+      });
+    }
+    if (DEPLOYMENT_ERROR_KEYWORDS.some((keyword) => errorMsg.includes(keyword))) {
+      const modelId = context?.modelId ?? extractModelIdentifier(originalErrorMsg);
+      return new NoSuchModelError({
+        message: `SAP AI Core deployment error: ${originalErrorMsg}
+
+Make sure you have a running orchestration deployment in your SAP AI Core instance.
+See: https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-deployment-for-orchestration`,
+        modelId: modelId ?? "unknown",
+        modelType: context?.modelType ?? "languageModel"
+      });
+    }
+    const statusMatch = /status code (\d+)/i.exec(originalErrorMsg);
+    const extractedStatus = statusMatch?.[1] ? Number.parseInt(statusMatch[1], 10) : void 0;
+    if (isHttpStatus(extractedStatus)) {
+      return createAPICallError(
+        error,
+        {
+          isRetryable: isRetryable(extractedStatus),
+          message: `SAP AI Core request failed: ${originalErrorMsg}`,
+          statusCode: extractedStatus
+        },
+        resolvedContext
+      );
+    }
+    for (const matcher of ERROR_MATCHERS) {
+      if (matcher.keywords.some((keyword) => errorMsg.includes(keyword))) {
+        const message2 = "message" in matcher ? matcher.message(originalErrorMsg) : `SAP AI Core ${matcher.category} error: ${originalErrorMsg}`;
+        return createAPICallError(
+          error,
+          {
+            isRetryable: matcher.isRetryable,
+            message: message2,
+            statusCode: matcher.statusCode
+          },
+          resolvedContext
+        );
+      }
+    }
+  }
+  const message = rootError instanceof Error ? rootError.message : typeof rootError === "string" ? rootError : "Unknown error occurred";
+  const fullMessage = context?.operation ? `SAP AI Core ${context.operation} failed: ${message}` : `SAP AI Core error: ${message}`;
+  return createAPICallError(
+    error,
+    {
+      isRetryable: false,
+      message: fullMessage,
+      statusCode: HTTP_STATUS.INTERNAL_ERROR
+    },
+    resolvedContext
+  );
+}
+function normalizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return void 0;
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    const out = Object.fromEntries(headers.entries());
+    return Object.keys(out).length === 0 ? void 0 : out;
+  }
+  const record = headers;
+  const entries = Object.entries(record).flatMap(([key, value]) => {
+    const k = key.toLowerCase();
+    if (typeof value === "string") return [[k, value]];
+    if (Array.isArray(value)) {
+      const strings = value.filter((item) => typeof item === "string").join("; ");
+      return strings.length > 0 ? [[k, strings]] : [];
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return [[k, String(value)]];
+    }
+    return [];
+  });
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+}
+function createAPICallError(error, options, context) {
+  return new APICallError({
+    cause: error,
+    isRetryable: options.isRetryable,
+    message: options.message,
+    requestBodyValues: context?.requestBody,
+    responseBody: context?.responseBody,
+    responseHeaders: context?.responseHeaders,
+    statusCode: options.statusCode,
+    url: context?.url ?? ""
+  });
+}
+function extractErrorFields(response) {
+  const innerError = response.error;
+  if (Array.isArray(innerError)) {
+    const first = innerError[0];
+    return {
+      code: first?.code,
+      location: first?.location,
+      message: first?.message ?? "Unknown SAP AI error",
+      requestId: first?.request_id
+    };
+  }
+  const entry = innerError;
+  return {
+    code: entry.code,
+    location: entry.location,
+    message: entry.message,
+    requestId: entry.request_id
+  };
+}
+function extractModelIdentifier(message, location) {
+  const patterns = [
+    /deployment[:\s]+([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)/i,
+    /model[:\s]+([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)/i,
+    /resource[:\s]+([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)/i
+  ];
+  for (const pattern of patterns) {
+    const match = pattern.exec(message);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  if (location) {
+    const locationMatch = /([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)/.exec(location);
+    if (locationMatch?.[1]) {
+      return locationMatch[1];
+    }
+  }
+  return void 0;
+}
+function findStructuredErrorResponse(rootError, axiosData) {
+  if (isStructuredErrorResponse(rootError)) return rootError;
+  if (isStructuredErrorResponse(axiosData)) return axiosData;
+  if (rootError instanceof Error) {
+    const parsed = tryExtractSAPErrorFromMessage(rootError.message);
+    if (isStructuredErrorResponse(parsed)) return parsed;
+  }
+  return void 0;
+}
+function getStatusCodeFromSAPError(code, httpStatusCode) {
+  if (isHttpStatus(code)) {
+    return code;
+  }
+  if (isHttpStatus(httpStatusCode)) {
+    return httpStatusCode;
+  }
+  return HTTP_STATUS.INTERNAL_ERROR;
+}
+function inspectError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let rootError = error;
+  let current = error;
+  let response;
+  let aborted = false;
+  while (typeof current === "object" && current !== null && !seen.has(current)) {
+    seen.add(current);
+    rootError = current;
+    aborted ||= isAbortError(current);
+    const entry = current;
+    if (response === void 0 && entry.isAxiosError === true) response = entry.response;
+    const cause = "cause" in entry ? entry.cause : current instanceof Error && isErrorWithCause(current) ? current.rootCause : void 0;
+    if (cause === void 0 || typeof cause === "object" && cause !== null && seen.has(cause)) {
+      break;
+    }
+    rootError = cause;
+    current = cause;
+  }
+  return { aborted, response, rootError };
+}
+function isAbortError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  const transportError = error;
+  return transportError.isAxiosError === true && transportError.code === "ERR_CANCELED";
+}
+function isHttpStatus(status) {
+  return typeof status === "number" && Number.isInteger(status) && status >= 100 && status < 600;
+}
+function isRetryable(statusCode) {
+  return statusCode === HTTP_STATUS.REQUEST_TIMEOUT || statusCode === HTTP_STATUS.CONFLICT || statusCode === HTTP_STATUS.RATE_LIMIT || statusCode >= HTTP_STATUS.INTERNAL_ERROR && statusCode < 600;
+}
+function isStructuredErrorResponse(error) {
+  if (error === null || typeof error !== "object" || !("error" in error)) {
+    return false;
+  }
+  const errorEnvelope = error;
+  const innerError = errorEnvelope.error;
+  if (innerError === void 0) return false;
+  if (Array.isArray(innerError)) {
+    return innerError.every((entry) => {
+      if (entry === null || typeof entry !== "object" || !("message" in entry)) {
+        return false;
+      }
+      const errorEntry = entry;
+      if (typeof errorEntry.message !== "string") {
+        return false;
+      }
+      if ("code" in entry && errorEntry.code != null && typeof errorEntry.code !== "number") {
+        return false;
+      }
+      return true;
+    });
+  }
+  if (typeof innerError !== "object" || innerError === null || !("message" in innerError)) {
+    return false;
+  }
+  const errorObj = innerError;
+  if (typeof errorObj.message !== "string") {
+    return false;
+  }
+  if ("code" in innerError && errorObj.code != null && typeof errorObj.code !== "number") {
+    return false;
+  }
+  return true;
+}
+function serializeAxiosResponseData(data, maxLength = 2e3) {
+  if (data === void 0) return void 0;
+  let serialized;
+  try {
+    if (typeof data === "string") {
+      serialized = data;
+    } else {
+      const json = JSON.stringify(data, null, 2);
+      serialized = typeof json === "string" ? json : `[Unable to serialize: ${typeof data}]`;
+    }
+  } catch {
+    serialized = `[Unable to serialize: ${typeof data}]`;
+  }
+  if (serialized.length > maxLength) {
+    return serialized.slice(0, maxLength) + "...[truncated]";
+  }
+  return serialized;
+}
+function tryExtractSAPErrorFromMessage(message) {
+  const startIdx = message.indexOf("{");
+  if (startIdx === -1) return null;
+  let depth = 0;
+  let endIdx = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = startIdx; i < message.length; i++) {
+    const character = message.charCodeAt(i);
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (character === 92) escaped = true;
+      else if (character === 34) inString = false;
+      continue;
+    }
+    if (character === 34) inString = true;
+    else if (character === 123) depth++;
+    else if (character === 125) {
+      depth--;
+      if (depth === 0) {
+        endIdx = i;
+        break;
+      }
+    }
+  }
+  if (endIdx === -1) return null;
+  try {
+    const parsed = JSON.parse(message.slice(startIdx, endIdx + 1));
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      return parsed;
+    }
+    if (parsed && typeof parsed === "object" && "message" in parsed) {
+      return { error: parsed };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/version.ts
+var VERSION = true ? "5.0.2" : "0.0.0-test";
+
+export {
+  SAP_AI_PROVIDER_NAME,
+  getProviderName,
+  validateEmbeddingModelParamsSettings,
+  validateModelParamsSettings,
+  validateModelParamsWithWarnings,
+  parseSAPPartProviderOptions,
+  orchestrationConfigRefSchema,
+  sapAILanguageModelProviderOptions,
+  sapAIEmbeddingProviderOptions,
+  deepMerge,
+  ApiSwitchError,
+  UnsupportedFeatureError,
+  convertToAISDKError,
+  normalizeHeaders,
+  VERSION
+};
+//# sourceMappingURL=chunk-77JSAAPE.js.map