@redis-iris/agent-memory 0.1.0 → 0.2.0

package/src/models/long-term-memory-filter.ts

@@ -4,6 +4,11 @@
  */
 
 import * as z from "zod/v3";
+import {
+  AttributeFilterClause,
+  AttributeFilterClause$Outbound,
+  AttributeFilterClause$outboundSchema,
+} from "./attribute-filter-clause.js";
 import {
   CreatedAtFilter,
   CreatedAtFilter$Outbound,
@@ -40,29 +45,39 @@ import {
  */
 export type LongTermMemoryFilter = {
   /**
-   * Filter by the long-term memory sessionId field.
+   * Filter by the long-term memory sessionId field. Matching is case-sensitive.
    */
   sessionId?: SessionIdFilter | undefined;
   /**
-   * Filter by the long-term memory ownerId field.
+   * Filter by the long-term memory ownerId field. Matching is case-sensitive.
    */
   ownerId?: OwnerIdFilter | undefined;
   /**
-   * Filter by namespace.
+   * Filter by namespace. Matching is case-insensitive.
+   *
+   * @remarks
+   *
+   * Namespace is optional, so records without one need care. The positive operators (`eq`, `in`, `all`) require the field to be present and therefore never match a record that has no namespace — including memories extracted from a session that has none. `ne` is a plain negation and *does* match those records, so use `eq` or `in` when you need strict namespace isolation rather than `ne` against the namespaces you want to exclude.
+   *
+   * Omit this filter to search across every namespace, and use it to keep recall inside one project, workspace, team, environment, or tenant.
    */
   namespace?: NamespaceFilter | undefined;
   /**
-   * Filter by topics.
+   * Filter by topics. Matching is case-insensitive.
    */
   topics?: TopicsFilter | undefined;
   /**
-   * Filter by memory type.
+   * Filter by memory type. Matching is case-insensitive.
    */
   memoryType?: MemoryTypeFilter | undefined;
   /**
    * Filter by creation timestamp.
    */
   createdAt?: CreatedAtFilter | undefined;
+  /**
+   * Per-attribute filter clauses keyed by the custom memory type's field name.
+   */
+  attributes?: { [k: string]: AttributeFilterClause } | undefined;
 };
 
 /** @internal */
@@ -73,6 +88,7 @@ export type LongTermMemoryFilter$Outbound = {
   topics?: TopicsFilter$Outbound | undefined;
   memoryType?: MemoryTypeFilter$Outbound | undefined;
   createdAt?: CreatedAtFilter$Outbound | undefined;
+  attributes?: { [k: string]: AttributeFilterClause$Outbound } | undefined;
 };
 
 /** @internal */
@@ -87,6 +103,7 @@ export const LongTermMemoryFilter$outboundSchema: z.ZodType<
   topics: TopicsFilter$outboundSchema.optional(),
   memoryType: MemoryTypeFilter$outboundSchema.optional(),
   createdAt: CreatedAtFilter$outboundSchema.optional(),
+  attributes: z.record(AttributeFilterClause$outboundSchema).optional(),
 });
 
 export function longTermMemoryFilterToJSON(

package/src/models/memory-record.ts

@@ -7,7 +7,6 @@ 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 { MemoryType, MemoryType$inboundSchema } from "./memory-type.js";
 
 /**
  * A long-term memory record.
@@ -22,9 +21,9 @@ export type MemoryRecord = {
    */
   text: string;
   /**
-   * Type of long-term memory.
+   * Type of memory. Built-in or a custom type registered on the store.
    */
-  memoryType?: MemoryType | undefined;
+  memoryType?: string | undefined;
   /**
    * Session ID associated with this memory.
    */
@@ -34,13 +33,17 @@ export type MemoryRecord = {
    */
   ownerId?: string | undefined;
   /**
-   * Namespace for logical grouping.
+   * Namespace for logical grouping. Absent when the record has none: either it was written directly without one, or it was extracted from a session that has no namespace.
    */
   namespace?: string | undefined;
   /**
    * Topic tags for categorization.
    */
   topics?: Array<string> | undefined;
+  /**
+   * Structured record attributes: a map from the custom memory type's field name to that field's value. Values are arbitrary JSON matching the field's declared type (str, int, float, bool, list[str], list[float], or object).
+   */
+  attributes?: { [k: string]: any } | undefined;
   /**
    * Timestamp when the memory was created (UTC).
    */
@@ -59,11 +62,12 @@ export const MemoryRecord$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   text: z.string(),
-  memoryType: MemoryType$inboundSchema.optional(),
+  memoryType: z.string().optional(),
   sessionId: z.string().optional(),
   ownerId: z.string().optional(),
   namespace: z.string().optional(),
   topics: z.array(z.string()).optional(),
+  attributes: z.record(z.any()).optional(),
   createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });

