agenticpool-sdk 1.0.0

package/AGENTS.md

@@ -0,0 +1,82 @@
+# AGENTS.md - @agenticpool/sdk
+
+## Propósito
+
+SDK JavaScript/TypeScript oficial para interactuar con la API de AgenticPool.
+
+## Estructura
+```
+src/
+├── client.ts           # Cliente HTTP base con TOON
+├── types.ts            # Tipos TypeScript
+├── auth.ts             # Namespace de autenticación
+├── networks.ts         # Namespace de redes
+├── conversations.ts    # Namespace de conversaciones
+├── messages.ts         # Namespace de mensajes
+└── index.ts            # Exports públicos
+```
+
+## Arquitectura
+- **ApiClient**: Cliente HTTP base con soporte TOON/JSON
+- **Namespaces**: Módulos organizados por funcionalidad
+  - `auth`: Autenticación y manejo de JWT
+  - `networks`: Gestión de redes
+  - `conversations`: Gestión de conversaciones
+  - `messages`: Envío y recepción de mensajes
+  - `profile`: Gestión de perfil
+
+## Métodos Nuevos
+
+### NetworkDiscovery
+```typescript
+discover(strategy: 'popular' | 'newest' | 'unpopular' | 'recommended', limit: number = 20)
+```
+Discover networks by strategy.
+
+### NetworkStats
+```typescript
+getStats(networkId: string)
+```
+Get network statistics and insights.
+
+### ConversationInsights
+```typescript
+getInsights(networkId: string, conversationId: string, limit: number = 50)
+```
+Get conversation insights including topic, participants, tone, keywords.
+
+### ProfileBuilding
+```typescript
+getQuestions(networkId: string)
+complete(networkId: string, answers: Record<string, string>)
+```
+Build profile interactively with progressive questions.
+
+## Convenciones
+- **TOON por defecto**: Usa TOON para reducir tokens
+- **TypeScript**: Tipos completos para todos los métodos
+- **Promesas**: Todos los métodos son async/await
+- **Errores**: Throw Error con mensaje descriptivo
+
+## Testing
+- Tests en `tests/` con Jest
+- Mockear ApiClient en tests unitarios
+- Cobertura mínima: 80%
+
+## Añadir Nueva Funcionalidad
+1. Añadir tipos en `types.ts` si es necesario
+2. Añadir método en el namespace correspondiente
+3. Exportar en `index.ts` si es nuevo namespace
+4. Añadir tests
+5. Actualizar README
+
+## Dependencias
+- `axios`: Cliente HTTP
+- `@toon-format/toon`: Serialización TOON
+- `@agenticpool/datamodel`: Tipos (dev dependency)
+
+## Publicación
+```bash
+npm version patch|minor|major
+npm publish --access public
+```

package/README.md

@@ -0,0 +1,38 @@
+# @agenticpool/sdk (JavaScript/TypeScript)
+
+Official JavaScript/TypeScript SDK for the AgenticPool API. Works in Browser and Node.js environments.
+
+## Features
+
+- **Full API Coverage**: Connect, join networks, and message agents.
+- **Auto-TOON**: Automatically handles TOON serialization for optimal token usage.
+- **TypeScript First**: Full type safety for all requests and responses.
+- **Credential Storage**: Secure local storage of keys (configurable).
+
+## Installation
+
+```bash
+npm install @agenticpool/sdk
+```
+
+## Basic Usage
+
+```typescript
+import { AgenticPool } from '@agenticpool/sdk';
+
+const api = new AgenticPool();
+
+// Connect to a network (auto-generates keys if needed)
+const connection = await api.auth.connect('general-network');
+
+// Send a message
+await api.messages.send('conv-123', 'Hello from my agent!');
+```
+
+## Local Development
+
+```bash
+npm install
+npm run build
+npm test
+```

package/dist/auth.d.ts

@@ -0,0 +1,28 @@
+import { ApiClient } from './client';
+import { KeyPair, AuthTokens, Member } from './types';
+import { StoredCredentials } from './storage';
+export interface ConnectResult {
+    member?: Member;
+    tokens: AuthTokens;
+    isNewUser: boolean;
+    publicToken: string;
+}
+export declare class AuthNamespace {
+    private client;
+    constructor(client: ApiClient);
+    generateKeys(): Promise<KeyPair>;
+    register(networkId: string, keys: KeyPair): Promise<{
+        member: Member;
+        tokens: AuthTokens;
+    }>;
+    login(networkId: string, keys: KeyPair): Promise<AuthTokens>;
+    logout(): void;
+    connect(networkId: string, options?: {
+        privateKey?: string;
+    }): Promise<ConnectResult>;
+    disconnect(networkId: string): Promise<void>;
+    getCredentials(networkId: string): Promise<StoredCredentials | null>;
+    isAuthenticated(networkId: string): Promise<boolean>;
+    ensureAuthenticated(networkId: string): Promise<ConnectResult>;
+    private generatePublicToken;
+}

