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

package/src/controlplane/models/custom-detectors-config.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  CustomDetector,
+  CustomDetector$inboundSchema,
+  CustomDetector$Outbound,
+  CustomDetector$outboundSchema,
+} from "./custom-detector.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * Customer-authored detectors for a store. Evaluated together with the built-in
+ *
+ * @remarks
+ * detectors. Nothing is defined by default.
+ */
+export type CustomDetectorsConfig = {
+  /**
+   * At most 32. Names must be unique within the store and must not be a built-in
+   *
+   * @remarks
+   * detector id.
+   */
+  detectors?: Array<CustomDetector> | undefined;
+  /**
+   * Toggle for the whole custom group. False keeps the detectors stored but
+   *
+   * @remarks
+   * inactive.
+   */
+  enabled: boolean;
+};
+
+/** @internal */
+export const CustomDetectorsConfig$inboundSchema: z.ZodType<
+  CustomDetectorsConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  detectors: z.array(CustomDetector$inboundSchema).optional(),
+  enabled: z.boolean(),
+});
+/** @internal */
+export type CustomDetectorsConfig$Outbound = {
+  detectors?: Array<CustomDetector$Outbound> | undefined;
+  enabled: boolean;
+};
+
+/** @internal */
+export const CustomDetectorsConfig$outboundSchema: z.ZodType<
+  CustomDetectorsConfig$Outbound,
+  z.ZodTypeDef,
+  CustomDetectorsConfig
+> = z.object({
+  detectors: z.array(CustomDetector$outboundSchema).optional(),
+  enabled: z.boolean(),
+});
+
+export function customDetectorsConfigToJSON(
+  customDetectorsConfig: CustomDetectorsConfig,
+): string {
+  return JSON.stringify(
+    CustomDetectorsConfig$outboundSchema.parse(customDetectorsConfig),
+  );
+}
+export function customDetectorsConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<CustomDetectorsConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomDetectorsConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomDetectorsConfig' from JSON`,
+  );
+}

package/src/controlplane/models/custom-extraction-strategy.ts

@@ -0,0 +1,64 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * Extraction strategy for a custom memory type.
+ */
+export type CustomExtractionStrategy = {
+  /**
+   * Whether the strategy is active. Defaults to true when omitted.
+   */
+  enabled?: boolean | undefined;
+  /**
+   * Prompt used to extract memories of this type from session events.
+   */
+  prompt: string;
+};
+
+/** @internal */
+export const CustomExtractionStrategy$inboundSchema: z.ZodType<
+  CustomExtractionStrategy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().optional(),
+  prompt: z.string(),
+});
+/** @internal */
+export type CustomExtractionStrategy$Outbound = {
+  enabled?: boolean | undefined;
+  prompt: string;
+};
+
+/** @internal */
+export const CustomExtractionStrategy$outboundSchema: z.ZodType<
+  CustomExtractionStrategy$Outbound,
+  z.ZodTypeDef,
+  CustomExtractionStrategy
+> = z.object({
+  enabled: z.boolean().optional(),
+  prompt: z.string(),
+});
+
+export function customExtractionStrategyToJSON(
+  customExtractionStrategy: CustomExtractionStrategy,
+): string {
+  return JSON.stringify(
+    CustomExtractionStrategy$outboundSchema.parse(customExtractionStrategy),
+  );
+}
+export function customExtractionStrategyFromJSON(
+  jsonString: string,
+): SafeParseResult<CustomExtractionStrategy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomExtractionStrategy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomExtractionStrategy' from JSON`,
+  );
+}

package/src/controlplane/models/custom-field-type.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+/**
+ * Supported custom field data types.
+ */
+export const CustomFieldType = {
+  Str: "str",
+  Int: "int",
+  Float: "float",
+  Bool: "bool",
+  ListStr: "list[str]",
+  ListFloat: "list[float]",
+  Object: "object",
+} as const;
+/**
+ * Supported custom field data types.
+ */
+export type CustomFieldType = OpenEnum<typeof CustomFieldType>;
+
+/** @internal */
+export const CustomFieldType$inboundSchema: z.ZodType<
+  CustomFieldType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CustomFieldType);
+/** @internal */
+export const CustomFieldType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  CustomFieldType
+> = openEnums.outboundSchema(CustomFieldType);