package/src/models/memory-type-filter.ts

@@ -6,7 +6,7 @@
 import * as z from "zod/v3";
 
 /**
- * Filter by memory type.
+ * Filter by memory type. Matching is case-insensitive.
  */
 export type MemoryTypeFilter = {
   /**

package/src/models/namespace-filter.ts

@@ -6,7 +6,13 @@
 import * as z from "zod/v3";
 
 /**
- * Filter by namespace.
+ * Filter by namespace. Matching is case-insensitive.
+ *
+ * @remarks
+ *
+ * Namespace is optional, so records without one need care. The positive operators (`eq`, `in`, `all`) require the field to be present and therefore never match a record that has no namespace — including memories extracted from a session that has none. `ne` is a plain negation and *does* match those records, so use `eq` or `in` when you need strict namespace isolation rather than `ne` against the namespaces you want to exclude.
+ *
+ * Omit this filter to search across every namespace, and use it to keep recall inside one project, workspace, team, environment, or tenant.
  */
 export type NamespaceFilter = {
   /**

package/src/models/operations/get-session-memory.ts

@@ -14,11 +14,16 @@ export type GetSessionMemoryRequest = {
    * The session ID.
    */
   sessionId: string;
+  /**
+   * When true, the response includes events that have already been covered by the session summary and have not yet been cleaned up. This flag is not expected to be set under normal usage.
+   */
+  includeSummarisedEvents?: boolean | undefined;
 };
 
 /** @internal */
 export type GetSessionMemoryRequest$Outbound = {
   sessionId: string;
+  includeSummarisedEvents?: boolean | undefined;
 };
 
 /** @internal */
@@ -28,6 +33,7 @@ export const GetSessionMemoryRequest$outboundSchema: z.ZodType<
   GetSessionMemoryRequest
 > = z.object({
   sessionId: z.string(),
+  includeSummarisedEvents: z.boolean().optional(),
 });
 
 export function getSessionMemoryRequestToJSON(

package/src/models/operations/index.ts

@@ -13,4 +13,6 @@ export * from "./get-session-event.js";
 export * from "./get-session-memory.js";
 export * from "./list-sessions.js";
 export * from "./search-long-term-memory.js";
+export * from "./store-health.js";
+export * from "./update-long-term-memory-fields.js";
 export * from "./update-long-term-memory.js";

package/src/models/operations/list-sessions.ts

@@ -18,12 +18,22 @@ export type ListSessionsRequest = {
    * Opaque token from a previous response for the next page.
    */
   pageToken?: string | undefined;
+  /**
+   * Filter sessions by owner. Matching is case-sensitive. Mutually exclusive with includeAll.
+   */
+  filterOwnerId?: string | undefined;
+  /**
+   * Set to true to list all sessions. Required when no filter is given; mutually exclusive with filters.
+   */
+  includeAll?: boolean | undefined;
 };
 
 /** @internal */
 export type ListSessionsRequest$Outbound = {
   limit: number;
   pageToken?: string | undefined;
+  filterOwnerId?: string | undefined;
+  includeAll?: boolean | undefined;
 };
 
 /** @internal */
@@ -34,6 +44,8 @@ export const ListSessionsRequest$outboundSchema: z.ZodType<
 > = z.object({
   limit: z.number().int().default(100),
   pageToken: z.string().optional(),
+  filterOwnerId: z.string().optional(),
+  includeAll: z.boolean().optional(),
 });
 
 export function listSessionsRequestToJSON(

package/src/models/operations/store-health.ts

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3740112e1f1e
+ */
+
+import * as z from "zod/v3";
+
+export type StoreHealthGlobals = {
+  storeId?: string | undefined;
+};
+
+export type StoreHealthRequest = {};
+
+/** @internal */
+export type StoreHealthRequest$Outbound = {};
+
+/** @internal */
+export const StoreHealthRequest$outboundSchema: z.ZodType<
+  StoreHealthRequest$Outbound,
+  z.ZodTypeDef,
+  StoreHealthRequest
+> = z.object({});
+
+export function storeHealthRequestToJSON(
+  storeHealthRequest: StoreHealthRequest,
+): string {
+  return JSON.stringify(
+    StoreHealthRequest$outboundSchema.parse(storeHealthRequest),
+  );
+}

package/src/models/operations/update-long-term-memory-fields.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 16560932b47d
+ */
+
+import * as z from "zod/v3";
+import * as models from "../index.js";
+
+export type UpdateLongTermMemoryFieldsGlobals = {
+  storeId?: string | undefined;
+};
+
+export type UpdateLongTermMemoryFieldsRequest = {
+  /**
+   * The memory record ID.
+   */
+  memoryId: string;
+  body: models.UpdateLongTermMemoryFieldsRequestContent;
+};
+
+/** @internal */
+export type UpdateLongTermMemoryFieldsRequest$Outbound = {
+  memoryId: string;
+  body: models.UpdateLongTermMemoryFieldsRequestContent$Outbound;
+};
+
+/** @internal */
+export const UpdateLongTermMemoryFieldsRequest$outboundSchema: z.ZodType<
+  UpdateLongTermMemoryFieldsRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateLongTermMemoryFieldsRequest
+> = z.object({
+  memoryId: z.string(),
+  body: models.UpdateLongTermMemoryFieldsRequestContent$outboundSchema,
+});
+
+export function updateLongTermMemoryFieldsRequestToJSON(
+  updateLongTermMemoryFieldsRequest: UpdateLongTermMemoryFieldsRequest,
+): string {
+  return JSON.stringify(
+    UpdateLongTermMemoryFieldsRequest$outboundSchema.parse(
+      updateLongTermMemoryFieldsRequest,
+    ),
+  );
+}

package/src/models/owner-id-filter.ts

@@ -6,7 +6,7 @@
 import * as z from "zod/v3";
 
 /**
- * Filter by the long-term memory ownerId field.
+ * Filter by the long-term memory ownerId field. Matching is case-sensitive.
  */
 export type OwnerIdFilter = {
   /**

package/src/models/session-id-filter.ts

@@ -6,7 +6,7 @@
 import * as z from "zod/v3";
 
 /**
- * Filter by the long-term memory sessionId field.
+ * Filter by the long-term memory sessionId field. Matching is case-sensitive.
  */
 export type SessionIdFilter = {
   /**

package/src/models/session-summary.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1dc482213cab
+ */
+
+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";
+
+/**
+ * Compacted summary of older session history for a session.
+ *
+ * @remarks
+ *
+ * This is derived session state maintained by the background summarization workflow, not a conversation event. It is present only after at least one summarization cycle has completed.
+ */
+export type SessionSummary = {
+  /**
+   * The summary text, a single coherent block.
+   */
+  text: string;
+  /**
+   * Boundary event ID. This event and all events before it (by array position) are covered by the summary; `events` contains the retained turns after this boundary.
+   */
+  summarizedUpToEventId: string;
+  /**
+   * Timestamp when the summary was first created (UTC). Preserved across re-summarization cycles.
+   */
+  createdAt: Date;
+  /**
+   * Timestamp when the summary was last regenerated (UTC). Updated on every summarization cycle. Equal to createdAt on the first cycle.
+   */
+  updatedAt: Date;
+  /**
+   * Metadata as a JSON object (e.g., model name, token count). Always present; defaults to an empty object when no metadata was supplied.
+   */
+  metadata?: any | undefined;
+  /**
+   * Cumulative number of session events folded into this summary across all summarization cycles. Always positive. A value of 1 may indicate a summary created before this field was tracked; it self-corrects to a real count on the next summarization cycle.
+   */
+  summarizedEvents: number;
+};
+
+/** @internal */
+export const SessionSummary$inboundSchema: z.ZodType<
+  SessionSummary,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+  summarizedUpToEventId: z.string(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  metadata: z.any().optional(),
+  summarizedEvents: z.number().int(),
+});
+
+export function sessionSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<SessionSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SessionSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SessionSummary' from JSON`,
+  );
+}

package/src/models/store-health-feature.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b5d2d2b8c673
+ */
+
+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 {
+  StoreHealthStatus,
+  StoreHealthStatus$inboundSchema,
+} from "./store-health-status.js";
+
+/**
+ * Feature-level store health.
+ */
+export type StoreHealthFeature = {
+  /**
+   * Store health status.
+   */
+  status: StoreHealthStatus;
+};
+
+/** @internal */
+export const StoreHealthFeature$inboundSchema: z.ZodType<
+  StoreHealthFeature,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: StoreHealthStatus$inboundSchema,
+});
+
+export function storeHealthFeatureFromJSON(
+  jsonString: string,
+): SafeParseResult<StoreHealthFeature, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoreHealthFeature$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoreHealthFeature' from JSON`,
+  );
+}

