pollax 1.0.0

package/dist/index.js

@@ -0,0 +1,907 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Agents: () => Agents,
+  Analytics: () => Analytics,
+  ApiKeys: () => ApiKeys,
+  AuthenticationError: () => AuthenticationError,
+  Calls: () => Calls,
+  Campaigns: () => Campaigns,
+  Integrations: () => Integrations,
+  Knowledge: () => Knowledge,
+  NotFoundError: () => NotFoundError,
+  PhoneNumbers: () => PhoneNumbers,
+  Pollax: () => Pollax,
+  PollaxError: () => PollaxError,
+  RateLimitError: () => RateLimitError,
+  ValidationError: () => ValidationError,
+  VoiceCloning: () => VoiceCloning,
+  default: () => Pollax
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_axios = __toESM(require("axios"));
+
+// src/resources/agents.ts
+var Agents = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new AI agent
+   * 
+   * @example
+   * const agent = await pollax.agents.create({
+   *   name: 'Customer Support Agent',
+   *   system_prompt: 'You are a helpful customer support agent.',
+   *   voice_id: 'alloy',
+   *   model: 'gpt-4',
+   * });
+   */
+  async create(params) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/agents",
+      data: params
+    });
+  }
+  /**
+   * List all agents
+   * 
+   * @example
+   * const agents = await pollax.agents.list({ is_active: true });
+   */
+  async list(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/agents",
+      params
+    });
+  }
+  /**
+   * Get a single agent by ID
+   * 
+   * @example
+   * const agent = await pollax.agents.retrieve('agent_123');
+   */
+  async retrieve(agentId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/agents/${agentId}`
+    });
+  }
+  /**
+   * Update an agent
+   * 
+   * @example
+   * const agent = await pollax.agents.update('agent_123', {
+   *   name: 'Updated Agent Name',
+   *   is_active: false,
+   * });
+   */
+  async update(agentId, params) {
+    return this.request({
+      method: "PUT",
+      url: `/api/v1/agents/${agentId}`,
+      data: params
+    });
+  }
+  /**
+   * Delete an agent
+   * 
+   * @example
+   * await pollax.agents.delete('agent_123');
+   */
+  async delete(agentId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/agents/${agentId}`
+    });
+  }
+  /**
+   * Test an agent with a sample prompt
+   * 
+   * @example
+   * const response = await pollax.agents.test('agent_123', {
+   *   message: 'Hello, how can you help me?',
+   * });
+   */
+  async test(agentId, params) {
+    return this.request({
+      method: "POST",
+      url: `/api/v1/agents/${agentId}/test`,
+      data: params
+    });
+  }
+};
+
+// src/resources/calls.ts
+var Calls = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new voice call
+   * 
+   * @example
+   * const call = await pollax.calls.create({
+   *   agent_id: 'agent_123',
+   *   to_number: '+1234567890',
+   * });
+   */
+  async create(params) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/calls",
+      data: params
+    });
+  }
+  /**
+   * List all calls
+   * 
+   * @example
+   * const calls = await pollax.calls.list({
+   *   agent_id: 'agent_123',
+   *   status: 'completed',
+   * });
+   */
+  async list(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/calls",
+      params
+    });
+  }
+  /**
+   * Get a single call by SID
+   * 
+   * @example
+   * const call = await pollax.calls.retrieve('CA123456789');
+   */
+  async retrieve(callSid) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/calls/${callSid}`
+    });
+  }
+  /**
+   * End an active call
+   * 
+   * @example
+   * await pollax.calls.end('CA123456789');
+   */
+  async end(callSid) {
+    return this.request({
+      method: "POST",
+      url: `/api/v1/calls/${callSid}/end`
+    });
+  }
+  /**
+   * Transfer a call to another number
+   * 
+   * @example
+   * await pollax.calls.transfer('CA123456789', {
+   *   to_number: '+1234567890',
+   * });
+   */
+  async transfer(callSid, params) {
+    return this.request({
+      method: "POST",
+      url: `/api/v1/calls/${callSid}/transfer`,
+      data: params
+    });
+  }
+  /**
+   * Get call transcript
+   * 
+   * @example
+   * const transcript = await pollax.calls.getTranscript('CA123456789');
+   */
+  async getTranscript(callSid) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/calls/${callSid}/transcript`
+    });
+  }
+  /**
+   * Get call recording URL
+   * 
+   * @example
+   * const recording = await pollax.calls.getRecording('CA123456789');
+   */
+  async getRecording(callSid) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/calls/${callSid}/recording`
+    });
+  }
+};
+
+// src/resources/campaigns.ts
+var Campaigns = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new campaign
+   * 
+   * @example
+   * const campaign = await pollax.campaigns.create({
+   *   name: 'Q1 Outreach Campaign',
+   *   agent_id: 'agent_123',
+   *   contacts: [
+   *     { name: 'John Doe', phone: '+1234567890' },
+   *     { name: 'Jane Smith', phone: '+0987654321' },
+   *   ],
+   * });
+   */
+  async create(params) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/campaigns",
+      data: params
+    });
+  }
+  /**
+   * List all campaigns
+   * 
+   * @example
+   * const campaigns = await pollax.campaigns.list();
+   */
+  async list() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/campaigns"
+    });
+  }
+  /**
+   * Get a single campaign by ID
+   * 
+   * @example
+   * const campaign = await pollax.campaigns.retrieve('campaign_123');
+   */
+  async retrieve(campaignId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/campaigns/${campaignId}`
+    });
+  }
+  /**
+   * Update a campaign
+   * 
+   * @example
+   * const campaign = await pollax.campaigns.update('campaign_123', {
+   *   status: 'paused',
+   * });
+   */
+  async update(campaignId, params) {
+    return this.request({
+      method: "PUT",
+      url: `/api/v1/campaigns/${campaignId}`,
+      data: params
+    });
+  }
+  /**
+   * Delete a campaign
+   * 
+   * @example
+   * await pollax.campaigns.delete('campaign_123');
+   */
+  async delete(campaignId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/campaigns/${campaignId}`
+    });
+  }
+  /**
+   * Start a campaign
+   * 
+   * @example
+   * await pollax.campaigns.start('campaign_123');
+   */
+  async start(campaignId) {
+    return this.request({
+      method: "POST",
+      url: `/api/v1/campaigns/${campaignId}/start`
+    });
+  }
+  /**
+   * Pause a running campaign
+   * 
+   * @example
+   * await pollax.campaigns.pause('campaign_123');
+   */
+  async pause(campaignId) {
+    return this.request({
+      method: "POST",
+      url: `/api/v1/campaigns/${campaignId}/pause`
+    });
+  }
+  /**
+   * Upload contacts to a campaign via CSV
+   * 
+   * @example
+   * const campaign = await pollax.campaigns.uploadContacts('campaign_123', csvFile);
+   */
+  async uploadContacts(campaignId, file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.request({
+      method: "POST",
+      url: `/api/v1/campaigns/${campaignId}/upload`,
+      data: formData,
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  }
+  /**
+   * Get campaign statistics
+   * 
+   * @example
+   * const stats = await pollax.campaigns.getStats('campaign_123');
+   */
+  async getStats(campaignId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/campaigns/${campaignId}/stats`
+    });
+  }
+};
+
+// src/resources/knowledge.ts
+var Knowledge = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Upload a document to the knowledge base
+   * 
+   * @example
+   * const doc = await pollax.knowledge.upload({
+   *   name: 'Product Manual',
+   *   file: pdfFile,
+   *   type: 'pdf',
+   * });
+   */
+  async upload(params) {
+    const formData = new FormData();
+    formData.append("name", params.name);
+    if (params.file) {
+      formData.append("file", params.file);
+    }
+    if (params.content) {
+      formData.append("content", params.content);
+    }
+    if (params.url) {
+      formData.append("url", params.url);
+    }
+    if (params.type) {
+      formData.append("type", params.type);
+    }
+    return this.request({
+      method: "POST",
+      url: "/api/v1/knowledge",
+      data: formData,
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  }
+  /**
+   * List all knowledge documents
+   * 
+   * @example
+   * const documents = await pollax.knowledge.list();
+   */
+  async list() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/knowledge"
+    });
+  }
+  /**
+   * Get a single document by ID
+   * 
+   * @example
+   * const doc = await pollax.knowledge.retrieve('doc_123');
+   */
+  async retrieve(documentId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/knowledge/${documentId}`
+    });
+  }
+  /**
+   * Delete a document
+   * 
+   * @example
+   * await pollax.knowledge.delete('doc_123');
+   */
+  async delete(documentId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/knowledge/${documentId}`
+    });
+  }
+  /**
+   * Search the knowledge base
+   * 
+   * @example
+   * const results = await pollax.knowledge.search({
+   *   query: 'How do I reset my password?',
+   *   limit: 5,
+   * });
+   */
+  async search(params) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/knowledge/search",
+      data: params
+    });
+  }
+};
+
+// src/resources/analytics.ts
+var Analytics = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Get dashboard statistics
+   * 
+   * @example
+   * const stats = await pollax.analytics.getStats();
+   */
+  async getStats() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/analytics/stats"
+    });
+  }
+  /**
+   * Get call volume over time
+   * 
+   * @example
+   * const volume = await pollax.analytics.getCallVolume({ period: '7d' });
+   */
+  async getCallVolume(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/analytics/call-volume",
+      params
+    });
+  }
+  /**
+   * Get agent performance metrics
+   * 
+   * @example
+   * const performance = await pollax.analytics.getAgentPerformance('agent_123');
+   */
+  async getAgentPerformance(agentId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/analytics/agents/${agentId}/performance`
+    });
+  }
+  /**
+   * Export analytics data
+   * 
+   * @example
+   * const csvData = await pollax.analytics.export({
+   *   start_date: '2024-01-01',
+   *   end_date: '2024-01-31',
+   *   format: 'csv',
+   * });
+   */
+  async export(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/analytics/export",
+      params
+    });
+  }
+};
+
+// src/resources/integrations.ts
+var Integrations = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new integration
+   * 
+   * @example
+   * const integration = await pollax.integrations.create({
+   *   name: 'Salesforce CRM',
+   *   type: 'salesforce',
+   *   config: {
+   *     client_id: '...',
+   *     client_secret: '...',
+   *   },
+   * });
+   */
+  async create(params) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/integrations",
+      data: params
+    });
+  }
+  /**
+   * List all integrations
+   * 
+   * @example
+   * const integrations = await pollax.integrations.list();
+   */
+  async list() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/integrations"
+    });
+  }
+  /**
+   * Get a single integration by ID
+   * 
+   * @example
+   * const integration = await pollax.integrations.retrieve('int_123');
+   */
+  async retrieve(integrationId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/integrations/${integrationId}`
+    });
+  }
+  /**
+   * Delete an integration
+   * 
+   * @example
+   * await pollax.integrations.delete('int_123');
+   */
+  async delete(integrationId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/integrations/${integrationId}`
+    });
+  }
+};
+
+// src/resources/phone-numbers.ts
+var PhoneNumbers = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * List all phone numbers
+   * 
+   * @example
+   * const numbers = await pollax.phoneNumbers.list();
+   */
+  async list() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/phone-numbers"
+    });
+  }
+  /**
+   * Search available phone numbers
+   * 
+   * @example
+   * const numbers = await pollax.phoneNumbers.search({
+   *   country_code: 'US',
+   *   area_code: '415',
+   * });
+   */
+  async search(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/phone-numbers/search",
+      params
+    });
+  }
+  /**
+   * Purchase a phone number
+   * 
+   * @example
+   * const number = await pollax.phoneNumbers.purchase('+14155551234');
+   */
+  async purchase(phoneNumber) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/phone-numbers",
+      data: { phone_number: phoneNumber }
+    });
+  }
+  /**
+   * Release a phone number
+   * 
+   * @example
+   * await pollax.phoneNumbers.release('num_123');
+   */
+  async release(numberId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/phone-numbers/${numberId}`
+    });
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeys = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new API key
+   * 
+   * @example
+   * const apiKey = await pollax.apiKeys.create({
+   *   name: 'Production Key',
+   *   permissions: ['read', 'write'],
+   * });
+   */
+  async create(params) {
+    return this.request({
+      method: "POST",
+      url: "/api/v1/api-keys",
+      data: params
+    });
+  }
+  /**
+   * List all API keys
+   * 
+   * @example
+   * const keys = await pollax.apiKeys.list();
+   */
+  async list() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/api-keys"
+    });
+  }
+  /**
+   * Revoke an API key
+   * 
+   * @example
+   * await pollax.apiKeys.revoke('key_123');
+   */
+  async revoke(keyId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/api-keys/${keyId}`
+    });
+  }
+};
+
+// src/resources/voice-cloning.ts
+var VoiceCloning = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new voice profile
+   * 
+   * @example
+   * const voice = await pollax.voiceCloning.create({
+   *   name: 'Custom Voice',
+   *   description: 'My custom voice profile',
+   *   audio_files: [audioFile1, audioFile2],
+   * });
+   */
+  async create(params) {
+    const formData = new FormData();
+    formData.append("name", params.name);
+    if (params.description) {
+      formData.append("description", params.description);
+    }
+    if (params.provider) {
+      formData.append("provider", params.provider);
+    }
+    params.audio_files.forEach((file, index) => {
+      formData.append("audio_files", file, `audio_${index}.wav`);
+    });
+    return this.request({
+      method: "POST",
+      url: "/api/v1/voice-cloning",
+      data: formData,
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  }
+  /**
+   * List all voice profiles
+   * 
+   * @example
+   * const voices = await pollax.voiceCloning.list();
+   */
+  async list() {
+    return this.request({
+      method: "GET",
+      url: "/api/v1/voice-cloning"
+    });
+  }
+  /**
+   * Get a single voice profile by ID
+   * 
+   * @example
+   * const voice = await pollax.voiceCloning.retrieve('voice_123');
+   */
+  async retrieve(voiceId) {
+    return this.request({
+      method: "GET",
+      url: `/api/v1/voice-cloning/${voiceId}`
+    });
+  }
+  /**
+   * Delete a voice profile
+   * 
+   * @example
+   * await pollax.voiceCloning.delete('voice_123');
+   */
+  async delete(voiceId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/v1/voice-cloning/${voiceId}`
+    });
+  }
+};
+
+// src/errors.ts
+var PollaxError = class _PollaxError extends Error {
+  constructor(message, statusCode = 0, response) {
+    super(message);
+    this.name = "PollaxError";
+    this.statusCode = statusCode;
+    this.response = response;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _PollaxError);
+    }
+  }
+};
+var AuthenticationError = class extends PollaxError {
+  constructor(message = "Authentication failed", response) {
+    super(message, 401, response);
+    this.name = "AuthenticationError";
+  }
+};
+var NotFoundError = class extends PollaxError {
+  constructor(message = "Resource not found", response) {
+    super(message, 404, response);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends PollaxError {
+  constructor(message = "Rate limit exceeded", response) {
+    super(message, 429, response);
+    this.name = "RateLimitError";
+  }
+};
+var ValidationError = class extends PollaxError {
+  constructor(message = "Validation error", response) {
+    super(message, 400, response);
+    this.name = "ValidationError";
+  }
+};
+
+// src/client.ts
+var Pollax = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new PollaxError("API key is required. Get one at https://pollax.ai/settings/api-keys");
+    }
+    this.maxRetries = config.maxRetries || 3;
+    const headers = {
+      "Authorization": `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": "Pollax-SDK-TypeScript/1.0.0"
+    };
+    if (config.tenantId) {
+      headers["X-Tenant-ID"] = config.tenantId;
+    }
+    this.client = import_axios.default.create({
+      baseURL: config.baseURL || "https://api.pollax.ai",
+      timeout: config.timeout || 3e4,
+      headers
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response) {
+          const { status, data } = error.response;
+          if (status === 429 && this.maxRetries > 0) {
+            const retryAfter = parseInt(error.response.headers["retry-after"] || "1", 10);
+            await this.sleep(retryAfter * 1e3);
+            return this.client.request(error.config);
+          }
+          throw new PollaxError(
+            data.error || data.detail || "An error occurred",
+            status,
+            data
+          );
+        }
+        throw new PollaxError(
+          error.message || "Network error occurred",
+          0,
+          error
+        );
+      }
+    );
+    this.agents = new Agents(this.request.bind(this));
+    this.calls = new Calls(this.request.bind(this));
+    this.campaigns = new Campaigns(this.request.bind(this));
+    this.knowledge = new Knowledge(this.request.bind(this));
+    this.analytics = new Analytics(this.request.bind(this));
+    this.integrations = new Integrations(this.request.bind(this));
+    this.phoneNumbers = new PhoneNumbers(this.request.bind(this));
+    this.apiKeys = new ApiKeys(this.request.bind(this));
+    this.voiceCloning = new VoiceCloning(this.request.bind(this));
+  }
+  /**
+   * Make an HTTP request with automatic retries
+   */
+  async request(config, retries = 0) {
+    try {
+      const response = await this.client.request(config);
+      return response.data;
+    } catch (error) {
+      if (retries < this.maxRetries && (error.code === "ECONNRESET" || error.code === "ETIMEDOUT" || error.response && error.response.status >= 500)) {
+        const delay = Math.pow(2, retries) * 1e3;
+        await this.sleep(delay);
+        return this.request(config, retries + 1);
+      }
+      throw error;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agents,
+  Analytics,
+  ApiKeys,
+  AuthenticationError,
+  Calls,
+  Campaigns,
+  Integrations,
+  Knowledge,
+  NotFoundError,
+  PhoneNumbers,
+  Pollax,
+  PollaxError,
+  RateLimitError,
+  ValidationError,
+  VoiceCloning
+});