@chainai/core 1.0.0

package/README.md

@@ -0,0 +1,162 @@
+# @chain-ai/core
+
+Core client library for Chain AI - Natural language blockchain assistant powered by the Internet Computer.
+
+## Installation
+
+```bash
+npm install @chain-ai/core
+```
+
+## Quick Start
+
+```typescript
+import { ChainAIClient } from '@chain-ai/core';
+
+// Initialize the client with your API key
+const client = new ChainAIClient({
+  apiKey: 'sk_dev_123_...',
+  host: 'https://icp0.io', // optional
+});
+
+// Send a chat message
+const response = await client.chat({
+  text: 'What is the price of Bitcoin?',
+  conversationId: 'my-conversation-id', // optional
+});
+
+console.log(response.data?.response);
+```
+
+## Features
+
+- ✅ **API Key Authentication** - Secure usage tracking per developer
+- ✅ **Response Customization** - Personalize AI responses (style, length, templates)
+- ✅ **Streaming Support** - Real-time word-by-word response streaming
+- ✅ **Multi-Chain Support** - Works with BTC, ETH, SOL, ICP
+- ✅ **TypeScript** - Full type safety with TypeScript definitions
+
+## API Reference
+
+### ChainAIClient
+
+#### Constructor
+
+```typescript
+new ChainAIClient(config: ChainAIConfig)
+```
+
+**Config Options:**
+- `apiKey` (required): Your Chain AI API key
+- `host` (optional): IC host URL (default: 'https://icp0.io')
+- `nlpEdgeCanisterId` (optional): Custom NLP canister ID
+- `developerManagerCanisterId` (optional): Custom developer manager canister ID
+
+#### Methods
+
+**`validateApiKey()`**
+```typescript
+await client.validateApiKey(): Promise<ValidationResult>
+```
+Validate your API key and get tier information.
+
+**`chat(request)`**
+```typescript
+await client.chat({
+  text: string,
+  conversationId?: string,
+  userContext?: any,
+  language?: string,
+}): Promise<ChatResponse>
+```
+Send a chat message and get AI response.
+
+**`streamChat(request, callbacks)`**
+```typescript
+await client.streamChat(
+  { text: string, ... },
+  {
+    onChunk?: (chunk: string) => void,
+    onDone?: (data: AIResponse) => void,
+    onError?: (error: string) => void,
+  }
+): Promise<void>
+```
+Stream chat response word-by-word for better UX.
+
+**`getCustomization()`**
+```typescript
+await client.getCustomization(): Promise<ResponseCustomization | null>
+```
+Get current response customization settings for your API key.
+
+**`updateCustomization(customization)`**
+```typescript
+await client.updateCustomization({
+  style?: 'professional' | 'casual' | 'technical' | 'friendly' | 'concise',
+  length?: 'short' | 'medium' | 'detailed',
+  actionTemplates?: {...},
+  dataFormat?: {...},
+}): Promise<{ok: boolean, message?: string}>
+```
+Update response customization settings.
+
+**`resetCustomization()`**
+```typescript
+await client.resetCustomization(): Promise<{ok: boolean, message?: string}>
+```
+Reset customization to defaults.
+
+## Response Customization
+
+Customize how Chain AI responds to queries:
+
+### Style Options
+- **professional**: Formal, complete sentences (default)
+- **casual**: Conversational, friendly tone
+- **technical**: Concise, data-focused
+- **friendly**: Enthusiastic language
+- **concise**: Short, minimal responses
+
+### Length Options
+- **short**: 1-2 sentences max
+- **medium**: 1 paragraph (default)
+- **detailed**: Multiple paragraphs with context
+
+### Example
+
+```typescript
+// Set casual, short responses
+await client.updateCustomization({
+  style: 'casual',
+  length: 'short',
+});
+
+// Now responses will be brief and conversational
+const response = await client.chat({
+  text: 'Send 0.1 ETH to vitalik.eth',
+});
+// Response: "Done! Transaction sent."
+```
+
+## Error Handling
+
+```typescript
+try {
+  const response = await client.chat({
+    text: 'What is the price of Bitcoin?',
+  });
+
+  if (response.ok) {
+    console.log(response.data?.response);
+  } else {
+    console.error('Error:', response.error);
+  }
+} catch (error) {
+  console.error('Network error:', error);
+}
+```
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * ChainAIClient - Main client class for interacting with Chain AI
+ */
+import type { ChainAIConfig, ChatRequest, ChatResponse, StreamCallbacks, ValidationResult, ResponseCustomization } from './types';
+export declare class ChainAIClient {
+    private icService;
+    private nlpService;
+    private apiKey;
+    private config;
+    constructor(config: ChainAIConfig);
+    /**
+     * Validate the API key
+     */
+    validateApiKey(): Promise<ValidationResult>;
+    /**
+     * Send a chat message and get AI response
+     */
+    chat(request: Omit<ChatRequest, 'apiKey'>): Promise<ChatResponse>;
+    /**
+     * Stream chat response with real-time updates
+     */
+    streamChat(request: Omit<ChatRequest, 'apiKey'>, callbacks: StreamCallbacks): Promise<void>;
+    /**
+     * Get current response customization settings
+     */
+    getCustomization(): Promise<ResponseCustomization | null>;
+    /**
+     * Update response customization settings
+     */
+    updateCustomization(customization: Partial<ResponseCustomization>): Promise<{
+        ok: boolean;
+        message?: string;
+        error?: string;
+    }>;
+    /**
+     * Reset customization to defaults
+     */
+    resetCustomization(): Promise<{
+        ok: boolean;
+        message?: string;
+    }>;
+    /**
+     * Check canister health
+     */
+    health(): Promise<string>;
+}

