@chainai/core 1.0.0 → 1.0.2

package/README.md

@@ -1,17 +1,17 @@
-# @chain-ai/core
+# @chainai/core
 
 Core client library for Chain AI - Natural language blockchain assistant powered by the Internet Computer.
 
 ## Installation
 
 ```bash
-npm install @chain-ai/core
+npm install @chainai/core
 ```
 
 ## Quick Start
 
 ```typescript
-import { ChainAIClient } from '@chain-ai/core';
+import { ChainAIClient } from '@chainai/core';
 
 // Initialize the client with your API key
 const client = new ChainAIClient({

package/dist/client.d.ts

@@ -1,23 +1,34 @@
 /**
  * ChainAIClient - Main client class for interacting with Chain AI
  */
-import type { ChainAIConfig, ChatRequest, ChatResponse, StreamCallbacks, ValidationResult, ResponseCustomization } from './types';
+import type { ChainAIConfig, ChatRequest, ChatResponse, StreamCallbacks, ValidationResult, ResponseCustomization, WalletProvider } from './types';
 export declare class ChainAIClient {
     private icService;
     private nlpService;
     private apiKey;
     private config;
+    private walletProvider?;
     constructor(config: ChainAIConfig);
+    /**
+     * Set or update the wallet provider
+     */
+    setWalletProvider(provider: WalletProvider): void;
+    /**
+     * Get current wallet context from the provider
+     */
+    private getWalletContext;
     /**
      * Validate the API key
      */
     validateApiKey(): Promise<ValidationResult>;
     /**
      * Send a chat message and get AI response
+     * Automatically includes wallet context if a walletProvider is configured
      */
     chat(request: Omit<ChatRequest, 'apiKey'>): Promise<ChatResponse>;
     /**
      * Stream chat response with real-time updates
+     * Automatically includes wallet context if a walletProvider is configured
      */
     streamChat(request: Omit<ChatRequest, 'apiKey'>, callbacks: StreamCallbacks): Promise<void>;
     /**

package/dist/client.js

@@ -10,6 +10,7 @@ class ChainAIClient {
     constructor(config) {
         this.config = config;
         this.apiKey = config.apiKey;
+        this.walletProvider = config.walletProvider;
         // Initialize IC service
         this.icService = new ic_service_1.ICService({
             host: config.host || 'https://icp0.io',
@@ -19,6 +20,28 @@ class ChainAIClient {
         // Initialize NLP service
         this.nlpService = new nlp_service_1.NLPService(this.icService);
     }
+    /**
+     * Set or update the wallet provider
+     */
+    setWalletProvider(provider) {
+        this.walletProvider = provider;
+    }
+    /**
+     * Get current wallet context from the provider
+     */
+    async getWalletContext() {
+        if (!this.walletProvider) {
+            return undefined;
+        }
+        try {
+            const context = await this.walletProvider();
+            return context;
+        }
+        catch (error) {
+            console.warn('Failed to get wallet context:', error);
+            return undefined;
+        }
+    }
     /**
      * Validate the API key
      */
@@ -27,21 +50,29 @@ class ChainAIClient {
     }
     /**
      * Send a chat message and get AI response
+     * Automatically includes wallet context if a walletProvider is configured
      */
     async chat(request) {
+        // Get wallet context from provider if available
+        const walletContext = request.walletContext || await this.getWalletContext();
         const fullRequest = {
             ...request,
             apiKey: this.apiKey,
+            walletContext,
         };
         return this.nlpService.chat(fullRequest);
     }
     /**
      * Stream chat response with real-time updates
+     * Automatically includes wallet context if a walletProvider is configured
      */
     async streamChat(request, callbacks) {
+        // Get wallet context from provider if available
+        const walletContext = request.walletContext || await this.getWalletContext();
         const fullRequest = {
             ...request,
             apiKey: this.apiKey,
+            walletContext,
         };
         return this.nlpService.streamChat(fullRequest, callbacks);
     }

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 /**
- * @chain-ai/core - Core client library for Chain AI
+ * @chainai/core - Core client library for Chain AI
  *
  * Natural language blockchain assistant powered by the Internet Computer
  */
 export { ChainAIClient } from './client';
 export { ICService } from './services/ic-service';
 export { NLPService } from './services/nlp-service';
-export type { ChainAIConfig, ValidationResult, ResponseCustomization, ResponseStyle, ResponseLength, ActionTemplates, DataFormatOptions, DateFormat, AddressFormat, NumberFormat, ChatRequest, ChatResponse, AIResponse, Message, StreamCallbacks, } from './types';
+export type { ChainAIConfig, ValidationResult, ResponseCustomization, ResponseStyle, ResponseLength, ActionTemplates, DataFormatOptions, DateFormat, AddressFormat, NumberFormat, ChatRequest, ChatResponse, AIResponse, Message, StreamCallbacks, WalletAddress, WalletContext, WalletProvider, } from './types';
 export { DEFAULT_CUSTOMIZATION } from './types';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @chain-ai/core - Core client library for Chain AI
+ * @chainai/core - Core client library for Chain AI
  *
  * Natural language blockchain assistant powered by the Internet Computer
  */

package/dist/services/ic-service.js

@@ -9,6 +9,20 @@ const principal_1 = require("@dfinity/principal");
 // IDL factory for NLP Edge canister
 const createNLPEdgeIdl = (idlFactory) => {
     const { IDL } = idlFactory;
+    // AIResponse type matches the canister's AIResponse record
+    const AIResponseType = IDL.Record({
+        'intent': IDL.Text,
+        'kind': IDL.Text,
+        'response': IDL.Text,
+        'toolData': IDL.Text,
+        'confidence': IDL.Nat,
+        'conversationId': IDL.Text,
+    });
+    // ChatResponse is Result<AIResponse, Text> = variant { ok: AIResponse; err: Text }
+    const ChatResponseType = IDL.Variant({
+        'ok': AIResponseType,
+        'err': IDL.Text,
+    });
     return IDL.Service({
         'chat': IDL.Func([IDL.Record({
                 'message': IDL.Text,
@@ -16,7 +30,7 @@ const createNLPEdgeIdl = (idlFactory) => {
                 'language': IDL.Opt(IDL.Text),
                 'userContext': IDL.Opt(IDL.Text),
                 'apiKey': IDL.Opt(IDL.Text),
-            })], [IDL.Text], []),
+            })], [ChatResponseType], []),
         'health': IDL.Func([], [IDL.Text], ['query']),
     });
 };

package/dist/services/nlp-service.js

@@ -13,11 +13,28 @@ class NLPService {
      */
     async chat(request) {
         const actor = this.icService.getNLPEdgeActor();
+        // Build user context with wallet information
+        const userContextData = {};
+        // Include legacy userContext if provided
+        if (request.userContext) {
+            Object.assign(userContextData, request.userContext);
+        }
+        // Include wallet context (this is the key addition for wallet addresses)
+        if (request.walletContext) {
+            userContextData.wallets = request.walletContext.wallets;
+            if (request.walletContext.activeChain) {
+                userContextData.activeChain = request.walletContext.activeChain;
+            }
+            if (request.walletContext.activeAddress) {
+                userContextData.activeAddress = request.walletContext.activeAddress;
+            }
+        }
+        const hasContext = Object.keys(userContextData).length > 0;
         const chatRequest = {
             message: request.text,
             conversationId: request.conversationId || '',
             language: request.language ? [request.language] : [],
-            userContext: request.userContext ? [JSON.stringify(request.userContext)] : [],
+            userContext: hasContext ? [JSON.stringify(userContextData)] : [],
             apiKey: request.apiKey ? [request.apiKey] : [],
         };
         try {

package/dist/types/chat.d.ts

@@ -1,10 +1,42 @@
 /**
  * Chat request and response types for Chain AI
  */
+/**
+ * Wallet address for a specific chain
+ */
+export interface WalletAddress {
+    chain: 'ethereum' | 'bitcoin' | 'solana' | 'icp' | string;
+    address: string;
+    /** Optional label (e.g., "MetaMask", "Phantom") */
+    label?: string;
+    /** Whether this is the primary wallet for the chain */
+    isPrimary?: boolean;
+}
+/**
+ * Wallet context included with each request
+ * Contains all connected wallet addresses so the AI can access them
+ * for queries like balance, transaction history, etc.
+ */
+export interface WalletContext {
+    /** All connected wallet addresses */
+    wallets: WalletAddress[];
+    /** Currently active/selected chain (optional) */
+    activeChain?: string;
+    /** Currently active wallet address (optional) */
+    activeAddress?: string;
+}
+/**
+ * Function type for dynamically fetching wallet addresses
+ * Useful when wallet state may change between requests
+ */
+export type WalletProvider = () => WalletContext | Promise<WalletContext>;
 export interface ChatRequest {
     text: string;
     conversationId?: string;
+    /** @deprecated Use walletContext instead for wallet data */
     userContext?: any;
+    /** Wallet addresses to include with the request */
+    walletContext?: WalletContext;
     language?: string;
     apiKey?: string;
 }

package/dist/types/index.d.ts

@@ -1,14 +1,33 @@
 /**
- * Main types export for @chain-ai/core
+ * Main types export for @chainai/core
  */
 export type { ResponseCustomization, ResponseStyle, ResponseLength, ActionTemplates, DataFormatOptions, DateFormat, AddressFormat, NumberFormat, } from './customization';
 export { DEFAULT_CUSTOMIZATION } from './customization';
-export type { ChatRequest, ChatResponse, AIResponse, Message, StreamCallbacks, } from './chat';
+export type { ChatRequest, ChatResponse, AIResponse, Message, StreamCallbacks, WalletAddress, WalletContext, WalletProvider, } from './chat';
 export interface ChainAIConfig {
     apiKey: string;
     host?: string;
     nlpEdgeCanisterId?: string;
     developerManagerCanisterId?: string;
+    /**
+     * Wallet provider function that returns connected wallet addresses.
+     * Called automatically before each request to include current wallet state.
+     *
+     * @example
+     * ```ts
+     * const config = {
+     *   apiKey: 'your-api-key',
+     *   walletProvider: () => ({
+     *     wallets: [
+     *       { chain: 'ethereum', address: '0x...', label: 'MetaMask' },
+     *       { chain: 'solana', address: 'ABC...', label: 'Phantom' },
+     *     ],
+     *     activeChain: 'ethereum',
+     *   }),
+     * };
+     * ```
+     */
+    walletProvider?: import('./chat').WalletProvider;
 }
 export interface ValidationResult {
     ok: boolean;

package/dist/types/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Main types export for @chain-ai/core
+ * Main types export for @chainai/core
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CUSTOMIZATION = void 0;

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@chainai/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Core client library for Chain AI - Natural language blockchain assistant",
   "main": "dist/index.js",
-  "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"