@band-ai/sdk 0.1.2

package/dist/rest.cjs

@@ -0,0 +1,1159 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rest/index.ts
+var rest_exports = {};
+__export(rest_exports, {
+  DEFAULT_REQUEST_OPTIONS: () => DEFAULT_REQUEST_OPTIONS,
+  FernRestAdapter: () => FernRestAdapter,
+  RestFacade: () => RestFacade,
+  fetchPaginated: () => fetchPaginated,
+  normalizePaginationMetadata: () => normalizePaginationMetadata
+});
+module.exports = __toCommonJS(rest_exports);
+
+// src/core/errors.ts
+var ThenvoiSdkError = class extends Error {
+  constructor(message, cause) {
+    super(message, cause !== void 0 ? { cause } : void 0);
+    this.name = "ThenvoiSdkError";
+  }
+};
+var UnsupportedFeatureError = class extends ThenvoiSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedFeatureError";
+  }
+};
+var ValidationError = class extends ThenvoiSdkError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ValidationError";
+  }
+};
+
+// src/client/rest/pagination.ts
+var DEFAULT_PAGE_SIZE = 100;
+var DEFAULT_MAX_PAGES = 100;
+var VALID_PAGINATION_STRATEGIES = /* @__PURE__ */ new Set([
+  "auto",
+  "total_pages",
+  "until_empty"
+]);
+function normalizePaginationMetadata(metadata, options) {
+  if (!metadata) {
+    return {};
+  }
+  const mode = options?.mode ?? "strict";
+  const snakeCaseMetadata = metadata;
+  const pageRaw = metadata.page ?? snakeCaseMetadata.page;
+  const pageSizeRaw = metadata.pageSize ?? snakeCaseMetadata.page_size;
+  const totalPagesRaw = metadata.totalPages ?? snakeCaseMetadata.total_pages;
+  const totalCountRaw = metadata.totalCount ?? snakeCaseMetadata.total_count;
+  const PAGINATION_KEYS = /* @__PURE__ */ new Set([
+    "page",
+    "pageSize",
+    "totalPages",
+    "totalCount",
+    "page_size",
+    "total_pages",
+    "total_count"
+  ]);
+  const passthrough = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!PAGINATION_KEYS.has(key)) {
+      passthrough[key] = value;
+    }
+  }
+  const page = toPositiveInteger(pageRaw);
+  const pageSize = toPositiveInteger(pageSizeRaw);
+  const totalPages = toNonNegativeInteger(totalPagesRaw);
+  const totalCount = toNonNegativeInteger(totalCountRaw);
+  if (mode === "strict") {
+    assertValidMetadataField("page", pageRaw, page);
+    assertValidMetadataField("pageSize", pageSizeRaw, pageSize);
+    assertValidMetadataField("totalPages", totalPagesRaw, totalPages);
+    assertValidMetadataField("totalCount", totalCountRaw, totalCount);
+  }
+  return {
+    ...passthrough,
+    ...page !== void 0 ? { page } : {},
+    ...pageSize !== void 0 ? { pageSize } : {},
+    ...totalPages !== void 0 ? { totalPages } : {},
+    ...totalCount !== void 0 ? { totalCount } : {}
+  };
+}
+function assertValidMetadataField(field, rawValue, normalizedValue) {
+  if (rawValue === void 0) {
+    return;
+  }
+  if (normalizedValue === void 0) {
+    throw new ValidationError(
+      `Invalid pagination metadata '${field}': expected an integer with valid bounds`
+    );
+  }
+}
+async function fetchPaginated(options) {
+  const pageSize = resolvePositiveInteger("pageSize", options.pageSize, DEFAULT_PAGE_SIZE);
+  const maxPages = resolvePositiveInteger("maxPages", options.maxPages, DEFAULT_MAX_PAGES);
+  const strategy = resolvePaginationStrategy(options.strategy);
+  const metadataValidation = options.metadataValidation ?? "strategy_aware";
+  const allItems = [];
+  let completed = false;
+  for (let page = 1; page <= maxPages; page += 1) {
+    const response = await options.fetchPage({ page, pageSize });
+    if (!Array.isArray(response.data)) {
+      throw new ValidationError("Paginated response.data must be an array");
+    }
+    const items = response.data;
+    allItems.push(...items);
+    const metadata = normalizePaginationMetadata(response.metadata, {
+      mode: resolveMetadataMode(strategy, metadataValidation)
+    });
+    const totalPages = metadata.totalPages;
+    if (strategy === "total_pages") {
+      if (typeof totalPages !== "number" || totalPages <= 0) {
+        throw new ValidationError(
+          "Pagination strategy 'total_pages' requires metadata.totalPages to be a positive number"
+        );
+      }
+      if (page >= totalPages) {
+        completed = true;
+        break;
+      }
+      continue;
+    }
+    if (strategy === "until_empty" && items.length === 0) {
+      completed = true;
+      break;
+    }
+    if (strategy === "auto") {
+      if (typeof totalPages === "number" && totalPages > 0) {
+        if (page >= totalPages) {
+          completed = true;
+          break;
+        }
+        continue;
+      }
+      if (items.length === 0) {
+        completed = true;
+        break;
+      }
+    }
+  }
+  if (!completed) {
+    throw new ValidationError(
+      `Pagination stopped after maxPages=${maxPages} before reaching a terminal condition`
+    );
+  }
+  return allItems;
+}
+function resolveMetadataMode(strategy, validation) {
+  if (validation === "strict") {
+    return "strict";
+  }
+  if (validation === "lossy") {
+    return "lossy";
+  }
+  return strategy === "until_empty" ? "lossy" : "strict";
+}
+function resolvePositiveInteger(name, value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new ValidationError(`${name} must be a positive integer`);
+  }
+  return value;
+}
+function resolvePaginationStrategy(value) {
+  if (value === void 0) {
+    return "auto";
+  }
+  if (VALID_PAGINATION_STRATEGIES.has(value)) {
+    return value;
+  }
+  throw new ValidationError(
+    `strategy must be one of: ${[...VALID_PAGINATION_STRATEGIES].join(", ")}`
+  );
+}
+function toInteger(value) {
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isInteger(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function toPositiveInteger(value) {
+  const normalized = toInteger(value);
+  if (normalized === void 0 || normalized <= 0) {
+    return void 0;
+  }
+  return normalized;
+}
+function toNonNegativeInteger(value) {
+  const normalized = toInteger(value);
+  if (normalized === void 0 || normalized < 0) {
+    return void 0;
+  }
+  return normalized;
+}
+
+// src/client/rest/requestOptions.ts
+var DEFAULT_REQUEST_OPTIONS = {
+  maxRetries: 3
+};
+
+// src/core/logger.ts
+var noop = () => void 0;
+var NoopLogger = class {
+  debug = noop;
+  info = noop;
+  warn = noop;
+  error = noop;
+};
+
+// src/adapters/shared/coercion.ts
+function asOptionalRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNullableString(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  return asString(value);
+}
+
+// src/client/rest/responseNormalization.ts
+function asMetadataMap(value) {
+  return asOptionalRecord(value);
+}
+function normalizeContactRequestDirection(value) {
+  const direction = asMetadataMap(value);
+  if (!direction) {
+    return void 0;
+  }
+  return {
+    total: typeof direction.total === "number" ? direction.total : typeof direction.total_count === "number" ? direction.total_count : void 0,
+    totalPages: typeof direction.totalPages === "number" ? direction.totalPages : typeof direction.total_pages === "number" ? direction.total_pages : void 0
+  };
+}
+function normalizeContactRequestsResult(result) {
+  const metadata = asMetadataMap(result.metadata);
+  return {
+    received: Array.isArray(result.received) ? result.received : [],
+    sent: Array.isArray(result.sent) ? result.sent : [],
+    metadata: metadata ? {
+      page: typeof metadata.page === "number" ? metadata.page : typeof metadata.page_number === "number" ? metadata.page_number : void 0,
+      pageSize: typeof metadata.pageSize === "number" ? metadata.pageSize : typeof metadata.page_size === "number" ? metadata.page_size : void 0,
+      received: normalizeContactRequestDirection(metadata.received),
+      sent: normalizeContactRequestDirection(metadata.sent)
+    } : void 0
+  };
+}
+
+// src/client/rest/FernRestAdapter.ts
+function mergeOptions(options) {
+  return {
+    ...DEFAULT_REQUEST_OPTIONS,
+    ...options
+  };
+}
+var AGENT_ME_RETRY_LIMIT = 4;
+var AGENT_ME_RETRY_BASE_DELAY_MS = 2e3;
+var MESSAGE_SEND_RETRY_LIMIT = 3;
+var MESSAGE_SEND_RETRY_BASE_DELAY_MS = 500;
+function asMetadataMap2(value) {
+  return asOptionalRecord(value);
+}
+function extractHttpStatus(error) {
+  const record = asOptionalRecord(error);
+  if (!record) {
+    return void 0;
+  }
+  const response = asOptionalRecord(record.response);
+  const status = record.statusCode ?? record.status ?? response?.statusCode ?? response?.status;
+  return typeof status === "number" ? status : void 0;
+}
+function isFernRateLimitError(error) {
+  return extractHttpStatus(error) === 429;
+}
+async function sleep(ms) {
+  await new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+function computeRetryDelayMs(baseDelayMs, attempt) {
+  const backoff = baseDelayMs * 2 ** (attempt - 1);
+  const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(backoff / 4)));
+  return backoff + jitter;
+}
+async function withRateLimitRetry(operation, options) {
+  let lastError;
+  for (let attempt = 1; attempt <= options.retryLimit; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      if (!isFernRateLimitError(error) || attempt === options.retryLimit) {
+        throw error;
+      }
+      await sleep(computeRetryDelayMs(options.baseDelayMs, attempt));
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Rate-limit retry exhausted without a terminal error.");
+}
+function requireNonEmptyStringField(value, field, source) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid ${source} response: expected non-empty string AgentIdentity.${field}`);
+  }
+  return value;
+}
+function normalizeOptionalStringField(value, field, source) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Invalid ${source} response: expected string or null AgentIdentity.${field}`);
+  }
+  return value;
+}
+function normalizeAgentIdentityRecord(record, source) {
+  return {
+    id: requireNonEmptyStringField(record.id, "id", source),
+    name: requireNonEmptyStringField(record.name, "name", source),
+    description: normalizeOptionalStringField(record.description, "description", source),
+    handle: normalizeOptionalStringField(record.handle, "handle", source),
+    ownerUuid: normalizeOptionalStringField(record.owner_uuid, "ownerUuid", source)
+  };
+}
+function normalizeAgentIdentityEnvelope(value, source) {
+  const payload = asMetadataMap2(extractEnvelopeData(value));
+  if (!payload) {
+    throw new Error(`Invalid ${source} response: expected object payload for AgentIdentity`);
+  }
+  return normalizeAgentIdentityRecord(payload, source);
+}
+function normalizeLegacyProfileIdentity(profile, source) {
+  const id = requireNonEmptyStringField(profile.id, "id", source);
+  const derivedName = profile.name ?? ([profile.first_name, profile.last_name].filter(Boolean).join(" ").trim() || void 0) ?? profile.username ?? profile.id;
+  const name = requireNonEmptyStringField(derivedName, "name", source);
+  return {
+    id,
+    name,
+    description: profile.description ?? null,
+    handle: null,
+    ownerUuid: null
+  };
+}
+function normalizeLegacyProfileEnvelope(value) {
+  const payload = asMetadataMap2(extractEnvelopeData(value));
+  if (!payload) {
+    throw new Error("Invalid profile.getMyProfile response: expected object payload");
+  }
+  return payload;
+}
+function asRecordArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.filter((entry) => asOptionalRecord(entry) !== void 0);
+}
+function extractEnvelopeData(value) {
+  const record = asMetadataMap2(value);
+  if (!record || record.data === void 0) {
+    return value;
+  }
+  return record.data;
+}
+function extractEnvelopeMetadata(value) {
+  const record = asMetadataMap2(value);
+  if (!record) {
+    return void 0;
+  }
+  return asMetadataMap2(record.metadata) ?? asMetadataMap2(record.meta);
+}
+function normalizeFernPaginatedResponse(response, normalizeItem) {
+  const topLevelData = extractEnvelopeData(response);
+  const nestedData = extractEnvelopeData(topLevelData);
+  const rawItems = asRecordArray(topLevelData) ?? asRecordArray(nestedData) ?? [];
+  return {
+    data: rawItems.map((item) => normalizeItem(item)).filter((item) => item !== null),
+    metadata: normalizePaginationMetadata(
+      extractEnvelopeMetadata(response) ?? extractEnvelopeMetadata(topLevelData)
+    )
+  };
+}
+function normalizeFernContactRequestsResponse(response) {
+  const payload = asMetadataMap2(extractEnvelopeData(response));
+  return normalizeContactRequestsResult({
+    received: asRecordArray(payload?.received) ?? [],
+    sent: asRecordArray(payload?.sent) ?? [],
+    metadata: extractEnvelopeMetadata(response) ?? extractEnvelopeMetadata(payload)
+  });
+}
+function normalizeToolOperationResult(response) {
+  return asMetadataMap2(extractEnvelopeData(response)) ?? {};
+}
+function normalizeMemoryRecord(response) {
+  const payload = asMetadataMap2(extractEnvelopeData(response));
+  return payload ? normalizeMemoryRecordItem(payload) ?? {} : {};
+}
+function extractChatId(response) {
+  const payload = asMetadataMap2(extractEnvelopeData(response));
+  return typeof payload?.id === "string" ? payload.id : void 0;
+}
+function isChatParticipant(value) {
+  const record = asMetadataMap2(value);
+  if (!record) {
+    return false;
+  }
+  return typeof record.id === "string" && typeof record.name === "string" && typeof record.type === "string" && (record.handle === void 0 || record.handle === null || typeof record.handle === "string");
+}
+function normalizeChatParticipantsResponse(response) {
+  const payload = extractEnvelopeData(response);
+  return Array.isArray(payload) ? payload.filter(isChatParticipant) : [];
+}
+function normalizeMetadataRecord(value) {
+  return value;
+}
+function hasInvalidString(value) {
+  return value !== void 0 && typeof value !== "string";
+}
+function hasInvalidNullableString(value) {
+  return value !== void 0 && value !== null && typeof value !== "string";
+}
+function hasInvalidNullableBoolean(value) {
+  return value !== void 0 && value !== null && typeof value !== "boolean";
+}
+function normalizePeerRecord(value) {
+  if (hasInvalidString(value.id) || hasInvalidString(value.name) || hasInvalidString(value.type) || hasInvalidNullableString(value.handle) || hasInvalidNullableString(value.description)) {
+    return null;
+  }
+  return {
+    ...typeof value.id === "string" ? { id: value.id } : {},
+    ...typeof value.name === "string" ? { name: value.name } : {},
+    ...typeof value.type === "string" ? { type: value.type } : {},
+    ...value.handle !== void 0 ? { handle: value.handle } : {},
+    ...value.description !== void 0 ? { description: value.description } : {}
+  };
+}
+function normalizeContactRecord(value) {
+  if (hasInvalidString(value.id) || hasInvalidString(value.handle) || hasInvalidNullableString(value.name) || hasInvalidString(value.type) || hasInvalidNullableString(value.description) || hasInvalidNullableBoolean(value.is_external) || hasInvalidString(value.inserted_at)) {
+    return null;
+  }
+  return {
+    ...typeof value.id === "string" ? { id: value.id } : {},
+    ...typeof value.handle === "string" ? { handle: value.handle } : {},
+    ...value.name !== void 0 ? { name: value.name } : {},
+    ...typeof value.type === "string" ? { type: value.type } : {},
+    ...value.description !== void 0 ? { description: value.description } : {},
+    ...value.is_external !== void 0 ? { is_external: value.is_external } : {},
+    ...typeof value.inserted_at === "string" ? { inserted_at: value.inserted_at } : {}
+  };
+}
+function normalizeMemoryRecordItem(value) {
+  if (hasInvalidString(value.id) || hasInvalidString(value.content) || hasInvalidString(value.system) || hasInvalidString(value.type) || hasInvalidString(value.segment) || hasInvalidNullableString(value.thought) || hasInvalidNullableString(value.subject_id) || hasInvalidNullableString(value.source_agent_id) || hasInvalidNullableString(value.organization_id) || hasInvalidString(value.scope) || hasInvalidString(value.status) || value.metadata !== void 0 && value.metadata !== null && asMetadataMap2(value.metadata) === void 0 || hasInvalidNullableString(value.inserted_at)) {
+    return null;
+  }
+  return {
+    ...typeof value.id === "string" ? { id: value.id } : {},
+    ...typeof value.content === "string" ? { content: value.content } : {},
+    ...typeof value.system === "string" ? { system: value.system } : {},
+    ...typeof value.type === "string" ? { type: value.type } : {},
+    ...typeof value.segment === "string" ? { segment: value.segment } : {},
+    ...value.thought !== void 0 ? { thought: value.thought } : {},
+    ...value.subject_id !== void 0 ? { subject_id: value.subject_id } : {},
+    ...value.source_agent_id !== void 0 ? { source_agent_id: value.source_agent_id } : {},
+    ...value.organization_id !== void 0 ? { organization_id: value.organization_id } : {},
+    ...typeof value.scope === "string" ? { scope: value.scope } : {},
+    ...typeof value.status === "string" ? { status: value.status } : {},
+    ...value.metadata !== void 0 ? { metadata: value.metadata === null ? null : asMetadataMap2(value.metadata) ?? null } : {},
+    ...value.inserted_at !== void 0 ? { inserted_at: value.inserted_at } : {}
+  };
+}
+function normalizePlatformMessageRecord(value) {
+  return normalizePlatformChatMessage(value);
+}
+function normalizePlatformChatMessage(value) {
+  const payload = asMetadataMap2(value);
+  if (!payload) {
+    return null;
+  }
+  const id = asString(payload.id);
+  const content = asString(payload.content);
+  const senderId = asString(payload.sender_id) ?? asString(payload.senderId);
+  const senderType = asString(payload.sender_type) ?? asString(payload.senderType);
+  const messageType = asString(payload.message_type) ?? asString(payload.messageType);
+  const insertedAt = asString(payload.inserted_at) ?? asString(payload.insertedAt);
+  if (!id || !content || !senderId || !senderType || !messageType || !insertedAt) {
+    return null;
+  }
+  const senderName = asNullableString(payload.sender_name ?? payload.senderName);
+  const updatedAt = asNullableString(payload.updated_at ?? payload.updatedAt);
+  const metadata = payload.metadata === null ? null : asMetadataMap2(payload.metadata);
+  return {
+    id,
+    content,
+    sender_id: senderId,
+    sender_type: senderType,
+    sender_name: senderName,
+    message_type: messageType,
+    metadata: payload.metadata === null ? null : metadata,
+    inserted_at: insertedAt,
+    updated_at: updatedAt
+  };
+}
+var FernRestAdapter = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async getAgentMe(options) {
+    return withRateLimitRetry(
+      async () => {
+        if (this.client.agentApiIdentity?.getAgentMe) {
+          const response = await this.client.agentApiIdentity.getAgentMe(mergeOptions(options));
+          return normalizeAgentIdentityEnvelope(response, "agentApiIdentity.getAgentMe");
+        }
+        const profileClient = this.client.myProfile ?? this.client.humanApiProfile;
+        if (!profileClient?.getMyProfile) {
+          throw new UnsupportedFeatureError(
+            "Fern client missing agentApiIdentity.getAgentMe or humanApiProfile.getMyProfile"
+          );
+        }
+        const profile = await profileClient.getMyProfile(mergeOptions(options));
+        return normalizeLegacyProfileIdentity(
+          normalizeLegacyProfileEnvelope(profile),
+          "profile.getMyProfile"
+        );
+      },
+      {
+        retryLimit: AGENT_ME_RETRY_LIMIT,
+        baseDelayMs: AGENT_ME_RETRY_BASE_DELAY_MS
+      }
+    );
+  }
+  async createChatMessage(chatId, message, options) {
+    const api = this.client.chatMessages?.createChatMessage?.bind(this.client.chatMessages) ?? this.client.agentApiMessages?.createAgentChatMessage?.bind(this.client.agentApiMessages) ?? this.client.myChatMessages?.createMyChatMessage?.bind(this.client.myChatMessages);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing chat message creation endpoint");
+    }
+    const response = await withRateLimitRetry(
+      async () => await api(
+        chatId,
+        {
+          message: {
+            content: message.content,
+            message_type: message.messageType,
+            metadata: message.metadata,
+            mentions: message.mentions
+          }
+        },
+        mergeOptions(options)
+      ),
+      {
+        retryLimit: MESSAGE_SEND_RETRY_LIMIT,
+        baseDelayMs: MESSAGE_SEND_RETRY_BASE_DELAY_MS
+      }
+    );
+    return normalizeToolOperationResult(response);
+  }
+  async createChatEvent(chatId, event, options) {
+    const createAgentChatEvent = this.client.agentApiEvents?.createAgentChatEvent?.bind(this.client.agentApiEvents);
+    if (createAgentChatEvent) {
+      const response = await withRateLimitRetry(
+        async () => await createAgentChatEvent(
+          chatId,
+          {
+            event: {
+              content: event.content,
+              message_type: event.messageType,
+              metadata: event.metadata
+            }
+          },
+          mergeOptions(options)
+        ),
+        {
+          retryLimit: MESSAGE_SEND_RETRY_LIMIT,
+          baseDelayMs: MESSAGE_SEND_RETRY_BASE_DELAY_MS
+        }
+      );
+      return normalizeToolOperationResult(response);
+    }
+    return this.createChatMessage(chatId, event, options);
+  }
+  async createChat(taskId, options) {
+    const api = this.client.chatRooms?.createChat?.bind(this.client.chatRooms) ?? this.client.agentApiChats?.createAgentChat?.bind(this.client.agentApiChats);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing chat creation endpoint");
+    }
+    const response = await api(
+      {
+        chat: {
+          task_id: taskId
+        }
+      },
+      mergeOptions(options)
+    );
+    const roomId = extractChatId(response);
+    if (!roomId) {
+      throw new UnsupportedFeatureError("Chat create response did not include id");
+    }
+    return { id: roomId };
+  }
+  async listChatParticipants(chatId, options) {
+    const requestOptions = mergeOptions(options);
+    const listChatParticipantsApi = this.client.chatParticipants?.listChatParticipants?.bind(this.client.chatParticipants);
+    if (listChatParticipantsApi) {
+      return normalizeChatParticipantsResponse(
+        await listChatParticipantsApi(chatId, {}, requestOptions)
+      );
+    }
+    const listAgentChatParticipantsApi = this.client.agentApiParticipants?.listAgentChatParticipants?.bind(this.client.agentApiParticipants);
+    if (!listAgentChatParticipantsApi) {
+      throw new UnsupportedFeatureError("Fern client missing chat participant list endpoint");
+    }
+    return normalizeChatParticipantsResponse(
+      await listAgentChatParticipantsApi(chatId, requestOptions)
+    );
+  }
+  async addChatParticipant(chatId, participant, options) {
+    const api = this.client.chatParticipants?.addChatParticipant?.bind(this.client.chatParticipants) ?? this.client.agentApiParticipants?.addAgentChatParticipant?.bind(this.client.agentApiParticipants);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing chat participant add endpoint");
+    }
+    const response = await api(
+      chatId,
+      {
+        participant: {
+          participant_id: participant.participantId,
+          role: participant.role
+        }
+      },
+      mergeOptions(options)
+    );
+    return normalizeToolOperationResult(response);
+  }
+  async removeChatParticipant(chatId, participantId, options) {
+    const api = this.client.chatParticipants?.removeChatParticipant?.bind(this.client.chatParticipants) ?? this.client.agentApiParticipants?.removeAgentChatParticipant?.bind(this.client.agentApiParticipants);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing chat participant remove endpoint");
+    }
+    const response = await api(chatId, participantId, mergeOptions(options));
+    return normalizeToolOperationResult(response);
+  }
+  async markMessageProcessing(chatId, messageId, options) {
+    const api = this.client.chatMessages?.markMessageProcessing?.bind(this.client.chatMessages) ?? this.client.agentApiMessages?.markAgentMessageProcessing?.bind(this.client.agentApiMessages);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing mark message processing endpoint");
+    }
+    const response = await api(chatId, messageId, mergeOptions(options));
+    return normalizeToolOperationResult(response);
+  }
+  async markMessageProcessed(chatId, messageId, options) {
+    const api = this.client.chatMessages?.markMessageProcessed?.bind(this.client.chatMessages) ?? this.client.agentApiMessages?.markAgentMessageProcessed?.bind(this.client.agentApiMessages);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing mark message processed endpoint");
+    }
+    const response = await api(chatId, messageId, mergeOptions(options));
+    return normalizeToolOperationResult(response);
+  }
+  async markMessageFailed(chatId, messageId, error, options) {
+    const api = this.client.chatMessages?.markMessageFailed?.bind(this.client.chatMessages) ?? this.client.agentApiMessages?.markAgentMessageFailed?.bind(this.client.agentApiMessages);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing mark message failed endpoint");
+    }
+    const response = await api(
+      chatId,
+      messageId,
+      { error },
+      mergeOptions(options)
+    );
+    return normalizeToolOperationResult(response);
+  }
+  async getNextMessage(request, options) {
+    const api = this.client.chatMessages?.getNextMessage?.bind(this.client.chatMessages) ?? this.client.agentApiMessages?.getAgentNextMessage?.bind(this.client.agentApiMessages);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing next-message endpoint");
+    }
+    const response = await api(request.chatId, mergeOptions(options));
+    return normalizePlatformChatMessage(extractEnvelopeData(response));
+  }
+  async listPeers(request, options) {
+    const api = this.client.agentPeers?.listAgentPeers?.bind(this.client.agentPeers) ?? this.client.agentApiPeers?.listAgentPeers?.bind(this.client.agentApiPeers);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing peer list endpoint");
+    }
+    const response = await api(
+      {
+        page: request.page,
+        page_size: request.pageSize,
+        ...request.notInChat ? { not_in_chat: request.notInChat } : {}
+      },
+      mergeOptions(options)
+    );
+    return normalizeFernPaginatedResponse(response, normalizePeerRecord);
+  }
+  async listChats(request, options) {
+    const api = this.client.chatRooms?.listChats?.bind(this.client.chatRooms) ?? this.client.agentApiChats?.listAgentChats?.bind(this.client.agentApiChats);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing chat list endpoint");
+    }
+    const response = await api(
+      {
+        page: request.page,
+        page_size: request.pageSize
+      },
+      mergeOptions(options)
+    );
+    return normalizeFernPaginatedResponse(response, normalizeMetadataRecord);
+  }
+  async listContacts(request, options) {
+    const api = this.client.agentContacts?.listAgentContacts?.bind(this.client.agentContacts) ?? this.client.agentApiContacts?.listAgentContacts?.bind(this.client.agentApiContacts);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing contact list endpoint");
+    }
+    const page = request.page ?? 1;
+    const pageSize = request.pageSize ?? 50;
+    const response = await api(
+      {
+        page,
+        page_size: pageSize
+      },
+      mergeOptions(options)
+    );
+    return normalizeFernPaginatedResponse(response, normalizeContactRecord);
+  }
+  async addContact(request, options) {
+    const api = this.client.agentContacts?.addAgentContact?.bind(this.client.agentContacts) ?? this.client.agentApiContacts?.addAgentContact?.bind(this.client.agentApiContacts);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing add contact endpoint");
+    }
+    return normalizeToolOperationResult(
+      await api(
+        { handle: request.handle, ...request.message ? { message: request.message } : {} },
+        mergeOptions(options)
+      )
+    );
+  }
+  async removeContact(request, options) {
+    const api = this.client.agentContacts?.removeAgentContact?.bind(this.client.agentContacts) ?? this.client.agentApiContacts?.removeAgentContact?.bind(this.client.agentApiContacts);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing remove contact endpoint");
+    }
+    return normalizeToolOperationResult(
+      await api(
+        request.target === "handle" ? { handle: request.handle } : { contact_id: request.contactId },
+        mergeOptions(options)
+      )
+    );
+  }
+  async listContactRequests(request, options) {
+    const api = this.client.agentContacts?.listAgentContactRequests?.bind(this.client.agentContacts) ?? this.client.agentApiContacts?.listAgentContactRequests?.bind(this.client.agentApiContacts);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing contact request list endpoint");
+    }
+    const page = request.page ?? 1;
+    const pageSize = request.pageSize ?? 50;
+    const sentStatus = request.sentStatus ?? "pending";
+    const response = await api(
+      {
+        page,
+        page_size: pageSize,
+        sent_status: sentStatus
+      },
+      mergeOptions(options)
+    );
+    return normalizeFernContactRequestsResponse(response);
+  }
+  async respondContactRequest(request, options) {
+    const api = this.client.agentContacts?.respondToAgentContactRequest?.bind(this.client.agentContacts) ?? this.client.agentApiContacts?.respondToAgentContactRequest?.bind(this.client.agentApiContacts);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing contact request response endpoint");
+    }
+    return normalizeToolOperationResult(
+      await api(
+        request.target === "handle" ? { action: request.action, handle: request.handle } : { action: request.action, request_id: request.requestId },
+        mergeOptions(options)
+      )
+    );
+  }
+  async listMemories(request, options) {
+    const api = this.client.agentMemories?.listAgentMemories?.bind(this.client.agentMemories) ?? this.client.agentApiMemories?.listAgentMemories?.bind(this.client.agentApiMemories);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing memory list endpoint");
+    }
+    const response = await api(request, mergeOptions(options));
+    return normalizeFernPaginatedResponse(response, normalizeMemoryRecordItem);
+  }
+  async storeMemory(request, options) {
+    const api = this.client.agentMemories?.createAgentMemory?.bind(this.client.agentMemories) ?? this.client.agentApiMemories?.createAgentMemory?.bind(this.client.agentApiMemories);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing create memory endpoint");
+    }
+    return normalizeMemoryRecord(
+      await api(
+        { memory: request },
+        mergeOptions(options)
+      )
+    );
+  }
+  async getMemory(memoryId, options) {
+    const api = this.client.agentMemories?.getAgentMemory?.bind(this.client.agentMemories) ?? this.client.agentApiMemories?.getAgentMemory?.bind(this.client.agentApiMemories);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing get memory endpoint");
+    }
+    return normalizeMemoryRecord(
+      await api(memoryId, mergeOptions(options))
+    );
+  }
+  async supersedeMemory(memoryId, options) {
+    const api = this.client.agentMemories?.supersedeAgentMemory?.bind(this.client.agentMemories) ?? this.client.agentApiMemories?.supersedeAgentMemory?.bind(this.client.agentApiMemories);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing supersede memory endpoint");
+    }
+    return normalizeToolOperationResult(
+      await api(memoryId, mergeOptions(options))
+    );
+  }
+  async archiveMemory(memoryId, options) {
+    const api = this.client.agentMemories?.archiveAgentMemory?.bind(this.client.agentMemories) ?? this.client.agentApiMemories?.archiveAgentMemory?.bind(this.client.agentApiMemories);
+    if (!api) {
+      throw new UnsupportedFeatureError("Fern client missing archive memory endpoint");
+    }
+    return normalizeToolOperationResult(
+      await api(memoryId, mergeOptions(options))
+    );
+  }
+  async listMessages(request, options) {
+    const requestOptions = mergeOptions(options);
+    const listRequest = {
+      page: request.page,
+      page_size: request.pageSize,
+      status: request.status
+    };
+    const listMessagesApi = this.client.chatMessages?.listMessages?.bind(this.client.chatMessages);
+    if (listMessagesApi) {
+      return normalizeFernPaginatedResponse(
+        await listMessagesApi(request.chatId, listRequest, requestOptions),
+        normalizePlatformMessageRecord
+      );
+    }
+    const listAgentMessagesApi = this.client.agentApiMessages?.listAgentMessages?.bind(this.client.agentApiMessages);
+    if (!listAgentMessagesApi) {
+      throw new UnsupportedFeatureError("Fern client missing message list endpoint");
+    }
+    return normalizeFernPaginatedResponse(
+      await listAgentMessagesApi(request.chatId, listRequest, requestOptions),
+      normalizePlatformMessageRecord
+    );
+  }
+  async getChatContext(request, options) {
+    const requestOptions = mergeOptions(options);
+    const contextRequest = {
+      page: request.page,
+      page_size: request.pageSize
+    };
+    const getChatContextApi = this.client.chatContext?.getChatContext?.bind(this.client.chatContext);
+    if (getChatContextApi) {
+      return normalizeFernPaginatedResponse(
+        await getChatContextApi(request.chatId, contextRequest, requestOptions),
+        normalizePlatformMessageRecord
+      );
+    }
+    const getAgentChatContextApi = this.client.agentApiContext?.getAgentChatContext?.bind(this.client.agentApiContext);
+    if (!getAgentChatContextApi) {
+      throw new UnsupportedFeatureError("Fern client missing chat context endpoint");
+    }
+    return normalizeFernPaginatedResponse(
+      await getAgentChatContextApi(request.chatId, contextRequest, requestOptions),
+      normalizePlatformMessageRecord
+    );
+  }
+};
+
+// src/client/rest/RestFacade.ts
+var OPTIONAL_UNSUPPORTED_MESSAGES = {
+  listChats: "Chat listing is not available in current REST adapter",
+  getChatContext: "Context hydration is not available in current REST adapter",
+  listMessages: "Message queue listing is not available in current REST adapter",
+  getNextMessage: "Message queue next-item lookup is not available in current REST adapter",
+  addContact: "Contact creation is not available in current REST adapter",
+  removeContact: "Contact removal is not available in current REST adapter",
+  respondContactRequest: "Contact request responses are not available in current REST adapter",
+  storeMemory: "Memory creation is not available in current REST adapter",
+  getMemory: "Memory lookup is not available in current REST adapter",
+  supersedeMemory: "Memory supersede is not available in current REST adapter",
+  archiveMemory: "Memory archive is not available in current REST adapter",
+  listContacts: "Contact listing is not available in current REST adapter",
+  listMemories: "Memory listing is not available in current REST adapter",
+  listPeers: "Peer listing is not available in current REST adapter",
+  listContactRequests: "Contact request listing is not available in current REST adapter"
+};
+var RestFacade = class {
+  api;
+  logger;
+  constructor(options) {
+    this.api = options.api;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  async getAgentMe(options) {
+    return this.forward("getAgentMe", () => this.api.getAgentMe(options));
+  }
+  async createChatMessage(chatId, message, options) {
+    return this.forward("createChatMessage", () => this.api.createChatMessage(chatId, message, options), {
+      chatId,
+      messageType: message.messageType ?? "text",
+      mentionCount: message.mentions?.length ?? 0
+    });
+  }
+  async createChatEvent(chatId, event, options) {
+    return this.forward("createChatEvent", () => this.api.createChatEvent(chatId, event, options), {
+      chatId,
+      messageType: event.messageType
+    });
+  }
+  async createChat(taskId, options) {
+    return this.forward("createChat", () => this.api.createChat(taskId, options), {
+      taskId: taskId ?? null
+    });
+  }
+  async listChatParticipants(chatId, options) {
+    return this.forward(
+      "listChatParticipants",
+      () => this.api.listChatParticipants(chatId, options),
+      { chatId }
+    );
+  }
+  async addChatParticipant(chatId, participant, options) {
+    return this.forward("addChatParticipant", () => this.api.addChatParticipant(chatId, participant, options), {
+      chatId,
+      participantId: participant.participantId,
+      role: participant.role
+    });
+  }
+  async removeChatParticipant(chatId, participantId, options) {
+    return this.forward(
+      "removeChatParticipant",
+      () => this.api.removeChatParticipant(chatId, participantId, options),
+      { chatId, participantId }
+    );
+  }
+  async markMessageProcessing(chatId, messageId, options) {
+    return this.forward(
+      "markMessageProcessing",
+      () => this.api.markMessageProcessing(chatId, messageId, options),
+      { chatId, messageId }
+    );
+  }
+  async markMessageProcessed(chatId, messageId, options) {
+    return this.forward(
+      "markMessageProcessed",
+      () => this.api.markMessageProcessed(chatId, messageId, options),
+      { chatId, messageId }
+    );
+  }
+  async markMessageFailed(chatId, messageId, error, options) {
+    return this.forward(
+      "markMessageFailed",
+      () => this.api.markMessageFailed(chatId, messageId, error, options),
+      { chatId, messageId }
+    );
+  }
+  async listChats(request, options) {
+    return this.callOptional(
+      "listChats",
+      OPTIONAL_UNSUPPORTED_MESSAGES.listChats,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async getChatContext(request, options) {
+    return this.callOptional(
+      "getChatContext",
+      OPTIONAL_UNSUPPORTED_MESSAGES.getChatContext,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async listMessages(request, options) {
+    return this.callOptional(
+      "listMessages",
+      OPTIONAL_UNSUPPORTED_MESSAGES.listMessages,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async getNextMessage(request, options) {
+    return this.callOptional(
+      "getNextMessage",
+      OPTIONAL_UNSUPPORTED_MESSAGES.getNextMessage,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async addContact(request, options) {
+    return this.callOptional(
+      "addContact",
+      OPTIONAL_UNSUPPORTED_MESSAGES.addContact,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async removeContact(request, options) {
+    return this.callOptional(
+      "removeContact",
+      OPTIONAL_UNSUPPORTED_MESSAGES.removeContact,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async respondContactRequest(request, options) {
+    return this.callOptional(
+      "respondContactRequest",
+      OPTIONAL_UNSUPPORTED_MESSAGES.respondContactRequest,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async storeMemory(request, options) {
+    return this.callOptional(
+      "storeMemory",
+      OPTIONAL_UNSUPPORTED_MESSAGES.storeMemory,
+      (method) => method(request, options),
+      request
+    );
+  }
+  async getMemory(memoryId, options) {
+    return this.callOptional(
+      "getMemory",
+      OPTIONAL_UNSUPPORTED_MESSAGES.getMemory,
+      (method) => method(memoryId, options),
+      { memoryId }
+    );
+  }
+  async supersedeMemory(memoryId, options) {
+    return this.callOptional(
+      "supersedeMemory",
+      OPTIONAL_UNSUPPORTED_MESSAGES.supersedeMemory,
+      (method) => method(memoryId, options),
+      { memoryId }
+    );
+  }
+  async archiveMemory(memoryId, options) {
+    return this.callOptional(
+      "archiveMemory",
+      OPTIONAL_UNSUPPORTED_MESSAGES.archiveMemory,
+      (method) => method(memoryId, options),
+      { memoryId }
+    );
+  }
+  async listContacts(request, options) {
+    return this.callOptional(
+      "listContacts",
+      OPTIONAL_UNSUPPORTED_MESSAGES.listContacts,
+      async (method) => {
+        const response = await method(request, options);
+        return {
+          data: response.data ?? [],
+          metadata: normalizePaginationMetadata(response.metadata)
+        };
+      },
+      request
+    );
+  }
+  async listMemories(request, options) {
+    return this.callOptional(
+      "listMemories",
+      OPTIONAL_UNSUPPORTED_MESSAGES.listMemories,
+      async (method) => {
+        const response = await method(request, options);
+        return {
+          data: response.data ?? [],
+          metadata: normalizePaginationMetadata(response.metadata)
+        };
+      },
+      request
+    );
+  }
+  async listPeers(request, options) {
+    return this.callOptional(
+      "listPeers",
+      OPTIONAL_UNSUPPORTED_MESSAGES.listPeers,
+      async (method) => {
+        const response = await method(request, options);
+        return {
+          data: response.data ?? [],
+          metadata: normalizePaginationMetadata(response.metadata)
+        };
+      },
+      request
+    );
+  }
+  async listContactRequests(request, options) {
+    return this.callOptional(
+      "listContactRequests",
+      OPTIONAL_UNSUPPORTED_MESSAGES.listContactRequests,
+      async (method) => normalizeContactRequestsResult(await method(request, options)),
+      request
+    );
+  }
+  async listAllChats(options, requestOptions) {
+    return fetchPaginated({
+      fetchPage: ({ page, pageSize }) => this.listChats({ page, pageSize }, requestOptions),
+      pageSize: options?.pageSize,
+      maxPages: options?.maxPages,
+      strategy: options?.strategy,
+      metadataValidation: options?.metadataValidation
+    });
+  }
+  callOptional(operation, unsupportedMessage, invoke, metadata) {
+    const method = this.api[operation];
+    if (!method) {
+      throw new UnsupportedFeatureError(unsupportedMessage);
+    }
+    const boundMethod = method.bind(this.api);
+    return this.forward(String(operation), () => invoke(boundMethod), metadata);
+  }
+  forward(operation, call, metadata) {
+    this.logger.debug(`REST ${operation}`, metadata);
+    return call();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_REQUEST_OPTIONS,
+  FernRestAdapter,
+  RestFacade,
+  fetchPaginated,
+  normalizePaginationMetadata
+});