package/src/models/store-health-response-content.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b8bf87d488ff
+ */
+
+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 {
+  StoreHealthFeature,
+  StoreHealthFeature$inboundSchema,
+} from "./store-health-feature.js";
+import {
+  StoreHealthStatus,
+  StoreHealthStatus$inboundSchema,
+} from "./store-health-status.js";
+
+/**
+ * Store-scoped RAM feature health.
+ */
+export type StoreHealthResponseContent = {
+  /**
+   * Store health status.
+   */
+  status: StoreHealthStatus;
+  features: { [k: string]: StoreHealthFeature };
+};
+
+/** @internal */
+export const StoreHealthResponseContent$inboundSchema: z.ZodType<
+  StoreHealthResponseContent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: StoreHealthStatus$inboundSchema,
+  features: z.record(StoreHealthFeature$inboundSchema),
+});
+
+export function storeHealthResponseContentFromJSON(
+  jsonString: string,
+): SafeParseResult<StoreHealthResponseContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoreHealthResponseContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoreHealthResponseContent' from JSON`,
+  );
+}

package/src/models/store-health-status.ts

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d59e984c90e9
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+/**
+ * Store health status.
+ */
+export const StoreHealthStatus = {
+  Healthy: "healthy",
+  Degraded: "degraded",
+  Unavailable: "unavailable",
+} as const;
+/**
+ * Store health status.
+ */
+export type StoreHealthStatus = OpenEnum<typeof StoreHealthStatus>;
+
+/** @internal */
+export const StoreHealthStatus$inboundSchema: z.ZodType<
+  StoreHealthStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(StoreHealthStatus);

