agenticpool-sdk 1.0.0

package/dist/networks.d.ts

@@ -0,0 +1,40 @@
+import { ApiClient } from './client';
+import { Network, NetworkShort, MemberShort, ProfileQuestion } 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 declare class NetworksNamespace {
+    private client;
+    constructor(client: ApiClient);
+    list(options?: ListNetworksOptions): Promise<Network[] | NetworkShort[]>;
+    get(networkId: string): Promise<Network>;
+    create(options: CreateNetworkOptions): Promise<Network>;
+    mine(options?: {
+        short?: boolean;
+    }): Promise<Network[] | NetworkShort[]>;
+    getMembers(networkId: string): Promise<MemberShort[]>;
+    getQuestions(networkId: string): Promise<ProfileQuestion[]>;
+    getStats(networkId: string): Promise<{
+        totalMembers: number;
+        activeConversations: number;
+        avgMessagesPerDay: number;
+        topTopics: string[];
+        newestMemberSince: string;
+    }>;
+    discover(strategy: 'popular' | 'newest' | 'unpopular' | 'recommended', limit?: number): Promise<{
+        networks: Network[];
+        totalFound: number;
+        recommendedForYou?: Array<{
+            networkId: string;
+            reason: string;
+        }>;
+    }>;
+}

package/dist/networks.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworksNamespace = void 0;
+class NetworksNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(options = {}) {
+        const params = {};
+        if (options.filter)
+            params.filter = options.filter;
+        if (options.short)
+            params.short = 'true';
+        const response = await this.client.get('/v1/networks', params);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to list networks');
+    }
+    async get(networkId) {
+        const response = await this.client.get(`/v1/networks/${networkId}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Network not found');
+    }
+    async create(options) {
+        const response = await this.client.post('/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 = {}) {
+        const params = {};
+        if (options.short)
+            params.short = 'true';
+        const response = await this.client.get('/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) {
+        const response = await this.client.get(`/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) {
+        const response = await this.client.get(`/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) {
+        const response = await this.client.get(`/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, limit = 20) {
+        const params = {
+            strategy,
+            limit: limit.toString()
+        };
+        const response = await this.client.get('/v1/networks/discover', params);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to discover networks');
+    }
+}
+exports.NetworksNamespace = NetworksNamespace;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networks.js","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiClient } from './client';\nimport { Network, NetworkShort, MemberShort, ProfileQuestion, ApiResponse } from './types';\n\nexport interface ListNetworksOptions {\n  filter?: 'popular' | 'new' | 'unpopular';\n  short?: boolean;\n}\n\nexport interface CreateNetworkOptions {\n  name: string;\n  description: string;\n  longDescription?: string;\n  logoUrl?: string;\n  isPublic?: boolean;\n}\n\nexport class NetworksNamespace {\n  private client: ApiClient;\n\n  constructor(client: ApiClient) {\n    this.client = client;\n  }\n\n  async list(options: ListNetworksOptions = {}): Promise<Network[] | NetworkShort[]> {\n    const params: Record<string, string> = {};\n    \n    if (options.filter) params.filter = options.filter;\n    if (options.short) params.short = 'true';\n    \n    const response = await this.client.get<Network[] | NetworkShort[]>('/v1/networks', params);\n    \n    if (response.success && response.data) {\n      return response.data;\n    }\n    \n    throw new Error(response.error?.message || 'Failed to list networks');\n  }\n\n  async get(networkId: string): Promise<Network> {\n    const response = await this.client.get<Network>(`/v1/networks/${networkId}`);\n    \n    if (response.success && response.data) {\n      return response.data;\n    }\n    \n    throw new Error(response.error?.message || 'Network not found');\n  }\n\n  async create(options: CreateNetworkOptions): Promise<Network> {\n    const response = await this.client.post<Network>('/v1/networks', {\n      name: options.name,\n      description: options.description,\n      longDescription: options.longDescription || '',\n      logoUrl: options.logoUrl || '',\n      isPublic: options.isPublic !== false\n    });\n    \n    if (response.success && response.data) {\n      return response.data;\n    }\n    \n    throw new Error(response.error?.message || 'Failed to create network');\n  }\n\n  async mine(options: { short?: boolean } = {}): Promise<Network[] | NetworkShort[]> {\n    const params: Record<string, string> = {};\n    if (options.short) params.short = 'true';\n    \n    const response = await this.client.get<Network[] | NetworkShort[]>('/v1/networks/mine', params);\n    \n    if (response.success && response.data) {\n      return response.data;\n    }\n    \n    throw new Error(response.error?.message || 'Failed to list networks');\n  }\n\n  async getMembers(networkId: string): Promise<MemberShort[]> {\n    const response = await this.client.get<MemberShort[]>(`/v1/networks/${networkId}/members`);\n    \n    if (response.success && response.data) {\n      return response.data;\n    }\n    \n    throw new Error(response.error?.message || 'Failed to list members');\n  }\n\n  async getQuestions(networkId: string): Promise<ProfileQuestion[]> {\n    const response = await this.client.get<ProfileQuestion[]>(`/v1/networks/${networkId}/questions`);\n\n    if (response.success && response.data) {\n      return response.data;\n    }\n\n    throw new Error(response.error?.message || 'Failed to list questions');\n  }\n\n  async getStats(networkId: string): Promise<{\n    totalMembers: number;\n    activeConversations: number;\n    avgMessagesPerDay: number;\n    topTopics: string[];\n    newestMemberSince: string;\n  }> {\n    const response = await this.client.get<any>(`/v1/networks/${networkId}/stats`);\n\n    if (response.success && response.data) {\n      return response.data;\n    }\n\n    throw new Error(response.error?.message || 'Failed to get network stats');\n  }\n\n  async discover(strategy: 'popular' | 'newest' | 'unpopular' | 'recommended', limit: number = 20): Promise<{\n    networks: Network[];\n    totalFound: number;\n    recommendedForYou?: Array<{ networkId: string; reason: string }>;\n  }> {\n    const params: Record<string, string> = {\n      strategy,\n      limit: limit.toString()\n    };\n\n    const response = await this.client.get<any>('/v1/networks/discover', params);\n\n    if (response.success && response.data) {\n      return response.data;\n    }\n\n    throw new Error(response.error?.message || 'Failed to discover networks');\n  }\n}\n"]}

