@bytexbyte/nxtlinq-ai-agent-sdk 1.0.8 → 1.0.9

package/src/core/metakeepClient.ts

@@ -1,13 +0,0 @@
-import { MetaKeep } from 'metakeep';
-
-const metakeepClient = new MetaKeep({
-  appId: 'e7d521f7-3eea-42d7-af42-4d8b962d9a6d',
-  chainId: 80002,
-  /* RPC node urls map */
-  rpcNodeUrls: {
-    // Update with your node API key
-    80002: 'https://rpc-amoy.polygon.technology'
-  }
-});
-
-export default metakeepClient;

package/src/hooks/useNxtlinqAIT.ts

@@ -1,99 +0,0 @@
-import { useEffect, useState } from 'react';
-import { NxtlinqAITSDK } from '../index';
-import { AITInfo, WalletInfo } from '../types/ait-api';
-
-export function useNxtlinqAIT(sdk: NxtlinqAITSDK) {
-  const [walletAddress, setWalletAddress] = useState<string | null>(null);
-  const [walletInfo, setWalletInfo] = useState<WalletInfo | null>(null);
-  const [ait, setAit] = useState<AITInfo | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const connectWallet = async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const address = await sdk.connectWallet();
-      setWalletAddress(address);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to connect wallet');
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const verifyWallet = async (token: string, method: string) => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const info = await sdk.verifyWallet(token, method);
-      setWalletInfo(info);
-      return info;
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to verify wallet');
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const signInWithWallet = async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const token = await sdk.signInWithWallet();
-      return token;
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to sign in with wallet');
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const generateAndRegisterAIT = async (permissions: string[]) => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const aitInfo = await sdk.generateAndRegisterAIT(permissions);
-      setAit(aitInfo);
-      return aitInfo;
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to generate AIT');
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  useEffect(() => {
-    const loadData = async () => {
-      if (walletAddress) {
-        try {
-          const [walletInfo, aitInfo] = await Promise.all([
-            sdk.getWalletInfo(),
-            sdk.getAIT()
-          ]);
-          setWalletInfo(walletInfo);
-          setAit(aitInfo);
-        } catch (err) {
-          console.error('Failed to load wallet info or AIT:', err);
-        }
-      }
-    };
-
-    loadData();
-  }, [walletAddress, sdk]);
-
-  return {
-    walletAddress,
-    walletInfo,
-    ait,
-    isLoading,
-    error,
-    connectWallet,
-    verifyWallet,
-    signInWithWallet,
-    generateAndRegisterAIT
-  };
-} 

package/src/index.ts

