@veroai/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1946 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/utils/errors.ts
+var VeroAIError = class extends Error {
+  code;
+  details;
+  statusCode;
+  constructor(message, code = "UNKNOWN_ERROR", statusCode, details) {
+    super(message);
+    this.name = "VeroAIError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var APIError = class extends VeroAIError {
+  response;
+  constructor(message, code, statusCode, details, response) {
+    super(message, code, statusCode, details);
+    this.name = "APIError";
+    this.response = response;
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(message = "Invalid API key or token", details) {
+    super(message, "AUTHENTICATION_ERROR", 401, details);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends APIError {
+  constructor(message = "Insufficient permissions", details) {
+    super(message, "AUTHORIZATION_ERROR", 403, details);
+    this.name = "AuthorizationError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message = "Resource not found", details) {
+    super(message, "NOT_FOUND", 404, details);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends APIError {
+  constructor(message = "Invalid request", details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends APIError {
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter, details) {
+    super(message, "RATE_LIMIT_EXCEEDED", 429, details);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends APIError {
+  constructor(message = "Internal server error", statusCode = 500, details) {
+    super(message, "SERVER_ERROR", statusCode, details);
+    this.name = "ServerError";
+  }
+};
+var TimeoutError = class extends VeroAIError {
+  constructor(message = "Request timed out") {
+    super(message, "TIMEOUT_ERROR");
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends VeroAIError {
+  constructor(message = "Network error", cause) {
+    super(message, "NETWORK_ERROR");
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+};
+
+// src/utils/http.ts
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  fetchFn;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || "https://api.veroai.dev";
+    this.timeout = config.timeout || 3e4;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.fetchFn = config.fetch || globalThis.fetch;
+    if (!this.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!this.fetchFn) {
+      throw new Error(
+        "fetch is not available. Please provide a fetch implementation or use Node.js >= 18."
+      );
+    }
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const headers = this.buildHeaders(options.headers);
+    const timeout = options.timeout || this.timeout;
+    let lastError = null;
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      try {
+        const response = await this.executeRequest(url, {
+          method: options.method,
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          timeout
+        });
+        if (!response.ok) {
+          const error = await this.handleErrorResponse(response);
+          if (response.status >= 500 || response.status === 429) {
+            const retryAfter = this.getRetryAfter(response, attempt);
+            if (attempt < this.maxRetries && retryAfter > 0) {
+              await this.sleep(retryAfter);
+              attempt++;
+              continue;
+            }
+          }
+          throw error;
+        }
+        if (response.status === 204) {
+          return void 0;
+        }
+        return await response.json();
+      } catch (error) {
+        if (error instanceof APIError) {
+          throw error;
+        }
+        lastError = error;
+        if (attempt < this.maxRetries) {
+          await this.sleep(this.calculateBackoff(attempt));
+          attempt++;
+          continue;
+        }
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+          throw new NetworkError("Failed to connect to API", error);
+        }
+        throw error;
+      }
+    }
+    throw lastError || new NetworkError("Request failed after retries");
+  }
+  async executeRequest(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+    try {
+      return await this.fetchFn(url, {
+        method: options.method,
+        headers: options.headers,
+        body: options.body,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${options.timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  buildUrl(path, query) {
+    const url = new URL(path.startsWith("/") ? path : `/${path}`, this.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(custom) {
+    const headers = new Headers({
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "User-Agent": "@veroai/sdk/0.1.0"
+    });
+    if (custom) {
+      for (const [key, value] of Object.entries(custom)) {
+        headers.set(key, value);
+      }
+    }
+    return headers;
+  }
+  async handleErrorResponse(response) {
+    let errorData = {};
+    try {
+      const json = await response.json();
+      if (json && typeof json === "object") {
+        errorData = json;
+      }
+    } catch {
+    }
+    const code = errorData.error?.code || "API_ERROR";
+    const message = errorData.error?.message || response.statusText || "Unknown error";
+    const details = errorData.error?.details;
+    switch (response.status) {
+      case 400:
+        return new ValidationError(message, details);
+      case 401:
+        return new AuthenticationError(message, details);
+      case 403:
+        return new AuthorizationError(message, details);
+      case 404:
+        return new NotFoundError(message, details);
+      case 429: {
+        const retryAfter = parseInt(response.headers.get("Retry-After") || "60", 10);
+        return new RateLimitError(message, retryAfter, details);
+      }
+      default:
+        if (response.status >= 500) {
+          return new ServerError(message, response.status, details);
+        }
+        return new APIError(message, code, response.status, details, response);
+    }
+  }
+  getRetryAfter(response, attempt) {
+    const retryAfterHeader = response.headers.get("Retry-After");
+    if (retryAfterHeader) {
+      const retryAfter = parseInt(retryAfterHeader, 10);
+      if (!isNaN(retryAfter)) {
+        return retryAfter * 1e3;
+      }
+    }
+    return this.calculateBackoff(attempt);
+  }
+  calculateBackoff(attempt) {
+    const baseDelay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+    const jitter = Math.random() * 1e3;
+    return baseDelay + jitter;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // Convenience methods
+  async get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  async post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  async put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  async patch(path, body) {
+    return this.request({ method: "PATCH", path, body });
+  }
+  async delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+};
+
+// src/resources/channels.ts
+function transformChannel(data) {
+  return {
+    id: data.id,
+    tenantId: data.tenant_id,
+    name: data.name,
+    description: data.description,
+    adapterType: data.adapter_type,
+    direction: data.direction,
+    status: data.status,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at
+  };
+}
+var ChannelsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all channels
+   */
+  async list() {
+    const response = await this.http.get("/v1/channels");
+    return {
+      data: response.channels.map(transformChannel),
+      total: response.total,
+      hasMore: false
+    };
+  }
+  /**
+   * Get a channel by ID
+   */
+  async get(channelId) {
+    const response = await this.http.get(`/v1/channels/${channelId}`);
+    return transformChannel(response.channel);
+  }
+  /**
+   * Create a new channel
+   * @returns The created channel and optionally an OAuth URL for OAuth-based adapters
+   */
+  async create(params) {
+    const response = await this.http.post("/v1/channels", {
+      name: params.name,
+      description: params.description,
+      adapter_type: params.adapterType,
+      direction: params.direction,
+      config: params.config
+    });
+    return {
+      channel: transformChannel(response.channel),
+      oauthUrl: response.oauth_url
+    };
+  }
+  /**
+   * Update a channel
+   */
+  async update(channelId, params) {
+    const response = await this.http.put(`/v1/channels/${channelId}`, {
+      name: params.name,
+      description: params.description,
+      status: params.status,
+      config: params.config
+    });
+    return transformChannel(response.channel);
+  }
+  /**
+   * Delete a channel
+   */
+  async delete(channelId) {
+    await this.http.delete(`/v1/channels/${channelId}`);
+  }
+  /**
+   * Test channel connectivity
+   */
+  async test(channelId) {
+    return this.http.post(`/v1/channels/${channelId}/test`);
+  }
+  /**
+   * Get channel health metrics
+   */
+  async health(channelId) {
+    const response = await this.http.get(`/v1/channels/${channelId}/health`);
+    return {
+      status: response.status,
+      lastEventAt: response.last_event_at,
+      errorCount24h: response.error_count_24h,
+      successRate: response.success_rate
+    };
+  }
+};
+
+// src/resources/events.ts
+function transformEvent(data) {
+  return {
+    eventId: data.event_id,
+    tenantId: data.tenant_id,
+    channelId: data.channel_id,
+    eventType: data.event_type,
+    canonicalType: data.canonical_type,
+    direction: data.direction,
+    adapterType: data.adapter_type,
+    occurredAt: data.occurred_at,
+    ingestedAt: data.ingested_at,
+    payload: data.payload
+  };
+}
+var EventsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List activity events with optional filters
+   */
+  async list(params = {}) {
+    const query = {
+      limit: params.limit,
+      offset: params.offset,
+      channel_id: params.channelId,
+      event_type: params.eventType,
+      canonical_type: params.canonicalType,
+      direction: params.direction
+    };
+    if (params.startDate) {
+      query.start_date = params.startDate instanceof Date ? params.startDate.toISOString() : params.startDate;
+    }
+    if (params.endDate) {
+      query.end_date = params.endDate instanceof Date ? params.endDate.toISOString() : params.endDate;
+    }
+    const response = await this.http.get("/v1/events", query);
+    return {
+      data: response.events.map(transformEvent),
+      total: response.total,
+      hasMore: response.next_offset !== void 0,
+      nextOffset: response.next_offset
+    };
+  }
+  /**
+   * Get a single event by ID
+   */
+  async get(eventId) {
+    const response = await this.http.get(`/v1/events/${eventId}`);
+    return transformEvent(response);
+  }
+  /**
+   * Get event statistics summary
+   */
+  async stats(options = {}) {
+    const response = await this.http.get("/v1/events/stats/summary", {
+      days: options.days || 7
+    });
+    return {
+      totalEvents: response.total_events,
+      eventsByType: response.events_by_type,
+      eventsByChannel: response.events_by_channel
+    };
+  }
+  /**
+   * Get time series data for charts
+   */
+  async timeseries(options = {}) {
+    const response = await this.http.get("/v1/events/stats/timeseries", {
+      days: options.days || 7,
+      granularity: options.granularity || "hour"
+    });
+    return response.data;
+  }
+};
+
+// src/resources/messages.ts
+var MessagesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send a message through a channel
+   *
+   * @example
+   * ```typescript
+   * // Send an SMS
+   * const result = await veroai.messages.send({
+   *   channelId: 'ch_abc123',
+   *   to: '+15551234567',
+   *   content: { type: 'text', text: 'Hello from VeroAI!' }
+   * });
+   *
+   * // Send an email
+   * const result = await veroai.messages.send({
+   *   channelId: 'ch_def456',
+   *   to: 'user@example.com',
+   *   subject: 'Welcome!',
+   *   content: {
+   *     type: 'html',
+   *     html: '<h1>Welcome to our platform</h1>'
+   *   }
+   * });
+   * ```
+   */
+  async send(params) {
+    const response = await this.http.post("/v1/messages", {
+      channel_id: params.channelId,
+      to: params.to,
+      subject: params.subject,
+      content: params.content,
+      metadata: params.metadata
+    });
+    return {
+      messageId: response.message_id,
+      eventId: response.event_id,
+      status: response.status,
+      providerMessageId: response.provider_message_id
+    };
+  }
+  /**
+   * Send a message to multiple recipients (batch)
+   *
+   * @example
+   * ```typescript
+   * const results = await veroai.messages.sendBatch({
+   *   channelId: 'ch_abc123',
+   *   messages: [
+   *     { to: '+15551234567', content: { type: 'text', text: 'Hello!' } },
+   *     { to: '+15559876543', content: { type: 'text', text: 'Hi there!' } },
+   *   ]
+   * });
+   * ```
+   */
+  async sendBatch(params) {
+    const results = [];
+    const batchSize = 100;
+    for (let i = 0; i < params.messages.length; i += batchSize) {
+      const batch = params.messages.slice(i, i + batchSize);
+      const batchResults = await Promise.all(
+        batch.map(
+          (msg) => this.send({
+            channelId: params.channelId,
+            to: msg.to,
+            subject: msg.subject,
+            content: msg.content,
+            metadata: msg.metadata
+          })
+        )
+      );
+      results.push(...batchResults);
+    }
+    return results;
+  }
+};
+
+// src/resources/webhooks.ts
+function transformWebhook(data) {
+  return {
+    id: data.id,
+    tenantId: data.tenant_id,
+    name: data.name,
+    url: data.url,
+    events: data.events,
+    channelId: data.channel_id,
+    headers: data.headers,
+    status: data.status,
+    retryConfig: {
+      enabled: data.retry_config?.enabled,
+      maxAttempts: data.retry_config?.max_attempts,
+      backoff: data.retry_config?.backoff
+    },
+    createdAt: data.created_at,
+    updatedAt: data.updated_at
+  };
+}
+function transformDelivery(data) {
+  return {
+    id: data.id,
+    webhookId: data.webhook_id,
+    eventId: data.event_id,
+    eventType: data.event_type,
+    status: data.status,
+    attempts: data.attempts,
+    responseCode: data.response_code,
+    responseBody: data.response_body,
+    responseTimeMs: data.response_time_ms,
+    createdAt: data.created_at,
+    completedAt: data.completed_at
+  };
+}
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all webhooks
+   */
+  async list() {
+    const response = await this.http.get("/v1/webhooks");
+    return {
+      data: response.webhooks.map(transformWebhook),
+      total: response.total,
+      hasMore: false
+    };
+  }
+  /**
+   * Get a webhook by ID
+   */
+  async get(webhookId) {
+    const response = await this.http.get(`/v1/webhooks/${webhookId}`);
+    return transformWebhook(response.webhook);
+  }
+  /**
+   * Create a new webhook
+   * @returns The created webhook and the signing secret (only returned once)
+   */
+  async create(params) {
+    const response = await this.http.post("/v1/webhooks", {
+      name: params.name,
+      url: params.url,
+      events: params.events,
+      channel_id: params.channelId,
+      headers: params.headers,
+      retry_config: params.retryConfig ? {
+        enabled: params.retryConfig.enabled ?? true,
+        max_attempts: params.retryConfig.maxAttempts ?? 5,
+        backoff: params.retryConfig.backoff ?? "exponential"
+      } : void 0
+    });
+    return {
+      webhook: transformWebhook(response.webhook),
+      secret: response.secret
+    };
+  }
+  /**
+   * Update a webhook
+   */
+  async update(webhookId, params) {
+    const response = await this.http.patch(`/v1/webhooks/${webhookId}`, {
+      name: params.name,
+      url: params.url,
+      events: params.events,
+      channel_id: params.channelId,
+      headers: params.headers,
+      status: params.status,
+      retry_config: params.retryConfig ? {
+        enabled: params.retryConfig.enabled,
+        max_attempts: params.retryConfig.maxAttempts,
+        backoff: params.retryConfig.backoff
+      } : void 0
+    });
+    return transformWebhook(response.webhook);
+  }
+  /**
+   * Delete a webhook
+   */
+  async delete(webhookId) {
+    await this.http.delete(`/v1/webhooks/${webhookId}`);
+  }
+  /**
+   * Regenerate webhook signing secret
+   * @returns The new signing secret (only returned once)
+   */
+  async regenerateSecret(webhookId) {
+    const response = await this.http.post(
+      `/v1/webhooks/${webhookId}/regenerate-secret`
+    );
+    return {
+      webhook: transformWebhook(response.webhook),
+      secret: response.secret
+    };
+  }
+  /**
+   * List delivery history for a webhook
+   */
+  async deliveries(webhookId, options = {}) {
+    const response = await this.http.get(
+      `/v1/webhooks/${webhookId}/deliveries`,
+      {
+        limit: options.limit || 50,
+        cursor: options.cursor
+      }
+    );
+    return {
+      data: response.deliveries.map(transformDelivery),
+      total: response.total,
+      hasMore: response.has_more,
+      nextCursor: response.next_cursor
+    };
+  }
+  /**
+   * Get webhook delivery statistics
+   */
+  async stats(webhookId, options = {}) {
+    const response = await this.http.get(
+      `/v1/webhooks/${webhookId}/stats`,
+      {
+        time_range: options.timeRange || "24h"
+      }
+    );
+    return {
+      total: response.total,
+      success: response.success,
+      failed: response.failed,
+      pending: response.pending,
+      successRate: response.success_rate,
+      averageResponseTimeMs: response.average_response_time_ms,
+      timeRange: response.time_range
+    };
+  }
+};
+
+// src/resources/api-keys.ts
+function transformApiKey(data) {
+  return {
+    id: data.id,
+    tenantId: data.tenant_id,
+    name: data.name,
+    keyPrefix: data.key_prefix,
+    environment: data.environment,
+    scopes: data.scopes,
+    expiresAt: data.expires_at,
+    lastUsedAt: data.last_used_at,
+    createdAt: data.created_at
+  };
+}
+var ApiKeysResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all API keys
+   */
+  async list() {
+    const response = await this.http.get("/v1/api-keys");
+    return {
+      data: response.api_keys.map(transformApiKey),
+      total: response.total,
+      hasMore: false
+    };
+  }
+  /**
+   * Get an API key by ID
+   */
+  async get(keyId) {
+    const response = await this.http.get(`/v1/api-keys/${keyId}`);
+    return transformApiKey(response.api_key);
+  }
+  /**
+   * Create a new API key
+   * @returns The created API key and the plaintext key (only returned once)
+   *
+   * @example
+   * ```typescript
+   * const { apiKey, key } = await veroai.apiKeys.create({
+   *   name: 'Production Key',
+   *   environment: 'production',
+   *   scopes: ['channels:read', 'channels:write', 'messages:send'],
+   * });
+   *
+   * // Save this key securely - it won't be shown again!
+   * console.log('API Key:', key); // sk_live_abc123...
+   * ```
+   */
+  async create(params) {
+    const response = await this.http.post("/v1/api-keys", {
+      name: params.name,
+      environment: params.environment,
+      scopes: params.scopes,
+      expires_at: params.expiresAt instanceof Date ? params.expiresAt.toISOString() : params.expiresAt
+    });
+    return {
+      apiKey: transformApiKey(response.api_key),
+      key: response.key
+    };
+  }
+  /**
+   * Delete (revoke) an API key
+   */
+  async delete(keyId) {
+    await this.http.delete(`/v1/api-keys/${keyId}`);
+  }
+  /**
+   * Alias for delete - revoke an API key
+   */
+  async revoke(keyId) {
+    return this.delete(keyId);
+  }
+};
+
+// src/resources/domains.ts
+function transformDomain(data) {
+  return {
+    id: data.id,
+    tenantId: data.tenant_id,
+    domain: data.domain,
+    status: data.status,
+    verificationRecord: data.verification_record,
+    verificationStatus: {
+      dkim: data.verification_status.dkim,
+      spf: data.verification_status.spf,
+      dmarc: data.verification_status.dmarc,
+      mx: data.verification_status.mx,
+      lastCheckedAt: data.verification_status.last_checked_at
+    },
+    dnsRecords: data.dns_records.map((record) => ({
+      type: record.type,
+      name: record.name,
+      value: record.value,
+      priority: record.priority,
+      verified: record.verified
+    })),
+    createdAt: data.created_at,
+    updatedAt: data.updated_at
+  };
+}
+var DomainsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all domains
+   */
+  async list() {
+    const response = await this.http.get("/v1/domains");
+    return {
+      data: response.domains.map(transformDomain),
+      total: response.total,
+      hasMore: false
+    };
+  }
+  /**
+   * Get a domain by ID
+   */
+  async get(domainId) {
+    const response = await this.http.get(`/v1/domains/${domainId}`);
+    return transformDomain(response.domain);
+  }
+  /**
+   * Add a new domain
+   *
+   * @example
+   * ```typescript
+   * // Manual DNS verification
+   * const { domain } = await veroai.domains.create({
+   *   domain: 'example.com',
+   *   verificationMethod: 'manual',
+   * });
+   *
+   * // Automatic via Cloudflare
+   * const { domain } = await veroai.domains.create({
+   *   domain: 'example.com',
+   *   verificationMethod: 'cloudflare',
+   *   cloudflareApiToken: 'your_cf_token',
+   * });
+   * ```
+   */
+  async create(params) {
+    const response = await this.http.post("/v1/domains", {
+      domain: params.domain,
+      verification_method: params.verificationMethod,
+      cloudflare_api_token: params.cloudflareApiToken
+    });
+    return {
+      domain: transformDomain(response.domain),
+      verificationRecord: response.verification_record
+    };
+  }
+  /**
+   * Delete a domain
+   */
+  async delete(domainId) {
+    await this.http.delete(`/v1/domains/${domainId}`);
+  }
+  /**
+   * Verify domain DNS records
+   */
+  async verify(domainId) {
+    const response = await this.http.post(
+      `/v1/domains/${domainId}/verify`
+    );
+    return {
+      domain: transformDomain(response.domain),
+      verificationResults: response.verification_results
+    };
+  }
+  /**
+   * Get DNS records that need to be configured
+   */
+  async dnsRecords(domainId) {
+    const domain = await this.get(domainId);
+    return domain.dnsRecords;
+  }
+};
+
+// src/resources/voice/numbers.ts
+function transformPhoneNumber(data) {
+  return {
+    id: data.id,
+    number: data.number,
+    country: data.country,
+    region: data.region,
+    locality: data.locality,
+    capabilities: data.capabilities,
+    channelId: data.channel_id,
+    channelName: data.channel_name,
+    status: data.status,
+    monthlyCostCents: data.monthly_cost_cents,
+    setupCostCents: data.setup_cost_cents,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at
+  };
+}
+function transformAvailableNumber(data) {
+  return {
+    number: data.number,
+    country: data.country,
+    region: data.region,
+    locality: data.locality,
+    capabilities: data.capabilities,
+    monthlyCostCents: data.monthly_cost_cents,
+    setupCostCents: data.setup_cost_cents,
+    provider: data.provider
+  };
+}
+var VoiceNumbersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Search for available phone numbers to purchase
+   */
+  async search(params) {
+    const response = await this.http.get("/v1/voice/numbers/search", {
+      country: params.country,
+      area_code: params.areaCode,
+      contains: params.contains,
+      capabilities: params.capabilities?.join(","),
+      limit: params.limit
+    });
+    return response.available_numbers.map(transformAvailableNumber);
+  }
+  /**
+   * Purchase a phone number
+   */
+  async purchase(params) {
+    const response = await this.http.post("/v1/voice/numbers/purchase", {
+      number: params.number,
+      channel_id: params.channelId
+    });
+    return transformPhoneNumber(response.number);
+  }
+  /**
+   * List owned phone numbers
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/voice/numbers", {
+      channel_id: params?.channelId,
+      status: params?.status,
+      country: params?.country,
+      capabilities: params?.capabilities?.join(","),
+      limit: params?.limit,
+      offset: params?.offset
+    });
+    return {
+      data: response.numbers.map(transformPhoneNumber),
+      total: response.total,
+      hasMore: response.offset + response.numbers.length < response.total,
+      nextOffset: response.offset + response.numbers.length
+    };
+  }
+  /**
+   * Get a phone number by ID
+   */
+  async get(numberId) {
+    const response = await this.http.get(`/v1/voice/numbers/${numberId}`);
+    return transformPhoneNumber(response);
+  }
+  /**
+   * Update a phone number (assign/unassign to channel)
+   */
+  async update(numberId, params) {
+    const response = await this.http.patch(`/v1/voice/numbers/${numberId}`, {
+      channel_id: params.channelId
+    });
+    return transformPhoneNumber(response.number);
+  }
+  /**
+   * Release a phone number
+   */
+  async release(numberId) {
+    await this.http.delete(`/v1/voice/numbers/${numberId}`);
+  }
+  /**
+   * Assign a phone number to a channel
+   */
+  async assignToChannel(numberId, channelId) {
+    return this.update(numberId, { channelId });
+  }
+  /**
+   * Unassign a phone number from its channel
+   */
+  async unassignFromChannel(numberId) {
+    return this.update(numberId, { channelId: null });
+  }
+};
+
+// src/resources/voice/calls.ts
+function transformCall(data) {
+  return {
+    id: data.id,
+    channelId: data.channel_id,
+    providerCallSid: data.provider_call_sid,
+    fromNumber: data.from_number,
+    toNumber: data.to_number,
+    direction: data.direction,
+    status: data.status,
+    endReason: data.end_reason,
+    initiatedAt: data.initiated_at,
+    ringingAt: data.ringing_at,
+    answeredAt: data.answered_at,
+    endedAt: data.ended_at,
+    durationSeconds: data.duration_seconds,
+    recordingUrl: data.recording_url,
+    transcriptionUrl: data.transcription_url,
+    agentId: data.agent_id,
+    metadata: data.metadata
+  };
+}
+var VoiceCallsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Initiate an outbound call
+   */
+  async dial(params) {
+    const response = await this.http.post("/v1/voice/calls", {
+      channel_id: params.channelId,
+      to: params.to,
+      from: params.from,
+      timeout: params.timeout,
+      metadata: params.metadata
+    });
+    return transformCall(response.call);
+  }
+  /**
+   * List calls
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/voice/calls", {
+      channel_id: params?.channelId,
+      direction: params?.direction,
+      status: params?.status,
+      from_number: params?.fromNumber,
+      to_number: params?.toNumber,
+      start_date: params?.startDate instanceof Date ? params.startDate.toISOString() : params?.startDate,
+      end_date: params?.endDate instanceof Date ? params.endDate.toISOString() : params?.endDate,
+      limit: params?.limit,
+      offset: params?.offset
+    });
+    return {
+      data: response.calls.map(transformCall),
+      total: response.total,
+      hasMore: response.offset + response.calls.length < response.total,
+      nextOffset: response.offset + response.calls.length
+    };
+  }
+  /**
+   * Get a call by ID
+   */
+  async get(callId) {
+    const response = await this.http.get(`/v1/voice/calls/${callId}`);
+    return transformCall(response);
+  }
+  /**
+   * Hang up an active call
+   */
+  async hangup(callId) {
+    await this.http.post(`/v1/voice/calls/${callId}/hangup`);
+  }
+};
+
+// src/resources/voice/rooms.ts
+var VoiceRoomsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new WebRTC room
+   *
+   * @example
+   * ```typescript
+   * const roomInfo = await veroai.voice.rooms.create({
+   *   name: 'support-call-123',
+   *   emptyTimeout: 300,
+   *   maxParticipants: 2,
+   * });
+   * // Connect to room using roomInfo.wsUrl and roomInfo.token
+   * ```
+   */
+  async create(params) {
+    const response = await this.http.post("/voice/rooms", {
+      name: params.name,
+      empty_timeout: params.emptyTimeout,
+      max_participants: params.maxParticipants,
+      metadata: params.metadata
+    });
+    return {
+      sid: response.room.id,
+      name: response.room.name,
+      wsUrl: response.room.ws_url,
+      token: response.room.token,
+      numParticipants: 0,
+      metadata: params.metadata
+    };
+  }
+  /**
+   * Join an existing room or create and join if it doesn't exist
+   *
+   * @example
+   * ```typescript
+   * const roomInfo = await veroai.voice.rooms.join({
+   *   roomName: 'support-call-123',
+   *   participantName: 'Agent Smith',
+   * });
+   * // Use roomInfo.token to connect via LiveKit client SDK
+   * ```
+   */
+  async join(params) {
+    const response = await this.http.post(
+      `/voice/rooms/${encodeURIComponent(params.roomName)}/join`,
+      {
+        participant_name: params.participantName,
+        can_publish: params.canPublish,
+        can_subscribe: params.canSubscribe,
+        metadata: params.metadata
+      }
+    );
+    return {
+      sid: "",
+      name: response.room_name,
+      wsUrl: response.ws_url,
+      token: response.token,
+      numParticipants: 0
+    };
+  }
+  /**
+   * Get room details
+   *
+   * @example
+   * ```typescript
+   * const room = await veroai.voice.rooms.get('support-call-123');
+   * console.log(`Room: ${room.name}`);
+   * ```
+   */
+  async get(roomName) {
+    const response = await this.http.get(
+      `/voice/rooms/${encodeURIComponent(roomName)}`
+    );
+    return {
+      sid: "",
+      name: response.room.name,
+      emptyTimeout: 300,
+      maxParticipants: 10,
+      creationTime: "",
+      numParticipants: 0
+    };
+  }
+  /**
+   * List all active rooms
+   *
+   * @example
+   * ```typescript
+   * const rooms = await veroai.voice.rooms.list();
+   * for (const room of rooms) {
+   *   console.log(`${room.name}`);
+   * }
+   * ```
+   */
+  async list(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.names) {
+      for (const name of params.names) {
+        searchParams.append("names", name);
+      }
+    }
+    const query = searchParams.toString();
+    const response = await this.http.get(
+      `/voice/rooms${query ? `?${query}` : ""}`
+    );
+    return response.rooms.map((room) => ({
+      sid: "",
+      name: room.name,
+      emptyTimeout: 300,
+      maxParticipants: 10,
+      creationTime: "",
+      numParticipants: 0
+    }));
+  }
+  /**
+   * Delete a room and disconnect all participants
+   *
+   * @example
+   * ```typescript
+   * await veroai.voice.rooms.delete('support-call-123');
+   * ```
+   */
+  async delete(roomName) {
+    await this.http.delete(`/voice/rooms/${encodeURIComponent(roomName)}`);
+  }
+  /**
+   * List participants in a room
+   *
+   * @example
+   * ```typescript
+   * const participants = await veroai.voice.rooms.listParticipants('support-call-123');
+   * for (const p of participants) {
+   *   console.log(`${p.name} (${p.state})`);
+   * }
+   * ```
+   */
+  async listParticipants(roomName) {
+    return this.http.get(
+      `/voice/rooms/${encodeURIComponent(roomName)}/participants`
+    );
+  }
+  /**
+   * Remove a participant from a room
+   *
+   * @example
+   * ```typescript
+   * await veroai.voice.rooms.removeParticipant('support-call-123', 'user-456');
+   * ```
+   */
+  async removeParticipant(roomName, identity) {
+    await this.http.delete(
+      `/voice/rooms/${encodeURIComponent(roomName)}/participants/${encodeURIComponent(identity)}`
+    );
+  }
+  /**
+   * Mute or unmute a participant's audio
+   *
+   * @example
+   * ```typescript
+   * // Mute participant
+   * await veroai.voice.rooms.muteParticipant('support-call-123', 'user-456', true);
+   *
+   * // Unmute participant
+   * await veroai.voice.rooms.muteParticipant('support-call-123', 'user-456', false);
+   * ```
+   */
+  async muteParticipant(roomName, identity, muted) {
+    await this.http.post(
+      `/voice/rooms/${encodeURIComponent(roomName)}/participants/${encodeURIComponent(identity)}/mute`,
+      { muted }
+    );
+  }
+  /**
+   * Send a data message to participants in a room
+   *
+   * @example
+   * ```typescript
+   * // Send to all participants
+   * await veroai.voice.rooms.sendData('support-call-123', { type: 'notification', message: 'Recording started' });
+   *
+   * // Send to specific participants
+   * await veroai.voice.rooms.sendData('support-call-123', { type: 'private' }, ['user-456']);
+   * ```
+   */
+  async sendData(roomName, data, destinationIdentities) {
+    await this.http.post(`/voice/rooms/${encodeURIComponent(roomName)}/data`, {
+      data,
+      destinationIdentities
+    });
+  }
+};
+
+// src/resources/voice/index.ts
+var VoiceResource = class {
+  /**
+   * Phone number management
+   */
+  numbers;
+  /**
+   * Call management
+   */
+  calls;
+  /**
+   * LiveKit WebRTC room management for browser-based voice/video calls
+   */
+  rooms;
+  constructor(http) {
+    this.numbers = new VoiceNumbersResource(http);
+    this.calls = new VoiceCallsResource(http);
+    this.rooms = new VoiceRoomsResource(http);
+  }
+};
+
+// src/resources/agents.ts
+function transformAgent(agent) {
+  return {
+    id: agent.id,
+    name: agent.name,
+    description: agent.description,
+    enabled: agent.enabled,
+    modelConfig: {
+      provider: agent.model_config.provider,
+      modelId: agent.model_config.model_id,
+      temperature: agent.model_config.temperature,
+      maxTokens: agent.model_config.max_tokens
+    },
+    systemPrompt: agent.system_prompt,
+    status: agent.status
+  };
+}
+var AgentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List AI agents
+   *
+   * @example
+   * ```typescript
+   * const agents = await veroai.agents.list({ status: 'active' });
+   * for (const agent of agents.data) {
+   *   console.log(`${agent.name} (${agent.modelConfig.provider})`);
+   * }
+   * ```
+   */
+  async list(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.status) searchParams.set("status", params.status);
+    if (params?.enabled !== void 0) searchParams.set("enabled", String(params.enabled));
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.offset) searchParams.set("offset", String(params.offset));
+    const query = searchParams.toString();
+    const response = await this.http.get(
+      `/agents${query ? `?${query}` : ""}`
+    );
+    return {
+      data: response.agents.map(transformAgent),
+      total: response.total,
+      hasMore: response.offset + response.agents.length < response.total,
+      nextOffset: response.offset + response.agents.length < response.total ? response.offset + response.limit : void 0
+    };
+  }
+  /**
+   * Get an agent by ID
+   *
+   * @example
+   * ```typescript
+   * const agent = await veroai.agents.get('agent_123');
+   * console.log(`System prompt: ${agent.systemPrompt}`);
+   * ```
+   */
+  async get(agentId) {
+    const response = await this.http.get(
+      `/agents/${encodeURIComponent(agentId)}`
+    );
+    return transformAgent(response.agent);
+  }
+  /**
+   * Create a new AI agent
+   *
+   * @example
+   * ```typescript
+   * const agent = await veroai.agents.create({
+   *   name: 'Support Agent',
+   *   modelConfig: {
+   *     provider: 'anthropic',
+   *     modelId: 'claude-3-5-sonnet-20241022',
+   *     temperature: 0.7,
+   *   },
+   *   systemPrompt: 'You are a helpful support agent...',
+   *   enabled: true,
+   * });
+   * ```
+   */
+  async create(params) {
+    const response = await this.http.post("/agents", {
+      name: params.name,
+      description: params.description,
+      model_config: {
+        provider: params.modelConfig.provider,
+        model_id: params.modelConfig.modelId,
+        temperature: params.modelConfig.temperature ?? 0.7,
+        max_tokens: params.modelConfig.maxTokens ?? 4096
+      },
+      system_prompt: params.systemPrompt,
+      enabled: params.enabled ?? false
+    });
+    return transformAgent(response.agent);
+  }
+  /**
+   * Update an agent
+   *
+   * @example
+   * ```typescript
+   * const agent = await veroai.agents.update('agent_123', {
+   *   systemPrompt: 'Updated prompt...',
+   *   enabled: true,
+   * });
+   * ```
+   */
+  async update(agentId, params) {
+    const body = {};
+    if (params.name !== void 0) body.name = params.name;
+    if (params.description !== void 0) body.description = params.description;
+    if (params.systemPrompt !== void 0) body.system_prompt = params.systemPrompt;
+    if (params.enabled !== void 0) body.enabled = params.enabled;
+    if (params.status !== void 0) body.status = params.status;
+    if (params.modelConfig) {
+      body.model_config = {
+        ...params.modelConfig.provider && { provider: params.modelConfig.provider },
+        ...params.modelConfig.modelId && { model_id: params.modelConfig.modelId },
+        ...params.modelConfig.temperature !== void 0 && { temperature: params.modelConfig.temperature },
+        ...params.modelConfig.maxTokens !== void 0 && { max_tokens: params.modelConfig.maxTokens }
+      };
+    }
+    const response = await this.http.patch(
+      `/agents/${encodeURIComponent(agentId)}`,
+      body
+    );
+    return transformAgent(response.agent);
+  }
+  /**
+   * Delete an agent
+   *
+   * @example
+   * ```typescript
+   * await veroai.agents.delete('agent_123');
+   * ```
+   */
+  async delete(agentId) {
+    await this.http.delete(`/agents/${encodeURIComponent(agentId)}`);
+  }
+  /**
+   * Enable an agent
+   *
+   * @example
+   * ```typescript
+   * const agent = await veroai.agents.enable('agent_123');
+   * ```
+   */
+  async enable(agentId) {
+    return this.update(agentId, { enabled: true });
+  }
+  /**
+   * Disable an agent
+   *
+   * @example
+   * ```typescript
+   * const agent = await veroai.agents.disable('agent_123');
+   * ```
+   */
+  async disable(agentId) {
+    return this.update(agentId, { enabled: false });
+  }
+};
+
+// src/realtime/realtime.ts
+var DEFAULT_REALTIME_URL = "wss://wss.veroai.dev/ws";
+var DEFAULT_RECONNECT_INTERVAL = 1e3;
+var MAX_RECONNECT_INTERVAL = 3e4;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.WebSocket !== "undefined";
+}
+async function getWebSocket() {
+  if (isBrowser()) {
+    return window.WebSocket;
+  }
+  try {
+    const ws = await import('ws');
+    return ws.default || ws;
+  } catch {
+    throw new Error(
+      'WebSocket is not available. In Node.js, install the "ws" package: npm install ws'
+    );
+  }
+}
+var RealtimeResource = class {
+  config;
+  tokenFetcher;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ws = null;
+  state = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  heartbeatInterval = null;
+  // Event handlers
+  eventHandlers = /* @__PURE__ */ new Set();
+  stateHandlers = /* @__PURE__ */ new Set();
+  errorHandlers = /* @__PURE__ */ new Set();
+  // Active subscriptions for reconnection
+  activeSubscriptions = {
+    eventTypes: /* @__PURE__ */ new Set(),
+    channels: /* @__PURE__ */ new Set(),
+    subscribedToAll: false
+  };
+  // Pending subscription confirmations
+  pendingSubscriptions = /* @__PURE__ */ new Map();
+  constructor(tokenFetcher, config) {
+    this.tokenFetcher = tokenFetcher;
+    this.config = {
+      url: config?.url ?? DEFAULT_REALTIME_URL,
+      autoReconnect: config?.autoReconnect ?? true,
+      reconnectInterval: config?.reconnectInterval ?? DEFAULT_RECONNECT_INTERVAL,
+      maxReconnectAttempts: config?.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS,
+      heartbeatInterval: config?.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL
+    };
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.setState("connecting");
+    return new Promise(async (resolve, reject) => {
+      try {
+        const token = await this.tokenFetcher();
+        const WS = await getWebSocket();
+        const url = new URL(this.config.url);
+        url.searchParams.set("token", token);
+        this.ws = new WS(url.toString());
+        this.ws.onopen = () => {
+          this.setState("connected");
+          this.reconnectAttempts = 0;
+          this.startHeartbeat();
+          this.resubscribe();
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          this.stopHeartbeat();
+          this.ws = null;
+          if (this.state === "connecting") {
+            reject(new Error(`Connection failed: ${event.reason || "Unknown reason"}`));
+            this.setState("disconnected");
+            return;
+          }
+          this.setState("disconnected");
+          if (this.config.autoReconnect && this.shouldReconnect()) {
+            this.scheduleReconnect();
+          }
+        };
+        this.ws.onerror = (event) => {
+          const error = new Error(
+            "WebSocket error" + (event.message ? `: ${event.message}` : "")
+          );
+          this.emitError(error);
+          if (this.state === "connecting") {
+            reject(error);
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        this.setState("disconnected");
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.config.autoReconnect = false;
+    this.clearReconnectTimeout();
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  /**
+   * Subscribe to all events for the tenant
+   */
+  async subscribeAll() {
+    this.activeSubscriptions.subscribedToAll = true;
+    return this.sendSubscription({
+      type: "subscribe",
+      subscriptionType: "all"
+    });
+  }
+  /**
+   * Unsubscribe from all events
+   */
+  async unsubscribeAll() {
+    this.activeSubscriptions.subscribedToAll = false;
+    return this.sendSubscription({
+      type: "unsubscribe",
+      subscriptionType: "all"
+    });
+  }
+  /**
+   * Subscribe to specific channels
+   */
+  async subscribeChannels(channelIds) {
+    for (const id of channelIds) {
+      this.activeSubscriptions.channels.add(id);
+    }
+    return this.sendSubscription({
+      type: "subscribe",
+      subscriptionType: "channel",
+      channels: channelIds
+    });
+  }
+  /**
+   * Unsubscribe from specific channels
+   */
+  async unsubscribeChannels(channelIds) {
+    for (const id of channelIds) {
+      this.activeSubscriptions.channels.delete(id);
+    }
+    return this.sendSubscription({
+      type: "unsubscribe",
+      subscriptionType: "channel",
+      channels: channelIds
+    });
+  }
+  /**
+   * Subscribe to specific event types
+   */
+  async subscribeEventTypes(eventTypes) {
+    for (const type of eventTypes) {
+      this.activeSubscriptions.eventTypes.add(type);
+    }
+    return this.sendSubscription({
+      type: "subscribe",
+      subscriptionType: "event_type",
+      eventTypes
+    });
+  }
+  /**
+   * Unsubscribe from specific event types
+   */
+  async unsubscribeEventTypes(eventTypes) {
+    for (const type of eventTypes) {
+      this.activeSubscriptions.eventTypes.delete(type);
+    }
+    return this.sendSubscription({
+      type: "unsubscribe",
+      subscriptionType: "event_type",
+      eventTypes
+    });
+  }
+  /**
+   * Subscribe to channels and/or event types
+   */
+  async subscribe(options) {
+    const promises = [];
+    if (options.channels?.length) {
+      promises.push(this.subscribeChannels(options.channels));
+    }
+    if (options.eventTypes?.length) {
+      promises.push(this.subscribeEventTypes(options.eventTypes));
+    }
+    if (promises.length === 0) {
+      throw new Error("Must specify at least one channel or event type");
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Unsubscribe from channels and/or event types
+   */
+  async unsubscribe(options) {
+    const promises = [];
+    if (options.channels?.length) {
+      promises.push(this.unsubscribeChannels(options.channels));
+    }
+    if (options.eventTypes?.length) {
+      promises.push(this.unsubscribeEventTypes(options.eventTypes));
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Add event handler
+   */
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  /**
+   * Add connection state change handler
+   */
+  onStateChange(handler) {
+    this.stateHandlers.add(handler);
+    return () => this.stateHandlers.delete(handler);
+  }
+  /**
+   * Add error handler
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  /**
+   * Remove all handlers
+   */
+  removeAllHandlers() {
+    this.eventHandlers.clear();
+    this.stateHandlers.clear();
+    this.errorHandlers.clear();
+  }
+  // Private methods
+  setState(state) {
+    if (this.state === state) return;
+    this.state = state;
+    for (const handler of this.stateHandlers) {
+      try {
+        handler(state);
+      } catch (error) {
+        console.error("State handler error:", error);
+      }
+    }
+  }
+  emitError(error) {
+    for (const handler of this.errorHandlers) {
+      try {
+        handler(error);
+      } catch (e) {
+        console.error("Error handler error:", e);
+      }
+    }
+  }
+  emitEvent(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Event handler error:", error);
+      }
+    }
+  }
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(typeof data === "string" ? data : data.toString());
+      if (message.type === "connected") {
+        return;
+      }
+      if (message.type === "subscription_confirmed" || message.type === "subscription_error") {
+        const confirmation = message;
+        const key = this.getSubscriptionKey(confirmation);
+        const pending = this.pendingSubscriptions.get(key);
+        if (pending) {
+          this.pendingSubscriptions.delete(key);
+          if (confirmation.type === "subscription_error") {
+            pending.reject(new Error(confirmation.error || "Subscription failed"));
+          } else {
+            pending.resolve(confirmation);
+          }
+        }
+        return;
+      }
+      if (message.type === "event" && message.data) {
+        const eventData = message.data;
+        const event = {
+          id: eventData.id,
+          tenantId: eventData.tenant_id || eventData.tenantId,
+          channelId: eventData.channel_id || eventData.channelId,
+          canonicalType: eventData.canonical_type || eventData.canonicalType,
+          eventType: eventData.event_type || eventData.eventType,
+          direction: eventData.direction,
+          payload: eventData.payload,
+          enrichment: eventData.enrichment,
+          timestamp: eventData.timestamp,
+          processedAt: eventData.processed_at || eventData.processedAt
+        };
+        this.emitEvent(event);
+      }
+    } catch (error) {
+      this.emitError(new Error(`Failed to parse message: ${error}`));
+    }
+  }
+  async sendSubscription(command) {
+    if (!this.ws || this.state !== "connected") {
+      throw new Error("Not connected");
+    }
+    return new Promise((resolve, reject) => {
+      const key = this.getSubscriptionKey({
+        action: command.type,
+        subscriptionType: command.subscriptionType
+      });
+      const timeout = setTimeout(() => {
+        this.pendingSubscriptions.delete(key);
+        reject(new Error("Subscription timeout"));
+      }, 1e4);
+      this.pendingSubscriptions.set(key, {
+        resolve: (confirmation) => {
+          clearTimeout(timeout);
+          resolve(confirmation);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+      this.ws.send(JSON.stringify(command));
+    });
+  }
+  getSubscriptionKey(confirmation) {
+    return `${confirmation.action}:${confirmation.subscriptionType}`;
+  }
+  shouldReconnect() {
+    if (this.config.maxReconnectAttempts === 0) {
+      return true;
+    }
+    return this.reconnectAttempts < this.config.maxReconnectAttempts;
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout) return;
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectInterval * Math.pow(2, this.reconnectAttempts - 1),
+      MAX_RECONNECT_INTERVAL
+    );
+    this.reconnectTimeout = setTimeout(async () => {
+      this.reconnectTimeout = null;
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  clearReconnectTimeout() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  async resubscribe() {
+    try {
+      if (this.activeSubscriptions.subscribedToAll) {
+        await this.subscribeAll();
+      }
+      if (this.activeSubscriptions.channels.size > 0) {
+        await this.subscribeChannels(Array.from(this.activeSubscriptions.channels));
+      }
+      if (this.activeSubscriptions.eventTypes.size > 0) {
+        await this.subscribeEventTypes(Array.from(this.activeSubscriptions.eventTypes));
+      }
+    } catch (error) {
+      this.emitError(new Error(`Failed to resubscribe: ${error}`));
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws && this.state === "connected") {
+        if (typeof this.ws.ping === "function") {
+          this.ws.ping();
+        }
+      }
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+};
+function createRealtimeResource(tokenFetcher, config) {
+  return new RealtimeResource(tokenFetcher, config);
+}
+
+// src/client.ts
+var VeroAI = class _VeroAI {
+  http;
+  /** Manage communication channels (email, SMS, WhatsApp, etc.) */
+  channels;
+  /** Query activity events and analytics */
+  events;
+  /** Send messages through channels */
+  messages;
+  /** Manage webhook endpoints for real-time notifications */
+  webhooks;
+  /** Manage API keys for authentication */
+  apiKeys;
+  /** Manage email domains for sending */
+  domains;
+  /** Voice phone numbers and call management */
+  voice;
+  /** AI agent configurations */
+  agents;
+  /** Real-time event subscriptions via WebSocket */
+  realtime;
+  /**
+   * Create a new VeroAI client instance
+   *
+   * @param config - Configuration options
+   * @param config.apiKey - Your API key (required)
+   * @param config.baseUrl - Custom API base URL (optional)
+   * @param config.timeout - Request timeout in ms (default: 30000)
+   * @param config.maxRetries - Max retry attempts (default: 3)
+   * @param config.realtime - Realtime WebSocket configuration
+   *
+   * @example
+   * ```typescript
+   * // Basic usage
+   * const veroai = new VeroAI({ apiKey: 'sk_live_...' });
+   *
+   * // With custom options
+   * const veroai = new VeroAI({
+   *   apiKey: 'sk_test_...',
+   *   baseUrl: 'https://api.staging.veroai.dev',
+   *   timeout: 60000,
+   *   maxRetries: 5,
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.http = new HttpClient(config);
+    this.channels = new ChannelsResource(this.http);
+    this.events = new EventsResource(this.http);
+    this.messages = new MessagesResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.apiKeys = new ApiKeysResource(this.http);
+    this.domains = new DomainsResource(this.http);
+    this.voice = new VoiceResource(this.http);
+    this.agents = new AgentsResource(this.http);
+    const tokenFetcher = async () => {
+      const response = await this.http.post("/v1/realtime/auth", {});
+      return response.token;
+    };
+    this.realtime = new RealtimeResource(tokenFetcher, config.realtime);
+  }
+  /**
+   * Create a client from environment variables
+   *
+   * Looks for VEROAI_API_KEY environment variable
+   *
+   * @example
+   * ```typescript
+   * // Reads VEROAI_API_KEY from environment
+   * const veroai = VeroAI.fromEnv();
+   * ```
+   */
+  static fromEnv(overrides) {
+    const apiKey = process.env.VEROAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("VEROAI_API_KEY environment variable is not set");
+    }
+    return new _VeroAI({
+      apiKey,
+      baseUrl: process.env.VEROAI_BASE_URL,
+      ...overrides
+    });
+  }
+};
+
+exports.APIError = APIError;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.RealtimeResource = RealtimeResource;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.VeroAI = VeroAI;
+exports.VeroAIError = VeroAIError;
+exports.VoiceCallsResource = VoiceCallsResource;
+exports.VoiceNumbersResource = VoiceNumbersResource;
+exports.VoiceResource = VoiceResource;
+exports.createRealtimeResource = createRealtimeResource;
+exports.default = VeroAI;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map