@redis-iris/agent-memory 0.4.0-beta.1 → 0.4.0-beta.2

package/src/controlplane/sdk/sdk.ts

@@ -0,0 +1,380 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { createExtractor } from "../funcs/create-extractor.js";
+import { createFreeDatabase } from "../funcs/create-free-database.js";
+import { createStore } from "../funcs/create-store.js";
+import { deleteStore } from "../funcs/delete-store.js";
+import { emptyStore } from "../funcs/empty-store.js";
+import { flushStoreEntries } from "../funcs/flush-store-entries.js";
+import { getExtractor } from "../funcs/get-extractor.js";
+import { getMemoryEULA } from "../funcs/get-memory-eula.js";
+import { getMemoryTypeReferenceData } from "../funcs/get-memory-type-reference-data.js";
+import { getNetworkInfo } from "../funcs/get-network-info.js";
+import { getStoreMetrics } from "../funcs/get-store-metrics.js";
+import { getStore } from "../funcs/get-store.js";
+import { listBuiltInDetectors } from "../funcs/list-built-in-detectors.js";
+import { listDatabases } from "../funcs/list-databases.js";
+import { listExtractors } from "../funcs/list-extractors.js";
+import { listStoreModels } from "../funcs/list-store-models.js";
+import { listStores } from "../funcs/list-stores.js";
+import { putMemoryEULA } from "../funcs/put-memory-eula.js";
+import { removeExtractor } from "../funcs/remove-extractor.js";
+import { updateExtractor } from "../funcs/update-extractor.js";
+import { updateStore } from "../funcs/update-store.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class AgentMemoryService extends ClientSDK {
+  /**
+   * Cloud only: list account databases that can back a store
+   *
+   * @remarks
+   * Redis Cloud only. List the caller's Redis Cloud databases that can back a memory store.
+   * Free-plan databases are always listed; other databases only when eligible
+   * and ready.
+   */
+  async listDatabases(
+    options?: RequestOptions,
+  ): Promise<models.ListDatabasesResponseContent> {
+    return unwrapAsync(listDatabases(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: create a free database for a store
+   *
+   * @remarks
+   * Redis Cloud only. Create a free Redis Cloud database in the caller's account.
+   */
+  async createFreeDatabase(
+    request: models.FreeDatabaseCreateRequest,
+    options?: RequestOptions,
+  ): Promise<models.CreateFreeDatabaseResponseContent> {
+    return unwrapAsync(createFreeDatabase(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: get Agent Memory EULA acceptance
+   *
+   * @remarks
+   * Redis Cloud only. Get the EULA acceptance status of the current user for Agent Memory.
+   */
+  async getMemoryEULA(
+    options?: RequestOptions,
+  ): Promise<models.GetMemoryEULAResponseContent> {
+    return unwrapAsync(getMemoryEULA(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: accept the Agent Memory EULA
+   *
+   * @remarks
+   * Redis Cloud only. Accept the EULA for Agent Memory.
+   */
+  async putMemoryEULA(
+    options?: RequestOptions,
+  ): Promise<models.PutMemoryEULAResponseContent> {
+    return unwrapAsync(putMemoryEULA(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * List the built-in sensitive-data detectors a store can select in its
+   * `longTermMemoryExclusions.builtInDetectors` configuration. Selecting an id this
+   * endpoint does not list is rejected.
+   */
+  async listBuiltInDetectors(
+    options?: RequestOptions,
+  ): Promise<models.ListBuiltInDetectorsResponseContent> {
+    return unwrapAsync(listBuiltInDetectors(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Get reference data for registering custom memory types.
+   *
+   * Returns the reserved built-in memory type names (which a custom memory type
+   * name must not collide with) and the system record fields present on every
+   * memory record, for display in memory-type registration UIs. This is static
+   * reference data and is not scoped to any store.
+   */
+  async getMemoryTypeReferenceData(
+    options?: RequestOptions,
+  ): Promise<models.GetMemoryTypeReferenceDataResponseContent> {
+    return unwrapAsync(getMemoryTypeReferenceData(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: get control-plane network information
+   *
+   * @remarks
+   * Redis Cloud only. Get the service's egress IP addresses, for allow-listing on the database
+   * backing a memory store. The control plane and the data plane egress through
+   * the same addresses.
+   *
+   * Served from configuration: no database access and no provider call. Returns
+   * an empty list in an environment with no configured egress IPs.
+   */
+  async getNetworkInfo(
+    options?: RequestOptions,
+  ): Promise<models.GetNetworkInfoResponseContent> {
+    return unwrapAsync(getNetworkInfo(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * List all memory stores.
+   */
+  async listStores(
+    options?: RequestOptions,
+  ): Promise<models.ListStoresResponseContent> {
+    return unwrapAsync(listStores(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Create a new memory store.
+   */
+  async createStore(
+    request: models.CreateStoreRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateStoreResponseContent> {
+    return unwrapAsync(createStore(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: list models a store can use
+   *
+   * @remarks
+   * Redis Cloud only. List the model providers and models a memory store can be configured with.
+   *
+   * Served from control-plane configuration: no database access and no provider
+   * call. Exists so the console never hardcodes a model list. Returns an empty
+   * provider list in an environment with no configured models.
+   */
+  async listStoreModels(
+    options?: RequestOptions,
+  ): Promise<models.ListStoreModelsResponseContent> {
+    return unwrapAsync(listStoreModels(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a memory store.
+   */
+  async deleteStore(
+    storeId: string,
+    flush?: boolean | undefined,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(deleteStore(
+      this,
+      storeId,
+      flush,
+      options,
+    ));
+  }
+
+  /**
+   * Get a memory store by ID. Returns the full configuration and status of the store.
+   */
+  async getStore(
+    storeId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetStoreResponseContent> {
+    return unwrapAsync(getStore(
+      this,
+      storeId,
+      options,
+    ));
+  }
+
+  /**
+   * Update a memory store configuration. Only the specified fields are updated.
+   * Returns the updated store.
+   */
+  async updateStore(
+    storeId: string,
+    body?: models.UpdateStoreRequestContent | undefined,
+    options?: RequestOptions,
+  ): Promise<models.UpdateStoreResponseContent> {
+    return unwrapAsync(updateStore(
+      this,
+      storeId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: flush a store's sessions and long-term memories
+   *
+   * @remarks
+   * Redis Cloud only. Delete all working memory sessions AND long-term memories for the store.
+   */
+  async flushStoreEntries(
+    storeId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(flushStoreEntries(
+      this,
+      storeId,
+      options,
+    ));
+  }
+
+  /**
+   * List a memory store's extractors.
+   */
+  async listExtractors(
+    storeId: string,
+    options?: RequestOptions,
+  ): Promise<models.ListExtractorsResponseContent> {
+    return unwrapAsync(listExtractors(
+      this,
+      storeId,
+      options,
+    ));
+  }
+
+  /**
+   * Create an extractor on a memory store. Returns the created extractor at revision 1.
+   */
+  async createExtractor(
+    storeId: string,
+    body: models.CreateExtractorRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateExtractorResponseContent> {
+    return unwrapAsync(createExtractor(
+      this,
+      storeId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Remove an extractor. `expectedRevision` must match the extractor's current
+   * revision; otherwise the request fails with 409.
+   */
+  async removeExtractor(
+    storeId: string,
+    extractorId: string,
+    expectedRevision: number,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(removeExtractor(
+      this,
+      storeId,
+      extractorId,
+      expectedRevision,
+      options,
+    ));
+  }
+
+  /**
+   * Get an extractor.
+   */
+  async getExtractor(
+    storeId: string,
+    extractorId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetExtractorResponseContent> {
+    return unwrapAsync(getExtractor(
+      this,
+      storeId,
+      extractorId,
+      options,
+    ));
+  }
+
+  /**
+   * Update an extractor. `expectedRevision` must match the extractor's current
+   * revision; otherwise the request fails with 409.
+   */
+  async updateExtractor(
+    storeId: string,
+    extractorId: string,
+    body: models.UpdateExtractorRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.UpdateExtractorResponseContent> {
+    return unwrapAsync(updateExtractor(
+      this,
+      storeId,
+      extractorId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: get store metrics
+   *
+   * @remarks
+   * Redis Cloud only. Get metrics for a memory store.
+   * Returns latency and request count metrics for short-term and long-term memory operations.
+   */
+  async getStoreMetrics(
+    storeId: string,
+    from: Date,
+    to: Date,
+    period: models.MetricsPeriod,
+    options?: RequestOptions,
+  ): Promise<models.GetStoreMetricsResponseContent> {
+    return unwrapAsync(getStoreMetrics(
+      this,
+      storeId,
+      from,
+      to,
+      period,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: empty a store
+   *
+   * @remarks
+   * Redis Cloud only. Empty a memory store by deleting all its data.
+   * This operation removes all working memory sessions from the store.
+   */
+  async emptyStore(
+    storeId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(emptyStore(
+      this,
+      storeId,
+      options,
+    ));
+  }
+}

package/src/controlplane/types/async.ts

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  #unwrapped: Promise<T> | null;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped = p instanceof Promise ? null : Promise.resolve(p[0]);
+  }
+
+  #getUnwrapped(): Promise<T> {
+    return (this.#unwrapped ??= this.#promise.then(([value]) => value));
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#getUnwrapped().catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#getUnwrapped().finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/controlplane/types/blobs.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> = z.custom<
+  Blob
+>(isBlobLike, {
+  message: "expected a Blob, File or Blob-like object",
+  fatal: true,
+});
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}

package/src/controlplane/types/const-date-time.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export function constDateTime(
+  val: string,
+): z.ZodType<string, z.ZodTypeDef, unknown> {
+  return z.custom<string>((v) => {
+    return (
+      typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
+    );
+  }, `Value must be equivalent to ${val}`);
+}

package/src/controlplane/types/enums.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { Unrecognized, unrecognized } from "./unrecognized.js";
+
+export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
+  T[keyof T];
+export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
+  | T[keyof T]
+  | Unrecognized<T[keyof T] extends number ? number : string>;
+
+export function inboundSchema<T extends Record<string, string>>(
+  enumObj: T,
+): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+  const options = Object.values(enumObj);
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.string().transform(x => unrecognized(x)),
+  ] as any);
+}
+
+export function inboundSchemaInt<T extends Record<string, number | string>>(
+  enumObj: T,
+): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+  // For numeric enums, Object.values returns both numbers and string keys
+  const options = Object.values(enumObj).filter(v => typeof v === "number");
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.number().int().transform(x => unrecognized(x)),
+  ] as any);
+}
+
+export function outboundSchema<T extends Record<string, string>>(
+  _: T,
+): z.ZodType<string, z.ZodTypeDef, OpenEnum<T>> {
+  return z.string() as any;
+}
+
+export function outboundSchemaInt<T extends Record<string, number | string>>(
+  _: T,
+): z.ZodType<number, z.ZodTypeDef, OpenEnum<T>> {
+  return z.number().int() as any;
+}

package/src/controlplane/types/fp.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/**
+ * A monad that captures the result of a function call or an error if it was not
+ * successful. Railway programming, enabled by this type, can be a nicer
+ * alternative to traditional exception throwing because it allows functions to
+ * declare all _known_ errors with static types and then check for them
+ * exhaustively in application code. Thrown exception have a type of `unknown`
+ * and break out of regular control flow of programs making them harder to
+ * inspect and more verbose work with due to try-catch blocks.
+ */
+export type Result<T, E = unknown> =
+  | { ok: true; value: T; error?: never }
+  | { ok: false; value?: never; error: E };
+
+export function OK<V>(value: V): Result<V, never> {
+  return { ok: true, value };
+}
+
+export function ERR<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+/**
+ * unwrap is a convenience function for extracting a value from a result or
+ * throwing if there was an error.
+ */
+export function unwrap<T>(r: Result<T, unknown>): T {
+  if (!r.ok) {
+    throw r.error;
+  }
+  return r.value;
+}
+
+/**
+ * unwrapAsync is a convenience function for resolving a value from a Promise
+ * of a result or rejecting if an error occurred.
+ */
+export async function unwrapAsync<T>(
+  pr: Promise<Result<T, unknown>>,
+): Promise<T> {
+  const r = await pr;
+  if (!r.ok) {
+    throw r.error;
+  }
+
+  return r.value;
+}

package/src/controlplane/types/index.ts

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export { blobLikeSchema, isBlobLike } from "./blobs.js";
+export type { ClosedEnum, OpenEnum } from "./enums.js";
+export type { Result } from "./fp.js";
+export type { PageIterator, Paginator } from "./operations.js";
+export { createPageIterator } from "./operations.js";
+export { RFCDate } from "./rfcdate.js";
+export * from "./unrecognized.js";

package/src/controlplane/types/operations.ts

@@ -0,0 +1,105 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { Result } from "./fp.js";
+
+export type Paginator<V> = () => Promise<V & { next: Paginator<V> }> | null;
+
+export type PageIterator<V, PageState = unknown> = V & {
+  next: Paginator<V>;
+  [Symbol.asyncIterator]: () => AsyncIterableIterator<V>;
+  "~next"?: PageState | undefined;
+};
+
+export function createPageIterator<V>(
+  page: V & { next: Paginator<V> },
+  halt: (v: V) => boolean,
+): {
+  [Symbol.asyncIterator]: () => AsyncIterableIterator<V>;
+} {
+  return {
+    [Symbol.asyncIterator]: async function* paginator() {
+      yield page;
+      if (halt(page)) {
+        return;
+      }
+
+      let p: typeof page | null = page;
+      for (p = await p.next(); p != null; p = await p.next()) {
+        yield p;
+        if (halt(p)) {
+          return;
+        }
+      }
+    },
+  };
+}
+
+/**
+ * This utility create a special iterator that yields a single value and
+ * terminates. It is useful in paginated SDK functions that have early return
+ * paths when things go wrong.
+ */
+export function haltIterator<V extends object>(
+  v: V,
+): PageIterator<V, undefined> {
+  return {
+    ...v,
+    next: () => null,
+    [Symbol.asyncIterator]: async function* paginator() {
+      yield v;
+    },
+  };
+}
+
+/**
+ * Converts an async iterator of `Result<V, E>` into an async iterator of `V`.
+ * When error results occur, the underlying error value is thrown.
+ */
+export async function unwrapResultIterator<V, PageState>(
+  iteratorPromise: Promise<PageIterator<Result<V, unknown>, PageState>>,
+): Promise<PageIterator<V, PageState>> {
+  const resultIter = await iteratorPromise;
+
+  if (!resultIter.ok) {
+    throw resultIter.error;
+  }
+
+  return {
+    ...resultIter.value,
+    next: unwrapPaginator(resultIter.next),
+    "~next": resultIter["~next"],
+    [Symbol.asyncIterator]: async function* paginator() {
+      for await (const page of resultIter) {
+        if (!page.ok) {
+          throw page.error;
+        }
+        yield page.value;
+      }
+    },
+  };
+}
+
+function unwrapPaginator<V>(
+  paginator: Paginator<Result<V, unknown>>,
+): Paginator<V> {
+  return () => {
+    const nextResult = paginator();
+    if (nextResult == null) {
+      return null;
+    }
+    return nextResult.then((res) => {
+      if (!res.ok) {
+        throw res.error;
+      }
+      const out = {
+        ...res.value,
+        next: unwrapPaginator(res.next),
+      };
+      return out;
+    });
+  };
+}
+
+export const URL_OVERRIDE = Symbol("URL_OVERRIDE");