@redis-iris/agent-playbook 0.1.0-alpha.2 → 0.1.0-alpha.4

package/src/controlplane/sdk/sdk.ts

@@ -0,0 +1,293 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { clearPlaybook } from "../funcs/clear-playbook.js";
+import { createExtractionBinding } from "../funcs/create-extraction-binding.js";
+import { createPlaybook } from "../funcs/create-playbook.js";
+import { deleteExtractionBinding } from "../funcs/delete-extraction-binding.js";
+import { deleteModelCredential } from "../funcs/delete-model-credential.js";
+import { deletePlaybook } from "../funcs/delete-playbook.js";
+import { getExtractionBinding } from "../funcs/get-extraction-binding.js";
+import { getModelCredential } from "../funcs/get-model-credential.js";
+import { getNetworkInfo } from "../funcs/get-network-info.js";
+import { getPlaybook } from "../funcs/get-playbook.js";
+import { listDatabases } from "../funcs/list-databases.js";
+import { listExtractionBindings } from "../funcs/list-extraction-bindings.js";
+import { listExtractionStores } from "../funcs/list-extraction-stores.js";
+import { listModels } from "../funcs/list-models.js";
+import { listPlaybooks } from "../funcs/list-playbooks.js";
+import { putModelCredential } from "../funcs/put-model-credential.js";
+import { updateExtractionBinding } from "../funcs/update-extraction-binding.js";
+import { updatePlaybook } from "../funcs/update-playbook.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class PlaybookService extends ClientSDK {
+  /**
+   * Cloud only: list account databases
+   *
+   * @remarks
+   * Lists account databases using Playbook eligibility. Free plans remain visible even when ineligible or not ready. Requires JSESSIONID and X-CSRF-Token in addition to the operator JWT.
+   */
+  async listDatabases(
+    options?: RequestOptions,
+  ): Promise<models.ListDatabasesResponseContent> {
+    return unwrapAsync(listDatabases(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * List models supported by this deployment
+   *
+   * @remarks
+   * Lists models supported by this deployment. On-prem returns the configured embedding allowlist; cloud may also advertise extraction models.
+   */
+  async listModels(
+    options?: RequestOptions,
+  ): Promise<models.ListModelsResponseContent> {
+    return unwrapAsync(listModels(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: get control-plane network information
+   *
+   * @remarks
+   * Returns configured control-plane egress addresses for database allow-listing. Requires operator read authority.
+   */
+  async getNetworkInfo(
+    options?: RequestOptions,
+  ): Promise<models.GetNetworkInfoResponseContent> {
+    return unwrapAsync(getNetworkInfo(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Lists the account's Playbooks. Cloud requests require JSESSIONID and X-CSRF-Token in addition to the operator JWT. If a selected database is unavailable, its Playbook remains listed without endpoint, database name or accessCidrs enrichment.
+   */
+  async listPlaybooks(
+    options?: RequestOptions,
+  ): Promise<models.ListPlaybooksResponseContent> {
+    return unwrapAsync(listPlaybooks(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Creates and provisions one Playbook. A deployment-configured per-tenant limit applies; the on-prem default is 128. Cloud requests require JSESSIONID and X-CSRF-Token in addition to the operator JWT.
+   */
+  async createPlaybook(
+    request: models.CreatePlaybookRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreatePlaybookResponseContent> {
+    return unwrapAsync(createPlaybook(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async deletePlaybook(
+    playbookId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(deletePlaybook(
+      this,
+      playbookId,
+      options,
+    ));
+  }
+
+  /**
+   * Reads one Playbook. Cloud requests require JSESSIONID and X-CSRF-Token in addition to the operator JWT.
+   */
+  async getPlaybook(
+    playbookId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetPlaybookResponseContent> {
+    return unwrapAsync(getPlaybook(
+      this,
+      playbookId,
+      options,
+    ));
+  }
+
+  /**
+   * Updates mutable Playbook settings. Cloud requests require JSESSIONID and X-CSRF-Token in addition to the operator JWT.
+   */
+  async updatePlaybook(
+    playbookId: string,
+    body?: models.UpdatePlaybookRequestContent | undefined,
+    options?: RequestOptions,
+  ): Promise<models.UpdatePlaybookResponseContent> {
+    return unwrapAsync(updatePlaybook(
+      this,
+      playbookId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Administratively clears all (default), entries, or proposals from a ready Playbook, preserving configuration and index readiness. Requires product_admin or suite_admin. Cleanup is not atomic across content: failures can leave partial progress; retry the same scope after resolving the failure. Without new writes, repeating a successful clear removes no additional entry families.
+   */
+  async clearPlaybook(
+    playbookId: string,
+    scope?: models.ClearScope | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ClearPlaybookResponseContent> {
+    return unwrapAsync(clearPlaybook(
+      this,
+      playbookId,
+      scope,
+      options,
+    ));
+  }
+
+  async listExtractionBindings(
+    playbookId: string,
+    options?: RequestOptions,
+  ): Promise<models.ListExtractionBindingsResponseContent> {
+    return unwrapAsync(listExtractionBindings(
+      this,
+      playbookId,
+      options,
+    ));
+  }
+
+  /**
+   * Registers a client-supplied RAM store reference and FAQ policy. Returns preparing and enabled=false. The control plane asynchronously provisions extraction-worker RAM source read and Playbook destination read/propose grants; both accepted grants make the binding ready, refused grants make it blocked, and dependency outages remain pending for retry. The worker validates live RAM access when extraction runs. Poll GET until ready, then PATCH to enable.
+   */
+  async createExtractionBinding(
+    playbookId: string,
+    body: models.CreateExtractionBindingRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateExtractionBindingResponseContent> {
+    return unwrapAsync(createExtractionBinding(
+      this,
+      playbookId,
+      body,
+      options,
+    ));
+  }
+
+  async deleteExtractionBinding(
+    playbookId: string,
+    bindingId: string,
+    options?: RequestOptions,
+  ): Promise<models.DeleteExtractionBindingResponseContent> {
+    return unwrapAsync(deleteExtractionBinding(
+      this,
+      playbookId,
+      bindingId,
+      options,
+    ));
+  }
+
+  async getExtractionBinding(
+    playbookId: string,
+    bindingId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetExtractionBindingResponseContent> {
+    return unwrapAsync(getExtractionBinding(
+      this,
+      playbookId,
+      bindingId,
+      options,
+    ));
+  }
+
+  /**
+   * Updates FAQ policy or activation using expectedVersion. Supply job or enabled. Enabling requires ready status; pause is allowed while extraction is disabled. The deployment gate blocks policy updates and activation. Source identity is immutable; create a replacement binding to change stores. Stale revisions return conflict.
+   */
+  async updateExtractionBinding(
+    playbookId: string,
+    bindingId: string,
+    body: models.UpdateExtractionBindingRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.UpdateExtractionBindingResponseContent> {
+    return unwrapAsync(updateExtractionBinding(
+      this,
+      playbookId,
+      bindingId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Returns tenant-scoped deployment-configured store suggestions, which may be empty. A client may submit another syntactically valid storeId. No RAM call or approval check occurs.
+   */
+  async listExtractionStores(
+    playbookId: string,
+    options?: RequestOptions,
+  ): Promise<models.ListExtractionStoresResponseContent> {
+    return unwrapAsync(listExtractionStores(
+      this,
+      playbookId,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: delete a model credential
+   */
+  async deleteModelCredential(
+    playbookId: string,
+    purpose: models.ModelPurpose,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(deleteModelCredential(
+      this,
+      playbookId,
+      purpose,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: get model credential status
+   */
+  async getModelCredential(
+    playbookId: string,
+    purpose: models.ModelPurpose,
+    options?: RequestOptions,
+  ): Promise<models.GetModelCredentialResponseContent> {
+    return unwrapAsync(getModelCredential(
+      this,
+      playbookId,
+      purpose,
+      options,
+    ));
+  }
+
+  /**
+   * Cloud only: set or rotate a model credential
+   *
+   * @remarks
+   * Creates or rotates the selected customer-funded provider's credential after account/resource authorization. No secret is returned. Each new attempt reloads credentials; in-flight attempts retain their resolved credential until completion or their configured timeout.
+   */
+  async putModelCredential(
+    playbookId: string,
+    purpose: models.ModelPurpose,
+    body: models.PutModelCredentialRequestContent,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(putModelCredential(
+      this,
+      playbookId,
+      purpose,
+      body,
+      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");

package/src/controlplane/types/rfcdate.ts

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const dateRE = /^\d{4}-\d{2}-\d{2}$/;
+
+export class RFCDate {
+  private serialized: string;
+
+  /**
+   * Creates a new RFCDate instance using today's date.
+   */
+  static today(): RFCDate {
+    return new RFCDate(new Date());
+  }
+
+  /**
+   * Creates a new RFCDate instance using the provided input.
+   * If a string is used then in must be in the format YYYY-MM-DD.
+   *
+   * @param date A Date object or a date string in YYYY-MM-DD format
+   * @example
+   * new RFCDate("2022-01-01")
+   * @example
+   * new RFCDate(new Date())
+   */
+  constructor(date: Date | string) {
+    if (typeof date === "string" && !dateRE.test(date)) {
+      throw new RangeError(
+        "RFCDate: date strings must be in the format YYYY-MM-DD: " + date,
+      );
+    }
+
+    const value = new Date(date);
+    if (isNaN(+value)) {
+      throw new RangeError("RFCDate: invalid date provided: " + date);
+    }
+
+    this.serialized = value.toISOString().slice(0, "YYYY-MM-DD".length);
+    if (!dateRE.test(this.serialized)) {
+      throw new TypeError(
+        `RFCDate: failed to build valid date with given value: ${date} serialized to ${this.serialized}`,
+      );
+    }
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+
+  toString(): string {
+    return this.serialized;
+  }
+}

package/src/controlplane/types/streams.ts

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export function isReadableStream<T = Uint8Array>(
+  val: unknown,
+): val is ReadableStream<T> {
+  if (typeof val !== "object" || val === null) {
+    return false;
+  }
+
+  // Check for the presence of methods specific to ReadableStream
+  const stream = val as ReadableStream<Uint8Array>;
+
+  // ReadableStream has methods like getReader, cancel, and tee
+  return (
+    typeof stream.getReader === "function" &&
+    typeof stream.cancel === "function" &&
+    typeof stream.tee === "function"
+  );
+}