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

package/src/controlplane/models/update-memory-type-response-content.ts

@@ -0,0 +1,71 @@
+/*
+ * 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,
+} from "./custom-extraction-strategy.js";
+import { CustomField, CustomField$inboundSchema } 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 UpdateMemoryTypeResponseContent = {
+  /**
+   * 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, session_summary_view).
+   */
+  name: string;
+  /**
+   * Opaque revision returned on reads. Server assigned; ignored on creation.
+   */
+  revision?: string | undefined;
+};
+
+/** @internal */
+export const UpdateMemoryTypeResponseContent$inboundSchema: z.ZodType<
+  UpdateMemoryTypeResponseContent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.string(),
+  extractionStrategy: CustomExtractionStrategy$inboundSchema.optional(),
+  fields: z.array(CustomField$inboundSchema).optional(),
+  name: z.string(),
+  revision: z.string().optional(),
+});
+
+export function updateMemoryTypeResponseContentFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateMemoryTypeResponseContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateMemoryTypeResponseContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateMemoryTypeResponseContent' from JSON`,
+  );
+}

package/src/controlplane/models/update-store-request-content.ts

@@ -3,11 +3,6 @@
  */
 
 import * as z from "zod/v3";
-import {
-  CustomMemoryType,
-  CustomMemoryType$Outbound,
-  CustomMemoryType$outboundSchema,
-} from "./custom-memory-type.js";
 import {
   ExtractionCadenceConfig,
   ExtractionCadenceConfig$Outbound,
@@ -23,11 +18,6 @@ import {
   LongTermMemoryExclusionsConfig$Outbound,
   LongTermMemoryExclusionsConfig$outboundSchema,
 } from "./long-term-memory-exclusions-config.js";
-import {
-  MemoryTypeStrategyUpdate,
-  MemoryTypeStrategyUpdate$Outbound,
-  MemoryTypeStrategyUpdate$outboundSchema,
-} from "./memory-type-strategy-update.js";
 import {
   ShortMemoryConfigInput,
   ShortMemoryConfigInput$Outbound,
@@ -40,10 +30,6 @@ import {
 } from "./summarization-config.js";
 
 export type UpdateStoreRequestContent = {
-  /**
-   * New custom memory types to add. Existing types cannot be redefined here.
-   */
-  addCustomMemoryTypes?: Array<CustomMemoryType> | undefined;
   /**
    * Cadence configuration for the extraction pipeline.
    */
@@ -83,20 +69,10 @@ export type UpdateStoreRequestContent = {
    * periodically condensed into a running summary while retaining the most recent events.
    */
   summarization?: SummarizationConfig | undefined;
-  /**
-   * Strategy edits (prompt and enabled flag) for existing custom memory types. A
-   *
-   * @remarks
-   * type's name, description, and fields cannot be changed.
-   */
-  updateCustomMemoryTypeStrategies?:
-    | Array<MemoryTypeStrategyUpdate>
-    | undefined;
 };
 
 /** @internal */
 export type UpdateStoreRequestContent$Outbound = {
-  addCustomMemoryTypes?: Array<CustomMemoryType$Outbound> | undefined;
   extractionCadence?: ExtractionCadenceConfig$Outbound | undefined;
   longTermMemory?: LongTermMemoryConfigUpdate$Outbound | undefined;
   longTermMemoryExclusions?:
@@ -105,9 +81,6 @@ export type UpdateStoreRequestContent$Outbound = {
   name?: string | undefined;
   shortMemory?: ShortMemoryConfigInput$Outbound | undefined;
   summarization?: SummarizationConfig$Outbound | undefined;
-  updateCustomMemoryTypeStrategies?:
-    | Array<MemoryTypeStrategyUpdate$Outbound>
-    | undefined;
 };
 
 /** @internal */
@@ -116,7 +89,6 @@ export const UpdateStoreRequestContent$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateStoreRequestContent
 > = z.object({
-  addCustomMemoryTypes: z.array(CustomMemoryType$outboundSchema).optional(),
   extractionCadence: ExtractionCadenceConfig$outboundSchema.optional(),
   longTermMemory: LongTermMemoryConfigUpdate$outboundSchema.optional(),
   longTermMemoryExclusions: LongTermMemoryExclusionsConfig$outboundSchema
@@ -124,9 +96,6 @@ export const UpdateStoreRequestContent$outboundSchema: z.ZodType<
   name: z.string().optional(),
   shortMemory: ShortMemoryConfigInput$outboundSchema.optional(),
   summarization: SummarizationConfig$outboundSchema.optional(),
-  updateCustomMemoryTypeStrategies: z.array(
-    MemoryTypeStrategyUpdate$outboundSchema,
-  ).optional(),
 });
 
 export function updateStoreRequestContentToJSON(

package/src/controlplane/models/update-store-response-content.ts

@@ -5,10 +5,6 @@
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  CustomMemoryType,
-  CustomMemoryType$inboundSchema,
-} from "./custom-memory-type.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 import {
   ExtractionCadenceConfig,
@@ -26,6 +22,10 @@ import {
   LongTermMemoryExclusionsConfig,
   LongTermMemoryExclusionsConfig$inboundSchema,
 } from "./long-term-memory-exclusions-config.js";
+import {
+  ResourceState,
+  ResourceState$inboundSchema,
+} from "./resource-state.js";
 import {
   ShortMemoryConfigStatus,
   ShortMemoryConfigStatus$inboundSchema,
@@ -39,7 +39,6 @@ import {
   StoreEndpoint$inboundSchema,
 } from "./store-endpoint.js";
 import { StoreFailure, StoreFailure$inboundSchema } from "./store-failure.js";
-import { StoreStatus, StoreStatus$inboundSchema } from "./store-status.js";
 import {
   SummarizationConfig,
   SummarizationConfig$inboundSchema,
@@ -53,10 +52,6 @@ export type UpdateStoreResponseContent = {
    * The UTC timestamp when the memory store was created.
    */
   createdAt: Date;
-  /**
-   * Custom memory types registered on the store.
-   */
-  customMemoryTypes?: Array<CustomMemoryType> | undefined;
   /**
    * The database a memory store's data is stored in.
    */
@@ -73,11 +68,11 @@ export type UpdateStoreResponseContent = {
    * Extraction strategy for promoting short-term memory to long-term memory. Defaults
    *
    * @remarks
-   * to `instruct`.
+   * to `INSTRUCT`.
    */
   extractionStrategy: ExtractionStrategy;
   /**
-   * Why the store failed to provision. Present only when the store's `status` is
+   * Why the store failed to provision. Present only when the store's `state` is
    *
    * @remarks
    * `UNAVAILABLE`. Not returned by ListStores.
@@ -103,9 +98,12 @@ export type UpdateStoreResponseContent = {
    */
   shortMemory?: ShortMemoryConfigStatus | undefined;
   /**
-   * Status of a memory store.
+   * The condition of a provisioned resource, returned as `state`. A resource is usable
+   *
+   * @remarks
+   * when its state is `READY`. A resource reports only the states that apply to it.
    */
-  status: StoreStatus;
+  state: ResourceState;
   /**
    * Unique identifier for the memory store.
    */
@@ -130,7 +128,6 @@ export const UpdateStoreResponseContent$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
-  customMemoryTypes: z.array(CustomMemoryType$inboundSchema).optional(),
   database: StoreDatabase$inboundSchema,
   endpoints: z.array(StoreEndpoint$inboundSchema).optional(),
   extractionCadence: ExtractionCadenceConfig$inboundSchema.optional(),
@@ -141,7 +138,7 @@ export const UpdateStoreResponseContent$inboundSchema: z.ZodType<
     .optional(),
   name: z.string(),
   shortMemory: ShortMemoryConfigStatus$inboundSchema.optional(),
-  status: StoreStatus$inboundSchema,
+  state: ResourceState$inboundSchema,
   storeId: z.string(),
   subscriptionId: z.string().optional(),
   summarization: SummarizationConfig$inboundSchema.optional(),

package/src/controlplane/sdk/sdk.ts

@@ -2,26 +2,32 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import { clearStore } from "../funcs/clear-store.js";
 import { createExtractor } from "../funcs/create-extractor.js";
 import { createFreeDatabase } from "../funcs/create-free-database.js";
+import { createMemoryType } from "../funcs/create-memory-type.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 { getMemoryType } from "../funcs/get-memory-type.js";
 import { getNetworkInfo } from "../funcs/get-network-info.js";
+import { getServiceLiveness } from "../funcs/get-service-liveness.js";
+import { getServiceReadiness } from "../funcs/get-service-readiness.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 { listMemoryTypes } from "../funcs/list-memory-types.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 { removeMemoryType } from "../funcs/remove-memory-type.js";
 import { updateExtractor } from "../funcs/update-extractor.js";
+import { updateMemoryType } from "../funcs/update-memory-type.js";
 import { updateStore } from "../funcs/update-store.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
@@ -62,6 +68,20 @@ export class AgentMemoryService extends ClientSDK {
     ));
   }
 
+  /**
+   * 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,
+    ));
+  }
+
   /**
    * Cloud only: get Agent Memory EULA acceptance
    *
@@ -93,14 +113,24 @@ export class AgentMemoryService extends ClientSDK {
   }
 
   /**
-   * 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.
+   * Reports that this API process can answer requests, independently of downstream dependencies.
    */
-  async listBuiltInDetectors(
+  async getServiceLiveness(
     options?: RequestOptions,
-  ): Promise<models.ListBuiltInDetectorsResponseContent> {
-    return unwrapAsync(listBuiltInDetectors(
+  ): Promise<models.GetServiceLivenessResponseContent> {
+    return unwrapAsync(getServiceLiveness(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Evaluates the same serving dependencies as the operational readiness probe. Returns 503 without dependency details when the service cannot serve requests.
+   */
+  async getServiceReadiness(
+    options?: RequestOptions,
+  ): Promise<models.GetServiceReadinessResponseContent> {
+    return unwrapAsync(getServiceReadiness(
       this,
       options,
     ));
@@ -123,6 +153,24 @@ export class AgentMemoryService extends ClientSDK {
     ));
   }
 
+  /**
+   * 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. Returns an empty provider list in an environment with no configured models.
+   */
+  async listStoreModels(
+    options?: RequestOptions,
+  ): Promise<models.ListStoreModelsResponseContent> {
+    return unwrapAsync(listStoreModels(
+      this,
+      options,
+    ));
+  }
+
   /**
    * Cloud only: get control-plane network information
    *
@@ -147,10 +195,16 @@ export class AgentMemoryService extends ClientSDK {
    * List all memory stores.
    */
   async listStores(
+    projectId?: string | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.ListStoresResponseContent> {
     return unwrapAsync(listStores(
       this,
+      projectId,
+      limit,
+      cursor,
       options,
     ));
   }
@@ -159,31 +213,14 @@ export class AgentMemoryService extends ClientSDK {
    * Create a new memory store.
    */
   async createStore(
-    request: models.CreateStoreRequestContent,
+    body: models.CreateStoreRequestContent,
+    projectId?: string | undefined,
     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,
+      body,
+      projectId,
       options,
     ));
   }
@@ -193,12 +230,14 @@ export class AgentMemoryService extends ClientSDK {
    */
   async deleteStore(
     storeId: string,
+    projectId?: string | undefined,
     flush?: boolean | undefined,
     options?: RequestOptions,
   ): Promise<void> {
     return unwrapAsync(deleteStore(
       this,
       storeId,
+      projectId,
       flush,
       options,
     ));
@@ -209,11 +248,13 @@ export class AgentMemoryService extends ClientSDK {
    */
   async getStore(
     storeId: string,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.GetStoreResponseContent> {
     return unwrapAsync(getStore(
       this,
       storeId,
+      projectId,
       options,
     ));
   }
@@ -224,30 +265,36 @@ export class AgentMemoryService extends ClientSDK {
    */
   async updateStore(
     storeId: string,
+    projectId?: string | undefined,
     body?: models.UpdateStoreRequestContent | undefined,
     options?: RequestOptions,
   ): Promise<models.UpdateStoreResponseContent> {
     return unwrapAsync(updateStore(
       this,
       storeId,
+      projectId,
       body,
       options,
     ));
   }
 
   /**
-   * Cloud only: flush a store's sessions and long-term memories
+   * Cloud only: clear a store's sessions (scope=SESSIONS) or everything (scope=ALL)
    *
    * @remarks
-   * Redis Cloud only. Delete all working memory sessions AND long-term memories for the store.
+   * Redis Cloud only. Delete a store's content, keeping the store and its configuration.
    */
-  async flushStoreEntries(
+  async clearStore(
     storeId: string,
+    scope: models.ClearScope,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<void> {
-    return unwrapAsync(flushStoreEntries(
+    return unwrapAsync(clearStore(
       this,
       storeId,
+      scope,
+      projectId,
       options,
     ));
   }
@@ -257,11 +304,17 @@ export class AgentMemoryService extends ClientSDK {
    */
   async listExtractors(
     storeId: string,
+    projectId?: string | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.ListExtractorsResponseContent> {
     return unwrapAsync(listExtractors(
       this,
       storeId,
+      projectId,
+      limit,
+      cursor,
       options,
     ));
   }
@@ -272,24 +325,27 @@ export class AgentMemoryService extends ClientSDK {
   async createExtractor(
     storeId: string,
     body: models.CreateExtractorRequestContent,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.CreateExtractorResponseContent> {
     return unwrapAsync(createExtractor(
       this,
       storeId,
       body,
+      projectId,
       options,
     ));
   }
 
   /**
    * Remove an extractor. `expectedRevision` must match the extractor's current
-   * revision; otherwise the request fails with 409.
+   * revision; otherwise the request fails with 412 `/errors/revision-conflict`.
    */
   async removeExtractor(
     storeId: string,
     extractorId: string,
-    expectedRevision: number,
+    expectedRevision: string,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<void> {
     return unwrapAsync(removeExtractor(
@@ -297,6 +353,7 @@ export class AgentMemoryService extends ClientSDK {
       storeId,
       extractorId,
       expectedRevision,
+      projectId,
       options,
     ));
   }
@@ -307,24 +364,27 @@ export class AgentMemoryService extends ClientSDK {
   async getExtractor(
     storeId: string,
     extractorId: string,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.GetExtractorResponseContent> {
     return unwrapAsync(getExtractor(
       this,
       storeId,
       extractorId,
+      projectId,
       options,
     ));
   }
 
   /**
    * Update an extractor. `expectedRevision` must match the extractor's current
-   * revision; otherwise the request fails with 409.
+   * revision; otherwise the request fails with 412 `/errors/revision-conflict`.
    */
   async updateExtractor(
     storeId: string,
     extractorId: string,
     body: models.UpdateExtractorRequestContent,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.UpdateExtractorResponseContent> {
     return unwrapAsync(updateExtractor(
@@ -332,6 +392,115 @@ export class AgentMemoryService extends ClientSDK {
       storeId,
       extractorId,
       body,
+      projectId,
+      options,
+    ));
+  }
+
+  /**
+   * List a store's custom memory types.
+   */
+  async listMemoryTypes(
+    storeId: string,
+    projectId?: string | undefined,
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListMemoryTypesResponseContent> {
+    return unwrapAsync(listMemoryTypes(
+      this,
+      storeId,
+      projectId,
+      limit,
+      cursor,
+      options,
+    ));
+  }
+
+  /**
+   * Register a custom memory type on a store. Its name, description and fields cannot
+   * change afterwards. A registered or retired name is a 409. A concurrent registry
+   * change may return 412; read the current registry and retry.
+   */
+  async createMemoryType(
+    storeId: string,
+    body: models.CustomMemoryType,
+    projectId?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.CreateMemoryTypeResponseContent> {
+    return unwrapAsync(createMemoryType(
+      this,
+      storeId,
+      body,
+      projectId,
+      options,
+    ));
+  }
+
+  /**
+   * Unregister a custom memory type without deleting existing memories or Search
+   * index fields. First disable its session extraction strategy and remove every
+   * document Extractor bound to it; otherwise this returns 409. The removed name
+   * is permanently reserved within this store to protect stored attribute schemas.
+   * Requests or extraction jobs already admitted with an older store configuration
+   * may finish. This operation is not a write barrier or a data purge.
+   * An optional expectedRevision protects against stale deletion (412 on mismatch).
+   * Even when omitted, a concurrent registry change may return 412; read and retry.
+   */
+  async removeMemoryType(
+    storeId: string,
+    memoryTypeName: string,
+    projectId?: string | undefined,
+    expectedRevision?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(removeMemoryType(
+      this,
+      storeId,
+      memoryTypeName,
+      projectId,
+      expectedRevision,
+      options,
+    ));
+  }
+
+  /**
+   * Get one of a store's custom memory types.
+   */
+  async getMemoryType(
+    storeId: string,
+    memoryTypeName: string,
+    projectId?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetMemoryTypeResponseContent> {
+    return unwrapAsync(getMemoryType(
+      this,
+      storeId,
+      memoryTypeName,
+      projectId,
+      options,
+    ));
+  }
+
+  /**
+   * Change a custom memory type's extraction strategy: its prompt, `enabled`, or both.
+   * Omitted members are unchanged. The type must already have a strategy.
+   * An optional expectedRevision protects against stale edits (412 on mismatch).
+   * Even when omitted, a concurrent registry change may return 412; read and retry.
+   */
+  async updateMemoryType(
+    storeId: string,
+    memoryTypeName: string,
+    body: models.UpdateMemoryTypeRequestContent,
+    projectId?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.UpdateMemoryTypeResponseContent> {
+    return unwrapAsync(updateMemoryType(
+      this,
+      storeId,
+      memoryTypeName,
+      body,
+      projectId,
       options,
     ));
   }
@@ -348,6 +517,7 @@ export class AgentMemoryService extends ClientSDK {
     from: Date,
     to: Date,
     period: models.MetricsPeriod,
+    projectId?: string | undefined,
     options?: RequestOptions,
   ): Promise<models.GetStoreMetricsResponseContent> {
     return unwrapAsync(getStoreMetrics(
@@ -356,24 +526,7 @@ export class AgentMemoryService extends ClientSDK {
       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,
+      projectId,
       options,
     ));
   }