@amigo-ai/platform-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1005 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AmigoClient: () => AmigoClient,
+  AmigoError: () => AmigoError,
+  AuthenticationError: () => AuthenticationError,
+  BadRequestError: () => BadRequestError,
+  ConfigurationError: () => ConfigurationError,
+  ConflictError: () => ConflictError,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  ParseError: () => ParseError,
+  PermissionError: () => PermissionError,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  ValidationError: () => ValidationError,
+  agentId: () => agentId,
+  apiKeyId: () => apiKeyId,
+  callId: () => callId,
+  contextGraphId: () => contextGraphId,
+  dataSourceId: () => dataSourceId,
+  entityId: () => entityId,
+  eventId: () => eventId,
+  integrationId: () => integrationId,
+  isAmigoError: () => isAmigoError,
+  isAuthenticationError: () => isAuthenticationError,
+  isNotFoundError: () => isNotFoundError,
+  isRateLimitError: () => isRateLimitError,
+  paginate: () => paginate,
+  phoneNumberId: () => phoneNumberId,
+  serviceId: () => serviceId,
+  simulationRunId: () => simulationRunId,
+  simulationSessionId: () => simulationSessionId,
+  skillId: () => skillId,
+  workspaceId: () => workspaceId
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/errors.ts
+var AmigoError = class extends Error {
+  statusCode;
+  errorCode;
+  requestId;
+  detail;
+  constructor(message, ctx = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = ctx.statusCode;
+    this.errorCode = ctx.errorCode;
+    this.requestId = ctx.requestId;
+    this.detail = ctx.detail;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var BadRequestError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 400 });
+  }
+};
+var AuthenticationError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 401 });
+  }
+};
+var PermissionError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 403 });
+  }
+};
+var NotFoundError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 404 });
+  }
+};
+var ConflictError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 409 });
+  }
+};
+var ValidationError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 422 });
+  }
+};
+var RateLimitError = class extends AmigoError {
+  retryAfter;
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 429 });
+    this.retryAfter = ctx.retryAfter;
+  }
+};
+var ServerError = class extends AmigoError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: ctx.statusCode ?? 500 });
+  }
+};
+var ServiceUnavailableError = class extends ServerError {
+  constructor(message, ctx = {}) {
+    super(message, { ...ctx, statusCode: 503 });
+  }
+};
+var NetworkError = class extends AmigoError {
+  constructor(message, cause) {
+    super(message);
+    if (cause !== void 0) {
+      ;
+      this.cause = cause;
+    }
+  }
+};
+var ParseError = class extends AmigoError {
+  body;
+  constructor(message, body) {
+    super(message);
+    this.body = body;
+  }
+};
+var ConfigurationError = class extends AmigoError {
+  constructor(message) {
+    super(message);
+  }
+};
+async function createApiError(response) {
+  let body = {};
+  let rawBody;
+  try {
+    rawBody = await response.text();
+    body = JSON.parse(rawBody);
+  } catch {
+  }
+  const ctx = {
+    statusCode: response.status,
+    errorCode: body.error_code,
+    requestId: body.request_id,
+    detail: body.detail
+  };
+  const message = body.message ?? body.detail ?? response.statusText ?? `HTTP ${response.status}`;
+  switch (response.status) {
+    case 400:
+      return new BadRequestError(message, ctx);
+    case 401:
+      return new AuthenticationError(message, ctx);
+    case 403:
+      return new PermissionError(message, ctx);
+    case 404:
+      return new NotFoundError(message, ctx);
+    case 409:
+      return new ConflictError(message, ctx);
+    case 422:
+      return new ValidationError(message, ctx);
+    case 429: {
+      const retryAfter = parseRetryAfter(response);
+      return new RateLimitError(message, { ...ctx, retryAfter });
+    }
+    case 503:
+      return new ServiceUnavailableError(message, ctx);
+    default:
+      return new ServerError(message, ctx);
+  }
+}
+function parseRetryAfter(response) {
+  const header = response.headers.get("Retry-After");
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (!isNaN(seconds)) return seconds;
+  const date = new Date(header);
+  if (!isNaN(date.getTime())) {
+    return Math.max(0, Math.ceil((date.getTime() - Date.now()) / 1e3));
+  }
+  return void 0;
+}
+function isAmigoError(err) {
+  return err instanceof AmigoError;
+}
+function isNotFoundError(err) {
+  return err instanceof NotFoundError;
+}
+function isRateLimitError(err) {
+  return err instanceof RateLimitError;
+}
+function isAuthenticationError(err) {
+  return err instanceof AuthenticationError;
+}
+
+// src/resources/base.ts
+var WorkspaceScopedResource = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  workspaceUrl(path) {
+    return `${this.config.baseUrl}/v1/${this.config.workspaceId}${path}`;
+  }
+  async fetch(path, init = {}) {
+    const url = this.workspaceUrl(path);
+    const response = await globalThis.fetch(url, {
+      ...init,
+      headers: {
+        ...this.headers,
+        ...init.headers
+      }
+    });
+    if (!response.ok) {
+      throw await createApiError(response);
+    }
+    if (response.status === 204) return void 0;
+    return response.json();
+  }
+};
+function buildQuery(params) {
+  if (!params) return "";
+  const entries = Object.entries(params).filter(
+    ([, v]) => v !== void 0 && v !== null
+  );
+  if (entries.length === 0) return "";
+  const searchParams = new URLSearchParams();
+  for (const [k, v] of entries) {
+    searchParams.set(k, String(v));
+  }
+  return "?" + searchParams.toString();
+}
+
+// src/resources/workspaces.ts
+var WorkspacesResource = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async request(path, init = {}) {
+    const url = `${this.config.baseUrl}/v1/workspaces${path}`;
+    const response = await globalThis.fetch(url, {
+      ...init,
+      headers: { ...this.headers, ...init.headers }
+    });
+    if (!response.ok) throw await createApiError(response);
+    if (response.status === 204) return void 0;
+    return response.json();
+  }
+  /** Create a new workspace */
+  async create(body) {
+    return this.request("", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List workspaces accessible to the current API key */
+  async list(params) {
+    return this.request(buildQuery(params));
+  }
+  /** Get a single workspace by ID */
+  async get(id) {
+    return this.request(`/${id}`);
+  }
+  /** Update workspace metadata */
+  async update(id, body) {
+    return this.request(`/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Archive (soft-delete) a workspace */
+  async delete(id) {
+    return this.request(`/${id}`, { method: "DELETE" });
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class extends WorkspaceScopedResource {
+  /**
+   * Get info about the currently authenticated API key.
+   * Does not require a workspace ID in the path.
+   */
+  async me() {
+    const url = `${this.config.baseUrl}/v1/auth/me`;
+    const response = await globalThis.fetch(url, { headers: this.headers });
+    if (!response.ok) throw await createApiError(response);
+    return response.json();
+  }
+  /** Create a new API key */
+  async create(body) {
+    return this.fetch("/api-keys", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List API keys in the workspace */
+  async list(params) {
+    return this.fetch(`/api-keys${buildQuery(params)}`);
+  }
+  /** Get a specific API key */
+  async get(keyId) {
+    return this.fetch(`/api-keys/${keyId}`);
+  }
+  /** Revoke an API key */
+  async revoke(keyId) {
+    return this.fetch(`/api-keys/${keyId}`, { method: "DELETE" });
+  }
+  /** Rotate an API key — invalidates the old key and issues a new one */
+  async rotate(keyId) {
+    return this.fetch(`/api-keys/${keyId}/rotate`, { method: "POST" });
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class extends WorkspaceScopedResource {
+  /** Create a new agent */
+  async create(body) {
+    return this.fetch("/agents", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List agents in the workspace */
+  async list(params) {
+    return this.fetch(`/agents${buildQuery(params)}`);
+  }
+  /** Get a single agent */
+  async get(agentId2) {
+    return this.fetch(`/agents/${agentId2}`);
+  }
+  /** Update an agent's configuration */
+  async update(agentId2, body) {
+    return this.fetch(`/agents/${agentId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Delete an agent */
+  async delete(agentId2) {
+    return this.fetch(`/agents/${agentId2}`, { method: "DELETE" });
+  }
+  /** List all versions of an agent */
+  async listVersions(agentId2, params) {
+    return this.fetch(
+      `/agents/${agentId2}/versions${buildQuery(params)}`
+    );
+  }
+  /** Get a specific version of an agent — pass `"latest"` to get the most recent */
+  async getVersion(agentId2, version) {
+    return this.fetch(`/agents/${agentId2}/versions/${version}`);
+  }
+  /** Create a new version of an agent */
+  async createVersion(agentId2, body) {
+    return this.fetch(`/agents/${agentId2}/versions`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+};
+
+// src/resources/skills.ts
+var SkillsResource = class extends WorkspaceScopedResource {
+  /** Create a new skill */
+  async create(body) {
+    return this.fetch("/skills", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List skills in the workspace */
+  async list(params) {
+    return this.fetch(`/skills${buildQuery(params)}`);
+  }
+  /** Get a single skill */
+  async get(skillId2) {
+    return this.fetch(`/skills/${skillId2}`);
+  }
+  /** Update a skill */
+  async update(skillId2, body) {
+    return this.fetch(`/skills/${skillId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Delete a skill */
+  async delete(skillId2) {
+    return this.fetch(`/skills/${skillId2}`, { method: "DELETE" });
+  }
+  /**
+   * Test a skill with a sample input.
+   * Executes the skill in a sandbox and returns the result.
+   */
+  async test(skillId2, body) {
+    return this.fetch(`/skills/${skillId2}/test`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+};
+
+// src/resources/services.ts
+var ServicesResource = class extends WorkspaceScopedResource {
+  async create(body) {
+    return this.fetch("/services", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async list(params) {
+    return this.fetch(`/services${buildQuery(params)}`);
+  }
+  async get(serviceId2) {
+    return this.fetch(`/services/${serviceId2}`);
+  }
+  async update(serviceId2, body) {
+    return this.fetch(`/services/${serviceId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  async delete(serviceId2) {
+    return this.fetch(`/services/${serviceId2}`, { method: "DELETE" });
+  }
+};
+
+// src/resources/context-graphs.ts
+var ContextGraphsResource = class extends WorkspaceScopedResource {
+  async create(body) {
+    return this.fetch("/context-graphs", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async list(params) {
+    return this.fetch(`/context-graphs${buildQuery(params)}`);
+  }
+  async get(contextGraphId2) {
+    return this.fetch(`/context-graphs/${contextGraphId2}`);
+  }
+  async update(contextGraphId2, body) {
+    return this.fetch(`/context-graphs/${contextGraphId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  async delete(contextGraphId2) {
+    return this.fetch(`/context-graphs/${contextGraphId2}`, { method: "DELETE" });
+  }
+  /** Create a version snapshot of the current context graph */
+  async createVersion(contextGraphId2) {
+    return this.fetch(`/context-graphs/${contextGraphId2}/versions`, {
+      method: "POST"
+    });
+  }
+  /** List all versions of a context graph */
+  async listVersions(contextGraphId2, params) {
+    return this.fetch(
+      `/context-graphs/${contextGraphId2}/versions${buildQuery(params)}`
+    );
+  }
+  /** Get a specific version */
+  async getVersion(contextGraphId2, version) {
+    return this.fetch(`/context-graphs/${contextGraphId2}/versions/${version}`);
+  }
+};
+
+// src/resources/data-sources.ts
+var DataSourcesResource = class extends WorkspaceScopedResource {
+  async create(body) {
+    return this.fetch("/data-sources", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async list(params) {
+    return this.fetch(`/data-sources${buildQuery(params)}`);
+  }
+  async get(dataSourceId2) {
+    return this.fetch(`/data-sources/${dataSourceId2}`);
+  }
+  async update(dataSourceId2, body) {
+    return this.fetch(`/data-sources/${dataSourceId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  async delete(dataSourceId2) {
+    return this.fetch(`/data-sources/${dataSourceId2}`, { method: "DELETE" });
+  }
+};
+
+// src/resources/world.ts
+var WorldResource = class extends WorkspaceScopedResource {
+  // ---- Entities ----
+  /** Create a new entity */
+  async createEntity(body) {
+    return this.fetch("/world/entities", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List entities with optional filtering */
+  async listEntities(params) {
+    return this.fetch(`/world/entities${buildQuery(params)}`);
+  }
+  /** Get a single entity */
+  async getEntity(entityId2) {
+    return this.fetch(`/world/entities/${entityId2}`);
+  }
+  /** Update entity properties */
+  async updateEntity(entityId2, body) {
+    return this.fetch(`/world/entities/${entityId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Get all relationships for an entity */
+  async getRelationships(entityId2) {
+    return this.fetch(`/world/entities/${entityId2}/relationships`);
+  }
+  /** Get the knowledge graph centered on an entity (entity + neighbors + edges) */
+  async getGraph(entityId2) {
+    return this.fetch(`/world/entities/${entityId2}/graph`);
+  }
+  /** Get provenance — which source systems contributed data for an entity */
+  async getProvenance(entityId2) {
+    return this.fetch(`/world/entities/${entityId2}/provenance`);
+  }
+  /** Get lineage — merge history and canonical identity for an entity */
+  async getLineage(entityId2) {
+    return this.fetch(`/world/entities/${entityId2}/lineage`);
+  }
+  /** Get merged entities for a canonical entity */
+  async getMerged(entityId2) {
+    return this.fetch(`/world/entities/${entityId2}/merged`);
+  }
+  // ---- Entity Types ----
+  /** List registered entity types with counts and schemas */
+  async listEntityTypes() {
+    return this.fetch("/world/entity-types");
+  }
+  // ---- Duplicate Detection ----
+  /** List potential duplicate entity pairs for review or merging */
+  async listDuplicates(params) {
+    return this.fetch(`/world/entities/duplicates${buildQuery(params)}`);
+  }
+  // ---- Semantic Search ----
+  /** Semantic (vector) search over entities */
+  async search(params) {
+    return this.fetch(`/world/search${buildQuery(params)}`);
+  }
+  // ---- Events ----
+  /**
+   * Emit an event for an entity.
+   * Events flow to Delta via ZeroBus for downstream analytics.
+   */
+  async emitEvent(body) {
+    return this.fetch("/world/events", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  // ---- Timeline ----
+  /** Get the event timeline for an entity (reverse-chronological) */
+  async getTimeline(entityId2, params) {
+    return this.fetch(`/world/timeline/${entityId2}${buildQuery(params)}`);
+  }
+  // ---- Intelligence ----
+  /** Get AI-derived intelligence for an entity */
+  async getIntelligence(entityId2) {
+    return this.fetch(`/world/intelligence/${entityId2}`);
+  }
+  /** Find entities similar to a given entity using vector similarity */
+  async getSimilar(entityId2, limit) {
+    return this.fetch(`/world/similar/${entityId2}${buildQuery({ limit })}`);
+  }
+  /** Merge multiple entities into one canonical entity */
+  async merge(body) {
+    return this.fetch("/world/merge", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  // ---- Sync ----
+  /** Get sync status grouped by sink (Lakebase, Delta, etc.) */
+  async getSyncStatusBySink() {
+    return this.fetch("/world/sync/by-sink");
+  }
+  /** List sync events with status filtering */
+  async listSyncEvents(params) {
+    return this.fetch(`/world/sync/events${buildQuery(params)}`);
+  }
+  /** Get current sync queue depth */
+  async getSyncQueueDepth() {
+    return this.fetch("/world/sync/queue");
+  }
+  /** Retry a single failed sync event */
+  async retrySyncEvent(eventId2) {
+    return this.fetch(`/world/sync/retry/${eventId2}`, { method: "POST" });
+  }
+  /** Retry all failed sync events */
+  async retryAllSyncEvents() {
+    return this.fetch("/world/sync/retry-all", { method: "POST" });
+  }
+  // ---- Statistics ----
+  /** Get aggregate entity and event statistics */
+  async getStats() {
+    return this.fetch("/world/entity-stats");
+  }
+  /** Get entity counts broken down by source system */
+  async getSourceBreakdown() {
+    return this.fetch("/world/source-breakdown");
+  }
+};
+
+// src/resources/calls.ts
+var CallsResource = class extends WorkspaceScopedResource {
+  /** List calls with optional filtering */
+  async list(params) {
+    return this.fetch(`/calls/${buildQuery(params)}`);
+  }
+  /** Get full call detail including transcript and intelligence */
+  async get(callSid) {
+    return this.fetch(`/calls/${callSid}`);
+  }
+  /** Get AI intelligence for a call */
+  async getIntelligence(callSid) {
+    return this.fetch(`/calls/${callSid}/intelligence`);
+  }
+  /** Get active intelligence across all in-progress calls */
+  async getActiveIntelligence() {
+    return this.fetch("/calls/active/intelligence");
+  }
+  /** Get performance benchmarks for a time period */
+  async getBenchmarks(params) {
+    return this.fetch(`/calls/benchmarks${buildQuery(params)}`);
+  }
+};
+
+// src/resources/phone-numbers.ts
+var PhoneNumbersResource = class extends WorkspaceScopedResource {
+  /** Provision a new phone number (area code or specific number) */
+  async provision(body) {
+    return this.fetch("/phone-numbers", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List phone numbers in the workspace */
+  async list(params) {
+    return this.fetch(`/phone-numbers${buildQuery(params)}`);
+  }
+  /** Get a phone number */
+  async get(phoneNumberId2) {
+    return this.fetch(`/phone-numbers/${phoneNumberId2}`);
+  }
+  /** Update a phone number (assign to agent, rename) */
+  async update(phoneNumberId2, body) {
+    return this.fetch(`/phone-numbers/${phoneNumberId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Release a phone number back to the carrier */
+  async release(phoneNumberId2) {
+    return this.fetch(`/phone-numbers/${phoneNumberId2}`, { method: "DELETE" });
+  }
+  /** Send a test call to a phone number to verify it's working */
+  async test(phoneNumberId2) {
+    return this.fetch(
+      `/phone-numbers/${phoneNumberId2}/test`,
+      { method: "POST" }
+    );
+  }
+};
+
+// src/resources/integrations.ts
+var IntegrationsResource = class extends WorkspaceScopedResource {
+  /** Create a new integration */
+  async create(body) {
+    return this.fetch("/integrations", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** List integrations */
+  async list(params) {
+    return this.fetch(`/integrations${buildQuery(params)}`);
+  }
+  /** Get a single integration */
+  async get(integrationId2) {
+    return this.fetch(`/integrations/${integrationId2}`);
+  }
+  /** Update integration configuration */
+  async update(integrationId2, body) {
+    return this.fetch(`/integrations/${integrationId2}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Delete an integration */
+  async delete(integrationId2) {
+    return this.fetch(`/integrations/${integrationId2}`, { method: "DELETE" });
+  }
+  /**
+   * Test a specific endpoint on an integration with given params.
+   * Used in the developer console to validate integration config.
+   */
+  async testEndpoint(integrationId2, endpointName, params) {
+    return this.fetch(
+      `/integrations/${integrationId2}/endpoints/${endpointName}/test`,
+      { method: "POST", body: JSON.stringify({ params }) }
+    );
+  }
+  /** Check health of all integrations in the workspace */
+  async getHealthCheck() {
+    return this.fetch("/integrations/health-check");
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsResource = class extends WorkspaceScopedResource {
+  /** High-level dashboard summary — pass `days` (default: 7) for the lookback window */
+  async getDashboard(params) {
+    return this.fetch(`/analytics/dashboard${buildQuery(params)}`);
+  }
+  /** Call volume and duration metrics */
+  async getCalls(params) {
+    return this.fetch(`/analytics/calls${buildQuery(params)}`);
+  }
+  /** Per-agent performance breakdown */
+  async getAgents(params) {
+    return this.fetch(`/analytics/agents${buildQuery(params)}`);
+  }
+  /** Call quality — sentiment, transcription confidence, flagged calls */
+  async getCallQuality(params) {
+    return this.fetch(`/analytics/call-quality${buildQuery(params)}`);
+  }
+  /** Emotion trend data over time */
+  async getEmotionTrends(params) {
+    return this.fetch(`/analytics/emotion-trends${buildQuery(params)}`);
+  }
+  /** Voice pipeline latency metrics (TTFB, response time) */
+  async getLatency(params) {
+    return this.fetch(`/analytics/latency${buildQuery(params)}`);
+  }
+  /** Tool call performance — success rates and latency per tool */
+  async getToolPerformance(params) {
+    return this.fetch(`/analytics/tool-performance${buildQuery(params)}`);
+  }
+  /** Data quality metrics for the workspace world model */
+  async getDataQuality(params) {
+    return this.fetch(`/analytics/data-quality${buildQuery(params)}`);
+  }
+  /** Usage summary — API requests, call minutes, storage */
+  async getUsage(params) {
+    return this.fetch(`/analytics/usage${buildQuery(params)}`);
+  }
+  /** Advanced call statistics (abandonment, transfers, silence, hour-of-day) */
+  async getAdvancedCallStats(params) {
+    return this.fetch(`/analytics/calls/advanced${buildQuery(params)}`);
+  }
+  /** Compare two time periods side by side */
+  async compareCallPeriods(params) {
+    return this.fetch(`/analytics/calls/comparison${buildQuery(params)}`);
+  }
+};
+
+// src/resources/simulations.ts
+var SimulationsResource = class extends WorkspaceScopedResource {
+  /** Start a simulation session — returns the agent's greeting and initial snapshot */
+  async createSession(body) {
+    return this.fetch("/simulations/sessions", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Get the current snapshot of a session */
+  async getSession(sessionId) {
+    return this.fetch(`/simulations/sessions/${sessionId}`);
+  }
+  /** Delete a simulation session */
+  async deleteSession(sessionId) {
+    return this.fetch(`/simulations/sessions/${sessionId}`, { method: "DELETE" });
+  }
+  /**
+   * Send a caller utterance and advance the session by one turn.
+   * Returns the agent's response observation and updated snapshot.
+   */
+  async step(body) {
+    return this.fetch("/simulations/sessions/step", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /**
+   * Get LLM-generated caller message suggestions for the current session state.
+   * Helps exploratory testing by suggesting realistic next caller turns.
+   */
+  async recommend(sessionId, n) {
+    return this.fetch("/simulations/sessions/recommend", {
+      method: "POST",
+      body: JSON.stringify({ session_id: sessionId, n })
+    });
+  }
+  /** Get AI-generated call intelligence for a completed session */
+  async getIntelligence(sessionId) {
+    return this.fetch(`/simulations/sessions/${sessionId}/intelligence`);
+  }
+};
+
+// src/resources/settings.ts
+var SettingsResource = class extends WorkspaceScopedResource {
+  async getSettings(key) {
+    return this.fetch(`/settings/${key}`);
+  }
+  async updateSettings(key, body) {
+    return this.fetch(`/settings/${key}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  voice = {
+    get: () => this.getSettings("voice"),
+    update: (body) => this.updateSettings("voice", body)
+  };
+  branding = {
+    get: () => this.getSettings("branding"),
+    update: (body) => this.updateSettings("branding", body)
+  };
+  outreach = {
+    get: () => this.getSettings("outreach"),
+    update: (body) => this.updateSettings("outreach", body)
+  };
+  memory = {
+    get: () => this.getSettings("memory"),
+    update: (body) => this.updateSettings("memory", body)
+  };
+  security = {
+    get: () => this.getSettings("security"),
+    update: (body) => this.updateSettings("security", body)
+  };
+  retention = {
+    get: () => this.getSettings("retention"),
+    update: (body) => this.updateSettings("retention", body)
+  };
+  workflows = {
+    get: () => this.getSettings("workflows"),
+    update: (body) => this.updateSettings("workflows", body)
+  };
+};
+
+// src/resources/billing.ts
+var BillingResource = class extends WorkspaceScopedResource {
+  /** Get usage summary for a time period */
+  async getUsage(params) {
+    return this.fetch(`/billing/usage${buildQuery(params)}`);
+  }
+  /** List invoices */
+  async listInvoices(params) {
+    return this.fetch(`/billing/invoices${buildQuery(params)}`);
+  }
+};
+
+// src/resources/memory.ts
+var MemoryResource = class extends WorkspaceScopedResource {
+  /**
+   * Get all memory dimension scores for an entity.
+   * Scores reflect how complete and confident each dimension's facts are.
+   */
+  async getEntityDimensions(entityId2) {
+    return this.fetch(`/memory/${entityId2}/dimensions`);
+  }
+  /**
+   * Get individual memory facts for an entity, optionally filtered by dimension.
+   */
+  async getEntityFacts(entityId2, params) {
+    return this.fetch(`/memory/${entityId2}/facts${buildQuery(params)}`);
+  }
+  /**
+   * Get workspace-level memory analytics — coverage rates, dimension health,
+   * and fact ingestion trends.
+   */
+  async getAnalytics() {
+    return this.fetch("/memory/analytics");
+  }
+};
+
+// src/core/branded-types.ts
+var workspaceId = (id) => id;
+var apiKeyId = (id) => id;
+var agentId = (id) => id;
+var skillId = (id) => id;
+var serviceId = (id) => id;
+var contextGraphId = (id) => id;
+var callId = (id) => id;
+var phoneNumberId = (id) => id;
+var integrationId = (id) => id;
+var entityId = (id) => id;
+var eventId = (id) => id;
+var simulationRunId = (id) => id;
+var simulationSessionId = (id) => id;
+var dataSourceId = (id) => id;
+
+// src/core/utils.ts
+async function* paginate(fetcher) {
+  let token = void 0;
+  while (true) {
+    const page = await fetcher(token);
+    for (const item of page.items) {
+      yield item;
+    }
+    if (!page.has_more || page.continuation_token === null) break;
+    token = page.continuation_token;
+  }
+}
+
+// src/index.ts
+var DEFAULT_BASE_URL = "https://api.platform.amigo.ai";
+var AmigoClient = class {
+  /** Workspace management */
+  workspaces;
+  /** API key management */
+  apiKeys;
+  /** Agent management — AI agents that handle calls */
+  agents;
+  /** Skill management — reusable AI capabilities */
+  skills;
+  /** Service management — external service configurations */
+  services;
+  /** Context graph management — conversation flow structures */
+  contextGraphs;
+  /** Data source management — external data connections */
+  dataSources;
+  /** World model — entities, events, and timelines */
+  world;
+  /** Call records and intelligence */
+  calls;
+  /** Phone number provisioning and management */
+  phoneNumbers;
+  /** Integration management — EHR, CRM, and other external systems */
+  integrations;
+  /** Analytics — aggregate metrics about calls and conversions */
+  analytics;
+  /** Simulation runs and interactive testing sessions */
+  simulations;
+  /** Workspace-level settings (voice, branding, security, outreach, etc.) */
+  settings;
+  /** Billing — usage summaries and invoices */
+  billing;
+  /** Agent Memory — structured long-term memory for entities */
+  memory;
+  constructor(config) {
+    if (!config.apiKey || typeof config.apiKey !== "string") {
+      throw new ConfigurationError("apiKey is required and must be a non-empty string");
+    }
+    if (!config.workspaceId || typeof config.workspaceId !== "string") {
+      throw new ConfigurationError("workspaceId is required and must be a non-empty string");
+    }
+    const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    const rc = {
+      apiKey: config.apiKey,
+      baseUrl,
+      workspaceId: config.workspaceId
+    };
+    this.workspaces = new WorkspacesResource({ apiKey: config.apiKey, baseUrl });
+    this.apiKeys = new ApiKeysResource(rc);
+    this.agents = new AgentsResource(rc);
+    this.skills = new SkillsResource(rc);
+    this.services = new ServicesResource(rc);
+    this.contextGraphs = new ContextGraphsResource(rc);
+    this.dataSources = new DataSourcesResource(rc);
+    this.world = new WorldResource(rc);
+    this.calls = new CallsResource(rc);
+    this.phoneNumbers = new PhoneNumbersResource(rc);
+    this.integrations = new IntegrationsResource(rc);
+    this.analytics = new AnalyticsResource(rc);
+    this.simulations = new SimulationsResource(rc);
+    this.settings = new SettingsResource(rc);
+    this.billing = new BillingResource(rc);
+    this.memory = new MemoryResource(rc);
+  }
+};
+//# sourceMappingURL=index.cjs.map