@gradientlabs/client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1223 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/errors.ts
+var ErrorCode = {
+  NotFound: "not_found",
+  Unauthenticated: "unauthenticated",
+  PermissionDenied: "permission_denied",
+  InvalidArgument: "invalid_argument",
+  FailedPrecondition: "failed_precondition",
+  ResourceExhausted: "resource_exhausted",
+  AlreadyExists: "already_exists",
+  Unavailable: "unavailable",
+  DeadlineExceeded: "deadline_exceeded",
+  Internal: "internal"
+};
+var GradientLabsError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "GradientLabsError";
+  }
+};
+var ConfigurationError = class extends GradientLabsError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var ApiError = class extends GradientLabsError {
+  /** HTTP status code of the response. */
+  statusCode;
+  /** Machine-readable error code from the response envelope. */
+  code;
+  /** Arbitrary structured details returned with the error. */
+  details;
+  constructor(args) {
+    super(args.message || `unexpected response status: ${args.statusCode}`);
+    this.name = "ApiError";
+    this.statusCode = args.statusCode;
+    this.code = args.code;
+    this.details = args.details ?? {};
+  }
+  /**
+   * The identifier that can be given to Gradient Labs technical support to
+   * investigate an error, if present in the error details.
+   */
+  get traceId() {
+    const traceId = this.details["trace_id"];
+    return typeof traceId === "string" ? traceId : void 0;
+  }
+};
+
+// src/internal/version.ts
+var VERSION = "0.1.0";
+
+// src/internal/user-agent.ts
+function userAgent() {
+  const runtimeVersion = typeof process !== "undefined" && process.version ? process.version : "unknown";
+  return `Gradient-Labs-Node/${VERSION} (node/${runtimeVersion})`;
+}
+
+// src/internal/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const headers = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      Accept: "application/json",
+      "User-Agent": userAgent()
+    };
+    let body;
+    if (options.body !== void 0) {
+      body = JSON.stringify(options.body);
+      headers["Content-Type"] = "application/json";
+    }
+    const signal = this.buildSignal(options.signal);
+    let response;
+    try {
+      response = await this.config.fetch(url, { method, headers, body, signal });
+    } catch (cause) {
+      throw new GradientLabsError(`request to ${method} ${path} failed: ${errorMessage(cause)}`, {
+        cause
+      });
+    }
+    const rawBody = await response.text();
+    if (response.status < 200 || response.status > 299) {
+      throw toApiError(response.status, rawBody);
+    }
+    if (!rawBody) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(rawBody);
+    } catch (cause) {
+      throw new GradientLabsError(`failed to parse response body: ${errorMessage(cause)}`, {
+        cause
+      });
+    }
+  }
+  buildUrl(path, query) {
+    const base = this.config.baseUrl.replace(/\/+$/, "");
+    const cleanPath = path.replace(/^\/+/, "");
+    const url = new URL(`${base}/${cleanPath}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  buildSignal(callerSignal) {
+    const { timeoutMs } = this.config;
+    if (timeoutMs === void 0) {
+      return callerSignal;
+    }
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    if (!callerSignal) {
+      return timeoutSignal;
+    }
+    if (typeof AbortSignal.any === "function") {
+      return AbortSignal.any([callerSignal, timeoutSignal]);
+    }
+    return callerSignal;
+  }
+};
+function toApiError(statusCode, rawBody) {
+  let code = "";
+  let message = "";
+  let details = {};
+  if (rawBody) {
+    try {
+      const parsed = JSON.parse(rawBody);
+      code = parsed.code ?? "";
+      message = parsed.message ?? "";
+      details = parsed.details ?? {};
+    } catch {
+    }
+  }
+  return new ApiError({ statusCode, code, message, details });
+}
+function errorMessage(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+
+// src/resources/articles.ts
+var Articles = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Creates or updates a help article. */
+  upsert(params, config = {}) {
+    return this.http.request("POST", "articles", { body: params, signal: config.signal });
+  }
+  /** Updates whether the AI agent can use an article or not. */
+  setUsageStatus(id, params, config = {}) {
+    return this.http.request("POST", `articles/${encodeURIComponent(id)}/usage-status`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Marks an article as deleted. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `articles/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/back-office-tasks.ts
+var BackOfficeTasks = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Creates a new back-office task. */
+  create(params, config = {}) {
+    return this.http.request("POST", "back-office-tasks", {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Retrieves detailed information about a back-office task. */
+  get(id, config = {}) {
+    return this.http.request("GET", `back-office-tasks/${encodeURIComponent(id)}/read`, {
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/conversations.ts
+var Conversations = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Begins a conversation. */
+  start(params, config = {}) {
+    return this.http.request("POST", "conversations", { body: params, signal: config.signal });
+  }
+  /** Retrieves a conversation, including the latest AI agent metadata. */
+  get(id, params = {}, config = {}) {
+    return this.http.request("GET", `conversations/${encodeURIComponent(id)}/read`, {
+      query: { support_platform: params.support_platform },
+      signal: config.signal
+    });
+  }
+  /**
+   * Retrieves a conversation.
+   *
+   * @deprecated Use {@link Conversations.get} instead, which reads from the
+   * canonical `/read` endpoint.
+   */
+  getDeprecated(id, config = {}) {
+    return this.http.request("GET", `conversations/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Adds a new message to an existing conversation. */
+  addMessage(id, params, config = {}) {
+    return this.http.request("POST", `conversations/${encodeURIComponent(id)}/messages`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Transfers responsibility for handling a conversation to a participant. */
+  assign(id, params, config = {}) {
+    return this.http.request("PUT", `conversations/${encodeURIComponent(id)}/assignee`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Logs an event against the conversation (e.g. typing, delivered, read). */
+  addEvent(id, params, config = {}) {
+    return this.http.request("POST", `conversations/${encodeURIComponent(id)}/events`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Adds the result of a customer survey (e.g. CSAT) to a conversation. */
+  rate(id, params, config = {}) {
+    return this.http.request("PUT", `conversations/${encodeURIComponent(id)}/rate`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Cancels a conversation (e.g. because a human has taken it over). */
+  cancel(id, params = {}, config = {}) {
+    return this.http.request("PUT", `conversations/${encodeURIComponent(id)}/cancel`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Finishes a conversation that has reached a natural end state. */
+  finish(id, params = {}, config = {}) {
+    return this.http.request("PUT", `conversations/${encodeURIComponent(id)}/finish`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Re-opens a conversation that was previously finished. */
+  resume(id, params, config = {}) {
+    return this.http.request("PUT", `conversations/${encodeURIComponent(id)}/resume`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Returns the result of an async tool execution. */
+  returnAsyncToolResult(id, params, config = {}) {
+    return this.http.request(
+      "PUT",
+      `conversations/${encodeURIComponent(id)}/return-async-tool-result`,
+      { body: params, signal: config.signal }
+    );
+  }
+};
+
+// src/resources/hand-off-targets.ts
+var HandOffTargets = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists the available hand-off targets. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "hand-off-targets", {
+      signal: config.signal
+    });
+    return rsp.targets;
+  }
+  /** Creates or updates a hand-off target. */
+  upsert(params, config = {}) {
+    return this.http.request("POST", "hand-off-targets", { body: params, signal: config.signal });
+  }
+  /** Deletes a hand-off target. */
+  delete(params, config = {}) {
+    return this.http.request("DELETE", "hand-off-targets", {
+      query: { id: params.id },
+      signal: config.signal
+    });
+  }
+  /** Gets the current default hand-off target for a channel. Returns "" if unset. */
+  async getDefault(params, config = {}) {
+    const rsp = await this.http.request("GET", "hand-off-targets/default", {
+      query: { channel: params.channel },
+      signal: config.signal
+    });
+    return rsp.id;
+  }
+  /** Sets the default hand-off target for a channel. */
+  setDefault(params, config = {}) {
+    return this.http.request("PUT", "hand-off-targets/default", {
+      body: params,
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/ip-addresses.ts
+var IpAddressesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Returns the list of IP addresses Gradient Labs uses, in CIDR format. */
+  list(config = {}) {
+    return this.http.request("GET", "ip-addresses", { signal: config.signal });
+  }
+};
+
+// src/resources/notes.ts
+var Notes = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Creates a new note. */
+  create(params, config = {}) {
+    return this.http.request("POST", "notes", { body: params, signal: config.signal });
+  }
+  /** Updates an existing note's contents. */
+  update(id, params, config = {}) {
+    return this.http.request("POST", `notes/${encodeURIComponent(id)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Updates a note's status. */
+  setStatus(id, params, config = {}) {
+    return this.http.request("POST", `notes/${encodeURIComponent(id)}/status`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Marks a note as deleted. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `notes/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/outbound-conversations.ts
+var OutboundConversations = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Creates and starts a new outbound conversation initiated by the AI agent. */
+  start(params, config = {}) {
+    return this.http.request("POST", "outbound/conversations", {
+      body: params,
+      signal: config.signal
+    });
+  }
+};
+
+// src/internal/pagination.ts
+async function* paginate(fetchPage) {
+  let after;
+  do {
+    const page = await fetchPage(after);
+    for (const item of page.data) {
+      yield item;
+    }
+    after = page.pageInfo.next;
+  } while (after);
+}
+
+// src/resources/procedures.ts
+var Procedures = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Retrieves one page of procedures. */
+  async list(params = {}, config = {}) {
+    const rsp = await this.http.request("GET", "procedures", {
+      query: { cursor: params.cursor, status: params.status },
+      signal: config.signal
+    });
+    return { data: rsp.procedures, pageInfo: rsp.pagination };
+  }
+  /** Iterates over all procedures, transparently following pagination cursors. */
+  listAll(params = {}, config = {}) {
+    return paginate((cursor) => this.list({ ...params, cursor }, config));
+  }
+  /** Retrieves a specific procedure by ID. */
+  get(id, config = {}) {
+    return this.http.request("GET", `procedure/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Configures daily usage limits for a procedure. Returns the updated procedure. */
+  async setLimit(id, params, config = {}) {
+    const rsp = await this.http.request(
+      "POST",
+      `procedure/${encodeURIComponent(id)}/limit`,
+      { body: params, signal: config.signal }
+    );
+    return rsp.procedure;
+  }
+  /** Lists the non-ephemeral versions of a procedure. */
+  async listVersions(id, config = {}) {
+    const rsp = await this.http.request(
+      "GET",
+      `procedures/${encodeURIComponent(id)}/versions`,
+      { signal: config.signal }
+    );
+    return rsp.Versions;
+  }
+  /** Promotes a procedure version to be the live (production) version. */
+  setLiveVersion(id, version, config = {}) {
+    return this.http.request(
+      "POST",
+      `procedures/${encodeURIComponent(id)}/versions/${version}/set-live`,
+      { signal: config.signal }
+    );
+  }
+  /** Removes a procedure version from being the live revision. */
+  unsetLiveVersion(id, version, config = {}) {
+    return this.http.request(
+      "POST",
+      `procedures/${encodeURIComponent(id)}/versions/${version}/unset-live`,
+      { signal: config.signal }
+    );
+  }
+  /** Marks a procedure version as gated for A/B testing. */
+  setGatedVersion(id, version, params, config = {}) {
+    return this.http.request(
+      "POST",
+      `procedures/${encodeURIComponent(id)}/versions/${version}/set-gated`,
+      { body: params, signal: config.signal }
+    );
+  }
+  /** Removes the gated marking from a procedure version. */
+  unsetGatedVersion(id, version, config = {}) {
+    return this.http.request(
+      "POST",
+      `procedures/${encodeURIComponent(id)}/versions/${version}/unset-gated`,
+      { signal: config.signal }
+    );
+  }
+};
+
+// src/resources/resource-sources.ts
+var ResourceSources = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists all resource sources accessible to the company. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "resource-sources", {
+      signal: config.signal
+    });
+    return rsp.resource_sources;
+  }
+  /** Creates a new resource source. */
+  create(params, config = {}) {
+    return this.http.request("POST", "resource-sources", { body: params, signal: config.signal });
+  }
+  /** Retrieves a specific resource source by ID. */
+  get(id, config = {}) {
+    return this.http.request("GET", `resource-sources/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Updates an existing resource source. */
+  update(id, params, config = {}) {
+    return this.http.request("PUT", `resource-sources/${encodeURIComponent(id)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Deletes a resource source. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `resource-sources/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Modifies the source schema based on the provided payload examples. */
+  updateSchemaByExamples(id, params, config = {}) {
+    return this.http.request(
+      "POST",
+      `resource-sources/${encodeURIComponent(id)}/schema-by-examples`,
+      { body: params, signal: config.signal }
+    );
+  }
+};
+
+// src/resources/resource-types.ts
+var ResourceTypes = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists all resource types accessible to the company. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "resource-types", {
+      signal: config.signal
+    });
+    return rsp.resource_types;
+  }
+  /** Creates a new resource type. */
+  create(params, config = {}) {
+    return this.http.request("POST", "resource-types", { body: params, signal: config.signal });
+  }
+  /** Retrieves a specific resource type by ID. */
+  get(id, config = {}) {
+    return this.http.request("GET", `resource-types/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Updates an existing resource type. */
+  update(id, params, config = {}) {
+    return this.http.request("PUT", `resource-types/${encodeURIComponent(id)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Deletes a resource type. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `resource-types/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/secrets.ts
+var Secrets = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists the company's configured secrets. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "secrets", {
+      signal: config.signal
+    });
+    return rsp.secrets;
+  }
+  /** Creates or updates a secret. */
+  write(name, params, config = {}) {
+    return this.http.request("PUT", `secrets/${encodeURIComponent(name)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Revokes a secret so it can no longer be used. */
+  revoke(name, config = {}) {
+    return this.http.request("DELETE", `secrets/${encodeURIComponent(name)}`, {
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/terminology-substitutions.ts
+var TerminologySubstitutions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Returns all terminology substitutions configured for the organization. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "terminology-substitutions", {
+      signal: config.signal
+    });
+    return rsp.substitutions;
+  }
+  /** Creates a new terminology substitution. */
+  create(params, config = {}) {
+    return this.http.request("POST", "terminology-substitutions", {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Returns a single terminology substitution by ID. */
+  get(id, config = {}) {
+    return this.http.request("GET", `terminology-substitutions/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Updates an existing terminology substitution. */
+  update(id, params, config = {}) {
+    return this.http.request("PUT", `terminology-substitutions/${encodeURIComponent(id)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Deletes a terminology substitution by ID. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `terminology-substitutions/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/tools.ts
+var Tools = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Returns all tools created by the company. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "tools", {
+      signal: config.signal
+    });
+    return rsp.tools;
+  }
+  /** Creates a new custom tool. */
+  create(params, config = {}) {
+    return this.http.request("POST", "tools", { body: params, signal: config.signal });
+  }
+  /** Reads a tool by ID and optional version. */
+  get(id, params = {}, config = {}) {
+    return this.http.request("GET", `tools/${encodeURIComponent(id)}`, {
+      query: { version: params.version },
+      signal: config.signal
+    });
+  }
+  /** Creates a new revision of a tool. The name and type cannot be changed. */
+  update(id, params, config = {}) {
+    return this.http.request("PUT", `tools/${encodeURIComponent(id)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Deletes a tool. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `tools/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Executes a tool, enabling you to test it without an actual conversation. */
+  execute(id, params, config = {}) {
+    return this.http.request("POST", `tools/${encodeURIComponent(id)}/execute`, {
+      body: { arguments: params.arguments, token: params.token ?? "" },
+      signal: config.signal
+    });
+  }
+};
+
+// src/resources/topics.ts
+var Topics = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists the company's topics, optionally filtered by support platform. */
+  async list(params = {}, config = {}) {
+    const rsp = await this.http.request("GET", "topics", {
+      query: { support_platform: params.support_platform },
+      signal: config.signal
+    });
+    return rsp.Topics;
+  }
+  /** Reads a single article topic. */
+  get(id, params = {}, config = {}) {
+    return this.http.request("GET", `topic/${encodeURIComponent(id)}`, {
+      query: { support_platform: params.support_platform },
+      signal: config.signal
+    });
+  }
+  /** Creates or updates an article topic. */
+  upsert(params, config = {}) {
+    return this.http.request("POST", "topics", { body: params, signal: config.signal });
+  }
+};
+
+// src/resources/traffic-groups.ts
+var TrafficGroups = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists all traffic groups for the company. */
+  async list(config = {}) {
+    const rsp = await this.http.request("GET", "traffic-groups", {
+      signal: config.signal
+    });
+    return rsp.traffic_groups;
+  }
+  /** Creates a new traffic group. */
+  create(params, config = {}) {
+    return this.http.request("POST", "traffic-groups", { body: params, signal: config.signal });
+  }
+  /** Updates an existing traffic group. */
+  update(id, params, config = {}) {
+    return this.http.request("PUT", `traffic-groups/${encodeURIComponent(id)}`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Deletes a traffic group and all associated targets. */
+  delete(id, config = {}) {
+    return this.http.request("DELETE", `traffic-groups/${encodeURIComponent(id)}`, {
+      signal: config.signal
+    });
+  }
+  /** Adds a target to a traffic group. */
+  addTarget(id, params, config = {}) {
+    return this.http.request("POST", `traffic-groups/${encodeURIComponent(id)}/targets`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Removes a target from a traffic group. */
+  removeTarget(id, targetId, config = {}) {
+    return this.http.request(
+      "DELETE",
+      `traffic-groups/${encodeURIComponent(id)}/targets/${encodeURIComponent(targetId)}`,
+      { signal: config.signal }
+    );
+  }
+  /** Excludes a target (e.g. a procedure) from a traffic group. */
+  addExclusion(id, params, config = {}) {
+    return this.http.request("POST", `traffic-groups/${encodeURIComponent(id)}/exclusions`, {
+      body: params,
+      signal: config.signal
+    });
+  }
+  /** Removes a target exclusion from a traffic group. */
+  removeExclusion(id, targetId, config = {}) {
+    return this.http.request(
+      "DELETE",
+      `traffic-groups/${encodeURIComponent(id)}/exclusions/${encodeURIComponent(targetId)}`,
+      { signal: config.signal }
+    );
+  }
+};
+
+// src/resources/voice.ts
+var Voice = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Retrieves the most recent call context for a given phone number. Throws an
+   * {@link ApiError} with status 404 if there have been no recent call events.
+   */
+  getLatestCallContext(phoneNumber, params = {}, config = {}) {
+    return this.http.request(
+      "GET",
+      `voice/latest-call-context/${encodeURIComponent(phoneNumber)}`,
+      {
+        query: {
+          lookback_seconds: params.lookback_seconds,
+          include_large_fields: params.include_large_fields
+        },
+        signal: config.signal
+      }
+    );
+  }
+};
+
+// src/webhooks/events.ts
+var WebhookType = {
+  AgentMessage: "agent.message",
+  ConversationHandOff: "conversation.hand_off",
+  ConversationFinished: "conversation.finished",
+  ActionExecute: "action.execute",
+  ResourcePull: "resource.pull",
+  BackOfficeTaskComplete: "back-office-task.complete",
+  BackOfficeTaskHandOff: "back-office-task.hand-off",
+  BackOfficeTaskFail: "back-office-task.fail"
+};
+
+// src/webhooks/verifier.ts
+var SIGNATURE_HEADER = "x-gradientlabs-signature";
+var TOKEN_HEADER = "x-gradientlabs-token";
+var DEFAULT_LEEWAY_MS = 5 * 60 * 1e3;
+var InvalidWebhookSignatureError = class extends GradientLabsError {
+  constructor(message = "webhook signature is invalid") {
+    super(message);
+    this.name = "InvalidWebhookSignatureError";
+  }
+};
+var UnknownWebhookTypeError = class extends GradientLabsError {
+  type;
+  constructor(type) {
+    super(`unknown webhook event type received: ${type}`);
+    this.name = "UnknownWebhookTypeError";
+    this.type = type;
+  }
+};
+var WebhookVerifier = class {
+  signingKey;
+  leewayMs;
+  now;
+  constructor(config) {
+    this.signingKey = config.signingKey;
+    this.leewayMs = config.leewayMs ?? DEFAULT_LEEWAY_MS;
+    this.now = config.now ?? Date.now;
+  }
+  /**
+   * Verifies a webhook's signature and timestamp. Throws
+   * {@link InvalidWebhookSignatureError} if verification fails.
+   */
+  verify(args) {
+    const body = toBuffer(args.body);
+    const { timestamp, signatures } = parseSignatureHeader(args.signature);
+    if (Math.abs(this.now() - timestamp * 1e3) > this.leewayMs) {
+      throw new InvalidWebhookSignatureError("webhook timestamp is outside the allowed leeway");
+    }
+    const expected = this.computeSignature(timestamp, body);
+    for (const candidate of signatures) {
+      if (constantTimeEqual(expected, candidate)) {
+        return;
+      }
+    }
+    throw new InvalidWebhookSignatureError();
+  }
+  /**
+   * Verifies a webhook request, then parses it into a typed event. Returns the
+   * event along with the optional `X-GradientLabs-Token` passthrough.
+   *
+   * Verification always happens before the event type is inspected.
+   */
+  parse(args) {
+    const signature = getHeader(args.headers, SIGNATURE_HEADER);
+    this.verify({ body: args.body, signature });
+    const text = typeof args.body === "string" ? args.body : Buffer.from(args.body).toString("utf8");
+    const payload = JSON.parse(text);
+    if (!isKnownType(payload.type)) {
+      throw new UnknownWebhookTypeError(payload.type);
+    }
+    const event = {
+      id: payload.id,
+      type: payload.type,
+      sequence_number: payload.sequence_number,
+      timestamp: payload.timestamp,
+      data: payload.data
+    };
+    const token = getHeader(args.headers, TOKEN_HEADER) ?? void 0;
+    return { event, token };
+  }
+  computeSignature(timestamp, body) {
+    return crypto.createHmac("sha256", this.signingKey).update(`${timestamp}.`).update(body).digest();
+  }
+};
+function isKnownType(type) {
+  return Object.values(WebhookType).includes(type);
+}
+function parseSignatureHeader(header) {
+  if (!header) {
+    throw new InvalidWebhookSignatureError("missing signature header");
+  }
+  let timestamp;
+  const signatures = [];
+  for (const pair of header.split(",")) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) {
+      throw new InvalidWebhookSignatureError("malformed signature header");
+    }
+    const key = pair.slice(0, idx);
+    const value = pair.slice(idx + 1);
+    if (key === "t") {
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsed)) {
+        throw new InvalidWebhookSignatureError("invalid timestamp component");
+      }
+      timestamp = parsed;
+    } else if (key === "v1") {
+      try {
+        signatures.push(Buffer.from(value, "hex"));
+      } catch {
+        throw new InvalidWebhookSignatureError("invalid signature component");
+      }
+    }
+  }
+  if (timestamp === void 0) {
+    throw new InvalidWebhookSignatureError("signature header contains no timestamp component");
+  }
+  if (signatures.length === 0) {
+    throw new InvalidWebhookSignatureError("signature header contains no v1 signature");
+  }
+  return { timestamp, signatures };
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(a, b);
+}
+function toBuffer(body) {
+  return typeof body === "string" ? Buffer.from(body, "utf8") : Buffer.from(body);
+}
+function getHeader(headers, name) {
+  if (typeof headers.get === "function") {
+    return headers.get(name);
+  }
+  const record = headers;
+  const direct = record[name];
+  const value = direct ?? findCaseInsensitive(record, name);
+  if (value === void 0) {
+    return null;
+  }
+  return Array.isArray(value) ? value[0] ?? null : value;
+}
+function findCaseInsensitive(record, name) {
+  const lower = name.toLowerCase();
+  for (const key of Object.keys(record)) {
+    if (key.toLowerCase() === lower) {
+      return record[key];
+    }
+  }
+  return void 0;
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.gradient-labs.ai";
+var defaultFetch = (input, init) => fetch(input, init);
+var GradientLabs = class {
+  // Integration role (publicapi)
+  conversations;
+  outboundConversations;
+  backOfficeTasks;
+  voice;
+  // Management role (publicmanagementapi)
+  tools;
+  articles;
+  topics;
+  procedures;
+  handOffTargets;
+  resourceSources;
+  resourceTypes;
+  secrets;
+  notes;
+  terminologySubstitutions;
+  trafficGroups;
+  ipAddresses;
+  webhookVerifier;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new ConfigurationError("apiKey is required");
+    }
+    const http = new HttpClient({
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      apiKey: config.apiKey,
+      fetch: config.fetch ?? defaultFetch,
+      timeoutMs: config.timeoutMs
+    });
+    this.conversations = new Conversations(http);
+    this.outboundConversations = new OutboundConversations(http);
+    this.backOfficeTasks = new BackOfficeTasks(http);
+    this.voice = new Voice(http);
+    this.tools = new Tools(http);
+    this.articles = new Articles(http);
+    this.topics = new Topics(http);
+    this.procedures = new Procedures(http);
+    this.handOffTargets = new HandOffTargets(http);
+    this.resourceSources = new ResourceSources(http);
+    this.resourceTypes = new ResourceTypes(http);
+    this.secrets = new Secrets(http);
+    this.notes = new Notes(http);
+    this.terminologySubstitutions = new TerminologySubstitutions(http);
+    this.trafficGroups = new TrafficGroups(http);
+    this.ipAddresses = new IpAddressesResource(http);
+    if (config.webhookSigningKey) {
+      this.webhookVerifier = new WebhookVerifier({
+        signingKey: config.webhookSigningKey,
+        leewayMs: config.webhookLeewayMs
+      });
+    }
+  }
+  /**
+   * The webhook verifier. Throws {@link ConfigurationError} if the client was
+   * created without a `webhookSigningKey`.
+   */
+  get webhooks() {
+    if (!this.webhookVerifier) {
+      throw new ConfigurationError(
+        "webhookSigningKey is required to verify webhooks; pass it to the GradientLabs constructor"
+      );
+    }
+    return this.webhookVerifier;
+  }
+};
+
+// src/models/enums.ts
+var ArticleStatus = {
+  Draft: "draft",
+  Published: "published",
+  Deleted: "deleted",
+  Excluded: "excluded",
+  Unknown: "unknown"
+};
+var ArticleUsageStatus = {
+  On: "on",
+  Off: "off"
+};
+var ArticleVisibility = {
+  Public: "public",
+  Users: "users",
+  Internal: "internal",
+  Unknown: "unknown"
+};
+var AttachmentType = {
+  Image: "image",
+  File: "file"
+};
+var Channel = {
+  Web: "web",
+  Email: "email",
+  Voice: "voice",
+  Unmapped: "unmapped"
+};
+var CustomerSource = {
+  Dixa: "dixa",
+  Intercom: "intercom",
+  Freshchat: "freshchat",
+  Freshdesk: "freshdesk",
+  PublicApi: "public-api",
+  ChatSdk: "chat-sdk",
+  Salesforce: "salesforce",
+  Zendesk: "zendesk",
+  Livekit: "livekit",
+  Twilio: "twilio",
+  Talkdesk: "talkdesk",
+  IntercomVoice: "intercom-voice",
+  Livechat: "livechat",
+  WebApp: "web-app",
+  Gmail: "gmail",
+  File: "file"
+};
+var ParticipantType = {
+  Customer: "Customer",
+  Agent: "Agent",
+  AIAgent: "AI Agent",
+  Bot: "Bot"
+};
+var ConversationEventType = {
+  Assigned: "assigned",
+  Cancelled: "cancelled",
+  Finished: "finished",
+  Resumed: "resumed",
+  InternalNote: "internal-note",
+  Message: "message",
+  Delivered: "delivered",
+  Read: "read",
+  Rated: "rated",
+  Started: "started",
+  Typing: "typing",
+  AsyncToolResult: "async-tool-result"
+};
+var ProcedureStatus = {
+  Unsaved: "unsaved",
+  Draft: "draft",
+  Live: "live",
+  Archived: "archived"
+};
+var NoteStatus = {
+  Draft: "draft",
+  Live: "live",
+  Deleted: "deleted"
+};
+var BackOfficeTaskStatus = {
+  Pending: "pending",
+  InProgress: "in-progress",
+  Completed: "completed",
+  Failed: "failed",
+  HandedOff: "handed-off"
+};
+var BackOfficeTaskResultType = {
+  Custom: "custom"
+};
+var AttributeCardinality = {
+  One: "one",
+  Many: "many"
+};
+var AttributeType = {
+  String: "string",
+  Date: "date",
+  Timestamp: "timestamp",
+  Boolean: "boolean",
+  Number: "number",
+  Array: "array",
+  Complex: "complex"
+};
+var ResourceSourceRefreshStrategy = {
+  Dynamic: "dynamic",
+  Static: "static"
+};
+var ResourceSourceScope = {
+  Global: "global",
+  Local: "local"
+};
+var ResourceSourceType = {
+  Http: "http",
+  Internal: "internal",
+  Webhook: "webhook"
+};
+var SchemaUpdateStrategy = {
+  Replace: "replace",
+  Merge: "merge"
+};
+var ResourceTypeRefreshStrategy = {
+  Dynamic: "dynamic",
+  Static: "static"
+};
+var ResourceTypeScope = {
+  Global: "global",
+  Local: "local"
+};
+var SupportPlatform = {
+  Dixa: "dixa",
+  Freshchat: "freshchat",
+  Freshdesk: "freshdesk",
+  Gmail: "gmail",
+  Intercom: "intercom",
+  Livechat: "livechat",
+  PublicApi: "public-api",
+  ChatSdk: "chat-sdk",
+  Salesforce: "salesforce",
+  Zendesk: "zendesk",
+  Livekit: "livekit",
+  Twilio: "twilio",
+  Talkdesk: "talkdesk",
+  IntercomVoice: "intercom-voice",
+  ConversationSynthesizor: "conversation-synthesizor",
+  WebApp: "web-app"
+};
+var BodyEncoding = {
+  Json: "application/json",
+  Form: "application/x-www-form-urlencoded"
+};
+var ParameterSource = {
+  Llm: "llm",
+  Literal: "literal",
+  Resource: "resource"
+};
+var ParameterType = {
+  String: "string",
+  StringArray: "string_array",
+  Integer: "integer",
+  Float: "float",
+  Boolean: "boolean",
+  Date: "date",
+  Timestamp: "timestamp",
+  Duration: "duration"
+};
+
+exports.ApiError = ApiError;
+exports.ArticleStatus = ArticleStatus;
+exports.ArticleUsageStatus = ArticleUsageStatus;
+exports.ArticleVisibility = ArticleVisibility;
+exports.Articles = Articles;
+exports.AttachmentType = AttachmentType;
+exports.AttributeCardinality = AttributeCardinality;
+exports.AttributeType = AttributeType;
+exports.BackOfficeTaskResultType = BackOfficeTaskResultType;
+exports.BackOfficeTaskStatus = BackOfficeTaskStatus;
+exports.BackOfficeTasks = BackOfficeTasks;
+exports.BodyEncoding = BodyEncoding;
+exports.Channel = Channel;
+exports.ConfigurationError = ConfigurationError;
+exports.ConversationEventType = ConversationEventType;
+exports.Conversations = Conversations;
+exports.CustomerSource = CustomerSource;
+exports.ErrorCode = ErrorCode;
+exports.GradientLabs = GradientLabs;
+exports.GradientLabsError = GradientLabsError;
+exports.HandOffTargets = HandOffTargets;
+exports.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
+exports.IpAddressesResource = IpAddressesResource;
+exports.NoteStatus = NoteStatus;
+exports.Notes = Notes;
+exports.OutboundConversations = OutboundConversations;
+exports.ParameterSource = ParameterSource;
+exports.ParameterType = ParameterType;
+exports.ParticipantType = ParticipantType;
+exports.ProcedureStatus = ProcedureStatus;
+exports.Procedures = Procedures;
+exports.ResourceSourceRefreshStrategy = ResourceSourceRefreshStrategy;
+exports.ResourceSourceScope = ResourceSourceScope;
+exports.ResourceSourceType = ResourceSourceType;
+exports.ResourceSources = ResourceSources;
+exports.ResourceTypeRefreshStrategy = ResourceTypeRefreshStrategy;
+exports.ResourceTypeScope = ResourceTypeScope;
+exports.ResourceTypes = ResourceTypes;
+exports.SchemaUpdateStrategy = SchemaUpdateStrategy;
+exports.Secrets = Secrets;
+exports.SupportPlatform = SupportPlatform;
+exports.TerminologySubstitutions = TerminologySubstitutions;
+exports.Tools = Tools;
+exports.Topics = Topics;
+exports.TrafficGroups = TrafficGroups;
+exports.UnknownWebhookTypeError = UnknownWebhookTypeError;
+exports.Voice = Voice;
+exports.WebhookType = WebhookType;
+exports.WebhookVerifier = WebhookVerifier;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map