```diff
--- test_files/477-original.txt	2025-03-07 19:07:03
+++ test_files/477-modified.txt	2025-03-07 19:07:03
@@ -1,86 +1,116 @@
-import { ComposioError } from "./composioError";
-import { SDK_ERROR_CODES, BASE_ERROR_CODE_INFO, BE_STATUS_CODE_TO_SDK_ERROR_CODES } from "./constants";
 import { AxiosError } from "axios";
+import {
+  API_TO_SDK_ERROR_CODE,
+  BASE_ERROR_CODE_INFO,
+  COMPOSIO_SDK_ERROR_CODES,
+} from "./constants";
 
-interface ErrorResponse {
-    errorKey: string;
-    message: string;
-    description: string;
-    possibleFix: string;
-    metadata?: Record<string, any>;
+export interface ErrorResponseData {
+  type: string;
+  name: string;
+  message: string;
+  details?: Record<string, unknown>[] | Record<string, unknown>;
 }
 
 interface ErrorDetails {
-    message: string;
-    description: string;
-    possibleFix: string;
-    metadata?: Record<string, any>;
+  message: string;
+  description: string;
+  possibleFix: string;
+  metadata?: Record<string, unknown>;
 }
 
+export const getAPIErrorDetails = (
+  axiosError: AxiosError<ErrorResponseData>
+): ErrorDetails => {
+  const statusCode = axiosError.response?.status;
+  const errorCode = statusCode
+    ? API_TO_SDK_ERROR_CODE[statusCode]
+    : COMPOSIO_SDK_ERROR_CODES.BACKEND.UNKNOWN;
+  const predefinedError = BASE_ERROR_CODE_INFO[errorCode];
 
-export const getAPIErrorDetails = (errorKey: string, axiosError: any, predefinedError: any): ErrorDetails => {
-    const defaultErrorDetails = {
-        message: axiosError.message,
-        description: axiosError.response?.data?.message || axiosError.response?.data?.error || axiosError.message,
-        possibleFix: "Please check the network connection, request parameters, and ensure the API endpoint is correct."
-    };
+  const defaultErrorDetails = {
+    message: axiosError.message,
+    description: axiosError?.response?.data?.message || axiosError.message,
+    possibleFix: "Please check the parameters you are passing to the API",
+  };
 
-    const metadata = generateMetadataFromAxiosError(axiosError);
-    switch (errorKey) {
-        case SDK_ERROR_CODES.BACKEND.NOT_FOUND:
-        case SDK_ERROR_CODES.BACKEND.UNAUTHORIZED:
-        case SDK_ERROR_CODES.BACKEND.SERVER_ERROR:
-        case SDK_ERROR_CODES.BACKEND.SERVER_UNAVAILABLE:
-        case SDK_ERROR_CODES.BACKEND.RATE_LIMIT:
-            return {
-                message: `${predefinedError.message || axiosError.message} for ${axiosError.config.baseURL + axiosError.config.url}`,
-                description: axiosError.response?.data?.message || predefinedError.description,
-                possibleFix: predefinedError.possibleFix || defaultErrorDetails.possibleFix,
-                metadata
-            };
+  const metadata = generateMetadataFromAxiosError(axiosError);
 
-        case SDK_ERROR_CODES.BACKEND.BAD_REQUEST:
-            const validationErrors = axiosError.response?.data?.errors; 
-            const formattedErrors = Array.isArray(validationErrors)
-                ? validationErrors.map(err => JSON.stringify(err)).join(", ")
-                : JSON.stringify(validationErrors);
+  const errorNameFromBE = axiosError?.response?.data?.name;
+  const errorTypeFromBE = axiosError?.response?.data?.type;
+  const errorMessage = axiosError?.response?.data?.message;
 
-            return {
-                message: `Validation Errors while making request to ${axiosError.config.baseURL + axiosError.config.url}`,
-                description: `Validation Errors: ${formattedErrors}`,
-                possibleFix: "Please check the request parameters and ensure they are correct.",
-                metadata
-            };
+  let genericMessage = "";
 
-        case SDK_ERROR_CODES.BACKEND.UNKNOWN:
-        case SDK_ERROR_CODES.COMMON.UNKNOWN:
-            return {
-                message: `${axiosError.message} for ${axiosError.config.baseURL + axiosError.config.url}`,
-                description: axiosError.response?.data?.message || axiosError.response?.data?.error || axiosError.message,
-                possibleFix: "Please contact tech@composio.dev with the error details.",
-                metadata
-            };
+  const hasNotReceivedResponseFromBE =
+    errorCode === COMPOSIO_SDK_ERROR_CODES.BACKEND.UNAUTHORIZED ||
+    errorCode === COMPOSIO_SDK_ERROR_CODES.BACKEND.RATE_LIMIT ||
+    errorCode === COMPOSIO_SDK_ERROR_CODES.BACKEND.SERVER_UNAVAILABLE ||
+    errorCode === COMPOSIO_SDK_ERROR_CODES.BACKEND.SERVER_UNREACHABLE;
+  if (hasNotReceivedResponseFromBE) {
+    genericMessage = predefinedError.message as string;
+  } else if (axiosError.config?.baseURL && axiosError.config?.url) {
+    genericMessage = `${errorNameFromBE || predefinedError.message} ${errorTypeFromBE ? `- ${errorTypeFromBE}` : ""} on ${axiosError.config?.baseURL! + axiosError.config?.url!}`;
+  }
 
-        default:
-            return {
-                message: `${predefinedError.message || axiosError.message} for ${axiosError.config.baseURL + axiosError.config.url}`,
-                description: axiosError.response?.data?.message || predefinedError.description,
-                possibleFix: predefinedError.possibleFix || defaultErrorDetails.possibleFix,
-                metadata
-            };
-    }
-};
+  switch (errorCode) {
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.BAD_REQUEST:
+      const validationErrors = axiosError.response?.data?.details;
+      const formattedErrors = Array.isArray(validationErrors)
+        ? validationErrors.map((err) => JSON.stringify(err)).join(", ")
+        : JSON.stringify(validationErrors);
 
+      return {
+        message: genericMessage,
+        description: `Validation Errors: ${formattedErrors}`,
+        possibleFix:
+          "Please check the request parameters and ensure they are correct.",
+        metadata,
+      };
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.NOT_FOUND:
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.UNAUTHORIZED:
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.SERVER_ERROR:
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.SERVER_UNAVAILABLE:
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.RATE_LIMIT:
+    case COMPOSIO_SDK_ERROR_CODES.BACKEND.UNKNOWN:
+      return {
+        message: genericMessage,
+        description: errorMessage || (predefinedError.description as string),
+        possibleFix:
+          predefinedError.possibleFix! ||
+          (defaultErrorDetails.possibleFix as string),
+        metadata,
+      };
 
-export const generateMetadataFromAxiosError = (axiosError: any): Record<string, any> => {
-    const requestId = axiosError.response?.headers["x-request-id"];
-    return {
-        fullUrl: axiosError.config.baseURL + axiosError.config.url,
-        method: axiosError.config.method.toUpperCase(),
-        statusCode: axiosError.response?.status,
-        requestId: requestId ? `Request ID: ${requestId}` : undefined,
-        metadata: axiosError.metadata,
-    }
-}
+    default:
+      const message = genericMessage || axiosError.message;
+      const description =
+        errorMessage || (predefinedError.description as string);
+      const possibleFix =
+        predefinedError.possibleFix! ||
+        (defaultErrorDetails.possibleFix as string) ||
+        "";
+      return {
+        message,
+        description,
+        possibleFix,
+        metadata,
+      };
+  }
+};
 
-
+export const generateMetadataFromAxiosError = (
+  axiosError: AxiosError<unknown> & {
+    metadata?: Record<string, unknown>;
+  }
+): Record<string, unknown> => {
+  const { requestId, ...restMetadata } = axiosError.metadata || {};
+  return {
+    fullUrl:
+      (axiosError.config?.baseURL ?? "") + (axiosError.config?.url ?? ""),
+    method: (axiosError.config?.method ?? "").toUpperCase(),
+    statusCode: axiosError.response?.status,
+    requestId: requestId ? `${requestId}` : undefined,
+    metadata: restMetadata,
+  };
+};
```
