@amigo-ai/sdk 1.0.0 → 1.1.1

package/dist/platform.cjs

@@ -0,0 +1,1788 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/platform/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AmigoError: () => AmigoError,
+  AuthenticationError: () => AuthenticationError,
+  BadRequestError: () => BadRequestError,
+  ConfigurationError: () => ConfigurationError,
+  ConflictError: () => ConflictError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  ParseError: () => ParseError,
+  PermissionError: () => PermissionError,
+  PlatformClient: () => PlatformClient,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  ValidationError: () => ValidationError,
+  callSid: () => callSid,
+  contextGraphId: () => contextGraphId,
+  createPlatformFetch: () => createPlatformFetch,
+  dataSourceId: () => dataSourceId,
+  entityId: () => entityId,
+  integrationId: () => integrationId,
+  isAmigoError: () => isAmigoError,
+  monitorConceptId: () => monitorConceptId,
+  operatorId: () => operatorId,
+  phoneNumberId: () => phoneNumberId,
+  platformAgentId: () => platformAgentId,
+  platformApiKeyId: () => platformApiKeyId,
+  platformConversationId: () => platformConversationId,
+  platformServiceId: () => platformServiceId,
+  reviewItemId: () => reviewItemId,
+  skillId: () => skillId,
+  taskId: () => taskId,
+  unificationRuleId: () => unificationRuleId,
+  workspaceId: () => workspaceId
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/utils.ts
+async function extractData(responsePromise) {
+  const result = await responsePromise;
+  const data = result.data;
+  if (data === void 0 || data === null) {
+    throw new ParseError("Expected response data to be present for successful request", "response");
+  }
+  return data;
+}
+async function* parseSseStream(response) {
+  const body = response.body;
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bufferedText = "";
+  let eventId;
+  let eventName;
+  let retry;
+  let dataLines = [];
+  const flushEvent = function* () {
+    if (dataLines.length === 0) {
+      eventName = void 0;
+      retry = void 0;
+      return;
+    }
+    const rawData = dataLines.join("\n");
+    let data = rawData;
+    try {
+      data = JSON.parse(rawData);
+    } catch {
+    }
+    const event = { data };
+    if (eventId !== void 0) event.id = eventId;
+    if (eventName !== void 0) event.event = eventName;
+    if (retry !== void 0) event.retry = retry;
+    eventName = void 0;
+    retry = void 0;
+    dataLines = [];
+    yield event;
+  };
+  const processLine = function* (line) {
+    if (line === "") {
+      yield* flushEvent();
+      return;
+    }
+    if (line.startsWith(":")) return;
+    const colonIndex = line.indexOf(":");
+    const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
+    const value = colonIndex === -1 ? "" : line.slice(colonIndex + 1).replace(/^ /, "");
+    switch (field) {
+      case "id":
+        eventId = value;
+        break;
+      case "event":
+        eventName = value;
+        break;
+      case "data":
+        dataLines.push(value);
+        break;
+      case "retry": {
+        const retryMs = Number.parseInt(value, 10);
+        if (!Number.isNaN(retryMs)) retry = retryMs;
+        break;
+      }
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bufferedText += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = bufferedText.search(/\r?\n/)) !== -1) {
+        const line = bufferedText.slice(0, newlineIndex);
+        const newlineLength = bufferedText[newlineIndex] === "\r" && bufferedText[newlineIndex + 1] === "\n" ? 2 : 1;
+        bufferedText = bufferedText.slice(newlineIndex + newlineLength);
+        yield* processLine(line);
+      }
+    }
+    const trailing = bufferedText.trimEnd();
+    if (trailing) {
+      yield* processLine(trailing);
+    }
+    yield* flushEvent();
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function parseResponseBody(response) {
+  try {
+    const text = await response.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function isNetworkError(error) {
+  if (!(error instanceof Error)) return false;
+  return error instanceof TypeError || error.message.includes("fetch") || error.message.includes("Failed to fetch") || error.message.includes("Network request failed") || error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("ENOTFOUND") || error.message.includes("network");
+}
+
+// src/core/errors.ts
+var SENSITIVE_FIELDS = /* @__PURE__ */ new Set([
+  "id_token",
+  "access_token",
+  "refresh_token",
+  "authorization",
+  "api_key",
+  "apikey",
+  "token",
+  "secret",
+  "password",
+  "x-api-key"
+]);
+function sanitizeErrorContext(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(sanitizeErrorContext);
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
+      result[key] = "[REDACTED]";
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = sanitizeErrorContext(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var AmigoError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    /** Unique error code for programmatic error handling */
+    __publicField(this, "errorCode");
+    /** HTTP status code if applicable */
+    __publicField(this, "statusCode");
+    /** Additional context data */
+    __publicField(this, "context");
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.statusCode = options?.statusCode;
+    this.errorCode = options?.errorCode;
+    this.context = options?.context;
+  }
+  /**
+   * Returns a JSON-serializable representation of the error.
+   * Sensitive fields (tokens, keys) are redacted to prevent leakage.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.errorCode,
+      statusCode: this.statusCode,
+      context: sanitizeErrorContext(this.context),
+      stack: this.stack
+    };
+  }
+};
+function isAmigoErrorOptions(value) {
+  if (!value || typeof value !== "object") return false;
+  const options = value;
+  return "statusCode" in options && (typeof options.statusCode === "number" || options.statusCode === void 0) || "errorCode" in options && (typeof options.errorCode === "string" || options.errorCode === void 0) || "context" in options && (typeof options.context === "object" || options.context === void 0);
+}
+var BadRequestError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 400 });
+  }
+};
+var AuthenticationError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 401 });
+  }
+};
+var PermissionError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 403 });
+  }
+};
+var NotFoundError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 404 });
+  }
+};
+var ConflictError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 409 });
+  }
+};
+var RateLimitError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 429 });
+  }
+};
+var ServerError = class extends AmigoError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 500 });
+  }
+};
+var ServiceUnavailableError = class extends ServerError {
+  constructor(message, options) {
+    super(message, { ...options, statusCode: options?.statusCode ?? 503 });
+  }
+};
+var ConfigurationError = class extends AmigoError {
+  constructor(message, field) {
+    super(message, { context: { field } });
+    this.field = field;
+  }
+};
+var ValidationError = class extends BadRequestError {
+  constructor(msg, optionsOrFieldErrors, fieldErrors) {
+    const isErrorOptions = isAmigoErrorOptions(optionsOrFieldErrors);
+    super(
+      msg,
+      isErrorOptions ? { ...optionsOrFieldErrors, statusCode: optionsOrFieldErrors.statusCode ?? 422 } : { statusCode: 422 }
+    );
+    this.fieldErrors = fieldErrors;
+    this.fieldErrors = isErrorOptions ? fieldErrors : optionsOrFieldErrors;
+  }
+};
+var NetworkError = class extends AmigoError {
+  constructor(message, originalError, request) {
+    super(message, { context: { request } });
+    this.originalError = originalError;
+    this.request = request;
+  }
+};
+var ParseError = class extends AmigoError {
+  constructor(message, parseType, originalError) {
+    super(message, { context: { parseType } });
+    this.parseType = parseType;
+    this.originalError = originalError;
+  }
+};
+function isAmigoError(error) {
+  return error instanceof AmigoError;
+}
+function createApiError(response, body) {
+  const map = {
+    400: BadRequestError,
+    401: AuthenticationError,
+    403: PermissionError,
+    404: NotFoundError,
+    409: ConflictError,
+    422: ValidationError,
+    429: RateLimitError,
+    500: ServerError,
+    503: ServiceUnavailableError
+  };
+  const errorMessageKeys = ["message", "error", "detail"];
+  const ErrorClass = map[response.status] ?? AmigoError;
+  let message = `HTTP ${response.status} ${response.statusText}`;
+  if (body && typeof body === "object") {
+    for (const key of errorMessageKeys) {
+      if (key in body) {
+        message = String(body[key]);
+        break;
+      }
+    }
+  }
+  const error = new ErrorClass(message, {
+    statusCode: response.status,
+    errorCode: body && typeof body === "object" && "code" in body ? String(body.code) : void 0,
+    context: { response: sanitizeErrorContext(body) }
+  });
+  return error;
+}
+function createErrorMiddleware() {
+  return {
+    onResponse: async ({ response }) => {
+      if (!response.ok) {
+        const body = await parseResponseBody(response);
+        throw createApiError(response, body);
+      }
+    },
+    onError: async ({ error, request }) => {
+      if (isNetworkError(error)) {
+        throw new NetworkError(
+          `Network error: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error)),
+          {
+            url: request?.url,
+            method: request?.method
+          }
+        );
+      }
+      throw error;
+    }
+  };
+}
+
+// src/platform/core/openapi-client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+
+// src/platform/core/auth.ts
+function createPlatformAuthMiddleware(apiKey) {
+  return {
+    onRequest: async ({ request }) => {
+      request.headers.set("Authorization", `Bearer ${apiKey}`);
+      return request;
+    }
+  };
+}
+
+// src/core/retry.ts
+var DEFAULT_RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var DEFAULT_RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET"]);
+function resolveRetryOptions(options) {
+  return {
+    maxAttempts: options?.maxAttempts ?? 3,
+    backoffBaseMs: options?.backoffBaseMs ?? 250,
+    maxDelayMs: options?.maxDelayMs ?? 3e4,
+    retryOnStatus: new Set(options?.retryOnStatus ?? DEFAULT_RETRYABLE_STATUS),
+    retryOnMethods: new Set(options?.retryOnMethods ?? DEFAULT_RETRYABLE_METHODS)
+  };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function parseRetryAfterMs(headerValue, maxDelayMs) {
+  if (!headerValue) return null;
+  const seconds = Number(headerValue);
+  if (Number.isFinite(seconds)) {
+    return clamp(seconds * 1e3, 0, maxDelayMs);
+  }
+  const date = new Date(headerValue);
+  const ms = date.getTime() - Date.now();
+  if (Number.isFinite(ms)) {
+    return clamp(ms, 0, maxDelayMs);
+  }
+  return null;
+}
+function computeBackoffWithJitterMs(attemptIndexZeroBased, baseMs, capMs) {
+  const windowMs = Math.min(capMs, baseMs * Math.pow(2, attemptIndexZeroBased));
+  return Math.random() * windowMs;
+}
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && "name" in err && err["name"] === "AbortError";
+}
+function isNetworkError2(err) {
+  return err instanceof TypeError && !isAbortError(err);
+}
+async function abortableSleep(ms, signal) {
+  if (ms <= 0) {
+    signal?.throwIfAborted?.();
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const rejectWith = signal?.reason instanceof Error ? signal.reason : signal?.reason ?? new Error("AbortError");
+    if (signal?.aborted) {
+      reject(rejectWith);
+      return;
+    }
+    const t = setTimeout(() => {
+      off();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      off();
+      clearTimeout(t);
+      reject(rejectWith);
+    };
+    const off = () => signal?.removeEventListener("abort", onAbort);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function createRetryingFetch(retryOptions, baseFetch) {
+  const resolved = resolveRetryOptions(retryOptions);
+  const underlying = baseFetch ?? globalThis.fetch;
+  const retryingFetch = async (input, init) => {
+    const inputMethod = typeof Request !== "undefined" && input instanceof Request ? input.method : void 0;
+    const method = (init?.method ?? inputMethod ?? "GET").toUpperCase();
+    const signal = init?.signal;
+    const isMethodRetryableByDefault = resolved.retryOnMethods.has(method);
+    const maxAttempts = Math.max(1, resolved.maxAttempts);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      let response = null;
+      let error = null;
+      try {
+        response = await underlying(input, init);
+      } catch (err) {
+        error = err;
+      }
+      if (!error && response && response.ok) {
+        return response;
+      }
+      let shouldRetry = false;
+      let delayMs = null;
+      if (isNetworkError2(error)) {
+        shouldRetry = isMethodRetryableByDefault;
+        if (shouldRetry) {
+          delayMs = computeBackoffWithJitterMs(
+            attempt - 1,
+            resolved.backoffBaseMs,
+            resolved.maxDelayMs
+          );
+        }
+      } else if (response) {
+        const status = response.status;
+        if (method === "POST") {
+          if (status === 429) {
+            const ra = response.headers.get("Retry-After");
+            const parsed = parseRetryAfterMs(ra, resolved.maxDelayMs);
+            if (parsed !== null) {
+              shouldRetry = true;
+              delayMs = parsed;
+            }
+          }
+        } else if (isMethodRetryableByDefault && resolved.retryOnStatus.has(status)) {
+          const ra = response.headers.get("Retry-After");
+          delayMs = parseRetryAfterMs(ra, resolved.maxDelayMs) ?? computeBackoffWithJitterMs(attempt - 1, resolved.backoffBaseMs, resolved.maxDelayMs);
+          shouldRetry = true;
+        }
+      }
+      const attemptsRemain = attempt < maxAttempts;
+      if (!shouldRetry || !attemptsRemain) {
+        if (error) throw error;
+        return response;
+      }
+      if (signal?.aborted) {
+        if (error) throw error;
+        return response;
+      }
+      await abortableSleep(delayMs ?? 0, signal ?? void 0);
+    }
+    throw new Error("Retry loop exited unexpectedly");
+  };
+  return retryingFetch;
+}
+
+// src/platform/core/openapi-client.ts
+var createClient = typeof import_openapi_fetch.default === "function" ? import_openapi_fetch.default : import_openapi_fetch.default.default;
+function createPlatformFetch(config, mockFetch) {
+  const wrappedFetch = createRetryingFetch(
+    config.retry,
+    mockFetch ?? config.fetch ?? globalThis.fetch
+  );
+  const client = createClient({
+    baseUrl: config.baseUrl,
+    fetch: wrappedFetch
+  });
+  client.use(createErrorMiddleware());
+  client.use(createPlatformAuthMiddleware(config.apiKey));
+  return client;
+}
+
+// src/platform/core/websocket.ts
+function webSocketBaseFromHttpBase(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol === "https:") {
+    url.protocol = "wss:";
+  } else if (url.protocol === "http:") {
+    url.protocol = "ws:";
+  } else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new ConfigurationError(`Unsupported Platform API protocol: ${url.protocol}`, "baseUrl");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+function getWebSocketConstructor(override) {
+  if (override) return override;
+  if (typeof globalThis.WebSocket === "function") {
+    return globalThis.WebSocket;
+  }
+  throw new ConfigurationError(
+    "WebSocket is not available in this runtime; pass WebSocket in the PlatformClient config",
+    "WebSocket"
+  );
+}
+
+// src/platform/resources/agents.ts
+var PlatformAgentResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List agents in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/agents", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get an agent by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/agents/{agent_id}", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: options.agentId } }
+      })
+    );
+  }
+  /** Create a new agent. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/agents", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update an agent. */
+  async update(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/agents/{agent_id}", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: options.agentId } },
+        body: options.body
+      })
+    );
+  }
+  /** Delete an agent. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/agents/{agent_id}", {
+      params: { path: { workspace_id: this.workspaceId, agent_id: options.agentId } }
+    });
+    return void 0;
+  }
+  /** List agent versions. */
+  async listVersions(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/agents/{agent_id}/versions", {
+        params: {
+          path: { workspace_id: this.workspaceId, agent_id: options.agentId },
+          query: options.query
+        }
+      })
+    );
+  }
+  /** Get a specific agent version, or pass `"latest"` for the most recent version. */
+  async getVersion(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/agents/{agent_id}/versions/{version}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            agent_id: options.agentId,
+            version: options.version
+          }
+        }
+      })
+    );
+  }
+  /** Create a new agent version. */
+  async createVersion(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/agents/{agent_id}/versions", {
+        params: { path: { workspace_id: this.workspaceId, agent_id: options.agentId } },
+        body: options.body
+      })
+    );
+  }
+};
+
+// src/platform/resources/api-keys.ts
+var PlatformApiKeyResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** Get information about the currently authenticated API key. */
+  async me() {
+    return extractData(this.c.GET("/v1/auth/me"));
+  }
+  /** List API keys in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/api-keys", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Create a new API key. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/api-keys", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Delete an API key. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/api-keys/{key_id}", {
+      params: { path: { workspace_id: this.workspaceId, key_id: options.keyId } }
+    });
+    return void 0;
+  }
+  /** Rotate an API key and return the replacement secret. */
+  async rotate(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/api-keys/{key_id}/rotate", {
+        params: { path: { workspace_id: this.workspaceId, key_id: options.keyId } },
+        body: options.body
+      })
+    );
+  }
+};
+
+// src/platform/resources/context-graphs.ts
+var ContextGraphResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List context graphs in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/context-graphs", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get a context graph by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/context-graphs/{context_graph_id}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            context_graph_id: options.contextGraphId
+          }
+        }
+      })
+    );
+  }
+  /** Create a new context graph. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/context-graphs", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update a context graph. */
+  async update(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/context-graphs/{context_graph_id}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            context_graph_id: options.contextGraphId
+          }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Delete a context graph. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/context-graphs/{context_graph_id}", {
+      params: {
+        path: {
+          workspace_id: this.workspaceId,
+          context_graph_id: options.contextGraphId
+        }
+      }
+    });
+    return void 0;
+  }
+  /** List context graph versions. */
+  async listVersions(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/context-graphs/{context_graph_id}/versions", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            context_graph_id: options.contextGraphId
+          },
+          query: options.query
+        }
+      })
+    );
+  }
+  /** Get a specific context graph version. */
+  async getVersion(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/context-graphs/{context_graph_id}/versions/{version}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            context_graph_id: options.contextGraphId,
+            version: options.version
+          }
+        }
+      })
+    );
+  }
+  /** Create a new context graph version. */
+  async createVersion(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/context-graphs/{context_graph_id}/versions", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            context_graph_id: options.contextGraphId
+          }
+        },
+        body: options.body
+      })
+    );
+  }
+};
+
+// src/platform/resources/conversations.ts
+var PlatformConversationResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List voice and text conversations in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/conversations", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Create a text conversation. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/conversations", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Get a conversation detail by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/conversations/{conversation_id}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            conversation_id: options.conversationId
+          }
+        }
+      })
+    );
+  }
+  /** Close a text conversation. */
+  async close(options) {
+    await this.c.DELETE("/v1/{workspace_id}/conversations/{conversation_id}", {
+      params: {
+        path: {
+          workspace_id: this.workspaceId,
+          conversation_id: options.conversationId
+        }
+      }
+    });
+    return void 0;
+  }
+  /** Send a text turn and receive the full JSON response. */
+  async createTurn(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/conversations/{conversation_id}/turns", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            conversation_id: options.conversationId
+          },
+          query: options.query
+        },
+        body: options.body,
+        headers: { Accept: "application/json" }
+      })
+    );
+  }
+  /** Send a text turn and receive typed Server-Sent Events. */
+  async streamTurn(options) {
+    const resp = await this.c.POST("/v1/{workspace_id}/conversations/{conversation_id}/turns", {
+      params: {
+        path: {
+          workspace_id: this.workspaceId,
+          conversation_id: options.conversationId
+        },
+        query: options.query
+      },
+      body: options.body,
+      headers: { Accept: "text/event-stream" },
+      parseAs: "stream",
+      ...options.signal && { signal: options.signal }
+    });
+    return parseSseStream(resp.response);
+  }
+};
+
+// src/platform/resources/data-sources.ts
+var DataSourceResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List data sources in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/data-sources", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get a data source by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/data-sources/{data_source_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, data_source_id: options.dataSourceId }
+        }
+      })
+    );
+  }
+  /** Create a new data source. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/data-sources", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update a data source. */
+  async update(options) {
+    return extractData(
+      this.c.PATCH("/v1/{workspace_id}/data-sources/{data_source_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, data_source_id: options.dataSourceId }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Get data source status. */
+  async getStatus(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/data-sources/{data_source_id}/status", {
+        params: {
+          path: { workspace_id: this.workspaceId, data_source_id: options.dataSourceId }
+        }
+      })
+    );
+  }
+  /** Get data source sync history. */
+  async getSyncHistory(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/data-sources/{data_source_id}/sync-history", {
+        params: {
+          path: { workspace_id: this.workspaceId, data_source_id: options.dataSourceId },
+          query: options.query
+        }
+      })
+    );
+  }
+  /** Trigger a data source sync. */
+  async triggerSync(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/data-sources/{data_source_id}/sync", {
+        params: {
+          path: { workspace_id: this.workspaceId, data_source_id: options.dataSourceId }
+        }
+      })
+    );
+  }
+  /** Delete a data source. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/data-sources/{data_source_id}", {
+      params: {
+        path: { workspace_id: this.workspaceId, data_source_id: options.dataSourceId }
+      }
+    });
+    return void 0;
+  }
+};
+
+// src/platform/resources/events.ts
+var PlatformEventResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** Open the workspace Server-Sent Events stream. */
+  async stream(options) {
+    const headers = { Accept: "text/event-stream" };
+    if (options?.lastEventId) {
+      headers["Last-Event-ID"] = options.lastEventId;
+    }
+    const resp = await this.c.GET("/v1/{workspace_id}/events/stream", {
+      params: { path: { workspace_id: this.workspaceId } },
+      headers,
+      parseAs: "stream",
+      ...options?.signal && { signal: options.signal }
+    });
+    return parseSseStream(resp.response);
+  }
+};
+
+// src/platform/resources/fhir.ts
+var FhirResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** Get FHIR store status for the workspace. */
+  async status() {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/status", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Search FHIR resources by type. */
+  async searchResources(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/resources/{resource_type}", {
+        params: {
+          path: { workspace_id: this.workspaceId, resource_type: options.resourceType },
+          query: options.query
+        }
+      })
+    );
+  }
+  /** Get a specific FHIR resource by type and ID. */
+  async getResource(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/resources/{resource_type}/{resource_id}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            resource_type: options.resourceType,
+            resource_id: options.resourceId
+          }
+        }
+      })
+    );
+  }
+  /** Create a FHIR resource. */
+  async createResource(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/fhir/resources/{resource_type}", {
+        params: {
+          path: { workspace_id: this.workspaceId, resource_type: options.resourceType }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Update a FHIR resource. */
+  async updateResource(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/fhir/resources/{resource_type}/{resource_id}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            resource_type: options.resourceType,
+            resource_id: options.resourceId
+          }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Get sync failures. */
+  async syncFailures(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/sync-failures", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Import FHIR data. */
+  async import(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/fhir/import", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Search patients. */
+  async searchPatients(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/patients", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get patient timeline. */
+  async getPatientTimeline(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/patients/{patient_id}/timeline", {
+        params: {
+          path: { workspace_id: this.workspaceId, patient_id: options.patientId },
+          query: options.query
+        }
+      })
+    );
+  }
+  /** Get patient summary. */
+  async getPatientSummary(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/patients/{patient_id}/summary", {
+        params: {
+          path: { workspace_id: this.workspaceId, patient_id: options.patientId }
+        }
+      })
+    );
+  }
+  /** Get FHIR views — patients. */
+  async viewPatients(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/views/patients", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get FHIR views — practitioners. */
+  async viewPractitioners(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/views/practitioners", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get FHIR views — locations. */
+  async viewLocations(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/views/locations", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get FHIR views — appointments. */
+  async viewAppointments(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/views/appointments", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get FHIR views — organizations. */
+  async viewOrganizations(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/views/organizations", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get FHIR views — slots. */
+  async viewSlots(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/fhir/views/slots", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+};
+
+// src/platform/resources/integrations.ts
+var IntegrationResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List integrations in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/integrations", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get an integration by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/integrations/{integration_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, integration_id: options.integrationId }
+        }
+      })
+    );
+  }
+  /** Create a new integration. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/integrations", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update an integration. */
+  async update(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/integrations/{integration_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, integration_id: options.integrationId }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Delete an integration. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/integrations/{integration_id}", {
+      params: {
+        path: { workspace_id: this.workspaceId, integration_id: options.integrationId }
+      }
+    });
+    return void 0;
+  }
+  /** Test an integration endpoint. */
+  async testEndpoint(options) {
+    return extractData(
+      this.c.POST(
+        "/v1/{workspace_id}/integrations/{integration_id}/endpoints/{endpoint_name}/test",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              integration_id: options.integrationId,
+              endpoint_name: options.endpointName
+            }
+          },
+          body: options.body
+        }
+      )
+    );
+  }
+  /** Check integration health for the workspace. */
+  async healthCheck() {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/integrations/health-check", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+};
+
+// src/platform/resources/phone-numbers.ts
+var PhoneNumberResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List phone numbers in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/phone-numbers", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get a phone number by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/phone-numbers/{phone_number_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, phone_number_id: options.phoneNumberId }
+        }
+      })
+    );
+  }
+  /** Create a phone number. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/phone-numbers", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update a phone number. */
+  async update(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/phone-numbers/{phone_number_id}", {
+        params: {
+          path: { workspace_id: this.workspaceId, phone_number_id: options.phoneNumberId }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Delete a phone number. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/phone-numbers/{phone_number_id}", {
+      params: {
+        path: { workspace_id: this.workspaceId, phone_number_id: options.phoneNumberId }
+      }
+    });
+    return void 0;
+  }
+  /** Set call forwarding for a phone number. */
+  async setForwarding(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/phone-numbers/{phone_number_id}/forwarding", {
+        params: {
+          path: { workspace_id: this.workspaceId, phone_number_id: options.phoneNumberId }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Clear call forwarding for a phone number. */
+  async clearForwarding(options) {
+    await this.c.DELETE("/v1/{workspace_id}/phone-numbers/{phone_number_id}/forwarding", {
+      params: {
+        path: { workspace_id: this.workspaceId, phone_number_id: options.phoneNumberId }
+      }
+    });
+    return void 0;
+  }
+  /** Get the Twilio sub-account for the workspace. */
+  async getTwilioSubAccount() {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/twilio/sub-account", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Provision a Twilio sub-account for the workspace. */
+  async provisionTwilioSubAccount() {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/twilio/sub-account", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Search available phone numbers for purchase. */
+  async searchAvailable(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/twilio/phone-numbers/available", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Purchase a phone number. */
+  async purchase(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/twilio/phone-numbers/purchase", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Release a purchased phone number. */
+  async release(options) {
+    await this.c.DELETE("/v1/{workspace_id}/twilio/phone-numbers/{phone_number_id}/release", {
+      params: {
+        path: { workspace_id: this.workspaceId, phone_number_id: options.phoneNumberId }
+      }
+    });
+    return void 0;
+  }
+  /** Bind a channel-manager phone number to a workspace/service. */
+  async bind(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/phone-numbers/bind", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+};
+
+// src/platform/resources/services.ts
+var PlatformServiceResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List services in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/services", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get a service by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/services/{service_id}", {
+        params: { path: { workspace_id: this.workspaceId, service_id: options.serviceId } }
+      })
+    );
+  }
+  /** Create a new service. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/services", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update a service. */
+  async update(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/services/{service_id}", {
+        params: { path: { workspace_id: this.workspaceId, service_id: options.serviceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Delete a service. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/services/{service_id}", {
+      params: { path: { workspace_id: this.workspaceId, service_id: options.serviceId } }
+    });
+    return void 0;
+  }
+  /** Upsert a version set for a service. */
+  async upsertVersionSet(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/services/{service_id}/version-sets/{name}", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            service_id: options.serviceId,
+            name: options.name
+          }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Resolve all tools available to a service. */
+  async resolveTools(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/services/{service_id}/tools/resolve", {
+        params: {
+          path: { workspace_id: this.workspaceId, service_id: options.serviceId },
+          query: options.query
+        }
+      })
+    );
+  }
+  /** Run one voice turn through a service. */
+  async voiceTurn(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/services/{service_id}/voice-turn", {
+        params: { path: { workspace_id: this.workspaceId, service_id: options.serviceId } },
+        body: options.body
+      })
+    );
+  }
+};
+
+// src/platform/resources/sessions.ts
+var PlatformSessionResource = class {
+  constructor(c, workspaceId2, realtime) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+    this.realtime = realtime;
+  }
+  /** List active voice sessions. */
+  async listActive() {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/sessions/active", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Start an SMS, WhatsApp, or web text session with an entity. */
+  async start(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/sessions/start", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Inject an external event or operator guidance into an active voice session. */
+  async inject(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/sessions/{call_sid}/inject", {
+        params: {
+          path: {
+            workspace_id: this.workspaceId,
+            call_sid: options.callSid
+          }
+        },
+        body: options.body
+      })
+    );
+  }
+  /** Build the public platform text-session WebSocket URL. */
+  buildTextSessionUrl(options) {
+    const url = new URL(
+      `/v1/${encodeURIComponent(this.workspaceId)}/sessions/connect`,
+      `${this.realtime.webSocketBaseUrl}/`
+    );
+    url.searchParams.set("service_id", options.serviceId);
+    url.searchParams.set("entity_id", options.entityId);
+    url.searchParams.set("tool_events", String(options.toolEvents ?? true));
+    if (options.conversationId) {
+      url.searchParams.set("conversation_id", options.conversationId);
+    }
+    return url.toString();
+  }
+  /** Connect to the public bidirectional text-session WebSocket. */
+  connectTextSession(options) {
+    const WebSocketCtor = getWebSocketConstructor(options.WebSocket ?? this.realtime.WebSocket);
+    const token = options.token ?? this.realtime.apiKey;
+    const url = this.buildTextSessionUrl(options);
+    return new WebSocketCtor(url, ["auth", token]);
+  }
+};
+
+// src/platform/resources/skills.ts
+var SkillResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  /** List skills in the workspace. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/skills", {
+        params: { path: { workspace_id: this.workspaceId }, query: options?.query }
+      })
+    );
+  }
+  /** Get a skill by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/skills/{skill_id}", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: options.skillId } }
+      })
+    );
+  }
+  /** Create a new skill. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/skills", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body: options.body
+      })
+    );
+  }
+  /** Update a skill. */
+  async update(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/skills/{skill_id}", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: options.skillId } },
+        body: options.body
+      })
+    );
+  }
+  /** Delete a skill. */
+  async delete(options) {
+    await this.c.DELETE("/v1/{workspace_id}/skills/{skill_id}", {
+      params: { path: { workspace_id: this.workspaceId, skill_id: options.skillId } }
+    });
+    return void 0;
+  }
+  /** Test a skill in isolation. */
+  async test(options) {
+    return extractData(
+      this.c.POST("/v1/{workspace_id}/skills/{skill_id}/test", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: options.skillId } },
+        body: options.body
+      })
+    );
+  }
+  /** Get HSM/service references for a skill. */
+  async getReferences(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/skills/{skill_id}/references", {
+        params: { path: { workspace_id: this.workspaceId, skill_id: options.skillId } }
+      })
+    );
+  }
+};
+
+// src/platform/resources/workspaces.ts
+var WorkspaceResource = class {
+  constructor(c, workspaceId2) {
+    this.c = c;
+    this.workspaceId = workspaceId2;
+  }
+  requireWorkspaceId() {
+    if (!this.workspaceId) {
+      throw new Error("workspaceId is required for this operation");
+    }
+    return this.workspaceId;
+  }
+  /** List workspaces accessible to this API key. */
+  async list(options) {
+    return extractData(
+      this.c.GET("/v1/workspaces", {
+        params: { query: options?.query }
+      })
+    );
+  }
+  /** Get a workspace by ID. */
+  async get(options) {
+    return extractData(
+      this.c.GET("/v1/workspaces/{workspace_id}", {
+        params: { path: { workspace_id: options?.workspaceId ?? this.requireWorkspaceId() } }
+      })
+    );
+  }
+  /** Create a new workspace. */
+  async create(options) {
+    return extractData(
+      this.c.POST("/v1/workspaces", {
+        body: options.body
+      })
+    );
+  }
+  /** Create a self-service workspace. */
+  async createSelfService(options) {
+    return extractData(
+      this.c.POST("/v1/workspaces/self-service", {
+        body: options.body
+      })
+    );
+  }
+  /** Update a workspace. */
+  async update(options) {
+    return extractData(
+      this.c.PATCH("/v1/workspaces/{workspace_id}", {
+        params: { path: { workspace_id: options.workspaceId ?? this.requireWorkspaceId() } },
+        body: options.body
+      })
+    );
+  }
+  /** Provision workspace resources (idempotent). */
+  async provision(options) {
+    return extractData(
+      this.c.POST("/v1/workspaces/{workspace_id}/provision", {
+        params: { path: { workspace_id: options?.workspaceId ?? this.requireWorkspaceId() } }
+      })
+    );
+  }
+  /** Archive a workspace. */
+  async archive(options) {
+    return extractData(
+      this.c.POST("/v1/workspaces/{workspace_id}/archive", {
+        params: { path: { workspace_id: options.workspaceId ?? this.requireWorkspaceId() } },
+        body: options.body
+      })
+    );
+  }
+  /** Check whether a workspace can be converted between environments. */
+  async checkEnvironmentConversion(options) {
+    return extractData(
+      this.c.GET("/v1/workspaces/{workspace_id}/environment-check", {
+        params: {
+          path: { workspace_id: options?.workspaceId ?? this.requireWorkspaceId() },
+          query: options?.query
+        }
+      })
+    );
+  }
+  /** Convert a workspace environment. */
+  async convertEnvironment(options) {
+    return extractData(
+      this.c.POST("/v1/workspaces/{workspace_id}/convert-environment", {
+        params: { path: { workspace_id: options.workspaceId ?? this.requireWorkspaceId() } },
+        body: options.body
+      })
+    );
+  }
+  /** Get voice settings for a workspace. */
+  async getVoiceSettings(options) {
+    return extractData(
+      this.c.GET("/v1/{workspace_id}/settings/voice", {
+        params: { path: { workspace_id: options?.workspaceId ?? this.requireWorkspaceId() } }
+      })
+    );
+  }
+  /** Update voice settings for a workspace. */
+  async updateVoiceSettings(options) {
+    return extractData(
+      this.c.PUT("/v1/{workspace_id}/settings/voice", {
+        params: { path: { workspace_id: options.workspaceId ?? this.requireWorkspaceId() } },
+        body: options.body
+      })
+    );
+  }
+  /** Get test caller numbers for a workspace. */
+  async getTestCallerNumbers(options) {
+    return extractData(
+      this.c.GET("/v1/workspaces/{workspace_id}/test-caller-numbers", {
+        params: { path: { workspace_id: options?.workspaceId ?? this.requireWorkspaceId() } }
+      })
+    );
+  }
+  /** Update test caller numbers for a workspace. */
+  async updateTestCallerNumbers(options) {
+    return extractData(
+      this.c.PUT("/v1/workspaces/{workspace_id}/test-caller-numbers", {
+        params: { path: { workspace_id: options.workspaceId ?? this.requireWorkspaceId() } },
+        body: options.body
+      })
+    );
+  }
+};
+
+// src/platform/core/branded-types.ts
+function workspaceId(id) {
+  return id;
+}
+function skillId(id) {
+  return id;
+}
+function integrationId(id) {
+  return id;
+}
+function contextGraphId(id) {
+  return id;
+}
+function platformAgentId(id) {
+  return id;
+}
+function platformServiceId(id) {
+  return id;
+}
+function phoneNumberId(id) {
+  return id;
+}
+function platformApiKeyId(id) {
+  return id;
+}
+function callSid(id) {
+  return id;
+}
+function platformConversationId(id) {
+  return id;
+}
+function dataSourceId(id) {
+  return id;
+}
+function operatorId(id) {
+  return id;
+}
+function reviewItemId(id) {
+  return id;
+}
+function monitorConceptId(id) {
+  return id;
+}
+function unificationRuleId(id) {
+  return id;
+}
+function entityId(id) {
+  return id;
+}
+function taskId(id) {
+  return id;
+}
+
+// src/platform/index.ts
+var defaultBaseUrl = "https://api.platform.amigo.ai";
+var PlatformClient = class {
+  constructor(config) {
+    __publicField(this, "api");
+    __publicField(this, "agents");
+    __publicField(this, "apiKeys");
+    __publicField(this, "contextGraphs");
+    __publicField(this, "conversations");
+    __publicField(this, "dataSources");
+    __publicField(this, "events");
+    __publicField(this, "fhir");
+    __publicField(this, "integrations");
+    __publicField(this, "phoneNumbers");
+    __publicField(this, "services");
+    __publicField(this, "sessions");
+    __publicField(this, "skills");
+    __publicField(this, "workspaces");
+    __publicField(this, "config");
+    this.config = validateConfig(config);
+    this.api = createPlatformFetch(this.config);
+    this.workspaces = new WorkspaceResource(this.api, this.config.workspaceId);
+    this.agents = new PlatformAgentResource(this.api, this.config.workspaceId);
+    this.apiKeys = new PlatformApiKeyResource(this.api, this.config.workspaceId);
+    this.contextGraphs = new ContextGraphResource(this.api, this.config.workspaceId);
+    this.conversations = new PlatformConversationResource(this.api, this.config.workspaceId);
+    this.dataSources = new DataSourceResource(this.api, this.config.workspaceId);
+    this.events = new PlatformEventResource(this.api, this.config.workspaceId);
+    this.fhir = new FhirResource(this.api, this.config.workspaceId);
+    this.integrations = new IntegrationResource(this.api, this.config.workspaceId);
+    this.phoneNumbers = new PhoneNumberResource(this.api, this.config.workspaceId);
+    this.services = new PlatformServiceResource(this.api, this.config.workspaceId);
+    this.sessions = new PlatformSessionResource(this.api, this.config.workspaceId, {
+      apiKey: this.config.apiKey,
+      webSocketBaseUrl: this.config.webSocketBaseUrl,
+      WebSocket: this.config.WebSocket
+    });
+    this.skills = new SkillResource(this.api, this.config.workspaceId);
+  }
+};
+function validateConfig(config) {
+  if (!config.apiKey) {
+    throw new ConfigurationError("Platform API key is required", "apiKey");
+  }
+  if (!config.workspaceId) {
+    throw new ConfigurationError("Workspace ID is required", "workspaceId");
+  }
+  const baseUrl = config.baseUrl ?? defaultBaseUrl;
+  const webSocketBaseUrl = config.webSocketBaseUrl ?? webSocketBaseFromHttpBase(baseUrl);
+  return {
+    ...config,
+    baseUrl,
+    webSocketBaseUrl
+  };
+}
+//# sourceMappingURL=platform.cjs.map