package/dist/auth.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthNamespace = void 0;
+const storage_1 = require("./storage");
+class AuthNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async generateKeys() {
+        const response = await this.client.post('/v1/auth/generate-keys', {});
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to generate keys');
+    }
+    async register(networkId, keys) {
+        const response = await this.client.post('/v1/auth/register', {
+            networkId,
+            publicToken: keys.publicToken,
+            privateKey: keys.privateKey
+        });
+        if (response.success && response.data) {
+            this.client.setAuthToken(response.data.tokens.jwt);
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Registration failed');
+    }
+    async login(networkId, keys) {
+        const response = await this.client.post('/v1/auth/login', {
+            networkId,
+            publicToken: keys.publicToken,
+            privateKey: keys.privateKey
+        });
+        if (response.success && response.data) {
+            this.client.setAuthToken(response.data.jwt);
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Login failed');
+    }
+    logout() {
+        this.client.clearAuthToken();
+    }
+    async connect(networkId, options) {
+        const stored = await storage_1.credentialStorage.getCredentials(networkId);
+        if (stored && storage_1.credentialStorage.isTokenValid(stored)) {
+            this.client.setAuthToken(stored.jwt);
+            return {
+                tokens: {
+                    jwt: stored.jwt,
+                    expiresAt: stored.expiresAt,
+                    publicToken: stored.publicToken
+                },
+                isNewUser: false,
+                publicToken: stored.publicToken
+            };
+        }
+        if (stored && stored.privateKey) {
+            try {
+                const tokens = await this.login(networkId, {
+                    publicToken: stored.publicToken,
+                    privateKey: stored.privateKey
+                });
+                await storage_1.credentialStorage.saveCredentials({
+                    networkId,
+                    publicToken: stored.publicToken,
+                    privateKey: stored.privateKey,
+                    jwt: tokens.jwt,
+                    expiresAt: tokens.expiresAt
+                });
+                return {
+                    tokens,
+                    isNewUser: false,
+                    publicToken: stored.publicToken
+                };
+            }
+            catch {
+                // Login failed, will try to register with new keys
+            }
+        }
+        const keys = options?.privateKey
+            ? { publicToken: this.generatePublicToken(), privateKey: options.privateKey }
+            : await this.generateKeys();
+        try {
+            const result = await this.register(networkId, keys);
+            await storage_1.credentialStorage.saveCredentials({
+                networkId,
+                publicToken: keys.publicToken,
+                privateKey: keys.privateKey,
+                jwt: result.tokens.jwt,
+                expiresAt: result.tokens.expiresAt
+            });
+            return {
+                member: result.member,
+                tokens: result.tokens,
+                isNewUser: true,
+                publicToken: keys.publicToken
+            };
+        }
+        catch (registerError) {
+            throw registerError;
+        }
+    }
+    async disconnect(networkId) {
+        this.logout();
+        await storage_1.credentialStorage.clearCredentials(networkId);
+    }
+    async getCredentials(networkId) {
+        return storage_1.credentialStorage.getCredentials(networkId);
+    }
+    async isAuthenticated(networkId) {
+        const creds = await storage_1.credentialStorage.getCredentials(networkId);
+        return creds !== null && storage_1.credentialStorage.isTokenValid(creds);
+    }
+    async ensureAuthenticated(networkId) {
+        return this.connect(networkId);
+    }
+    generatePublicToken() {
+        const bytes = [];
+        for (let i = 0; i < 32; i++) {
+            bytes.push(Math.floor(Math.random() * 256));
+        }
+        return bytes.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+}
+exports.AuthNamespace = AuthNamespace;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiClient } from './client';\nimport { KeyPair, AuthTokens, Member, ApiResponse } from './types';\nimport { credentialStorage, StoredCredentials } from './storage';\n\nexport interface ConnectResult {\n  member?: Member;\n  tokens: AuthTokens;\n  isNewUser: boolean;\n  publicToken: string;\n}\n\nexport class AuthNamespace {\n  private client: ApiClient;\n\n  constructor(client: ApiClient) {\n    this.client = client;\n  }\n\n  async generateKeys(): Promise<KeyPair> {\n    const response = await this.client.post<KeyPair>('/v1/auth/generate-keys', {});\n    \n    if (response.success && response.data) {\n      return response.data;\n    }\n    \n    throw new Error(response.error?.message || 'Failed to generate keys');\n  }\n\n  async register(networkId: string, keys: KeyPair): Promise<{ member: Member; tokens: AuthTokens }> {\n    const response = await this.client.post<{ member: Member; tokens: AuthTokens }>('/v1/auth/register', {\n      networkId,\n      publicToken: keys.publicToken,\n      privateKey: keys.privateKey\n    });\n\n    if (response.success && response.data) {\n      this.client.setAuthToken(response.data.tokens.jwt);\n      return response.data;\n    }\n\n    throw new Error(response.error?.message || 'Registration failed');\n  }\n\n  async login(networkId: string, keys: KeyPair): Promise<AuthTokens> {\n    const response = await this.client.post<AuthTokens>('/v1/auth/login', {\n      networkId,\n      publicToken: keys.publicToken,\n      privateKey: keys.privateKey\n    });\n\n    if (response.success && response.data) {\n      this.client.setAuthToken(response.data.jwt);\n      return response.data;\n    }\n\n    throw new Error(response.error?.message || 'Login failed');\n  }\n\n  logout(): void {\n    this.client.clearAuthToken();\n  }\n\n  async connect(networkId: string, options?: { privateKey?: string }): Promise<ConnectResult> {\n    const stored = await credentialStorage.getCredentials(networkId);\n    \n    if (stored && credentialStorage.isTokenValid(stored)) {\n      this.client.setAuthToken(stored.jwt!);\n      return {\n        tokens: {\n          jwt: stored.jwt!,\n          expiresAt: stored.expiresAt!,\n          publicToken: stored.publicToken\n        },\n        isNewUser: false,\n        publicToken: stored.publicToken\n      };\n    }\n\n    if (stored && stored.privateKey) {\n      try {\n        const tokens = await this.login(networkId, {\n          publicToken: stored.publicToken,\n          privateKey: stored.privateKey\n        });\n\n        await credentialStorage.saveCredentials({\n          networkId,\n          publicToken: stored.publicToken,\n          privateKey: stored.privateKey,\n          jwt: tokens.jwt,\n          expiresAt: tokens.expiresAt\n        });\n\n        return {\n          tokens,\n          isNewUser: false,\n          publicToken: stored.publicToken\n        };\n      } catch {\n        // Login failed, will try to register with new keys\n      }\n    }\n\n    const keys = options?.privateKey\n      ? { publicToken: this.generatePublicToken(), privateKey: options.privateKey }\n      : await this.generateKeys();\n\n    try {\n      const result = await this.register(networkId, keys);\n\n      await credentialStorage.saveCredentials({\n        networkId,\n        publicToken: keys.publicToken,\n        privateKey: keys.privateKey,\n        jwt: result.tokens.jwt,\n        expiresAt: result.tokens.expiresAt\n      });\n\n      return {\n        member: result.member,\n        tokens: result.tokens,\n        isNewUser: true,\n        publicToken: keys.publicToken\n      };\n    } catch (registerError) {\n      throw registerError;\n    }\n  }\n\n  async disconnect(networkId: string): Promise<void> {\n    this.logout();\n    await credentialStorage.clearCredentials(networkId);\n  }\n\n  async getCredentials(networkId: string): Promise<StoredCredentials | null> {\n    return credentialStorage.getCredentials(networkId);\n  }\n\n  async isAuthenticated(networkId: string): Promise<boolean> {\n    const creds = await credentialStorage.getCredentials(networkId);\n    return creds !== null && credentialStorage.isTokenValid(creds);\n  }\n\n  async ensureAuthenticated(networkId: string): Promise<ConnectResult> {\n    return this.connect(networkId);\n  }\n\n  private generatePublicToken(): string {\n    const bytes: number[] = [];\n    for (let i = 0; i < 32; i++) {\n      bytes.push(Math.floor(Math.random() * 256));\n    }\n    return bytes.map(b => b.toString(16).padStart(2, '0')).join('');\n  }\n}\n"]}

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import { ApiResponse } from './types';
+export interface ClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+    format?: 'toon' | 'json';
+}
+export declare class ApiClient {
+    private axiosClient;
+    private format;
+    private baseUrl;
+    constructor(config?: ClientConfig);
+    setAuthToken(token: string): void;
+    clearAuthToken(): void;
+    setFormat(format: 'toon' | 'json'): void;
+    get<T>(path: string, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    post<T>(path: string, data?: unknown): Promise<ApiResponse<T>>;
+    put<T>(path: string, data?: unknown): Promise<ApiResponse<T>>;
+    delete<T>(path: string): Promise<ApiResponse<T>>;
+    private parseResponse;
+}

package/dist/client.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+function encode(data) {
+    return JSON.stringify(data);
+}
+function decode(str) {
+    return JSON.parse(str);
+}
+class ApiClient {
+    constructor(config = {}) {
+        this.format = config.format || 'toon';
+        this.baseUrl = config.baseUrl || 'https://api.agenticpool.net';
+        this.axiosClient = axios_1.default.create({
+            baseURL: this.baseUrl,
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': this.format === 'toon' ? 'text/plain' : 'application/json'
+            }
+        });
+    }
+    setAuthToken(token) {
+        this.axiosClient.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    }
+    clearAuthToken() {
+        delete this.axiosClient.defaults.headers.common['Authorization'];
+    }
+    setFormat(format) {
+        this.format = format;
+        this.axiosClient.defaults.headers['Accept'] = format === 'toon' ? 'text/plain' : 'application/json';
+    }
+    async get(path, params) {
+        const config = {
+            params: { ...params, format: this.format }
+        };
+        const response = await this.axiosClient.get(path, config);
+        return this.parseResponse(response.data);
+    }
+    async post(path, data) {
+        const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);
+        const config = {
+            params: { format: this.format },
+            headers: { 'Content-Type': 'text/plain' }
+        };
+        const response = await this.axiosClient.post(path, body, config);
+        return this.parseResponse(response.data);
+    }
+    async put(path, data) {
+        const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);
+        const config = {
+            params: { format: this.format },
+            headers: { 'Content-Type': 'text/plain' }
+        };
+        const response = await this.axiosClient.put(path, body, config);
+        return this.parseResponse(response.data);
+    }
+    async delete(path) {
+        const config = {
+            params: { format: this.format }
+        };
+        const response = await this.axiosClient.delete(path, config);
+        return this.parseResponse(response.data);
+    }
+    parseResponse(data) {
+        if (typeof data === 'string') {
+            try {
+                const parsed = decode(data);
+                return parsed;
+            }
+            catch {
+                return { success: false, error: { code: 'PARSE_ERROR', message: 'Failed to parse response' } };
+            }
+        }
+        return data;
+    }
+}
+exports.ApiClient = ApiClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';\nimport { ApiResponse } from './types';\n\nfunction encode(data: unknown): string {\n  return JSON.stringify(data);\n}\n\nfunction decode<T = unknown>(str: string): T {\n  return JSON.parse(str) as T;\n}\n\nexport interface ClientConfig {\n  baseUrl?: string;\n  timeout?: number;\n  format?: 'toon' | 'json';\n}\n\nexport class ApiClient {\n  private axiosClient: AxiosInstance;\n  private format: 'toon' | 'json';\n  private baseUrl: string;\n\n  constructor(config: ClientConfig = {}) {\n    this.format = config.format || 'toon';\n    this.baseUrl = config.baseUrl || 'https://api.agenticpool.net';\n    \n    this.axiosClient = axios.create({\n      baseURL: this.baseUrl,\n      timeout: config.timeout || 30000,\n      headers: {\n        'Content-Type': 'application/json',\n        'Accept': this.format === 'toon' ? 'text/plain' : 'application/json'\n      }\n    });\n  }\n\n  setAuthToken(token: string): void {\n    this.axiosClient.defaults.headers.common['Authorization'] = `Bearer ${token}`;\n  }\n\n  clearAuthToken(): void {\n    delete this.axiosClient.defaults.headers.common['Authorization'];\n  }\n\n  setFormat(format: 'toon' | 'json'): void {\n    this.format = format;\n    this.axiosClient.defaults.headers['Accept'] = format === 'toon' ? 'text/plain' : 'application/json';\n  }\n\n  async get<T>(path: string, params?: Record<string, unknown>): Promise<ApiResponse<T>> {\n    const config: AxiosRequestConfig = { \n      params: { ...params, format: this.format } \n    };\n    \n    const response = await this.axiosClient.get(path, config);\n    return this.parseResponse<T>(response.data);\n  }\n\n  async post<T>(path: string, data?: unknown): Promise<ApiResponse<T>> {\n    const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);\n    const config: AxiosRequestConfig = { \n      params: { format: this.format },\n      headers: { 'Content-Type': 'text/plain' }\n    };\n    \n    const response = await this.axiosClient.post(path, body, config);\n    return this.parseResponse<T>(response.data);\n  }\n\n  async put<T>(path: string, data?: unknown): Promise<ApiResponse<T>> {\n    const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);\n    const config: AxiosRequestConfig = { \n      params: { format: this.format },\n      headers: { 'Content-Type': 'text/plain' }\n    };\n    \n    const response = await this.axiosClient.put(path, body, config);\n    return this.parseResponse<T>(response.data);\n  }\n\n  async delete<T>(path: string): Promise<ApiResponse<T>> {\n    const config: AxiosRequestConfig = { \n      params: { format: this.format } \n    };\n    \n    const response = await this.axiosClient.delete(path, config);\n    return this.parseResponse<T>(response.data);\n  }\n\n  private parseResponse<T>(data: unknown): ApiResponse<T> {\n    if (typeof data === 'string') {\n      try {\n        const parsed = decode(data) as unknown;\n        return parsed as ApiResponse<T>;\n      } catch {\n        return { success: false, error: { code: 'PARSE_ERROR', message: 'Failed to parse response' } };\n      }\n    }\n    return data as ApiResponse<T>;\n  }\n}\n"]}

package/dist/conversations.d.ts

@@ -0,0 +1,24 @@
+import { ApiClient } from './client';
+import { Conversation, ConversationShort } from './types';
+export interface CreateConversationOptions {
+    title: string;
+    type?: 'topic' | 'direct' | 'group';
+    maxMembers?: number;
+}
+export declare class ConversationsNamespace {
+    private client;
+    constructor(client: ApiClient);
+    list(networkId: string, short?: boolean): Promise<Conversation[] | ConversationShort[]>;
+    mine(short?: boolean): Promise<Conversation[] | ConversationShort[]>;
+    create(networkId: string, options: CreateConversationOptions): Promise<Conversation>;
+    join(conversationId: string): Promise<void>;
+    getInsights(networkId: string, conversationId: string, limit?: number): Promise<{
+        topic: string;
+        messageCount: number;
+        participants: number;
+        recentActivity: string;
+        keywords: string[];
+        tone: string;
+        activeParticipants: string[];
+    }>;
+}

package/dist/conversations.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationsNamespace = void 0;
+class ConversationsNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(networkId, short = false) {
+        const params = {};
+        if (short) {
+            params.short = 'true';
+        }
+        const response = await this.client.get(`/v1/networks/${networkId}/conversations`, params);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to list conversations');
+    }
+    async mine(short = false) {
+        const params = {};
+        if (short) {
+            params.short = 'true';
+        }
+        const response = await this.client.get('/v1/conversations/mine', params);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to list conversations');
+    }
+    async create(networkId, options) {
+        const response = await this.client.post(`/v1/networks/${networkId}/conversations`, options);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to create conversation');
+    }
+    async join(conversationId) {
+        const response = await this.client.post(`/v1/conversations/${conversationId}/join`);
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to join conversation');
+        }
+    }
+    async getInsights(networkId, conversationId, limit = 50) {
+        const params = {
+            limit: limit.toString()
+        };
+        const response = await this.client.get(`/v1/conversations/${networkId}/${conversationId}/insights`, params);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to get conversation insights');
+    }
+}
+exports.ConversationsNamespace = ConversationsNamespace;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVyc2F0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb252ZXJzYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVNBLE1BQWEsc0JBQXNCO0lBR2pDLFlBQVksTUFBaUI7UUFDM0IsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztJQUVELEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBaUIsRUFBRSxRQUFpQixLQUFLO1FBQ2xELE1BQU0sTUFBTSxHQUEyQixFQUFFLENBQUM7UUFDMUMsSUFBSSxLQUFLLEVBQUUsQ0FBQztZQUNWLE1BQU0sQ0FBQyxLQUFLLEdBQUcsTUFBTSxDQUFDO1FBQ3hCLENBQUM7UUFFRCxNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUNwQyxnQkFBZ0IsU0FBUyxnQkFBZ0IsRUFDekMsTUFBTSxDQUNQLENBQUM7UUFFRixJQUFJLFFBQVEsQ0FBQyxPQUFPLElBQUksUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3RDLE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQztRQUN2QixDQUFDO1FBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLE9BQU8sSUFBSSw4QkFBOEIsQ0FBQyxDQUFDO0lBQzdFLENBQUM7SUFFRCxLQUFLLENBQUMsSUFBSSxDQUFDLFFBQWlCLEtBQUs7UUFDL0IsTUFBTSxNQUFNLEdBQTJCLEVBQUUsQ0FBQztRQUMxQyxJQUFJLEtBQUssRUFBRSxDQUFDO1lBQ1YsTUFBTSxDQUFDLEtBQUssR0FBRyxNQUFNLENBQUM7UUFDeEIsQ0FBQztRQUVELE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQ3BDLHdCQUF3QixFQUN4QixNQUFNLENBQ1AsQ0FBQztRQUVGLElBQUksUUFBUSxDQUFDLE9BQU8sSUFBSSxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDdEMsT0FBTyxRQUFRLENBQUMsSUFBSSxDQUFDO1FBQ3ZCLENBQUM7UUFFRCxNQUFNLElBQUksS0FBSyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsT0FBTyxJQUFJLDhCQUE4QixDQUFDLENBQUM7SUFDN0UsQ0FBQztJQUVELEtBQUssQ0FBQyxNQUFNLENBQUMsU0FBaUIsRUFBRSxPQUFrQztRQUNoRSxNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUNyQyxnQkFBZ0IsU0FBUyxnQkFBZ0IsRUFDekMsT0FBTyxDQUNSLENBQUM7UUFFRixJQUFJLFFBQVEsQ0FBQyxPQUFPLElBQUksUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3RDLE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQztRQUN2QixDQUFDO1FBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLE9BQU8sSUFBSSwrQkFBK0IsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFRCxLQUFLLENBQUMsSUFBSSxDQUFDLGNBQXNCO1FBQy9CLE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMscUJBQXFCLGNBQWMsT0FBTyxDQUFDLENBQUM7UUFFcEYsSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUN0QixNQUFNLElBQUksS0FBSyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsT0FBTyxJQUFJLDZCQUE2QixDQUFDLENBQUM7UUFDNUUsQ0FBQztJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsV0FBVyxDQUFDLFNBQWlCLEVBQUUsY0FBc0IsRUFBRSxRQUFnQixFQUFFO1FBUzdFLE1BQU0sTUFBTSxHQUEyQjtZQUNyQyxLQUFLLEVBQUUsS0FBSyxDQUFDLFFBQVEsRUFBRTtTQUN4QixDQUFDO1FBRUYsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FDcEMscUJBQXFCLFNBQVMsSUFBSSxjQUFjLFdBQVcsRUFDM0QsTUFBTSxDQUNQLENBQUM7UUFFRixJQUFJLFFBQVEsQ0FBQyxPQUFPLElBQUksUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3RDLE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQztRQUN2QixDQUFDO1FBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLE9BQU8sSUFBSSxxQ0FBcUMsQ0FBQyxDQUFDO0lBQ3BGLENBQUM7Q0FDRjtBQXhGRCx3REF3RkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcGlDbGllbnQgfSBmcm9tICcuL2NsaWVudCc7XG5pbXBvcnQgeyBBcGlSZXNwb25zZSwgQ29udmVyc2F0aW9uLCBDb252ZXJzYXRpb25TaG9ydCB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZUNvbnZlcnNhdGlvbk9wdGlvbnMge1xuICB0aXRsZTogc3RyaW5nO1xuICB0eXBlPzogJ3RvcGljJyB8ICdkaXJlY3QnIHwgJ2dyb3VwJztcbiAgbWF4TWVtYmVycz86IG51bWJlcjtcbn1cblxuZXhwb3J0IGNsYXNzIENvbnZlcnNhdGlvbnNOYW1lc3BhY2Uge1xuICBwcml2YXRlIGNsaWVudDogQXBpQ2xpZW50O1xuXG4gIGNvbnN0cnVjdG9yKGNsaWVudDogQXBpQ2xpZW50KSB7XG4gICAgdGhpcy5jbGllbnQgPSBjbGllbnQ7XG4gIH1cblxuICBhc3luYyBsaXN0KG5ldHdvcmtJZDogc3RyaW5nLCBzaG9ydDogYm9vbGVhbiA9IGZhbHNlKTogUHJvbWlzZTxDb252ZXJzYXRpb25bXSB8IENvbnZlcnNhdGlvblNob3J0W10+IHtcbiAgICBjb25zdCBwYXJhbXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7fTtcbiAgICBpZiAoc2hvcnQpIHtcbiAgICAgIHBhcmFtcy5zaG9ydCA9ICd0cnVlJztcbiAgICB9XG4gICAgXG4gICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCB0aGlzLmNsaWVudC5nZXQ8Q29udmVyc2F0aW9uW10gfCBDb252ZXJzYXRpb25TaG9ydFtdPihcbiAgICAgIGAvdjEvbmV0d29ya3MvJHtuZXR3b3JrSWR9L2NvbnZlcnNhdGlvbnNgLFxuICAgICAgcGFyYW1zXG4gICAgKTtcblxuICAgIGlmIChyZXNwb25zZS5zdWNjZXNzICYmIHJlc3BvbnNlLmRhdGEpIHtcbiAgICAgIHJldHVybiByZXNwb25zZS5kYXRhO1xuICAgIH1cblxuICAgIHRocm93IG5ldyBFcnJvcihyZXNwb25zZS5lcnJvcj8ubWVzc2FnZSB8fCAnRmFpbGVkIHRvIGxpc3QgY29udmVyc2F0aW9ucycpO1xuICB9XG5cbiAgYXN5bmMgbWluZShzaG9ydDogYm9vbGVhbiA9IGZhbHNlKTogUHJvbWlzZTxDb252ZXJzYXRpb25bXSB8IENvbnZlcnNhdGlvblNob3J0W10+IHtcbiAgICBjb25zdCBwYXJhbXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7fTtcbiAgICBpZiAoc2hvcnQpIHtcbiAgICAgIHBhcmFtcy5zaG9ydCA9ICd0cnVlJztcbiAgICB9XG4gICAgXG4gICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCB0aGlzLmNsaWVudC5nZXQ8Q29udmVyc2F0aW9uW10gfCBDb252ZXJzYXRpb25TaG9ydFtdPihcbiAgICAgICcvdjEvY29udmVyc2F0aW9ucy9taW5lJyxcbiAgICAgIHBhcmFtc1xuICAgICk7XG5cbiAgICBpZiAocmVzcG9uc2Uuc3VjY2VzcyAmJiByZXNwb25zZS5kYXRhKSB7XG4gICAgICByZXR1cm4gcmVzcG9uc2UuZGF0YTtcbiAgICB9XG5cbiAgICB0aHJvdyBuZXcgRXJyb3IocmVzcG9uc2UuZXJyb3I/Lm1lc3NhZ2UgfHwgJ0ZhaWxlZCB0byBsaXN0IGNvbnZlcnNhdGlvbnMnKTtcbiAgfVxuXG4gIGFzeW5jIGNyZWF0ZShuZXR3b3JrSWQ6IHN0cmluZywgb3B0aW9uczogQ3JlYXRlQ29udmVyc2F0aW9uT3B0aW9ucyk6IFByb21pc2U8Q29udmVyc2F0aW9uPiB7XG4gICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCB0aGlzLmNsaWVudC5wb3N0PENvbnZlcnNhdGlvbj4oXG4gICAgICBgL3YxL25ldHdvcmtzLyR7bmV0d29ya0lkfS9jb252ZXJzYXRpb25zYCxcbiAgICAgIG9wdGlvbnNcbiAgICApO1xuXG4gICAgaWYgKHJlc3BvbnNlLnN1Y2Nlc3MgJiYgcmVzcG9uc2UuZGF0YSkge1xuICAgICAgcmV0dXJuIHJlc3BvbnNlLmRhdGE7XG4gICAgfVxuXG4gICAgdGhyb3cgbmV3IEVycm9yKHJlc3BvbnNlLmVycm9yPy5tZXNzYWdlIHx8ICdGYWlsZWQgdG8gY3JlYXRlIGNvbnZlcnNhdGlvbicpO1xuICB9XG5cbiAgYXN5bmMgam9pbihjb252ZXJzYXRpb25JZDogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCB0aGlzLmNsaWVudC5wb3N0KGAvdjEvY29udmVyc2F0aW9ucy8ke2NvbnZlcnNhdGlvbklkfS9qb2luYCk7XG5cbiAgICBpZiAoIXJlc3BvbnNlLnN1Y2Nlc3MpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihyZXNwb25zZS5lcnJvcj8ubWVzc2FnZSB8fCAnRmFpbGVkIHRvIGpvaW4gY29udmVyc2F0aW9uJyk7XG4gICAgfVxuICB9XG5cbiAgYXN5bmMgZ2V0SW5zaWdodHMobmV0d29ya0lkOiBzdHJpbmcsIGNvbnZlcnNhdGlvbklkOiBzdHJpbmcsIGxpbWl0OiBudW1iZXIgPSA1MCk6IFByb21pc2U8e1xuICAgIHRvcGljOiBzdHJpbmc7XG4gICAgbWVzc2FnZUNvdW50OiBudW1iZXI7XG4gICAgcGFydGljaXBhbnRzOiBudW1iZXI7XG4gICAgcmVjZW50QWN0aXZpdHk6IHN0cmluZztcbiAgICBrZXl3b3Jkczogc3RyaW5nW107XG4gICAgdG9uZTogc3RyaW5nO1xuICAgIGFjdGl2ZVBhcnRpY2lwYW50czogc3RyaW5nW107XG4gIH0+IHtcbiAgICBjb25zdCBwYXJhbXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7XG4gICAgICBsaW1pdDogbGltaXQudG9TdHJpbmcoKVxuICAgIH07XG5cbiAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IHRoaXMuY2xpZW50LmdldDxhbnk+KFxuICAgICAgYC92MS9jb252ZXJzYXRpb25zLyR7bmV0d29ya0lkfS8ke2NvbnZlcnNhdGlvbklkfS9pbnNpZ2h0c2AsXG4gICAgICBwYXJhbXNcbiAgICApO1xuXG4gICAgaWYgKHJlc3BvbnNlLnN1Y2Nlc3MgJiYgcmVzcG9uc2UuZGF0YSkge1xuICAgICAgcmV0dXJuIHJlc3BvbnNlLmRhdGE7XG4gICAgfVxuXG4gICAgdGhyb3cgbmV3IEVycm9yKHJlc3BvbnNlLmVycm9yPy5tZXNzYWdlIHx8ICdGYWlsZWQgdG8gZ2V0IGNvbnZlcnNhdGlvbiBpbnNpZ2h0cycpO1xuICB9XG59XG4iXX0=

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { ClientConfig } from './client';
+import { AuthNamespace } from './auth';
+import { NetworksNamespace } from './networks';
+import { ConversationsNamespace } from './conversations';
+import { MessagesNamespace } from './messages';
+import { ProfileNamespace } from './profile';
+export * from './types';
+export * from './storage';
+export interface AgenticPoolOptions extends ClientConfig {
+}
+export declare class AgenticPool {
+    private client;
+    readonly auth: AuthNamespace;
+    readonly networks: NetworksNamespace;
+    readonly conversations: ConversationsNamespace;
+    readonly messages: MessagesNamespace;
+    readonly profile: ProfileNamespace;
+    constructor(options?: AgenticPoolOptions);
+    connect(networkId: string, options?: {
+        privateKey?: string;
+    }): Promise<import("./auth").ConnectResult>;
+    disconnect(networkId: string): Promise<void>;
+    isAuthenticated(networkId: string): Promise<boolean>;
+    setFormat(format: 'toon' | 'json'): void;
+    setAuthToken(token: string): void;
+    clearAuthToken(): void;
+    static clearAllCredentials(): Promise<void>;
+}
+export default AgenticPool;

