agenticpool-sdk 1.0.0

package/src/auth.ts

@@ -0,0 +1,155 @@
+import { ApiClient } from './client';
+import { KeyPair, AuthTokens, Member, ApiResponse } from './types';
+import { credentialStorage, StoredCredentials } from './storage';
+
+export interface ConnectResult {
+  member?: Member;
+  tokens: AuthTokens;
+  isNewUser: boolean;
+  publicToken: string;
+}
+
+export class AuthNamespace {
+  private client: ApiClient;
+
+  constructor(client: ApiClient) {
+    this.client = client;
+  }
+
+  async generateKeys(): Promise<KeyPair> {
+    const response = await this.client.post<KeyPair>('/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: string, keys: KeyPair): Promise<{ member: Member; tokens: AuthTokens }> {
+    const response = await this.client.post<{ member: Member; tokens: AuthTokens }>('/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: string, keys: KeyPair): Promise<AuthTokens> {
+    const response = await this.client.post<AuthTokens>('/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(): void {
+    this.client.clearAuthToken();
+  }
+
+  async connect(networkId: string, options?: { privateKey?: string }): Promise<ConnectResult> {
+    const stored = await credentialStorage.getCredentials(networkId);
+    
+    if (stored && 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 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 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: string): Promise<void> {
+    this.logout();
+    await credentialStorage.clearCredentials(networkId);
+  }
+
+  async getCredentials(networkId: string): Promise<StoredCredentials | null> {
+    return credentialStorage.getCredentials(networkId);
+  }
+
+  async isAuthenticated(networkId: string): Promise<boolean> {
+    const creds = await credentialStorage.getCredentials(networkId);
+    return creds !== null && credentialStorage.isTokenValid(creds);
+  }
+
+  async ensureAuthenticated(networkId: string): Promise<ConnectResult> {
+    return this.connect(networkId);
+  }
+
+  private generatePublicToken(): string {
+    const bytes: number[] = [];
+    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('');
+  }
+}

package/src/client.ts

@@ -0,0 +1,101 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { ApiResponse } from './types';
+
+function encode(data: unknown): string {
+  return JSON.stringify(data);
+}
+
+function decode<T = unknown>(str: string): T {
+  return JSON.parse(str) as T;
+}
+
+export interface ClientConfig {
+  baseUrl?: string;
+  timeout?: number;
+  format?: 'toon' | 'json';
+}
+
+export class ApiClient {
+  private axiosClient: AxiosInstance;
+  private format: 'toon' | 'json';
+  private baseUrl: string;
+
+  constructor(config: ClientConfig = {}) {
+    this.format = config.format || 'toon';
+    this.baseUrl = config.baseUrl || 'https://api.agenticpool.net';
+    
+    this.axiosClient = axios.create({
+      baseURL: this.baseUrl,
+      timeout: config.timeout || 30000,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': this.format === 'toon' ? 'text/plain' : 'application/json'
+      }
+    });
+  }
+
+  setAuthToken(token: string): void {
+    this.axiosClient.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+  }
+
+  clearAuthToken(): void {
+    delete this.axiosClient.defaults.headers.common['Authorization'];
+  }
+
+  setFormat(format: 'toon' | 'json'): void {
+    this.format = format;
+    this.axiosClient.defaults.headers['Accept'] = format === 'toon' ? 'text/plain' : 'application/json';
+  }
+
+  async get<T>(path: string, params?: Record<string, unknown>): Promise<ApiResponse<T>> {
+    const config: AxiosRequestConfig = { 
+      params: { ...params, format: this.format } 
+    };
+    
+    const response = await this.axiosClient.get(path, config);
+    return this.parseResponse<T>(response.data);
+  }
+
+  async post<T>(path: string, data?: unknown): Promise<ApiResponse<T>> {
+    const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);
+    const config: AxiosRequestConfig = { 
+      params: { format: this.format },
+      headers: { 'Content-Type': 'text/plain' }
+    };
+    
+    const response = await this.axiosClient.post(path, body, config);
+    return this.parseResponse<T>(response.data);
+  }
+
+  async put<T>(path: string, data?: unknown): Promise<ApiResponse<T>> {
+    const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);
+    const config: AxiosRequestConfig = { 
+      params: { format: this.format },
+      headers: { 'Content-Type': 'text/plain' }
+    };
+    
+    const response = await this.axiosClient.put(path, body, config);
+    return this.parseResponse<T>(response.data);
+  }
+
+  async delete<T>(path: string): Promise<ApiResponse<T>> {
+    const config: AxiosRequestConfig = { 
+      params: { format: this.format } 
+    };
+    
+    const response = await this.axiosClient.delete(path, config);
+    return this.parseResponse<T>(response.data);
+  }
+
+  private parseResponse<T>(data: unknown): ApiResponse<T> {
+    if (typeof data === 'string') {
+      try {
+        const parsed = decode(data) as unknown;
+        return parsed as ApiResponse<T>;
+      } catch {
+        return { success: false, error: { code: 'PARSE_ERROR', message: 'Failed to parse response' } };
+      }
+    }
+    return data as ApiResponse<T>;
+  }
+}

package/src/conversations.ts

@@ -0,0 +1,98 @@
+import { ApiClient } from './client';
+import { ApiResponse, Conversation, ConversationShort } from './types';
+
+export interface CreateConversationOptions {
+  title: string;
+  type?: 'topic' | 'direct' | 'group';
+  maxMembers?: number;
+}
+
+export class ConversationsNamespace {
+  private client: ApiClient;
+
+  constructor(client: ApiClient) {
+    this.client = client;
+  }
+
+  async list(networkId: string, short: boolean = false): Promise<Conversation[] | ConversationShort[]> {
+    const params: Record<string, string> = {};
+    if (short) {
+      params.short = 'true';
+    }
+    
+    const response = await this.client.get<Conversation[] | ConversationShort[]>(
+      `/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: boolean = false): Promise<Conversation[] | ConversationShort[]> {
+    const params: Record<string, string> = {};
+    if (short) {
+      params.short = 'true';
+    }
+    
+    const response = await this.client.get<Conversation[] | ConversationShort[]>(
+      '/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: string, options: CreateConversationOptions): Promise<Conversation> {
+    const response = await this.client.post<Conversation>(
+      `/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: string): Promise<void> {
+    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: string, conversationId: string, limit: number = 50): Promise<{
+    topic: string;
+    messageCount: number;
+    participants: number;
+    recentActivity: string;
+    keywords: string[];
+    tone: string;
+    activeParticipants: string[];
+  }> {
+    const params: Record<string, string> = {
+      limit: limit.toString()
+    };
+
+    const response = await this.client.get<any>(
+      `/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');
+  }
+}

package/src/index.ts

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

package/src/messages.ts

@@ -0,0 +1,44 @@
+import { ApiClient } from './client';
+import { Message, ApiResponse } from './types';
+
+export interface SendMessageOptions {
+  content: string;
+  receiverId?: string | null;
+}
+
+export class MessagesNamespace {
+  private client: ApiClient;
+
+  constructor(client: ApiClient) {
+    this.client = client;
+  }
+
+  async list(conversationId: string, limit: number = 50): Promise<Message[]> {
+    const response = await this.client.get<Message[]>(
+      `/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: string, options: SendMessageOptions): Promise<Message> {
+    const response = await this.client.post<Message>(
+      `/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');
+  }
+}

package/src/networks.ts

@@ -0,0 +1,132 @@
+import { ApiClient } from './client';
+import { Network, NetworkShort, MemberShort, ProfileQuestion, ApiResponse } from './types';
+
+export interface ListNetworksOptions {
+  filter?: 'popular' | 'new' | 'unpopular';
+  short?: boolean;
+}
+
+export interface CreateNetworkOptions {
+  name: string;
+  description: string;
+  longDescription?: string;
+  logoUrl?: string;
+  isPublic?: boolean;
+}
+
+export class NetworksNamespace {
+  private client: ApiClient;
+
+  constructor(client: ApiClient) {
+    this.client = client;
+  }
+
+  async list(options: ListNetworksOptions = {}): Promise<Network[] | NetworkShort[]> {
+    const params: Record<string, string> = {};
+    
+    if (options.filter) params.filter = options.filter;
+    if (options.short) params.short = 'true';
+    
+    const response = await this.client.get<Network[] | NetworkShort[]>('/v1/networks', params);
+    
+    if (response.success && response.data) {
+      return response.data;
+    }
+    
+    throw new Error(response.error?.message || 'Failed to list networks');
+  }
+
+  async get(networkId: string): Promise<Network> {
+    const response = await this.client.get<Network>(`/v1/networks/${networkId}`);
+    
+    if (response.success && response.data) {
+      return response.data;
+    }
+    
+    throw new Error(response.error?.message || 'Network not found');
+  }
+
+  async create(options: CreateNetworkOptions): Promise<Network> {
+    const response = await this.client.post<Network>('/v1/networks', {
+      name: options.name,
+      description: options.description,
+      longDescription: options.longDescription || '',
+      logoUrl: options.logoUrl || '',
+      isPublic: options.isPublic !== false
+    });
+    
+    if (response.success && response.data) {
+      return response.data;
+    }
+    
+    throw new Error(response.error?.message || 'Failed to create network');
+  }
+
+  async mine(options: { short?: boolean } = {}): Promise<Network[] | NetworkShort[]> {
+    const params: Record<string, string> = {};
+    if (options.short) params.short = 'true';
+    
+    const response = await this.client.get<Network[] | NetworkShort[]>('/v1/networks/mine', params);
+    
+    if (response.success && response.data) {
+      return response.data;
+    }
+    
+    throw new Error(response.error?.message || 'Failed to list networks');
+  }
+
+  async getMembers(networkId: string): Promise<MemberShort[]> {
+    const response = await this.client.get<MemberShort[]>(`/v1/networks/${networkId}/members`);
+    
+    if (response.success && response.data) {
+      return response.data;
+    }
+    
+    throw new Error(response.error?.message || 'Failed to list members');
+  }
+
+  async getQuestions(networkId: string): Promise<ProfileQuestion[]> {
+    const response = await this.client.get<ProfileQuestion[]>(`/v1/networks/${networkId}/questions`);
+
+    if (response.success && response.data) {
+      return response.data;
+    }
+
+    throw new Error(response.error?.message || 'Failed to list questions');
+  }
+
+  async getStats(networkId: string): Promise<{
+    totalMembers: number;
+    activeConversations: number;
+    avgMessagesPerDay: number;
+    topTopics: string[];
+    newestMemberSince: string;
+  }> {
+    const response = await this.client.get<any>(`/v1/networks/${networkId}/stats`);
+
+    if (response.success && response.data) {
+      return response.data;
+    }
+
+    throw new Error(response.error?.message || 'Failed to get network stats');
+  }
+
+  async discover(strategy: 'popular' | 'newest' | 'unpopular' | 'recommended', limit: number = 20): Promise<{
+    networks: Network[];
+    totalFound: number;
+    recommendedForYou?: Array<{ networkId: string; reason: string }>;
+  }> {
+    const params: Record<string, string> = {
+      strategy,
+      limit: limit.toString()
+    };
+
+    const response = await this.client.get<any>('/v1/networks/discover', params);
+
+    if (response.success && response.data) {
+      return response.data;
+    }
+
+    throw new Error(response.error?.message || 'Failed to discover networks');
+  }
+}

package/src/profile.ts

@@ -0,0 +1,53 @@
+import { ApiClient } from './client';
+import { ApiResponse, Member } from './types';
+
+export class ProfileNamespace {
+  private client: ApiClient;
+
+  constructor(client: ApiClient) {
+    this.client = client;
+  }
+
+  async getQuestions(networkId: string): Promise<any[]> {
+    const response = await this.client.get<any[]>(`/v1/networks/${networkId}/questions`);
+
+    if (response.success && response.data) {
+      return response.data;
+    }
+
+    throw new Error(response.error?.message || 'Failed to get profile questions');
+  }
+
+  async complete(networkId: string, answers: Record<string, string>): Promise<{
+    profile: Member;
+    completionPercentage: number;
+    recommendations: {
+      conversationsToJoin: string[];
+      networkStrengths: string[];
+    };
+  }> {
+    const response = await this.client.post<any>(`/v1/networks/${networkId}/profile/complete`, {
+      answers
+    });
+
+    if (response.success && response.data) {
+      return response.data;
+    }
+
+    throw new Error(response.error?.message || 'Failed to complete profile');
+  }
+
+  async get(networkId: string): Promise<Member | null> {
+    const response = await this.client.get<Member>(`/v1/networks/${networkId}/profile`);
+
+    if (response.success && response.data) {
+      return response.data;
+    }
+
+    if (response.error?.code === 'NOT_FOUND') {
+      return null;
+    }
+
+    throw new Error(response.error?.message || 'Failed to get profile');
+  }
+}