@bytexbyte/nxtlinq-ai-agent-core-development 0.2.0

package/src/api/nxtlinq-api.ts

@@ -0,0 +1,656 @@
+import type { AITApi } from '../types/ait-api';
+import { STORAGE_KEYS } from '../constants/storageKeys';
+import type { PlatformPorts } from '../ports/PlatformPorts';
+import { createDefaultHttpPort } from '../ports/HttpPort';
+import { getAiAgentApiHost, getAitServiceApiHost } from './hosts';
+import { parseSSEResponse, parseSSEText } from './parse-sse';
+import { postTextTts, type PostTextTtsResult } from './tts';
+
+export type { PostTextTtsResult };
+export { postTextTts, buildTextTtsDataUri } from './tts';
+
+export type CoreAITApi = Omit<AITApi, 'voice'>;
+
+export type ApiClientDeps = Pick<PlatformPorts, 'storage' | 'http' | 'getTimezone'>;
+
+/** RN/Hermes 的 URLSearchParams 常缺少 set/append，改用手動組 query。 */
+function withQuery(
+  baseUrl: string,
+  query: Record<string, string | number | undefined | null>,
+): string {
+  const pairs: string[] = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null || value === '') continue;
+    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  if (pairs.length === 0) return baseUrl;
+  const sep = baseUrl.includes('?') ? '&' : '?';
+  return `${baseUrl}${sep}${pairs.join('&')}`;
+}
+
+function createApiHelpers(deps: ApiClientDeps) {
+  const fetchFn = deps.http?.fetch ?? createDefaultHttpPort().fetch;
+  const getTimezone = deps.getTimezone ?? (() => {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+      return 'UTC';
+    }
+  });
+
+  const getAuthHeader = async (): Promise<Record<string, string>> => {
+    const token = await deps.storage.getItem(STORAGE_KEYS.AIT_SERVICE_ACCESS_TOKEN);
+    return token ? { Authorization: `Bearer ${JSON.parse(token)}` } : {};
+  };
+
+  const makeRequest = async (
+    url: string,
+    options: RequestInit,
+    apiKey: string,
+    apiSecret: string,
+  ): Promise<any> => {
+    const auth = await getAuthHeader();
+    const response = await fetchFn(url, {
+      ...options,
+      headers: {
+        'X-API-Key': apiKey,
+        'X-API-Secret': apiSecret,
+        ...auth,
+        ...options.headers,
+      },
+    });
+    return response.json();
+  };
+
+  const getWalletContext = async () => {
+    const walletAddress = await deps.storage.getItem(STORAGE_KEYS.WALLET_ADDRESS);
+    const aitTokenRaw = await deps.storage.getItem(STORAGE_KEYS.AIT_SERVICE_ACCESS_TOKEN);
+    const aitToken = aitTokenRaw ? JSON.parse(aitTokenRaw) : null;
+    return { walletAddress, aitToken };
+  };
+
+  return { fetchFn, getTimezone, getAuthHeader, makeRequest, getWalletContext };
+}
+
+// AIT API module
+const createAITApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  getAITByServiceIdAndController: async (params: { serviceId: string; controller: string; customUsername?: string }, token: string) => {
+    const url = withQuery(
+      `${getAitServiceApiHost()}/api/ait/service/${params.serviceId}/controller/${params.controller}`,
+      { customUsername: params.customUsername },
+    );
+    return helpers.makeRequest(
+      url,
+      { method: 'GET' },
+      apiKey,
+      apiSecret
+    );
+  },
+
+  createAIT: async (params: any, token: string) => {
+    return helpers.makeRequest(
+      `${getAitServiceApiHost()}/api/ait`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(params)
+      },
+      apiKey,
+      apiSecret
+    );
+  },
+});
+
+// Wallet API module
+const createWalletApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  verifyWallet: async (params: any, token: string) => {
+    return helpers.makeRequest(
+      `${getAitServiceApiHost()}/api/wallet`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(params)
+      },
+      apiKey,
+      apiSecret
+    );
+  },
+
+  getWallet: async (params: { address: string }, token: string) => {
+    return helpers.makeRequest(
+      `${getAitServiceApiHost()}/api/wallet/address/${params.address}`,
+      { method: 'GET' },
+      apiKey,
+      apiSecret
+    );
+  }
+});
+
+// Metadata API module
+const createMetadataApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  createMetadata: async (metadata: any, token: string) => {
+    return helpers.makeRequest(
+      `${getAitServiceApiHost()}/api/metadata`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(metadata)
+      },
+      apiKey,
+      apiSecret
+    );
+  }
+});
+
+// Auth API module
+const createAuthApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  getNonce: async (params: { address: string }) => {
+    return helpers.makeRequest(
+      `${getAitServiceApiHost()}/api/auth/address/${params.address}/nonce`,
+      { method: 'GET' },
+      apiKey,
+      apiSecret
+    );
+  },
+
+  signIn: async (params: any) => {
+    return helpers.makeRequest(
+      `${getAitServiceApiHost()}/api/auth`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(params)
+      },
+      apiKey,
+      apiSecret
+    );
+  }
+});
+
+// Agent API module
+const createAgentApi = (helpers: ReturnType<typeof createApiHelpers>) => ({
+  sendMessage: async (params: {
+    model?: string;
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId?: string;
+    customUserInfo?: Record<string, any>;
+    customUsername?: string;
+    message: string;
+    attachments?: Array<{
+      type: 'image' | 'file';
+      url: string;
+      name: string;
+      mimeType: string;
+    }>;
+    context?: Array<{ role: string; text: string }>;
+    isRetry?: boolean;
+    /** 客戶端步驟耗時（如 Azure Speech STT），會寫入後端 ai_service_call_log */
+    clientPipelineTimings?: Array<{ name: string; durationMs: number }>;
+    onPiiProgress?: (step: 'scan_start' | 'scan_complete' | 'send_start' | 'done', data?: any) => void;
+    /** Token chunks from `*-stream` routes (`event: text_delta`). */
+    onStreamDelta?: (text: string) => void;
+  }) => {
+    try {
+      const model = params.model || 'open-ai';
+      const { walletAddress, aitToken } = await helpers.getWalletContext();
+      const auth = await helpers.getAuthHeader();
+
+      const requestBody = {
+        apiKey: params.apiKey,
+        apiSecret: params.apiSecret,
+        pseudoId: params.pseudoId,
+        externalId: params.externalId,
+        customUserInfo: params.customUserInfo,
+        customUsername: params.customUsername,
+        message: params.message,
+        attachments: params.attachments,
+        walletAddress: walletAddress || undefined,
+        aitToken: aitToken || undefined,
+        timezone: helpers.getTimezone(),
+        ...(params.isRetry ? { isRetry: true } : {}),
+        ...(params.clientPipelineTimings &&
+        params.clientPipelineTimings.length > 0
+          ? { clientPipelineTimings: params.clientPipelineTimings }
+          : {}),
+      };
+
+      const useSSE = Boolean(
+        params.onPiiProgress || params.onStreamDelta || model.endsWith('-stream')
+      );
+
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/${model}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Wallet-Address': walletAddress || '',
+          'X-AIT-Token': aitToken || '',
+          ...auth,
+          ...(params.onPiiProgress ? { 'X-Stream-PII': '1' } : {}),
+        },
+        body: JSON.stringify(requestBody),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to send message');
+      }
+
+      const contentType = response.headers.get('content-type') || '';
+
+      if (useSSE && contentType.includes('text/event-stream')) {
+        const sseHandlers = {
+          onPiiProgress: params.onPiiProgress,
+          onStreamDelta: params.onStreamDelta,
+        };
+        // Always buffer first: RN often exposes a `body` stream that closes
+        // immediately without data, which breaks incremental parsing.
+        const rawText = await response.text();
+        if (rawText.trimStart().startsWith('event:') || rawText.includes('\nevent:')) {
+          return parseSSEText(rawText, sseHandlers);
+        }
+        // Gateway returned JSON despite SSE content-type.
+        return rawText ? JSON.parse(rawText) : {};
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to send message:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to send message' };
+    }
+  },
+  generateSuggestions: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId?: string;
+  }) => {
+    try {
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/suggestions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+        body: JSON.stringify({
+          apiKey: params.apiKey,
+          apiSecret: params.apiSecret,
+          pseudoId: params.pseudoId,
+          externalId: params.externalId || undefined,
+        }),
+      });
+      if (!response.ok) {
+        throw new Error('Failed to generate suggestions');
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to generate suggestions:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to generate suggestions' };
+    }
+  },
+  getMessageHistory: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId?: string;
+    last?: number;
+  }) => {
+    try {
+      const url = withQuery(
+        `${getAiAgentApiHost()}/api/message/pseudoId/${encodeURIComponent(params.pseudoId)}`,
+        {
+          externalId: params.externalId,
+          last: params.last != null ? params.last : undefined,
+        },
+      );
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(url, {
+        method: 'GET',
+        headers: {
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+      });
+      if (!response.ok) {
+        throw new Error('Failed to fetch message history');
+      }
+      return await response.json() as {
+        messages: Array<{
+          id: string;
+          role: 'user' | 'assistant';
+          content: string;
+          createdAt?: string;
+        }>;
+      };
+    } catch (error) {
+      console.error('Failed to fetch message history:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to fetch message history' };
+    }
+  },
+  updateMessagesExternalIdByPseudoId: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId: string;
+  }) => {
+    try {
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/message/pseudoId/${params.pseudoId}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+        body: JSON.stringify({
+          apiKey: params.apiKey,
+          apiSecret: params.apiSecret,
+          externalId: params.externalId,
+        }),
+      });
+      if (!response.ok) {
+        throw new Error('Failed to update message history');
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to update message history:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to update message history' };
+    }
+  },
+  cloneUserProfileByPseudoId: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId: string;
+  }) => {
+    try {
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/userProfile/pseudoId/${params.pseudoId}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+        body: JSON.stringify({
+          apiKey: params.apiKey,
+          apiSecret: params.apiSecret,
+          externalId: params.externalId,
+        }),
+      });
+      if (!response.ok) {
+        throw new Error('Failed to clone user profile');
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to clone user profile:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to clone user profile' };
+    }
+  },
+  cloneUserTopicByPseudoId: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId: string;
+  }) => {
+    try {
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/userTopic/pseudoId/${params.pseudoId}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+        body: JSON.stringify({
+          apiKey: params.apiKey,
+          apiSecret: params.apiSecret,
+          externalId: params.externalId,
+        }),
+      });
+      if (!response.ok) {
+        throw new Error('Failed to clone user topic');
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to clone user topic:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to clone user topic' };
+    }
+  },
+  checkToolPermission: async (params: { apiKey: string, apiSecret: string, aitToken: string, controller: string, toolName: string; }) => {
+    try {
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/utils/checkToolPermission`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+        body: JSON.stringify({
+          apiKey: params.apiKey,
+          apiSecret: params.apiSecret,
+          aitToken: params.aitToken,
+          controller: params.controller,
+          toolName: params.toolName,
+        }),
+      });
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to clone user topic:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to clone user topic' };
+    }
+  },
+  getServiceModels: async (params: { apiKey: string; apiSecret: string; }) => {
+    try {
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/service-models`, {
+        method: 'GET',
+        headers: {
+          'x-api-key': params.apiKey,
+          'x-api-secret': params.apiSecret,
+        }
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch service models');
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to fetch service models:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to fetch service models' };
+    }
+  },
+  updateMessageContent: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    messageId: string;
+    content: string;
+  }) => {
+    try {
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/message/${params.messageId}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': params.apiKey,
+          'X-API-Secret': params.apiSecret,
+          ...auth,
+        },
+        body: JSON.stringify({
+          apiKey: params.apiKey,
+          apiSecret: params.apiSecret,
+          content: params.content,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to update message content');
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to update message content:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to update message content' };
+    }
+  },
+  uploadAttachment: async (params: {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    file: File;
+  }): Promise<{ url: string; key?: string; name?: string; mimeType?: string } | { error: string }> => {
+    try {
+      const originalName = params.file.name;
+      const safeName = originalName.replace(/[^\x00-\x7F.a-zA-Z0-9_-]/g, '_').replace(/^\.+/, '') || 'file';
+      const fileForUpload = safeName !== originalName
+        ? new File([params.file], safeName, { type: params.file.type, lastModified: params.file.lastModified })
+        : params.file;
+
+      const form = new FormData();
+      form.append('file', fileForUpload);
+      form.append('pseudoId', params.pseudoId);
+      if (safeName !== originalName) {
+        form.append('originalName', originalName);
+      }
+      const { walletAddress, aitToken } = await helpers.getWalletContext();
+      const headers: Record<string, string> = {
+        'X-API-Key': params.apiKey,
+        'X-API-Secret': params.apiSecret,
+        'X-Wallet-Address': walletAddress || '',
+        'X-AIT-Token': aitToken || '',
+      };
+      const response = await helpers.fetchFn(`${getAiAgentApiHost()}/api/upload`, {
+        method: 'POST',
+        headers,
+        body: form,
+      });
+      const text = await response.text();
+      let data: { url?: string; key?: string; name?: string; mimeType?: string; error?: string };
+      try {
+        data = text ? JSON.parse(text) : {};
+      } catch {
+        data = {};
+      }
+      if (!response.ok) {
+        return { error: data.error || response.statusText || 'Upload failed' };
+      }
+      if (!data.url) {
+        return { error: data.error || 'Upload failed' };
+      }
+      return data as { url: string; key?: string; name?: string; mimeType?: string };
+    } catch (e) {
+      console.error('Upload attachment failed:', e);
+      return { error: e instanceof Error ? e.message : 'Upload failed' };
+    }
+  },
+});
+
+// Permissions API module
+const createPermissionsApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  getServicePermissions: async (params: { serviceId: string; groupName?: string }) => {
+    try {
+      const url = withQuery(
+        `${getAiAgentApiHost()}/api/permissions/service/${params.serviceId}`,
+        {
+          groupName: params.groupName,
+          _t: Date.now(),
+        },
+      );
+
+      const auth = await helpers.getAuthHeader();
+      const response = await helpers.fetchFn(url, {
+        method: 'GET',
+        cache: 'no-store',
+        headers: {
+          'X-API-Key': apiKey,
+          'X-API-Secret': apiSecret,
+          'Content-Type': 'application/json',
+          ...auth,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch permissions');
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to fetch permissions:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to fetch permissions' };
+    }
+  }
+});
+
+// Cognitive API Module
+const createCognitiveApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  getCognitiveToken: async () => {
+    try {
+      const url = `${getAiAgentApiHost()}/api/cognitive/token`;
+      const auth = await helpers.getAuthHeader();
+
+      const response = await helpers.fetchFn(url, {
+        method: 'GET',
+        headers: {
+          'X-API-Key': apiKey,
+          'X-API-Secret': apiSecret,
+          'Content-Type': 'application/json',
+          ...auth,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch permissions');
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to fetch cognitive token:', error);
+      return { error: error instanceof Error ? error.message : 'Failed to fetch cognitive token' };
+    }
+  }
+});
+
+function resolveApiDeps(deps: ApiClientDeps): ReturnType<typeof createApiHelpers> {
+  return createApiHelpers({
+    storage: deps.storage,
+    http: deps.http ?? createDefaultHttpPort(),
+    getTimezone: deps.getTimezone,
+  });
+}
+
+/** Platform-agnostic API client (no `voice` — attach via Web/RN layer). */
+const createTtsApi = (apiKey: string, apiSecret: string, helpers: ReturnType<typeof createApiHelpers>) => ({
+  postTextTts: (text: string) =>
+    postTextTts(
+      { apiKey, apiSecret, text },
+      helpers.fetchFn,
+    ),
+});
+
+export function createNxtlinqApiWithDeps(
+  apiKey: string,
+  apiSecret: string,
+  deps: ApiClientDeps,
+): CoreAITApi {
+  const helpers = resolveApiDeps(deps);
+  return {
+    ait: createAITApi(apiKey, apiSecret, helpers),
+    wallet: createWalletApi(apiKey, apiSecret, helpers),
+    metadata: createMetadataApi(apiKey, apiSecret, helpers),
+    auth: createAuthApi(apiKey, apiSecret, helpers),
+    agent: createAgentApi(helpers),
+    permissions: createPermissionsApi(apiKey, apiSecret, helpers),
+    cognitive: createCognitiveApi(apiKey, apiSecret, helpers),
+    tts: createTtsApi(apiKey, apiSecret, helpers),
+  };
+}