@bytexbyte/nxtlinq-ai-agent-sdk 1.0.2

package/README.md

@@ -0,0 +1,262 @@
+# Nxtlinq AI Agent SDK
+
+A powerful SDK for building intelligent conversation applications with Nxtlinq AI Agent.
+
+## Features
+
+- 💬 Real-time chat interface with AI Agent
+- 🎯 Preset messages for quick interactions
+- 🛠️ Tool integration support
+- 🔄 Automatic retry mechanism for failed requests
+- 📱 Responsive and modern UI design
+- 🎨 Customizable styling
+- 🔌 Easy integration with React applications
+- 🔒 Secure authentication and API key management
+- 👛 MetaMask wallet integration
+- 🔐 AIT (AI Token) management
+- 🔑 Permission-based access control
+
+## Installation
+
+```bash
+npm install @bytexbyte/nxtlinq-ai-agent-sdk
+# or
+yarn add @bytexbyte/nxtlinq-ai-agent-sdk
+```
+
+## Quick Start
+
+```tsx
+import { ChatBot } from '@bytexbyte/nxtlinq-ai-agent-sdk';
+
+function App() {
+  const handleMessage = (message) => {
+    console.log('Received new message:', message);
+  };
+
+  const handleToolUse = async (toolUse) => {
+    console.log('Tool use:', toolUse);
+    return {
+      id: Date.now().toString(),
+      content: 'Tool execution response',
+      role: 'assistant',
+      timestamp: new Date().toISOString()
+    };
+  };
+
+  const presetMessages = [
+    { text: 'Hello, how can you help me?' },
+    { text: 'I want to add a new member' },
+    { text: 'I want to view the analytics page' },
+    { text: 'I want to change my name' }
+  ];
+
+  return (
+    <ChatBot
+      serviceId="your-service-id"
+      apiKey="your-api-key"
+      apiSecret="your-api-secret"
+      onMessage={handleMessage}
+      onToolUse={handleToolUse}
+      presetMessages={presetMessages}
+      onVerifyWallet={async (address) => {
+        // Implement your wallet verification logic here
+        return { token: 'verification-token' };
+      }}
+    />
+  );
+}
+```
+
+## API Reference
+
+### NxtlinqAITSDK
+
+| Method | Description |
+|--------|-------------|
+| `connectWallet()` | Connect to MetaMask wallet |
+| `verifyWallet(token: string, method: string)` | Verify wallet ownership |
+| `signInWithWallet()` | Sign in using wallet |
+| `generateAndRegisterAIT(permissions: string[])` | Generate and register a new AIT |
+| `getAIT()` | Get AIT information |
+| `getWalletInfo()` | Get wallet information |
+
+### NxtlinqAIAgent
+
+| Method | Description |
+|--------|-------------|
+| `setAIT(ait: AIT, signer?: ethers.Signer)` | Set AIT for the agent |
+| `generateAIT(options: GenerateAITOptions)` | Generate a new AIT |
+| `getAITInfo(serviceId: string, controller: string, signer?: ethers.Signer)` | Get AIT information |
+| `sendMessage(message: string, toolName?: string)` | Send a message to the agent |
+
+### API Endpoints
+
+#### AIT API
+- `getAITByServiceIdAndController`: Get AIT by service ID and controller
+- `createAIT`: Create a new AIT
+
+#### Wallet API
+- `verifyWallet`: Verify wallet ownership
+- `getWallet`: Get wallet information
+
+#### Metadata API
+- `createMetadata`: Create metadata for AIT
+
+#### Auth API
+- `getNonce`: Get nonce for wallet sign-in
+- `signIn`: Sign in with wallet
+
+#### Agent API
+- `sendMessage`: Send message to AI agent
+
+### ChatBot Component Props
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| serviceId | string | Yes | Your Nxtlinq service ID |
+| apiKey | string | Yes | Your Nxtlinq API key |
+| apiSecret | string | Yes | Your Nxtlinq API secret |
+| onMessage | (message: Message) => void | No | Callback when a new message is received |
+| onError | (error: Error) => void | No | Callback when an error occurs |
+| onToolUse | (toolUse: ToolUse) => Promise<Message \| void> | No | Callback for handling tool usage |
+| onVerifyWallet | (address: string) => Promise<{ token: string }> | Yes | Callback for wallet verification |
+| presetMessages | PresetMessage[] | No | Array of preset messages to display |
+| placeholder | string | No | Input placeholder text (default: "Type a message...") |
+| className | string | No | Additional CSS class name |
+| maxRetries | number | No | Maximum number of retry attempts (default: 3) |
+| retryDelay | number | No | Delay between retries in milliseconds (default: 1000) |
+
+## Types
+
+### Message
+```typescript
+interface Message {
+  id: string;
+  content: string;
+  role: 'user' | 'assistant';
+  timestamp: string;
+  button?: boolean;
+  error?: string;
+}
+```
+
+### PresetMessage
+```typescript
+interface PresetMessage {
+  text: string;
+  autoSend?: boolean;
+}
+```
+
+### ToolUse
+```typescript
+interface ToolUse {
+  name: string;
+  input: Record<string, any>;
+}
+```
+
+### AIT
+```typescript
+interface AIT {
+  aitId: string;
+  controller: string;
+  metadata: AITMetadata;
+  metadataHash: string;
+  metadataCid: string;
+  signature: string;
+}
+
+interface AITMetadata {
+  model: string;
+  permissions: string[];
+  issuedBy: string;
+  serviceId?: string;
+}
+
+interface AITInfo {
+  aitId: string;
+  controller: string;
+  metadata: AITMetadata;
+  metadataHash: string;
+  metadataCid: string;
+  signature: string;
+}
+
+interface AITPermission {
+  hasPermission: boolean;
+  reason?: string;
+  permissions?: string[];
+}
+
+interface GenerateAITOptions {
+  hitAddress: string;
+  signer: ethers.Signer;
+  permissions: string[];
+  serviceId: string;
+}
+
+interface WalletInfo {
+  id: string;
+  address: string;
+  verified: boolean;
+  method?: string;
+}
+
+interface MessageContext {
+  aitId?: string;
+  walletAddress?: string | null;
+}
+```
+
+## Features
+
+### Wallet Integration
+- MetaMask wallet connection
+- Wallet verification
+- Wallet-based authentication
+- AIT (AI Token) generation and management
+
+### Available Permissions
+- Set User Name
+- Navigate To Page
+- Add Member
+
+### Authentication Flow
+1. Connect MetaMask wallet
+2. Verify wallet ownership
+3. Sign in with wallet
+4. Generate and register AIT with required permissions
+5. Use AIT for authenticated operations
+
+## Error Handling
+
+The SDK includes built-in error handling with:
+- Automatic retry mechanism for failed requests
+- Error callback for custom error handling
+- User-friendly error messages
+- Wallet connection error handling
+- Authentication error handling
+
+## Best Practices
+
+1. Implement proper wallet verification logic
+2. Handle AIT permissions appropriately
+3. Set appropriate timeout values
+4. Implement error retry mechanisms
+5. Use context management to maintain conversation coherence
+6. Handle wallet connection errors gracefully
+7. Implement proper error handling for authentication flow
+
+## License
+
+Proprietary - All Rights Reserved
+
+Copyright (c) 2025 ByteXByte. All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary and confidential. The Software is protected by copyright laws and international copyright treaties, as well as other intellectual property laws and treaties.
+
+Unauthorized copying, distribution, modification, public display, or public performance of the Software is strictly prohibited. The Software may only be used in accordance with the terms of a valid license agreement with ByteXByte.
+
+For licensing inquiries, please contact: [Your Contact Information] 