@@ -1,557 +0,0 @@
-import { ethers } from 'ethers';
-import stringify from 'json-stable-stringify';
-import { AITInfo, AITMetadata, PermissionGroup, PermissionOption, WalletInfo, CreateAITParams, CreateMetadataParams, VerifyWalletParams, SignInParams, AITApi } from './types/ait-api';
-
-const AI_AGENT_API_HOST = 'https://ai-agent.nxtlinq.ai';
-const AIT_SERVICE_API_HOST = 'https://staging-ait-service.nxtlinq.ai';
-
-export const createNxtlinqApi = (apiKey: string, apiSecret: string): AITApi => {
-  const getAuthHeader = (): Record<string, string> => {
-    const token = localStorage.getItem('nxtlinqAITServiceAccessToken');
-    return token ? { 'Authorization': `Bearer ${JSON.parse(token)}` } : {};
-  };
-
-  return {
-    ait: {
-      getAITByServiceIdAndController: async (params: { serviceId: string; controller: string }, token: string) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/ait/service/${params.serviceId}/controller/${params.controller}`, {
-          method: 'GET',
-          headers: {
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            ...getAuthHeader()
-          }
-        });
-        return response.json();
-      },
-      createAIT: async (params: any, token: string) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/ait`, {
-          method: 'POST',
-          headers: { 
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            'Content-Type': 'application/json',
-            ...getAuthHeader()
-          },
-          body: JSON.stringify(params)
-        });
-        return response.json();
-      }
-    },
-    wallet: {
-      verifyWallet: async (params: any, token: string) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/wallet`, {
-          method: 'POST',
-          headers: { 
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            'Content-Type': 'application/json',
-            ...getAuthHeader()
-          },
-          body: JSON.stringify(params)
-        });
-        return response.json();
-      },
-      getWallet: async (params: { address: string }, token: string) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/wallet/address/${params.address}`, {
-          method: 'GET',
-          headers: {
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            ...getAuthHeader()
-          }
-        });
-        return response.json();
-      }
-    },
-    metadata: {
-      createMetadata: async (metadata: any, token: string) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/metadata`, {
-          method: 'POST',
-          headers: { 
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            'Content-Type': 'application/json',
-            ...getAuthHeader()
-          },
-          body: JSON.stringify(metadata)
-        });
-        return response.json();
-      }
-    },
-    auth: {
-      getNonce: async (params: { address: string }) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/auth/address/${params.address}/nonce`, {
-          method: 'GET',
-          headers: {
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            ...getAuthHeader()
-          }
-        });
-        return response.json();
-      },
-      signIn: async (params: any) => {
-        const response = await fetch(`${AIT_SERVICE_API_HOST}/api/auth`, {
-          method: 'POST',
-          headers: { 
-            'X-API-Key': apiKey,
-            'X-API-Secret': apiSecret,
-            'Content-Type': 'application/json',
-            ...getAuthHeader()
-          },
-          body: JSON.stringify(params)
-        });
-        return response.json();
-      }
-    },
-    agent: {
-      sendMessage: async (params) => {
-        try {
-          const response = await fetch(`${AI_AGENT_API_HOST}/api/agent/message`, {
-            method: 'POST',
-            headers: {
-              'X-API-Key': apiKey,
-              'X-API-Secret': apiSecret,
-              'Content-Type': 'application/json',
-              ...getAuthHeader()
-            },
-            body: JSON.stringify(params)
-          });
-
-          if (!response.ok) {
-            throw new Error('发送消息失败');
-          }
-
-          return await response.json();
-        } catch (error) {
-          return { error: error instanceof Error ? error.message : '发送消息失败' };
-        }
-      }
-    }
-  };
-};
-
-export { ChatBot } from './components/ChatBot';
-export type { Message, PresetMessage, ToolUse, ChatBotProps } from './components/ChatBot';
-
-// 导出类型
-export type {
-  AITInfo,
-  AITMetadata,
-  PermissionGroup,
-  PermissionOption,
-  WalletInfo,
-  CreateAITParams,
-  CreateMetadataParams,
-  VerifyWalletParams,
-  SignInParams
-};
-
-export interface AITPermission {
-  hasPermission: boolean;
-  reason?: string;
-  permissions?: string[];
-}
-
-export interface AIT {
-  aitId: string;
-  controller: string;
-  metadata: AITMetadata;
-  metadataHash: string;
-  metadataCid: string;
-  signature: string;
-}
-
-export interface GenerateAITOptions {
-  hitAddress: string;
-  signer: ethers.Signer;
-  permissions: string[];
-  serviceId: string;
-}
-
-export interface MessageResponse {
-  reply: string;
-  timestamp: string;
-}
-
-export class NxtlinqAITSDK {
-  private serviceId: string;
-  private signer: ethers.Signer | null = null;
-  private walletAddress: string | null = null;
-  private api: AITApi;
-
-  constructor(serviceId: string, apiKey: string, apiSecret: string) {
-    this.serviceId = serviceId;
-    this.api = createNxtlinqApi(apiKey, apiSecret);
-  }
-
-  async connectWallet(): Promise<string> {
-    if (typeof window === 'undefined' || !window.ethereum) {
-      throw new Error('MetaMask is not installed');
-    }
-
-    const provider = new ethers.BrowserProvider(window.ethereum);
-    this.signer = await provider.getSigner();
-    this.walletAddress = await this.signer.getAddress();
-    return this.walletAddress;
-  }
-
-  async verifyWallet(token: string, method: string): Promise<WalletInfo> {
-    if (!this.walletAddress) {
-      throw new Error('Please connect wallet first');
-    }
-
-    const response = await this.api.wallet.verifyWallet({
-      address: this.walletAddress,
-      token,
-      method,
-      timestamp: Date.now()
-    }, token);
-
-    if ('error' in response) {
-      throw new Error(response.error);
-    }
-
-    return response;
-  }
-
-  async signInWithWallet(): Promise<string> {
-    if (!this.walletAddress || !this.signer) {
-      throw new Error('Please connect wallet first');
-    }
-
-    const nonceResponse = await this.api.auth.getNonce({ address: this.walletAddress });
-    if ('error' in nonceResponse) {
-      throw new Error(nonceResponse.error);
-    }
-
-    const payload = {
-      address: this.walletAddress,
-      code: nonceResponse.code,
-      timestamp: nonceResponse.timestamp
-    };
-
-    const stringToSign = stringify(payload);
-    const signature = await this.signer.signMessage(stringToSign || '');
-
-    const response = await this.api.auth.signIn({
-      ...payload,
-      signature
-    });
-
-    if ('error' in response) {
-      throw new Error(response.error);
-    }
-
-    return response.accessToken;
-  }
-
-  async generateAndRegisterAIT(permissions: string[]): Promise<AITInfo> {
-    if (!this.signer || !this.walletAddress) {
-      throw new Error('Please connect wallet first');
-    }
-
-    const token = localStorage.getItem('nxtlinqAITServiceAccessToken');
-    if (!token) {
-      throw new Error('未找到访问令牌');
-    }
-
-    const timestamp = Math.floor(Date.now() / 1000);
-    const aitId = `did:polygon:ike-dashboard:${this.walletAddress}:${timestamp}`;
-
-    const metadata: AITMetadata = {
-      model: 'gpt-4',
-      permissions,
-      issuedBy: this.walletAddress
-    };
-
-    const metadataStr = stringify(metadata);
-    const metadataHash = ethers.keccak256(ethers.toUtf8Bytes(metadataStr || ''));
-
-    // Upload metadata
-    const uploadResponse = await this.api.metadata.createMetadata({
-      ...metadata,
-      controller: this.walletAddress
-    }, token);
-
-    if ('error' in uploadResponse) {
-      throw new Error(`Failed to upload metadata: ${uploadResponse.error}`);
-    }
-
-    const { metadataCid } = uploadResponse;
-
-    // Sign the message
-    const messageHash = ethers.solidityPackedKeccak256(
-      ['string', 'address', 'string', 'bytes32', 'uint256'],
-      [aitId, this.walletAddress, this.serviceId, metadataHash, timestamp]
-    );
-
-    const signature = await this.signer.signMessage(ethers.getBytes(messageHash));
-
-    // Register AIT
-    const response = await this.api.ait.createAIT({
-      aitId,
-      controller: this.walletAddress,
-      serviceId: this.serviceId,
-      metadataHash,
-      metadataCid,
-      timestamp,
-      signature
-    }, token);
-
-    if ('error' in response) {
-      throw new Error(response.error);
-    }
-
-    return response;
-  }
-
-  async getAIT(): Promise<AITInfo | null> {
-    if (!this.walletAddress) {
-      return null;
-    }
-
-    const token = localStorage.getItem('nxtlinqAITServiceAccessToken');
-    if (!token) {
-      throw new Error('未找到访问令牌');
-    }
-
-    const response = await this.api.ait.getAITByServiceIdAndController({
-      serviceId: this.serviceId,
-      controller: this.walletAddress
-    }, token);
-
-    if ('error' in response) {
-      return null;
-    }
-
-    return response;
-  }
-
-  async getWalletInfo(): Promise<WalletInfo | null> {
-    if (!this.walletAddress) {
-      return null;
-    }
-
-    const token = localStorage.getItem('nxtlinqAITServiceAccessToken');
-    if (!token) {
-      throw new Error('未找到访问令牌');
-    }
-
-    const response = await this.api.wallet.getWallet({ address: this.walletAddress }, token);
-    if ('error' in response) {
-      return null;
-    }
-
-    return response;
-  }
-
-  createPermissionForm(permissionGroups: PermissionGroup[]): PermissionGroup[] {
-    return permissionGroups.map(group => ({
-      label: group.label,
-      options: group.options.map((option: PermissionOption) => ({
-        ...option,
-        isChecked: false,
-      }))
-    }));
-  }
-
-  getSelectedPermissions(form: PermissionGroup[]): string[] {
-    return form.flatMap(group =>
-      group.options.filter((opt: PermissionOption) => opt.isChecked).map((opt: PermissionOption) => opt.value)
-    );
-  }
-}
-
-export class NxtlinqAIAgent {
-  private projectId: string;
-  private apiKey?: string;
-  private ait?: AIT;
-  private permissions: string[] = [];
-  private signer?: ethers.Signer;
-  private api: AITApi;
-
-  constructor(projectId: string, apiKey: string, apiSecret: string) {
-    this.projectId = projectId;
-    this.apiKey = apiKey;
-    this.api = createNxtlinqApi(apiKey, apiSecret);
-  }
-
-  setAIT(ait: AIT, signer?: ethers.Signer) {
-    this.ait = ait;
-    this.permissions = ait.metadata.permissions;
-    if (signer) {
-      this.signer = signer;
-    }
-  }
-
-  private async hasPermission(toolName: string): Promise<boolean> {
-    if (!this.ait) {
-      throw new Error('请先连接钱包以访问权限');
-    }
-    return this.permissions.includes(toolName);
-  }
-
-  private async checkAITPermission(toolName?: string): Promise<AITPermission> {
-    try {
-      if (!this.ait) {
-        return {
-          hasPermission: false,
-          reason: '请先连接钱包以访问权限'
-        };
-      }
-
-      if (!toolName) {
-        return {
-          hasPermission: true,
-          permissions: this.permissions
-        };
-      }
-
-      const hasPermission = await this.hasPermission(toolName);
-      return {
-        hasPermission,
-        reason: hasPermission ? undefined : '没有权限使用该工具',
-        permissions: this.permissions
-      };
-    } catch (error) {
-      return {
-        hasPermission: false,
-        reason: error instanceof Error ? error.message : '未知错误',
-        permissions: this.permissions
-      };
-    }
-  }
-
-  async generateAIT(options: GenerateAITOptions): Promise<AIT> {
-    const { hitAddress, signer, permissions, serviceId } = options;
-    const token = localStorage.getItem('nxtlinqAITServiceAccessToken');
-    if (!token) {
-      throw new Error('未找到访问令牌');
-    }
-
-    const timestamp = Math.floor(Date.now() / 1000);
-    const aitId = `did:polygon:ike-dashboard:${hitAddress}:${timestamp}`;
-
-    const metadata: AITMetadata = {
-      model: 'gpt-4',
-      permissions,
-      issuedBy: hitAddress
-    };
-
-    const metadataStr = stringify(metadata);
-    const metadataHash = ethers.keccak256(ethers.toUtf8Bytes(metadataStr || ''));
-
-    // Upload metadata
-    const uploadResponse = await this.api.metadata.createMetadata({
-      ...metadata,
-      controller: hitAddress
-    }, token);
-
-    if ('error' in uploadResponse) {
-      throw new Error(`Failed to upload metadata: ${uploadResponse.error}`);
-    }
-
-    const { metadataCid } = uploadResponse;
-
-    // Sign the message
-    const messageHash = ethers.solidityPackedKeccak256(
-      ['string', 'address', 'string', 'bytes32', 'uint256'],
-      [aitId, hitAddress, serviceId, metadataHash, timestamp]
-    );
-
-    const signature = await signer.signMessage(ethers.getBytes(messageHash));
-
-    // Register AIT
-    const response = await this.api.ait.createAIT({
-      aitId,
-      controller: hitAddress,
-      serviceId,
-      metadataHash,
-      metadataCid,
-      timestamp,
-      signature
-    }, token);
-
-    if ('error' in response) {
-      throw new Error(response.error);
-    }
-
-    return {
-      aitId: response.aitId,
-      controller: response.controller,
-      metadata: response.metadata,
-      metadataHash: response.metadataHash,
-      metadataCid: response.metadataCid,
-      signature: response.signature
-    };
-  }
-
-  async getAITInfo(serviceId: string, controller: string, signer?: ethers.Signer): Promise<AIT | null> {
-    const token = localStorage.getItem('nxtlinqAITServiceAccessToken');
-    if (!token) {
-      throw new Error('未找到访问令牌');
-    }
-
-    const response = await this.api.ait.getAITByServiceIdAndController({
-      serviceId,
-      controller
-    }, token);
-
-    if ('error' in response) {
-      return null;
-    }
-
-    if (signer) {
-      this.signer = signer;
-    }
-
-    return {
-      aitId: response.aitId,
-      controller: response.controller,
-      metadata: response.metadata,
-      metadataHash: response.metadataHash,
-      metadataCid: response.metadataCid,
-      signature: response.signature
-    };
-  }
-
-  async sendMessage(message: string, toolName?: string): Promise<MessageResponse> {
-    const permission = await this.checkAITPermission(toolName);
-    if (!permission.hasPermission) {
-      throw new Error(permission.reason || '没有权限使用该工具');
-    }
-
-    if (!this.ait || !this.signer) {
-      throw new Error('请先连接钱包以访问权限');
-    }
-
-    const timestamp = Math.floor(Date.now() / 1000);
-    const stringToSign = stringify({
-      message,
-      aitId: this.ait.aitId,
-      controller: this.ait.controller,
-      metadata: this.ait.metadata,
-      metadataHash: this.ait.metadataHash,
-      serviceId: this.projectId,
-      timestamp
-    }) || '';
-
-    const signature = await this.signer.signMessage(stringToSign);
-
-    const response = await this.api.agent.sendMessage({
-      message,
-      serviceId: this.projectId,
-    });
-
-    if ('error' in response) {
-      throw new Error(response.error);
-    }
-
-    return {
-      reply: response.reply,
-      timestamp: new Date().toISOString()
-    };
-  }
-}