package/dist/client.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * ChainAIClient - Main client class for interacting with Chain AI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainAIClient = void 0;
+const ic_service_1 = require("./services/ic-service");
+const nlp_service_1 = require("./services/nlp-service");
+class ChainAIClient {
+    constructor(config) {
+        this.config = config;
+        this.apiKey = config.apiKey;
+        // Initialize IC service
+        this.icService = new ic_service_1.ICService({
+            host: config.host || 'https://icp0.io',
+            nlpEdgeCanisterId: config.nlpEdgeCanisterId || 'ypzdi-iqaaa-aaaam-qfhla-cai',
+            developerManagerCanisterId: config.developerManagerCanisterId || 'yiyf4-fiaaa-aaaam-qfhlq-cai',
+        });
+        // Initialize NLP service
+        this.nlpService = new nlp_service_1.NLPService(this.icService);
+    }
+    /**
+     * Validate the API key
+     */
+    async validateApiKey() {
+        return this.icService.validateApiKey(this.apiKey);
+    }
+    /**
+     * Send a chat message and get AI response
+     */
+    async chat(request) {
+        const fullRequest = {
+            ...request,
+            apiKey: this.apiKey,
+        };
+        return this.nlpService.chat(fullRequest);
+    }
+    /**
+     * Stream chat response with real-time updates
+     */
+    async streamChat(request, callbacks) {
+        const fullRequest = {
+            ...request,
+            apiKey: this.apiKey,
+        };
+        return this.nlpService.streamChat(fullRequest, callbacks);
+    }
+    /**
+     * Get current response customization settings
+     */
+    async getCustomization() {
+        return this.icService.getResponseCustomization(this.apiKey);
+    }
+    /**
+     * Update response customization settings
+     */
+    async updateCustomization(customization) {
+        return this.icService.setResponseCustomization(this.apiKey, customization);
+    }
+    /**
+     * Reset customization to defaults
+     */
+    async resetCustomization() {
+        return this.icService.deleteResponseCustomization(this.apiKey);
+    }
+    /**
+     * Check canister health
+     */
+    async health() {
+        return this.nlpService.health();
+    }
+}
+exports.ChainAIClient = ChainAIClient;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @chain-ai/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 { DEFAULT_CUSTOMIZATION } from './types';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @chain-ai/core - Core client library for Chain AI
+ *
+ * Natural language blockchain assistant powered by the Internet Computer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CUSTOMIZATION = exports.NLPService = exports.ICService = exports.ChainAIClient = void 0;
+// Main client export
+var client_1 = require("./client");
+Object.defineProperty(exports, "ChainAIClient", { enumerable: true, get: function () { return client_1.ChainAIClient; } });
+// Service exports
+var ic_service_1 = require("./services/ic-service");
+Object.defineProperty(exports, "ICService", { enumerable: true, get: function () { return ic_service_1.ICService; } });
+var nlp_service_1 = require("./services/nlp-service");
+Object.defineProperty(exports, "NLPService", { enumerable: true, get: function () { return nlp_service_1.NLPService; } });
+// Constants
+var types_1 = require("./types");
+Object.defineProperty(exports, "DEFAULT_CUSTOMIZATION", { enumerable: true, get: function () { return types_1.DEFAULT_CUSTOMIZATION; } });

package/dist/services/ic-service.d.ts