package/src/controlplane/models/custom-field.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  CustomFieldType,
+  CustomFieldType$inboundSchema,
+  CustomFieldType$outboundSchema,
+} from "./custom-field-type.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * A structured field within a custom memory type.
+ */
+export type CustomField = {
+  /**
+   * Human-readable description of the field.
+   */
+  description: string;
+  /**
+   * Field name.
+   */
+  name: string;
+  /**
+   * Supported custom field data types.
+   */
+  type: CustomFieldType;
+};
+
+/** @internal */
+export const CustomField$inboundSchema: z.ZodType<
+  CustomField,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.string(),
+  name: z.string(),
+  type: CustomFieldType$inboundSchema,
+});
+/** @internal */
+export type CustomField$Outbound = {
+  description: string;
+  name: string;
+  type: string;
+};
+
+/** @internal */
+export const CustomField$outboundSchema: z.ZodType<
+  CustomField$Outbound,
+  z.ZodTypeDef,
+  CustomField
+> = z.object({
+  description: z.string(),
+  name: z.string(),
+  type: CustomFieldType$outboundSchema,
+});
+
+export function customFieldToJSON(customField: CustomField): string {
+  return JSON.stringify(CustomField$outboundSchema.parse(customField));
+}
+export function customFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<CustomField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomField' from JSON`,
+  );
+}

package/src/controlplane/models/custom-memory-type.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  CustomExtractionStrategy,
+  CustomExtractionStrategy$inboundSchema,
+  CustomExtractionStrategy$Outbound,
+  CustomExtractionStrategy$outboundSchema,
+} from "./custom-extraction-strategy.js";
+import {
+  CustomField,
+  CustomField$inboundSchema,
+  CustomField$Outbound,
+  CustomField$outboundSchema,
+} from "./custom-field.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * A custom memory type registered on a store: a named category of long-term memory
+ *
+ * @remarks
+ * with its structured fields and, optionally, an extraction strategy.
+ */
+export type CustomMemoryType = {
+  /**
+   * Human-readable description of what this memory type captures.
+   */
+  description: string;
+  /**
+   * Extraction strategy for a custom memory type.
+   */
+  extractionStrategy?: CustomExtractionStrategy | undefined;
+  /**
+   * Structured fields that make up a record of this type. Optional; a type with no
+   *
+   * @remarks
+   * fields accepts direct writes carrying no structured attributes.
+   */
+  fields?: Array<CustomField> | undefined;
+  /**
+   * Unique type name within the store. Must not collide with built-in types
+   *
+   * @remarks
+   * (semantic, episodic, message, session_summary_view).
+   */
+  name: string;
+};
+
+/** @internal */
+export const CustomMemoryType$inboundSchema: z.ZodType<
+  CustomMemoryType,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.string(),
+  extractionStrategy: CustomExtractionStrategy$inboundSchema.optional(),
+  fields: z.array(CustomField$inboundSchema).optional(),
+  name: z.string(),
+});
+/** @internal */
+export type CustomMemoryType$Outbound = {
+  description: string;
+  extractionStrategy?: CustomExtractionStrategy$Outbound | undefined;
+  fields?: Array<CustomField$Outbound> | undefined;
+  name: string;
+};
+
+/** @internal */
+export const CustomMemoryType$outboundSchema: z.ZodType<
+  CustomMemoryType$Outbound,
+  z.ZodTypeDef,
+  CustomMemoryType
+> = z.object({
+  description: z.string(),
+  extractionStrategy: CustomExtractionStrategy$outboundSchema.optional(),
+  fields: z.array(CustomField$outboundSchema).optional(),
+  name: z.string(),
+});
+
+export function customMemoryTypeToJSON(
+  customMemoryType: CustomMemoryType,
+): string {
+  return JSON.stringify(
+    CustomMemoryType$outboundSchema.parse(customMemoryType),
+  );
+}
+export function customMemoryTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<CustomMemoryType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomMemoryType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomMemoryType' from JSON`,
+  );
+}

package/src/controlplane/models/database-ref.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+/**
+ * The database to store memory data in.
+ */
+export type DatabaseRef = {
+  /**
+   * The database ID.
+   */
+  id: string;
+};
+
+/** @internal */
+export type DatabaseRef$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const DatabaseRef$outboundSchema: z.ZodType<
+  DatabaseRef$Outbound,
+  z.ZodTypeDef,
+  DatabaseRef
+> = z.object({
+  id: z.string(),
+});
+
+export function databaseRefToJSON(databaseRef: DatabaseRef): string {
+  return JSON.stringify(DatabaseRef$outboundSchema.parse(databaseRef));
+}

package/src/controlplane/models/database.ts