package/src/models/topics-filter.ts

@@ -6,7 +6,7 @@
 import * as z from "zod/v3";
 
 /**
- * Filter by topics.
+ * Filter by topics. Matching is case-insensitive.
  */
 export type TopicsFilter = {
   /**

package/src/models/update-long-term-memory-fields-request-content.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3e5d9fd9c7a3
+ */
+
+import * as z from "zod/v3";
+
+/**
+ * Type- and namespace-scoped field update request for a custom-typed long-term memory record.
+ */
+export type UpdateLongTermMemoryFieldsRequestContent = {
+  /**
+   * The caller's bound memory type. The update is rejected unless the record's stored memoryType matches.
+   */
+  memoryType: string;
+  /**
+   * The caller's namespace. The update is rejected with 409 unless the record's stored namespace matches exactly.
+   *
+   * @remarks
+   *
+   * Omit it to assert that the record has no namespace — an omitted value matches only records stored without one, it does not mean "any namespace". The check is applied atomically with the update, so a record cannot be re-filed into another namespace between the check and the write.
+   */
+  namespace?: string | undefined;
+  /**
+   * Updated text content (1-50000 chars). Omit to leave the text unchanged.
+   */
+  text?: string | undefined;
+  /**
+   * Structured record attributes: a map from the custom memory type's field name to that field's value. Values are arbitrary JSON matching the field's declared type (str, int, float, bool, list[str], list[float], or object).
+   */
+  attributes?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export type UpdateLongTermMemoryFieldsRequestContent$Outbound = {
+  memoryType: string;
+  namespace?: string | undefined;
+  text?: string | undefined;
+  attributes?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const UpdateLongTermMemoryFieldsRequestContent$outboundSchema: z.ZodType<
+  UpdateLongTermMemoryFieldsRequestContent$Outbound,
+  z.ZodTypeDef,
+  UpdateLongTermMemoryFieldsRequestContent
+> = z.object({
+  memoryType: z.string(),
+  namespace: z.string().optional(),
+  text: z.string().optional(),
+  attributes: z.record(z.any()).optional(),
+});
+
+export function updateLongTermMemoryFieldsRequestContentToJSON(
+  updateLongTermMemoryFieldsRequestContent:
+    UpdateLongTermMemoryFieldsRequestContent,
+): string {
+  return JSON.stringify(
+    UpdateLongTermMemoryFieldsRequestContent$outboundSchema.parse(
+      updateLongTermMemoryFieldsRequestContent,
+    ),
+  );
+}

package/src/models/update-long-term-memory-request-content.ts

@@ -4,7 +4,6 @@
  */
 
 import * as z from "zod/v3";
-import { MemoryType, MemoryType$outboundSchema } from "./memory-type.js";
 
 /**
  * Partial update request for a long-term memory record.
@@ -15,19 +14,23 @@ export type UpdateLongTermMemoryRequestContent = {
    */
   text?: string | undefined;
   /**
-   * Type of long-term memory.
+   * Updated memory type. Built-in or a custom type registered on the store.
    */
-  memoryType?: MemoryType | undefined;
+  memoryType?: string | undefined;
   /**
    * Updated topics (max 50 topics, each 1-100 chars).
    */
   topics?: Array<string> | undefined;
   /**
    * Updated namespace. When provided, must be 1-64 chars alphanumeric and dashes; omit the field or send an empty string to clear.
+   *
+   * @remarks
+   *
+   * This is the only way to change the namespace of an existing record, including one produced by extraction: a record inherits its session's namespace at creation and is not revised afterwards, so use this to re-file a record or to add a namespace to one created before the session had any.
    */
   namespace?: string | undefined;
   /**
-   * Updated owner ID. When provided, must be 1-64 chars alphanumeric and dashes; omit the field or send an empty string to clear.
+   * Updated owner ID. When provided, must be 1-64 chars alphanumeric and dashes and non-empty; omit the field to leave unchanged. Clearing is not supported because ownerId is required.
    */
   ownerId?: string | undefined;
   /**
@@ -53,7 +56,7 @@ export const UpdateLongTermMemoryRequestContent$outboundSchema: z.ZodType<
   UpdateLongTermMemoryRequestContent
 > = z.object({
   text: z.string().optional(),
-  memoryType: MemoryType$outboundSchema.optional(),
+  memoryType: z.string().optional(),
   topics: z.array(z.string()).optional(),
   namespace: z.string().optional(),
   ownerId: z.string().optional(),

package/src/models/update-long-term-memory-response-content.ts

@@ -7,7 +7,6 @@ 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 { MemoryType, MemoryType$inboundSchema } from "./memory-type.js";
 
 /**
  * A long-term memory record.
@@ -22,9 +21,9 @@ export type UpdateLongTermMemoryResponseContent = {
    */
   text: string;
   /**
-   * Type of long-term memory.
+   * Type of memory. Built-in or a custom type registered on the store.
    */
-  memoryType?: MemoryType | undefined;
+  memoryType?: string | undefined;
   /**
    * Session ID associated with this memory.
    */
@@ -34,13 +33,17 @@ export type UpdateLongTermMemoryResponseContent = {
    */
   ownerId?: string | undefined;
   /**
-   * Namespace for logical grouping.
+   * Namespace for logical grouping. Absent when the record has none: either it was written directly without one, or it was extracted from a session that has no namespace.
    */
   namespace?: string | undefined;
   /**
    * Topic tags for categorization.
    */
   topics?: Array<string> | undefined;
+  /**
+   * Structured record attributes: a map from the custom memory type's field name to that field's value. Values are arbitrary JSON matching the field's declared type (str, int, float, bool, list[str], list[float], or object).
+   */
+  attributes?: { [k: string]: any } | undefined;
   /**
    * Timestamp when the memory was created (UTC).
    */
@@ -59,11 +62,12 @@ export const UpdateLongTermMemoryResponseContent$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   text: z.string(),
-  memoryType: MemoryType$inboundSchema.optional(),
+  memoryType: z.string().optional(),
   sessionId: z.string().optional(),
   ownerId: z.string().optional(),
   namespace: z.string().optional(),
   topics: z.array(z.string()).optional(),
+  attributes: z.record(z.any()).optional(),
   createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });