fix(ai-providers): route openai compat model fetch/test through api-call to avoid CORS

src/services/api/apiCall.ts

@@ -0,0 +1,86 @@
+/**
+ * Generic API call helper (proxied via management API).
+ */
+
+import type { AxiosRequestConfig } from 'axios';
+import { apiClient } from './client';
+
+export interface ApiCallRequest {
+  authIndex?: string;
+  method: string;
+  url: string;
+  header?: Record<string, string>;
+  data?: string;
+}
+
+export interface ApiCallResult<T = any> {
+  statusCode: number;
+  header: Record<string, string[]>;
+  bodyText: string;
+  body: T | null;
+}
+
+const normalizeBody = (input: unknown): { bodyText: string; body: any | null } => {
+  if (input === undefined || input === null) {
+    return { bodyText: '', body: null };
+  }
+
+  if (typeof input === 'string') {
+    const text = input;
+    const trimmed = text.trim();
+    if (!trimmed) {
+      return { bodyText: text, body: null };
+    }
+    try {
+      return { bodyText: text, body: JSON.parse(trimmed) };
+    } catch {
+      return { bodyText: text, body: text };
+    }
+  }
+
+  try {
+    return { bodyText: JSON.stringify(input), body: input };
+  } catch {
+    return { bodyText: String(input), body: input };
+  }
+};
+
+export const getApiCallErrorMessage = (result: ApiCallResult): string => {
+  const status = result.statusCode;
+  const body = result.body;
+  const bodyText = result.bodyText;
+  let message = '';
+
+  if (body && typeof body === 'object') {
+    message = body?.error?.message || body?.error || body?.message || '';
+  } else if (typeof body === 'string') {
+    message = body;
+  }
+
+  if (!message && bodyText) {
+    message = bodyText;
+  }
+
+  if (status && message) return `${status} ${message}`.trim();
+  if (status) return `HTTP ${status}`;
+  return message || 'Request failed';
+};
+
+export const apiCallApi = {
+  request: async (
+    payload: ApiCallRequest,
+    config?: AxiosRequestConfig
+  ): Promise<ApiCallResult> => {
+    const response = await apiClient.post('/api-call', payload, config);
+    const statusCode = Number(response?.status_code ?? response?.statusCode ?? 0);
+    const header = (response?.header ?? response?.headers ?? {}) as Record<string, string[]>;
+    const { bodyText, body } = normalizeBody(response?.body);
+
+    return {
+      statusCode,
+      header,
+      bodyText,
+      body
+    };
+  }
+};

src/services/api/index.ts

@@ -1,4 +1,5 @@
 export * from './client';
+export * from './apiCall';
 export * from './config';
 export * from './configFile';
 export * from './apiKeys';

src/services/api/models.ts

@@ -4,6 +4,7 @@
 
 import axios from 'axios';
 import { normalizeModelList } from '@/utils/models';
+import { apiCallApi, getApiCallErrorMessage } from './apiCall';
 
 const normalizeBaseUrl = (baseUrl: string): string => {
   let normalized = String(baseUrl || '').trim();
@@ -39,5 +40,35 @@ export const modelsApi = {
     });
     const payload = response.data?.data ?? response.data?.models ?? response.data;
     return normalizeModelList(payload, { dedupe: true });
+  },
+
+  async fetchModelsViaApiCall(
+    baseUrl: string,
+    apiKey?: string,
+    headers: Record<string, string> = {}
+  ) {
+    const endpoint = buildModelsEndpoint(baseUrl);
+    if (!endpoint) {
+      throw new Error('Invalid base url');
+    }
+
+    const resolvedHeaders = { ...headers };
+    const hasAuthHeader = Boolean(resolvedHeaders.Authorization || resolvedHeaders.authorization);
+    if (apiKey && !hasAuthHeader) {
+      resolvedHeaders.Authorization = `Bearer ${apiKey}`;
+    }
+
+    const result = await apiCallApi.request({
+      method: 'GET',
+      url: endpoint,
+      header: Object.keys(resolvedHeaders).length ? resolvedHeaders : undefined
+    });
+
+    if (result.statusCode < 200 || result.statusCode >= 300) {
+      throw new Error(getApiCallErrorMessage(result));
+    }
+
+    const payload = result.body ?? result.bodyText;
+    return normalizeModelList(payload, { dedupe: true });
   }
 };