@@ -0,0 +1,47 @@
+/**
+ * IC Service - Manages connections to Internet Computer canisters
+ */
+import type { ValidationResult, ResponseCustomization } from '../types';
+export interface ICServiceConfig {
+    host: string;
+    nlpEdgeCanisterId: string;
+    developerManagerCanisterId: string;
+}
+export declare class ICService {
+    private agent;
+    private nlpEdgeActor;
+    private developerManagerActor;
+    private config;
+    constructor(config: ICServiceConfig);
+    /**
+     * Validate an API key with the developer_manager canister
+     */
+    validateApiKey(apiKey: string): Promise<ValidationResult>;
+    /**
+     * Get response customization for an API key
+     */
+    getResponseCustomization(apiKey: string): Promise<ResponseCustomization | null>;
+    /**
+     * Set response customization for an API key
+     */
+    setResponseCustomization(apiKey: string, customization: Partial<ResponseCustomization>): Promise<{
+        ok: boolean;
+        message?: string;
+        error?: string;
+    }>;
+    /**
+     * Delete response customization (reset to defaults)
+     */
+    deleteResponseCustomization(apiKey: string): Promise<{
+        ok: boolean;
+        message?: string;
+    }>;
+    /**
+     * Get the NLP Edge actor for direct canister calls
+     */
+    getNLPEdgeActor(): any;
+    /**
+     * Get the Developer Manager actor for direct canister calls
+     */
+    getDeveloperManagerActor(): any;
+}