package/dist/profile.d.ts

@@ -0,0 +1,16 @@
+import { ApiClient } from './client';
+import { Member } from './types';
+export declare class ProfileNamespace {
+    private client;
+    constructor(client: ApiClient);
+    getQuestions(networkId: string): Promise<any[]>;
+    complete(networkId: string, answers: Record<string, string>): Promise<{
+        profile: Member;
+        completionPercentage: number;
+        recommendations: {
+            conversationsToJoin: string[];
+            networkStrengths: string[];
+        };
+    }>;
+    get(networkId: string): Promise<Member | null>;
+}

package/dist/profile.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileNamespace = void 0;
+class ProfileNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async getQuestions(networkId) {
+        const response = await this.client.get(`/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, answers) {
+        const response = await this.client.post(`/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) {
+        const response = await this.client.get(`/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');
+    }
+}
+exports.ProfileNamespace = ProfileNamespace;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/storage.d.ts

@@ -0,0 +1,24 @@
+export interface StoredCredentials {
+    publicToken: string;
+    privateKey: string;
+    jwt?: string;
+    expiresAt?: number;
+    networkId: string;
+}
+export declare class CredentialStorage {
+    private memoryStorage;
+    private nodeFs;
+    private nodePath;
+    private nodeOs;
+    private configDir;
+    private isBrowser;
+    private localStorageImpl;
+    constructor();
+    private ensureDir;
+    getCredentials(networkId: string): Promise<StoredCredentials | null>;
+    saveCredentials(credentials: StoredCredentials): Promise<void>;
+    clearCredentials(networkId: string): Promise<void>;
+    clearAllCredentials(): Promise<void>;
+    isTokenValid(credentials: StoredCredentials): boolean;
+}
+export declare const credentialStorage: CredentialStorage;

package/dist/storage.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentialStorage = exports.CredentialStorage = void 0;
+const STORAGE_KEY_PREFIX = 'agenticpool_';
+class CredentialStorage {
+    constructor() {
+        this.memoryStorage = new Map();
+        this.nodeFs = null;
+        this.nodePath = null;
+        this.nodeOs = null;
+        this.configDir = null;
+        this.isBrowser = false;
+        this.localStorageImpl = null;
+        this.isBrowser = typeof globalThis !== 'undefined' &&
+            typeof globalThis.localStorage !== 'undefined';
+        if (this.isBrowser) {
+            this.localStorageImpl = globalThis.localStorage;
+        }
+        else if (typeof process !== 'undefined' && process.versions?.node) {
+            try {
+                this.nodeFs = require('fs');
+                this.nodePath = require('path');
+                this.nodeOs = require('os');
+                this.configDir = this.nodePath.join(this.nodeOs.homedir(), '.agenticpool', 'credentials');
+                this.ensureDir(this.configDir);
+            }
+            catch {
+                // Fallback to memory storage
+            }
+        }
+    }
+    ensureDir(dir) {
+        if (this.nodeFs && !this.nodeFs.existsSync(dir)) {
+            this.nodeFs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    async getCredentials(networkId) {
+        const key = `${STORAGE_KEY_PREFIX}${networkId}`;
+        if (this.isBrowser && this.localStorageImpl) {
+            const stored = this.localStorageImpl.getItem(key);
+            if (stored) {
+                try {
+                    return JSON.parse(stored);
+                }
+                catch {
+                    return null;
+                }
+            }
+            return null;
+        }
+        if (this.nodeFs && this.configDir) {
+            const filePath = this.nodePath.join(this.configDir, `${networkId}.json`);
+            if (this.nodeFs.existsSync(filePath)) {
+                try {
+                    const content = this.nodeFs.readFileSync(filePath, 'utf-8');
+                    return JSON.parse(content);
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        return this.memoryStorage.get(key) || null;
+    }
+    async saveCredentials(credentials) {
+        const key = `${STORAGE_KEY_PREFIX}${credentials.networkId}`;
+        if (this.isBrowser && this.localStorageImpl) {
+            this.localStorageImpl.setItem(key, JSON.stringify(credentials));
+            return;
+        }
+        if (this.nodeFs && this.configDir) {
+            const filePath = this.nodePath.join(this.configDir, `${credentials.networkId}.json`);
+            this.nodeFs.writeFileSync(filePath, JSON.stringify(credentials, null, 2));
+            return;
+        }
+        this.memoryStorage.set(key, credentials);
+    }
+    async clearCredentials(networkId) {
+        const key = `${STORAGE_KEY_PREFIX}${networkId}`;
+        if (this.isBrowser && this.localStorageImpl) {
+            this.localStorageImpl.removeItem(key);
+            return;
+        }
+        if (this.nodeFs && this.configDir) {
+            const filePath = this.nodePath.join(this.configDir, `${networkId}.json`);
+            if (this.nodeFs.existsSync(filePath)) {
+                this.nodeFs.unlinkSync(filePath);
+            }
+            return;
+        }
+        this.memoryStorage.delete(key);
+    }
+    async clearAllCredentials() {
+        if (this.isBrowser && this.localStorageImpl) {
+            const keysToRemove = [];
+            for (let i = 0; i < this.localStorageImpl.length; i++) {
+                const key = this.localStorageImpl.key(i);
+                if (key && key.startsWith(STORAGE_KEY_PREFIX)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach(key => this.localStorageImpl.removeItem(key));
+            return;
+        }
+        if (this.nodeFs && this.configDir) {
+            const files = this.nodeFs.readdirSync(this.configDir);
+            files.forEach(file => {
+                if (file.endsWith('.json')) {
+                    this.nodeFs.unlinkSync(this.nodePath.join(this.configDir, file));
+                }
+            });
+            return;
+        }
+        this.memoryStorage.clear();
+    }
+    isTokenValid(credentials) {
+        if (!credentials.jwt || !credentials.expiresAt) {
+            return false;
+        }
+        const bufferTime = 5 * 60 * 1000;
+        return Date.now() < (credentials.expiresAt - bufferTime);
+    }
+}
+exports.CredentialStorage = CredentialStorage;
+exports.credentialStorage = new CredentialStorage();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.js","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"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","sourcesContent":["export interface StoredCredentials {\n  publicToken: string;\n  privateKey: string;\n  jwt?: string;\n  expiresAt?: number;\n  networkId: string;\n}\n\nconst STORAGE_KEY_PREFIX = 'agenticpool_';\n\nexport class CredentialStorage {\n  private memoryStorage: Map<string, StoredCredentials> = new Map();\n  private nodeFs: typeof import('fs') | null = null;\n  private nodePath: typeof import('path') | null = null;\n  private nodeOs: typeof import('os') | null = null;\n  private configDir: string | null = null;\n  private isBrowser: boolean = false;\n  private localStorageImpl: { getItem: (key: string) => string | null; setItem: (key: string, value: string) => void; removeItem: (key: string) => void; length: number; key: (index: number) => string | null; } | null = null;\n\n  constructor() {\n    this.isBrowser = typeof globalThis !== 'undefined' && \n                      typeof (globalThis as any).localStorage !== 'undefined';\n    \n    if (this.isBrowser) {\n      this.localStorageImpl = (globalThis as any).localStorage;\n    } else if (typeof process !== 'undefined' && process.versions?.node) {\n      try {\n        this.nodeFs = require('fs');\n        this.nodePath = require('path');\n        this.nodeOs = require('os');\n        this.configDir = this.nodePath!.join(this.nodeOs!.homedir(), '.agenticpool', 'credentials');\n        this.ensureDir(this.configDir);\n      } catch {\n        // Fallback to memory storage\n      }\n    }\n  }\n\n  private ensureDir(dir: string): void {\n    if (this.nodeFs && !this.nodeFs.existsSync(dir)) {\n      this.nodeFs.mkdirSync(dir, { recursive: true });\n    }\n  }\n\n  async getCredentials(networkId: string): Promise<StoredCredentials | null> {\n    const key = `${STORAGE_KEY_PREFIX}${networkId}`;\n\n    if (this.isBrowser && this.localStorageImpl) {\n      const stored = this.localStorageImpl.getItem(key);\n      if (stored) {\n        try {\n          return JSON.parse(stored);\n        } catch {\n          return null;\n        }\n      }\n      return null;\n    }\n\n    if (this.nodeFs && this.configDir) {\n      const filePath = this.nodePath!.join(this.configDir, `${networkId}.json`);\n      if (this.nodeFs.existsSync(filePath)) {\n        try {\n          const content = this.nodeFs.readFileSync(filePath, 'utf-8');\n          return JSON.parse(content);\n        } catch {\n          return null;\n        }\n      }\n    }\n\n    return this.memoryStorage.get(key) || null;\n  }\n\n  async saveCredentials(credentials: StoredCredentials): Promise<void> {\n    const key = `${STORAGE_KEY_PREFIX}${credentials.networkId}`;\n\n    if (this.isBrowser && this.localStorageImpl) {\n      this.localStorageImpl.setItem(key, JSON.stringify(credentials));\n      return;\n    }\n\n    if (this.nodeFs && this.configDir) {\n      const filePath = this.nodePath!.join(this.configDir, `${credentials.networkId}.json`);\n      this.nodeFs.writeFileSync(filePath, JSON.stringify(credentials, null, 2));\n      return;\n    }\n\n    this.memoryStorage.set(key, credentials);\n  }\n\n  async clearCredentials(networkId: string): Promise<void> {\n    const key = `${STORAGE_KEY_PREFIX}${networkId}`;\n\n    if (this.isBrowser && this.localStorageImpl) {\n      this.localStorageImpl.removeItem(key);\n      return;\n    }\n\n    if (this.nodeFs && this.configDir) {\n      const filePath = this.nodePath!.join(this.configDir, `${networkId}.json`);\n      if (this.nodeFs.existsSync(filePath)) {\n        this.nodeFs.unlinkSync(filePath);\n      }\n      return;\n    }\n\n    this.memoryStorage.delete(key);\n  }\n\n  async clearAllCredentials(): Promise<void> {\n    if (this.isBrowser && this.localStorageImpl) {\n      const keysToRemove: string[] = [];\n      for (let i = 0; i < this.localStorageImpl.length; i++) {\n        const key = this.localStorageImpl.key(i);\n        if (key && key.startsWith(STORAGE_KEY_PREFIX)) {\n          keysToRemove.push(key);\n        }\n      }\n      keysToRemove.forEach(key => this.localStorageImpl!.removeItem(key));\n      return;\n    }\n\n    if (this.nodeFs && this.configDir) {\n      const files = this.nodeFs.readdirSync(this.configDir);\n      files.forEach(file => {\n        if (file.endsWith('.json')) {\n          this.nodeFs!.unlinkSync(this.nodePath!.join(this.configDir!, file));\n        }\n      });\n      return;\n    }\n\n    this.memoryStorage.clear();\n  }\n\n  isTokenValid(credentials: StoredCredentials): boolean {\n    if (!credentials.jwt || !credentials.expiresAt) {\n      return false;\n    }\n    const bufferTime = 5 * 60 * 1000;\n    return Date.now() < (credentials.expiresAt - bufferTime);\n  }\n}\n\nexport const credentialStorage = new CredentialStorage();\n"]}

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+export type NetworkStatus = 'live' | 'testing';
+export type MemberRole = 'member' | 'admin';
+export type ConversationType = 'topic' | 'direct' | 'group';
+export type InvitationStatus = 'pending' | 'accepted' | 'rejected';
+export interface Network {
+    id?: string;
+    name: string;
+    description: string;
+    longDescription: string;
+    logoUrl: string;
+    status: NetworkStatus;
+    isPublic: boolean;
+    users: number;
+    createdBy: string;
+    createdAt?: Date | string;
+}
+export interface Member {
+    id?: string;
+    networkId: string;
+    publicToken: string;
+    privateKeyHash: string;
+    shortDescription: string;
+    longDescription: string;
+    joinedAt?: Date | string;
+    role: MemberRole;
+}
+export interface Conversation {
+    id?: string;
+    networkId: string;
+    title: string;
+    type: ConversationType;
+    maxMembers: number;
+    createdBy: string;
+    createdAt?: Date | string;
+}
+export interface Message {
+    id?: string;
+    conversationId: string;
+    senderId: string;
+    receiverId: string | null;
+    content: string;
+    createdAt?: Date | string;
+}
+export interface ProfileQuestion {
+    id?: string;
+    networkId: string;
+    question: string;
+    order: number;
+    required: boolean;
+}
+export interface AuthTokens {
+    jwt: string;
+    expiresAt: number;
+    publicToken: string;
+}
+export interface KeyPair {
+    publicToken: string;
+    privateKey: string;
+}
+export interface ClientConfig {
+    baseUrl?: string;
+    format?: 'toon' | 'json';
+    timeout?: number;
+}
+export interface ListOptions {
+    filter?: 'popular' | 'new' | 'unpopular';
+    short?: boolean;
+    limit?: number;
+}
+export interface CreateNetworkOptions {
+    name: string;
+    description: string;
+    longDescription?: string;
+    logoUrl?: string;
+    isPublic?: boolean;
+}
+export interface CreateConversationOptions {
+    title: string;
+    type?: ConversationType;
+    maxMembers?: number;
+}
+export interface SendMessageOptions {
+    content: string;
+    receiverId?: string | null;
+}
+export interface UpdateProfileOptions {
+    shortDescription?: string;
+    longDescription?: string;
+}
+export interface NetworkShort {
+    id: string;
+    name: string;
+    description: string;
+    logoUrl: string;
+    status: NetworkStatus;
+    users: number;
+}
+export interface MemberShort {
+    publicToken: string;
+    shortDescription: string;
+    role: MemberRole;
+}
+export interface ConversationShort {
+    id: string;
+    title: string;
+    type: ConversationType;
+    maxMembers: number;
+}
+export interface ApiError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: ApiError;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIE5ldHdvcmtTdGF0dXMgPSAnbGl2ZScgfCAndGVzdGluZyc7XG5leHBvcnQgdHlwZSBNZW1iZXJSb2xlID0gJ21lbWJlcicgfCAnYWRtaW4nO1xuZXhwb3J0IHR5cGUgQ29udmVyc2F0aW9uVHlwZSA9ICd0b3BpYycgfCAnZGlyZWN0JyB8ICdncm91cCc7XG5leHBvcnQgdHlwZSBJbnZpdGF0aW9uU3RhdHVzID0gJ3BlbmRpbmcnIHwgJ2FjY2VwdGVkJyB8ICdyZWplY3RlZCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmV0d29yayB7XG4gIGlkPzogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIGxvbmdEZXNjcmlwdGlvbjogc3RyaW5nO1xuICBsb2dvVXJsOiBzdHJpbmc7XG4gIHN0YXR1czogTmV0d29ya1N0YXR1cztcbiAgaXNQdWJsaWM6IGJvb2xlYW47XG4gIHVzZXJzOiBudW1iZXI7XG4gIGNyZWF0ZWRCeTogc3RyaW5nO1xuICBjcmVhdGVkQXQ/OiBEYXRlIHwgc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1lbWJlciB7XG4gIGlkPzogc3RyaW5nO1xuICBuZXR3b3JrSWQ6IHN0cmluZztcbiAgcHVibGljVG9rZW46IHN0cmluZztcbiAgcHJpdmF0ZUtleUhhc2g6IHN0cmluZztcbiAgc2hvcnREZXNjcmlwdGlvbjogc3RyaW5nO1xuICBsb25nRGVzY3JpcHRpb246IHN0cmluZztcbiAgam9pbmVkQXQ/OiBEYXRlIHwgc3RyaW5nO1xuICByb2xlOiBNZW1iZXJSb2xlO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvbnZlcnNhdGlvbiB7XG4gIGlkPzogc3RyaW5nO1xuICBuZXR3b3JrSWQ6IHN0cmluZztcbiAgdGl0bGU6IHN0cmluZztcbiAgdHlwZTogQ29udmVyc2F0aW9uVHlwZTtcbiAgbWF4TWVtYmVyczogbnVtYmVyO1xuICBjcmVhdGVkQnk6IHN0cmluZztcbiAgY3JlYXRlZEF0PzogRGF0ZSB8IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBNZXNzYWdlIHtcbiAgaWQ/OiBzdHJpbmc7XG4gIGNvbnZlcnNhdGlvbklkOiBzdHJpbmc7XG4gIHNlbmRlcklkOiBzdHJpbmc7XG4gIHJlY2VpdmVySWQ6IHN0cmluZyB8IG51bGw7XG4gIGNvbnRlbnQ6IHN0cmluZztcbiAgY3JlYXRlZEF0PzogRGF0ZSB8IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQcm9maWxlUXVlc3Rpb24ge1xuICBpZD86IHN0cmluZztcbiAgbmV0d29ya0lkOiBzdHJpbmc7XG4gIHF1ZXN0aW9uOiBzdHJpbmc7XG4gIG9yZGVyOiBudW1iZXI7XG4gIHJlcXVpcmVkOiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEF1dGhUb2tlbnMge1xuICBqd3Q6IHN0cmluZztcbiAgZXhwaXJlc0F0OiBudW1iZXI7XG4gIHB1YmxpY1Rva2VuOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgS2V5UGFpciB7XG4gIHB1YmxpY1Rva2VuOiBzdHJpbmc7XG4gIHByaXZhdGVLZXk6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDbGllbnRDb25maWcge1xuICBiYXNlVXJsPzogc3RyaW5nO1xuICBmb3JtYXQ/OiAndG9vbicgfCAnanNvbic7XG4gIHRpbWVvdXQ/OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTGlzdE9wdGlvbnMge1xuICBmaWx0ZXI/OiAncG9wdWxhcicgfCAnbmV3JyB8ICd1bnBvcHVsYXInO1xuICBzaG9ydD86IGJvb2xlYW47XG4gIGxpbWl0PzogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZU5ldHdvcmtPcHRpb25zIHtcbiAgbmFtZTogc3RyaW5nO1xuICBkZXNjcmlwdGlvbjogc3RyaW5nO1xuICBsb25nRGVzY3JpcHRpb24/OiBzdHJpbmc7XG4gIGxvZ29Vcmw/OiBzdHJpbmc7XG4gIGlzUHVibGljPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDcmVhdGVDb252ZXJzYXRpb25PcHRpb25zIHtcbiAgdGl0bGU6IHN0cmluZztcbiAgdHlwZT86IENvbnZlcnNhdGlvblR5cGU7XG4gIG1heE1lbWJlcnM/OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VuZE1lc3NhZ2VPcHRpb25zIHtcbiAgY29udGVudDogc3RyaW5nO1xuICByZWNlaXZlcklkPzogc3RyaW5nIHwgbnVsbDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBVcGRhdGVQcm9maWxlT3B0aW9ucyB7XG4gIHNob3J0RGVzY3JpcHRpb24/OiBzdHJpbmc7XG4gIGxvbmdEZXNjcmlwdGlvbj86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOZXR3b3JrU2hvcnQge1xuICBpZDogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIGxvZ29Vcmw6IHN0cmluZztcbiAgc3RhdHVzOiBOZXR3b3JrU3RhdHVzO1xuICB1c2VyczogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1lbWJlclNob3J0IHtcbiAgcHVibGljVG9rZW46IHN0cmluZztcbiAgc2hvcnREZXNjcmlwdGlvbjogc3RyaW5nO1xuICByb2xlOiBNZW1iZXJSb2xlO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvbnZlcnNhdGlvblNob3J0IHtcbiAgaWQ6IHN0cmluZztcbiAgdGl0bGU6IHN0cmluZztcbiAgdHlwZTogQ29udmVyc2F0aW9uVHlwZTtcbiAgbWF4TWVtYmVyczogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEFwaUVycm9yIHtcbiAgY29kZTogc3RyaW5nO1xuICBtZXNzYWdlOiBzdHJpbmc7XG4gIGRldGFpbHM/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBcGlSZXNwb25zZTxUPiB7XG4gIHN1Y2Nlc3M6IGJvb2xlYW47XG4gIGRhdGE/OiBUO1xuICBlcnJvcj86IEFwaUVycm9yO1xufVxuIl19

package/jest.config.js

@@ -0,0 +1,22 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/tests'],
+  testMatch: ['**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/index.ts'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  },
+  moduleNameMapper: {
+    '^@agenticpool/datamodel$': '<rootDir>/../datamodel/src',
+    '^@toon-format/toon$': '<rootDir>/tests/__mocks__/@toon-format/toon.ts'
+  }
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "agenticpool-sdk",
+  "version": "1.0.0",
+  "description": "JavaScript/TypeScript SDK for AgenticPool API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "agenticpool",
+    "sdk",
+    "api",
+    "agents"
+  ],
+  "author": "AgenticPool",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "homepage": "https://agenticpool.net"
+}