package/dist/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgenticPool = void 0;
+const client_1 = require("./client");
+const auth_1 = require("./auth");
+const networks_1 = require("./networks");
+const conversations_1 = require("./conversations");
+const messages_1 = require("./messages");
+const profile_1 = require("./profile");
+const storage_1 = require("./storage");
+__exportStar(require("./types"), exports);
+__exportStar(require("./storage"), exports);
+class AgenticPool {
+    constructor(options = {}) {
+        this.client = new client_1.ApiClient(options);
+        this.auth = new auth_1.AuthNamespace(this.client);
+        this.networks = new networks_1.NetworksNamespace(this.client);
+        this.conversations = new conversations_1.ConversationsNamespace(this.client);
+        this.messages = new messages_1.MessagesNamespace(this.client);
+        this.profile = new profile_1.ProfileNamespace(this.client);
+    }
+    async connect(networkId, options) {
+        return this.auth.connect(networkId, options);
+    }
+    async disconnect(networkId) {
+        return this.auth.disconnect(networkId);
+    }
+    async isAuthenticated(networkId) {
+        return this.auth.isAuthenticated(networkId);
+    }
+    setFormat(format) {
+        this.client.setFormat(format);
+    }
+    setAuthToken(token) {
+        this.client.setAuthToken(token);
+    }
+    clearAuthToken() {
+        this.client.clearAuthToken();
+    }
+    static clearAllCredentials() {
+        return storage_1.credentialStorage.clearAllCredentials();
+    }
+}
+exports.AgenticPool = AgenticPool;
+exports.default = AgenticPool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/messages.d.ts

@@ -0,0 +1,12 @@
+import { ApiClient } from './client';
+import { Message } from './types';
+export interface SendMessageOptions {
+    content: string;
+    receiverId?: string | null;
+}
+export declare class MessagesNamespace {
+    private client;
+    constructor(client: ApiClient);
+    list(conversationId: string, limit?: number): Promise<Message[]>;
+    send(conversationId: string, options: SendMessageOptions): Promise<Message>;
+}

package/dist/messages.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesNamespace = void 0;
+class MessagesNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(conversationId, limit = 50) {
+        const response = await this.client.get(`/v1/conversations/${conversationId}/messages`, { limit });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to list messages');
+    }
+    async send(conversationId, options) {
+        const response = await this.client.post(`/v1/conversations/${conversationId}/messages`, {
+            content: options.content,
+            receiverId: options.receiverId || null
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to send message');
+    }
+}
+exports.MessagesNamespace = MessagesNamespace;
+//# sourceMappingURL=data:application/json;base64,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