package/dist/services/ic-service.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * IC Service - Manages connections to Internet Computer canisters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICService = void 0;
+const agent_1 = require("@dfinity/agent");
+const principal_1 = require("@dfinity/principal");
+// IDL factory for NLP Edge canister
+const createNLPEdgeIdl = (idlFactory) => {
+    const { IDL } = idlFactory;
+    return IDL.Service({
+        'chat': IDL.Func([IDL.Record({
+                'message': IDL.Text,
+                'conversationId': IDL.Text,
+                'language': IDL.Opt(IDL.Text),
+                'userContext': IDL.Opt(IDL.Text),
+                'apiKey': IDL.Opt(IDL.Text),
+            })], [IDL.Text], []),
+        'health': IDL.Func([], [IDL.Text], ['query']),
+    });
+};
+// IDL factory for Developer Manager canister
+const createDeveloperManagerIdl = (idlFactory) => {
+    const { IDL } = idlFactory;
+    return IDL.Service({
+        'validateApiKey': IDL.Func([IDL.Text], [IDL.Text], ['query']),
+        'getResponseCustomization': IDL.Func([IDL.Text], [IDL.Text], ['query']),
+        'setResponseCustomization': IDL.Func([IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text], [IDL.Text], []),
+        'deleteResponseCustomization': IDL.Func([IDL.Text], [IDL.Text], []),
+        'recordUsage': IDL.Func([IDL.Text], [], []),
+    });
+};
+class ICService {
+    constructor(config) {
+        this.config = config;
+        this.agent = new agent_1.HttpAgent({ host: config.host });
+        // For local development, fetch root key
+        if (config.host.includes('localhost') || config.host.includes('127.0.0.1')) {
+            this.agent.fetchRootKey().catch(console.warn);
+        }
+        // Create actors (using simplified IDL for now)
+        this.nlpEdgeActor = agent_1.Actor.createActor(createNLPEdgeIdl, {
+            agent: this.agent,
+            canisterId: principal_1.Principal.fromText(config.nlpEdgeCanisterId),
+        });
+        this.developerManagerActor = agent_1.Actor.createActor(createDeveloperManagerIdl, {
+            agent: this.agent,
+            canisterId: principal_1.Principal.fromText(config.developerManagerCanisterId),
+        });
+    }
+    /**
+     * Validate an API key with the developer_manager canister
+     */
+    async validateApiKey(apiKey) {
+        try {
+            const result = await this.developerManagerActor.validateApiKey(apiKey);
+            const parsed = JSON.parse(result);
+            if (parsed.ok) {
+                return {
+                    ok: true,
+                    developerId: parsed.developerId,
+                    tier: parsed.tier,
+                    rateLimit: parsed.rateLimit,
+                    hasCustomization: parsed.hasCustomization || false,
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    error: parsed.error,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Get response customization for an API key
+     */
+    async getResponseCustomization(apiKey) {
+        try {
+            const result = await this.developerManagerActor.getResponseCustomization(apiKey);
+            const parsed = JSON.parse(result);
+            if (parsed.ok && parsed.customization) {
+                return {
+                    apiKey,
+                    ...parsed.customization,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error fetching customization:', error);
+            return null;
+        }
+    }
+    /**
+     * Set response customization for an API key
+     */
+    async setResponseCustomization(apiKey, customization) {
+        try {
+            const styleText = customization.style || 'professional';
+            const lengthText = customization.length || 'medium';
+            const responseFormatText = customization.responseFormat || 'text';
+            const actionTemplatesJson = JSON.stringify(customization.actionTemplates || {});
+            const actionSchemasJson = JSON.stringify(customization.actionSchemas || {});
+            const dataFormatJson = JSON.stringify(customization.dataFormat || {});
+            const result = await this.developerManagerActor.setResponseCustomization(apiKey, styleText, lengthText, responseFormatText, actionTemplatesJson, actionSchemasJson, dataFormatJson);
+            return JSON.parse(result);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Delete response customization (reset to defaults)
+     */
+    async deleteResponseCustomization(apiKey) {
+        try {
+            const result = await this.developerManagerActor.deleteResponseCustomization(apiKey);
+            return JSON.parse(result);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Get the NLP Edge actor for direct canister calls
+     */
+    getNLPEdgeActor() {
+        return this.nlpEdgeActor;
+    }
+    /**
+     * Get the Developer Manager actor for direct canister calls
+     */
+    getDeveloperManagerActor() {
+        return this.developerManagerActor;
+    }
+}
+exports.ICService = ICService;

package/dist/services/nlp-service.d.ts

@@ -0,0 +1,21 @@
+/**
+ * NLP Service - Handles chat requests and streaming responses
+ */
+import type { ICService } from './ic-service';
+import type { ChatRequest, ChatResponse, StreamCallbacks } from '../types';
+export declare class NLPService {
+    private icService;
+    constructor(icService: ICService);
+    /**
+     * Send a chat message and get AI response
+     */
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    /**
+     * Stream chat response word-by-word for better UX
+     */
+    streamChat(request: ChatRequest, callbacks: StreamCallbacks): Promise<void>;
+    /**
+     * Check canister health
+     */
+    health(): Promise<string>;
+}

package/dist/services/nlp-service.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * NLP Service - Handles chat requests and streaming responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NLPService = void 0;
+class NLPService {
+    constructor(icService) {
+        this.icService = icService;
+    }
+    /**
+     * Send a chat message and get AI response
+     */
+    async chat(request) {
+        const actor = this.icService.getNLPEdgeActor();
+        const chatRequest = {
+            message: request.text,
+            conversationId: request.conversationId || '',
+            language: request.language ? [request.language] : [],
+            userContext: request.userContext ? [JSON.stringify(request.userContext)] : [],
+            apiKey: request.apiKey ? [request.apiKey] : [],
+        };
+        try {
+            const result = await actor.chat(chatRequest);
+            if (result.ok) {
+                return {
+                    ok: true,
+                    data: {
+                        response: result.ok.response,
+                        intent: result.ok.intent,
+                        kind: result.ok.kind,
+                        toolData: result.ok.toolData,
+                        confidence: result.ok.confidence,
+                        conversationId: result.ok.conversationId,
+                    },
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    error: result.err,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Stream chat response word-by-word for better UX
+     */
+    async streamChat(request, callbacks) {
+        try {
+            // Send start event
+            callbacks.onChunk?.('');
+            const result = await this.chat(request);
+            if (result.ok && result.data) {
+                const response = result.data.response;
+                // Stream response word-by-word with 15ms delay
+                const words = response.split(' ');
+                for (let i = 0; i < words.length; i++) {
+                    const chunk = words[i] + (i < words.length - 1 ? ' ' : '');
+                    callbacks.onChunk?.(chunk);
+                    await new Promise(resolve => setTimeout(resolve, 15));
+                }
+                callbacks.onDone?.(result.data);
+            }
+            else {
+                callbacks.onError?.(result.error || 'An error occurred');
+            }
+        }
+        catch (error) {
+            callbacks.onError?.(error instanceof Error ? error.message : 'Unknown error');
+        }
+    }
+    /**
+     * Check canister health
+     */
+    async health() {
+        const actor = this.icService.getNLPEdgeActor();
+        return await actor.health();
+    }
+}
+exports.NLPService = NLPService;

package/dist/types/chat.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Chat request and response types for Chain AI
+ */
+export interface ChatRequest {
+    text: string;
+    conversationId?: string;
+    userContext?: any;
+    language?: string;
+    apiKey?: string;
+}
+export interface AIResponse {
+    response: string;
+    intent: string;
+    kind: string;
+    toolData: string;
+    confidence: number;
+    conversationId: string;
+}
+export interface ChatResponse {
+    ok: boolean;
+    data?: AIResponse;
+    error?: string;
+}
+export interface Message {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+}
+export interface StreamCallbacks {
+    onChunk?: (chunk: string) => void;
+    onDone?: (data: AIResponse) => void;
+    onError?: (error: string) => void;
+}

package/dist/types/chat.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Chat request and response types for Chain AI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/customization.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Response customization types for Chain AI
+ * Allows per-API-key customization of AI responses
+ */
+export type ResponseStyle = 'professional' | 'casual' | 'technical' | 'friendly' | 'concise';
+export type ResponseLength = 'short' | 'medium' | 'detailed';
+export type ResponseFormat = 'text' | 'json' | 'hybrid';
+export type DateFormat = 'relative' | 'absolute' | 'both';
+export type AddressFormat = 'full' | 'truncated' | 'ens';
+export type NumberFormat = 'us' | 'eu' | 'scientific';
+export interface ActionSchema {
+    required: string[];
+    optional?: string[];
+    inferRules?: {
+        [field: string]: string;
+    };
+}
+export interface ActionSchemas {
+    send?: ActionSchema;
+    swap?: ActionSchema;
+    approve?: ActionSchema;
+    transfer?: ActionSchema;
+    stake?: ActionSchema;
+    [key: string]: ActionSchema | undefined;
+}
+export interface ActionTemplates {
+    send?: string;
+    swap?: string;
+    approve?: string;
+    price?: string;
+    balance?: string;
+    fees?: string;
+    transaction_status?: string;
+    transaction_history?: string;
+}
+export interface DataFormatOptions {
+    priceDecimals: number;
+    showUsdEquivalent: boolean;
+    dateFormat: DateFormat;
+    addressDisplay: AddressFormat;
+    numberFormat: NumberFormat;
+}
+export interface ResponseCustomization {
+    apiKey: string;
+    style: ResponseStyle;
+    length: ResponseLength;
+    responseFormat: ResponseFormat;
+    actionTemplates: ActionTemplates;
+    actionSchemas?: ActionSchemas;
+    dataFormat: DataFormatOptions;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare const DEFAULT_ACTION_SCHEMAS: ActionSchemas;
+export declare const DEFAULT_CUSTOMIZATION: Omit<ResponseCustomization, 'apiKey' | 'createdAt' | 'updatedAt'>;

package/dist/types/customization.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Response customization types for Chain AI
+ * Allows per-API-key customization of AI responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CUSTOMIZATION = exports.DEFAULT_ACTION_SCHEMAS = void 0;
+// Example action schema for common wallet operations
+exports.DEFAULT_ACTION_SCHEMAS = {
+    send: {
+        required: ['amount', 'currency', 'address'],
+        optional: ['fee', 'memo'],
+        inferRules: {
+            chain: 'Infer from address format (e.g., bc1q... = Bitcoin, 0x... = Ethereum)',
+        },
+    },
+    swap: {
+        required: ['fromCurrency', 'toCurrency', 'amount'],
+        optional: ['slippage', 'deadline'],
+    },
+};
+exports.DEFAULT_CUSTOMIZATION = {
+    style: 'professional',
+    length: 'medium',
+    responseFormat: 'text',
+    actionTemplates: {},
+    actionSchemas: undefined, // Wallet providers can define their own
+    dataFormat: {
+        priceDecimals: 2,
+        showUsdEquivalent: true,
+        dateFormat: 'relative',
+        addressDisplay: 'truncated',
+        numberFormat: 'us',
+    },
+};

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Main types export for @chain-ai/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 interface ChainAIConfig {
+    apiKey: string;
+    host?: string;
+    nlpEdgeCanisterId?: string;
+    developerManagerCanisterId?: string;
+}
+export interface ValidationResult {
+    ok: boolean;
+    developerId?: string;
+    tier?: string;
+    rateLimit?: number;
+    hasCustomization?: boolean;
+    error?: string;
+}

package/dist/types/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Main types export for @chain-ai/core
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CUSTOMIZATION = void 0;
+var customization_1 = require("./customization");
+Object.defineProperty(exports, "DEFAULT_CUSTOMIZATION", { enumerable: true, get: function () { return customization_1.DEFAULT_CUSTOMIZATION; } });

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@chainai/core",
+  "version": "1.0.0",
+  "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"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "blockchain",
+    "ai",
+    "nlp",
+    "crypto",
+    "icp",
+    "internet-computer",
+    "chain-ai"
+  ],
+  "author": "Chain AI",
+  "license": "MIT",
+  "dependencies": {
+    "@dfinity/agent": "^3.4.3",
+    "@dfinity/candid": "^3.4.3",
+    "@dfinity/principal": "^3.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chain-ai/npm-packages.git"
+  }
+}