@@ -0,0 +1,84 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type Database = {
+  /**
+   * Database CIDR allow-list items
+   */
+  accessCidrs?: Array<string> | undefined;
+  /**
+   * Cloud provider of the database
+   */
+  databaseProvider?: string | undefined;
+  /**
+   * Cloud region of the database
+   */
+  databaseRegion?: string | undefined;
+  /**
+   * ID of the database
+   */
+  id: string;
+  /**
+   * Whether the database is accessible from the control plane based on IP restrictions
+   */
+  isCPAccessible: boolean;
+  /**
+   * Whether the database is eligible for the service being onboarded
+   */
+  isEligible: boolean;
+  /**
+   * Whether the database is active and ready to be used
+   */
+  isReady: boolean;
+  /**
+   * Name of the database
+   */
+  name: string;
+  /**
+   * Plan type of the database
+   */
+  planType?: string | undefined;
+  /**
+   * Subscription ID of the database
+   */
+  subscriptionId?: string | undefined;
+  /**
+   * Whether Redis Cloud TLS is enabled on the database
+   */
+  tlsEnabled?: boolean | undefined;
+};
+
+/** @internal */
+export const Database$inboundSchema: z.ZodType<
+  Database,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accessCidrs: z.array(z.string()).optional(),
+  databaseProvider: z.string().optional(),
+  databaseRegion: z.string().optional(),
+  id: z.string(),
+  isCPAccessible: z.boolean(),
+  isEligible: z.boolean(),
+  isReady: z.boolean(),
+  name: z.string(),
+  planType: z.string().optional(),
+  subscriptionId: z.string().optional(),
+  tlsEnabled: z.boolean().optional(),
+});
+
+export function databaseFromJSON(
+  jsonString: string,
+): SafeParseResult<Database, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Database$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Database' from JSON`,
+  );
+}

package/src/controlplane/models/detector-selection.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  ExclusionAction,
+  ExclusionAction$inboundSchema,
+  ExclusionAction$outboundSchema,
+} from "./exclusion-action.js";
+
+/**
+ * One selected built-in detector.
+ */
+export type DetectorSelection = {
+  /**
+   * What to do with a memory a detector matched. Defaults to `redact`. When matching
+   *
+   * @remarks
+   * detectors disagree, `drop` wins.
+   */
+  action?: ExclusionAction | undefined;
+  /**
+   * Whether this detector is active.
+   */
+  enabled: boolean;
+  /**
+   * The built-in detector id, as listed by ListBuiltInDetectors.
+   */
+  id: string;
+};
+
+/** @internal */
+export const DetectorSelection$inboundSchema: z.ZodType<
+  DetectorSelection,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  action: ExclusionAction$inboundSchema.optional(),
+  enabled: z.boolean(),
+  id: z.string(),
+});
+/** @internal */
+export type DetectorSelection$Outbound = {
+  action?: string | undefined;
+  enabled: boolean;
+  id: string;
+};
+
+/** @internal */
+export const DetectorSelection$outboundSchema: z.ZodType<
+  DetectorSelection$Outbound,
+  z.ZodTypeDef,
+  DetectorSelection
+> = z.object({
+  action: ExclusionAction$outboundSchema.optional(),
+  enabled: z.boolean(),
+  id: z.string(),
+});
+
+export function detectorSelectionToJSON(
+  detectorSelection: DetectorSelection,
+): string {
+  return JSON.stringify(
+    DetectorSelection$outboundSchema.parse(detectorSelection),
+  );
+}
+export function detectorSelectionFromJSON(
+  jsonString: string,
+): SafeParseResult<DetectorSelection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DetectorSelection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DetectorSelection' from JSON`,
+  );
+}

package/src/controlplane/models/errors/agent-memory-default-error.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { AgentMemoryServiceError } from "./agent-memory-service-error.js";
+
+/** The fallback error class if no more specific error class is matched */
+export class AgentMemoryDefaultError extends AgentMemoryServiceError {
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    if (message) {
+      message += `: `;
+    }
+    message += `Status ${httpMeta.response.status}`;
+    const contentType = httpMeta.response.headers.get("content-type") || `""`;
+    if (contentType !== "application/json") {
+      message += ` Content-Type ${
+        contentType.includes(" ") ? `"${contentType}"` : contentType
+      }`;
+    }
+    const body = httpMeta.body || `""`;
+    message += body.length > 100 ? "\n" : ". ";
+    let bodyDisplay = body;
+    if (body.length > 10000) {
+      const truncated = body.substring(0, 10000);
+      const remaining = body.length - 10000;
+      bodyDisplay = `${truncated}...and ${remaining} more chars`;
+    }
+    message += `Body: ${bodyDisplay}`;
+    message = message.trim();
+    super(message, httpMeta);
+    this.name = "AgentMemoryDefaultError";
+  }
+}

package/src/controlplane/models/errors/agent-memory-service-error.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/** The base class for all HTTP error responses */
+export class AgentMemoryServiceError extends Error {
+  /** HTTP status code */
+  public readonly statusCode: number;
+  /** HTTP body */
+  public readonly body: string;
+  /** HTTP headers */
+  public readonly headers: Headers;
+  /** HTTP content type */
+  public readonly contentType: string;
+  /** Raw response */
+  public readonly rawResponse: Response;
+
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    super(message);
+    this.statusCode = httpMeta.response.status;
+    this.body = httpMeta.body;
+    this.headers = httpMeta.response.headers;
+    this.contentType = httpMeta.response.headers.get("content-type") || "";
+    this.rawResponse = httpMeta.response;
+
+    this.name = "AgentMemoryServiceError";
+  }
+}