smritea-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,815 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SmriteaAuthError: () => SmriteaAuthError,
+  SmriteaClient: () => SmriteaClient,
+  SmriteaError: () => SmriteaError,
+  SmriteaNotFoundError: () => SmriteaNotFoundError,
+  SmriteaQuotaError: () => SmriteaQuotaError,
+  SmriteaRateLimitError: () => SmriteaRateLimitError,
+  SmriteaValidationError: () => SmriteaValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/_internal/autogen/runtime.ts
+var BASE_PATH = "http://api.smritea.ai/api/v1".replace(/\/+$/, "");
+var Configuration = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+};
+var DefaultConfig = new Configuration();
+var BaseAPI = class _BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(:?;.*)?$", "i");
+  middleware;
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return _BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = void 0;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : void 0
+          }) || response;
+        }
+      }
+      if (response === void 0) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+  name = "ResponseError";
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+  name = "FetchError";
+};
+var RequiredError = class extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+  }
+  name = "RequiredError";
+};
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+var JSONApiResponse = class {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+};
+var VoidApiResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return void 0;
+  }
+};
+
+// src/_internal/autogen/models/CommondtoPersonaDomainConfig.ts
+function CommondtoPersonaDomainConfigToJSON(json) {
+  return CommondtoPersonaDomainConfigToJSONTyped(json, false);
+}
+function CommondtoPersonaDomainConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "description": value["description"],
+    "is_default": value["isDefault"],
+    "name": value["name"],
+    "traits": value["traits"]
+  };
+}
+
+// src/_internal/autogen/models/CommondtoPersonaExtractionConfig.ts
+function CommondtoPersonaExtractionConfigToJSON(json) {
+  return CommondtoPersonaExtractionConfigToJSONTyped(json, false);
+}
+function CommondtoPersonaExtractionConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "actor_types": value["actorTypes"],
+    "domains": value["domains"] == null ? void 0 : value["domains"].map(CommondtoPersonaDomainConfigToJSON),
+    "enabled": value["enabled"],
+    "max_tokens": value["maxTokens"],
+    "model": value["model"],
+    "temperature": value["temperature"]
+  };
+}
+
+// src/_internal/autogen/models/CommondtoFactExtractionConfig.ts
+function CommondtoFactExtractionConfigToJSON(json) {
+  return CommondtoFactExtractionConfigToJSONTyped(json, false);
+}
+function CommondtoFactExtractionConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "max_passes": value["maxPasses"],
+    "max_tokens": value["maxTokens"],
+    "min_importance": value["minImportance"],
+    "model": value["model"],
+    "strategy": value["strategy"],
+    "temperature": value["temperature"]
+  };
+}
+
+// src/_internal/autogen/models/CommondtoEntityExtractionConfig.ts
+function CommondtoEntityExtractionConfigToJSON(json) {
+  return CommondtoEntityExtractionConfigToJSONTyped(json, false);
+}
+function CommondtoEntityExtractionConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "context_window": value["contextWindow"],
+    "enable_context": value["enableContext"],
+    "entity_types": value["entityTypes"],
+    "fallback_messages": value["fallbackMessages"],
+    "max_passes": value["maxPasses"],
+    "max_tokens": value["maxTokens"],
+    "min_confidence": value["minConfidence"],
+    "model": value["model"],
+    "temperature": value["temperature"]
+  };
+}
+
+// src/_internal/autogen/models/CommondtoRelativeStandingConfig.ts
+function CommondtoRelativeStandingConfigFromJSON(json) {
+  return CommondtoRelativeStandingConfigFromJSONTyped(json, false);
+}
+function CommondtoRelativeStandingConfigFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "decayFactor": json["decay_factor"] == null ? void 0 : json["decay_factor"],
+    "decayFunction": json["decay_function"] == null ? void 0 : json["decay_function"],
+    "importance": json["importance"] == null ? void 0 : json["importance"]
+  };
+}
+function CommondtoRelativeStandingConfigToJSON(json) {
+  return CommondtoRelativeStandingConfigToJSONTyped(json, false);
+}
+function CommondtoRelativeStandingConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "decay_factor": value["decayFactor"],
+    "decay_function": value["decayFunction"],
+    "importance": value["importance"]
+  };
+}
+
+// src/_internal/autogen/models/MemoryMemoryResponse.ts
+function MemoryMemoryResponseFromJSON(json) {
+  return MemoryMemoryResponseFromJSONTyped(json, false);
+}
+function MemoryMemoryResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "activeFrom": json["active_from"] == null ? void 0 : json["active_from"],
+    "activeTo": json["active_to"] == null ? void 0 : json["active_to"],
+    "actorId": json["actor_id"] == null ? void 0 : json["actor_id"],
+    "actorName": json["actor_name"] == null ? void 0 : json["actor_name"],
+    "actorType": json["actor_type"] == null ? void 0 : json["actor_type"],
+    "appId": json["app_id"] == null ? void 0 : json["app_id"],
+    "content": json["content"] == null ? void 0 : json["content"],
+    "conversationId": json["conversation_id"] == null ? void 0 : json["conversation_id"],
+    "conversationMessageId": json["conversation_message_id"] == null ? void 0 : json["conversation_message_id"],
+    "createdAt": json["created_at"] == null ? void 0 : json["created_at"],
+    "id": json["id"] == null ? void 0 : json["id"],
+    "metadata": json["metadata"] == null ? void 0 : json["metadata"],
+    "relativeStanding": json["relative_standing"] == null ? void 0 : CommondtoRelativeStandingConfigFromJSON(json["relative_standing"]),
+    "updatedAt": json["updated_at"] == null ? void 0 : json["updated_at"]
+  };
+}
+
+// src/_internal/autogen/models/MemoryCreateMemoryRequest.ts
+function MemoryCreateMemoryRequestToJSON(json) {
+  return MemoryCreateMemoryRequestToJSONTyped(json, false);
+}
+function MemoryCreateMemoryRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "active_from": value["activeFrom"],
+    "active_to": value["activeTo"],
+    "actor_id": value["actorId"],
+    "actor_name": value["actorName"],
+    "actor_type": value["actorType"],
+    "app_id": value["appId"],
+    "content": value["content"],
+    "conversation_id": value["conversationId"],
+    "conversation_message_id": value["conversationMessageId"],
+    "entity_extraction_overrides": CommondtoEntityExtractionConfigToJSON(value["entityExtractionOverrides"]),
+    "fact_extraction_overrides": CommondtoFactExtractionConfigToJSON(value["factExtractionOverrides"]),
+    "metadata": value["metadata"],
+    "persona_extraction_overrides": CommondtoPersonaExtractionConfigToJSON(value["personaExtractionOverrides"]),
+    "relative_standing": CommondtoRelativeStandingConfigToJSON(value["relativeStanding"])
+  };
+}
+
+// src/_internal/autogen/models/MemorySearchMemoryResponse.ts
+function MemorySearchMemoryResponseFromJSON(json) {
+  return MemorySearchMemoryResponseFromJSONTyped(json, false);
+}
+function MemorySearchMemoryResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "memory": json["memory"] == null ? void 0 : MemoryMemoryResponseFromJSON(json["memory"]),
+    "score": json["score"] == null ? void 0 : json["score"]
+  };
+}
+
+// src/_internal/autogen/models/MemorySearchMemoriesResponse.ts
+function MemorySearchMemoriesResponseFromJSON(json) {
+  return MemorySearchMemoriesResponseFromJSONTyped(json, false);
+}
+function MemorySearchMemoriesResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "memories": json["memories"] == null ? void 0 : json["memories"].map(MemorySearchMemoryResponseFromJSON)
+  };
+}
+
+// src/_internal/autogen/models/SearchStrategiesSearchMethod.ts
+function SearchStrategiesSearchMethodToJSON(value) {
+  return value;
+}
+
+// src/_internal/autogen/models/MemorySearchMemoryRequest.ts
+function MemorySearchMemoryRequestToJSON(json) {
+  return MemorySearchMemoryRequestToJSONTyped(json, false);
+}
+function MemorySearchMemoryRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "actor_id": value["actorId"],
+    "actor_type": value["actorType"],
+    "app_id": value["appId"],
+    "conversation_id": value["conversationId"],
+    "from_time": value["fromTime"],
+    "graph_depth": value["graphDepth"],
+    "limit": value["limit"],
+    "method": SearchStrategiesSearchMethodToJSON(value["method"]),
+    "query": value["query"],
+    "threshold": value["threshold"],
+    "to_time": value["toTime"],
+    "valid_at": value["validAt"]
+  };
+}
+
+// src/_internal/autogen/apis/SDKMemoryApi.ts
+var SDKMemoryApi = class extends BaseAPI {
+  /**
+   * Create a new memory with quota and rate limit enforcement
+   * Create memory (SDK)
+   */
+  async createMemoryRaw(requestParameters, initOverrides) {
+    if (requestParameters["request"] == null) {
+      throw new RequiredError(
+        "request",
+        'Required parameter "request" was null or undefined when calling createMemory().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key");
+    }
+    let urlPath = `/api/v1/sdk/memories`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: MemoryCreateMemoryRequestToJSON(requestParameters["request"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => MemoryMemoryResponseFromJSON(jsonValue));
+  }
+  /**
+   * Create a new memory with quota and rate limit enforcement
+   * Create memory (SDK)
+   */
+  async createMemory(requestParameters, initOverrides) {
+    const response = await this.createMemoryRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Delete a memory by ID with rate limit enforcement
+   * Delete memory (SDK)
+   */
+  async deleteMemoryRaw(requestParameters, initOverrides) {
+    if (requestParameters["memoryId"] == null) {
+      throw new RequiredError(
+        "memoryId",
+        'Required parameter "memoryId" was null or undefined when calling deleteMemory().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key");
+    }
+    let urlPath = `/api/v1/sdk/memories/{memory_id}`;
+    urlPath = urlPath.replace(`{${"memory_id"}}`, encodeURIComponent(String(requestParameters["memoryId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Delete a memory by ID with rate limit enforcement
+   * Delete memory (SDK)
+   */
+  async deleteMemory(requestParameters, initOverrides) {
+    await this.deleteMemoryRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Get a single memory by ID with rate limit enforcement
+   * Get memory by ID (SDK)
+   */
+  async getMemoryRaw(requestParameters, initOverrides) {
+    if (requestParameters["memoryId"] == null) {
+      throw new RequiredError(
+        "memoryId",
+        'Required parameter "memoryId" was null or undefined when calling getMemory().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key");
+    }
+    let urlPath = `/api/v1/sdk/memories/{memory_id}`;
+    urlPath = urlPath.replace(`{${"memory_id"}}`, encodeURIComponent(String(requestParameters["memoryId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => MemoryMemoryResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get a single memory by ID with rate limit enforcement
+   * Get memory by ID (SDK)
+   */
+  async getMemory(requestParameters, initOverrides) {
+    const response = await this.getMemoryRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search memories with quota and rate limit enforcement
+   * Search memories (SDK)
+   */
+  async searchMemoriesRaw(requestParameters, initOverrides) {
+    if (requestParameters["request"] == null) {
+      throw new RequiredError(
+        "request",
+        'Required parameter "request" was null or undefined when calling searchMemories().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key");
+    }
+    let urlPath = `/api/v1/sdk/memories/search`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: MemorySearchMemoryRequestToJSON(requestParameters["request"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => MemorySearchMemoriesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Search memories with quota and rate limit enforcement
+   * Search memories (SDK)
+   */
+  async searchMemories(requestParameters, initOverrides) {
+    const response = await this.searchMemoriesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/errors.ts
+var SmriteaError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "SmriteaError";
+    this.statusCode = statusCode;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmriteaAuthError = class extends SmriteaError {
+  constructor(message, statusCode) {
+    super(message, statusCode ?? 401);
+    this.name = "SmriteaAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmriteaNotFoundError = class extends SmriteaError {
+  constructor(message, statusCode) {
+    super(message, statusCode ?? 404);
+    this.name = "SmriteaNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmriteaValidationError = class extends SmriteaError {
+  constructor(message, statusCode) {
+    super(message, statusCode ?? 400);
+    this.name = "SmriteaValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmriteaQuotaError = class extends SmriteaError {
+  constructor(message, statusCode) {
+    super(message, statusCode ?? 402);
+    this.name = "SmriteaQuotaError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmriteaRateLimitError = class extends SmriteaError {
+  retryAfter;
+  constructor(message, statusCode, retryAfter) {
+    super(message, statusCode ?? 429);
+    this.name = "SmriteaRateLimitError";
+    this.retryAfter = retryAfter;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/client.ts
+var RETRY_CAP_MS = 3e4;
+var SmriteaClient = class {
+  appId;
+  api;
+  maxRetries;
+  constructor(config) {
+    this.appId = config.appId;
+    this.maxRetries = config.maxRetries ?? 2;
+    const configuration = new Configuration({
+      basePath: config.baseUrl?.replace(/\/$/, "") ?? "https://api.smritea.ai",
+      apiKey: config.apiKey
+    });
+    this.api = new SDKMemoryApi(configuration);
+  }
+  async add(content, options) {
+    const actorId = options?.userId ?? options?.actorId;
+    const actorType = options?.userId !== void 0 ? "user" : options?.actorType;
+    return this.withRetry(
+      () => this.api.createMemory({
+        request: {
+          appId: this.appId,
+          content,
+          actorId,
+          actorType,
+          actorName: options?.actorName,
+          metadata: options?.metadata,
+          conversationId: options?.conversationId
+        }
+      })
+    );
+  }
+  async search(query, options) {
+    const actorId = options?.userId ?? options?.actorId;
+    const actorType = options?.userId !== void 0 ? "user" : options?.actorType;
+    const response = await this.withRetry(
+      () => this.api.searchMemories({
+        request: {
+          appId: this.appId,
+          query,
+          actorId,
+          actorType,
+          limit: options?.limit,
+          method: options?.method,
+          threshold: options?.threshold,
+          graphDepth: options?.graphDepth,
+          conversationId: options?.conversationId
+        }
+      })
+    );
+    return response.memories ?? [];
+  }
+  async get(memoryId) {
+    return this.withRetry(() => this.api.getMemory({ memoryId }));
+  }
+  async delete(memoryId) {
+    await this.withRetry(() => this.api.deleteMemory({ memoryId }));
+  }
+  // ------------------------------------------------------------------
+  // Private helpers
+  // ------------------------------------------------------------------
+  /**
+   * Execute fn, retrying on HTTP 429 up to maxRetries times.
+   *
+   * Sleep strategy per attempt:
+   * 1. Retry-After header value (seconds), capped at 30 s.
+   * 2. Exponential backoff (1 s, 2 s, 4 s, …) with ±25 % jitter, capped at 30 s.
+   *
+   * After all retries are exhausted the 429 is re-raised as SmriteaRateLimitError
+   * with retryAfter populated from the final response header if available.
+   */
+  async withRetry(fn) {
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        if (err instanceof ResponseError && err.response.status === 429 && attempt < this.maxRetries) {
+          await new Promise(
+            (resolve) => setTimeout(resolve, this.retryDelayMs(attempt, this.parseRetryAfter(err.response)))
+          );
+          continue;
+        }
+        this.handleError(err);
+      }
+    }
+    throw new Error("unreachable");
+  }
+  /** Calculate sleep duration in milliseconds for a retry attempt. */
+  retryDelayMs(attempt, retryAfterSeconds) {
+    if (retryAfterSeconds !== void 0 && retryAfterSeconds > 0) {
+      return Math.min(retryAfterSeconds * 1e3, RETRY_CAP_MS);
+    }
+    const baseMs = Math.min(1e3 * Math.pow(2, attempt), RETRY_CAP_MS);
+    const jitter = baseMs * (0.75 + 0.5 * Math.random());
+    return Math.min(jitter, RETRY_CAP_MS);
+  }
+  /** Extract the Retry-After header value in seconds, or undefined. */
+  parseRetryAfter(response) {
+    const header = response.headers.get("Retry-After");
+    if (header === null) return void 0;
+    const parsed = parseInt(header, 10);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  handleError(err) {
+    if (err instanceof ResponseError) {
+      const status = err.response.status;
+      const message = err.message;
+      switch (status) {
+        case 400:
+          throw new SmriteaValidationError(message, status);
+        case 401:
+          throw new SmriteaAuthError(message, status);
+        case 402:
+          throw new SmriteaQuotaError(message, status);
+        case 404:
+          throw new SmriteaNotFoundError(message, status);
+        case 429:
+          throw new SmriteaRateLimitError(message, status, this.parseRetryAfter(err.response));
+        default:
+          throw new SmriteaError(message, status);
+      }
+    }
+    throw new SmriteaError(String(err));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SmriteaAuthError,
+  SmriteaClient,
+  SmriteaError,
+  SmriteaNotFoundError,
+  SmriteaQuotaError,
+  SmriteaRateLimitError,
+  SmriteaValidationError
+});