package/dist/index.js

@@ -0,0 +1,301 @@
+import { ethers } from 'ethers';
+import stringify from 'json-stable-stringify';
+import { createNxtlinqApi } from './api/nxtlinq-api';
+export { ChatBot } from './components/ChatBot';
+export class NxtlinqAITSDK {
+    constructor(serviceId, apiKey, apiSecret) {
+        this.signer = null;
+        this.walletAddress = null;
+        this.serviceId = serviceId;
+        this.api = createNxtlinqApi(apiKey, apiSecret);
+    }
+    async connectWallet() {
+        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, method) {
+        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() {
+        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) {
+        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 = {
+            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() {
+        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() {
+        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) {
+        return permissionGroups.map(group => ({
+            label: group.label,
+            options: group.options.map((option) => ({
+                ...option,
+                isChecked: false,
+            }))
+        }));
+    }
+    getSelectedPermissions(form) {
+        return form.flatMap(group => group.options.filter((opt) => opt.isChecked).map((opt) => opt.value));
+    }
+}
+export class NxtlinqAIAgent {
+    constructor(projectId, apiKey, apiSecret) {
+        this.permissions = [];
+        this.projectId = projectId;
+        this.apiKey = apiKey;
+        this.api = createNxtlinqApi(apiKey, apiSecret);
+    }
+    setAIT(ait, signer) {
+        this.ait = ait;
+        this.permissions = ait.metadata.permissions;
+        if (signer) {
+            this.signer = signer;
+        }
+    }
+    async hasPermission(toolName) {
+        if (!this.ait) {
+            throw new Error('请先连接钱包以访问权限');
+        }
+        return this.permissions.includes(toolName);
+    }
+    async checkAITPermission(toolName) {
+        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) {
+        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 = {
+            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, controller, signer) {
+        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, toolName) {
+        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()
+        };
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@bytexbyte/nxtlinq-ai-agent-sdk",
+  "version": "1.0.2",
+  "description": "Nxtlinq AI Agent SDK - Proprietary Software",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
+  },
+  "keywords": [
+    "nxtlinq",
+    "ai",
+    "agent",
+    "sdk"
+  ],
+  "author": "ByteXByte",
+  "license": "UNLICENSED",
+  "private": false,
+  "peerDependencies": {
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/json-stable-stringify": "^1.0.34",
+    "@types/react": "^18.2.64",
+    "jest": "^29.7.0",
+    "typescript": "^5.4.2"
+  },
+  "dependencies": {
+    "@emotion/react": "^11.11.4",
+    "@emotion/styled": "^11.11.0",
+    "@mui/material": "^5.15.12",
+    "ethers": "^6.11.1",
+    "json-stable-stringify": "^1.0.2",
+    "metakeep": "^2.2.8"
+  }
+}