@redis-iris/agent-memory 0.1.0 → 0.2.0

package/src/funcs/update-long-term-memory-fields.ts

@@ -0,0 +1,220 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e08db4fff588
+ */
+
+import * as z from "zod/v3";
+import { AgentMemoryCore } from "../core.js";
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { AgentMemoryError } from "../models/errors/agent-memory-error.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/http-client-errors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Atomically updates a custom-typed long-term memory's text and/or attributes, scoped to the caller's bound memory type. Used by the custom-extraction worker.
+ */
+export function updateLongTermMemoryFields(
+  client: AgentMemoryCore,
+  memoryId: string,
+  body: models.UpdateLongTermMemoryFieldsRequestContent,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    void,
+    | errors.BadRequestErrorResponseContent
+    | errors.AuthenticationErrorResponseContent
+    | errors.ForbiddenErrorResponseContent
+    | errors.NotFoundErrorResponseContent
+    | errors.TimeoutErrorResponseContent
+    | errors.FailedDependencyErrorResponseContent
+    | errors.TooManyRequestsErrorResponseContent
+    | errors.UnexpectedErrorResponseContent
+    | AgentMemoryError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    memoryId,
+    body,
+    options,
+  ));
+}
+
+async function $do(
+  client: AgentMemoryCore,
+  memoryId: string,
+  body: models.UpdateLongTermMemoryFieldsRequestContent,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      void,
+      | errors.BadRequestErrorResponseContent
+      | errors.AuthenticationErrorResponseContent
+      | errors.ForbiddenErrorResponseContent
+      | errors.NotFoundErrorResponseContent
+      | errors.TimeoutErrorResponseContent
+      | errors.FailedDependencyErrorResponseContent
+      | errors.TooManyRequestsErrorResponseContent
+      | errors.UnexpectedErrorResponseContent
+      | AgentMemoryError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const input: operations.UpdateLongTermMemoryFieldsRequest = {
+    memoryId: memoryId,
+    body: body,
+  };
+
+  const parsed = safeParse(
+    input,
+    (value) =>
+      operations.UpdateLongTermMemoryFieldsRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body$ = encodeJSON("body", payload.body, { explode: true });
+
+  const pathParams = {
+    memoryId: encodeSimple("memoryId", payload.memoryId, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+    storeId: encodeSimple("storeId", client._options.storeId, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+  const path = pathToFunc(
+    "/v1/stores/{storeId}/long-term-memory/{memoryId}/fields",
+  )(pathParams);
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "UpdateLongTermMemoryFields",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body$,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    void,
+    | errors.BadRequestErrorResponseContent
+    | errors.AuthenticationErrorResponseContent
+    | errors.ForbiddenErrorResponseContent
+    | errors.NotFoundErrorResponseContent
+    | errors.TimeoutErrorResponseContent
+    | errors.FailedDependencyErrorResponseContent
+    | errors.TooManyRequestsErrorResponseContent
+    | errors.UnexpectedErrorResponseContent
+    | AgentMemoryError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.nil(200, z.void()),
+    M.jsonErr(400, errors.BadRequestErrorResponseContent$inboundSchema),
+    M.jsonErr(401, errors.AuthenticationErrorResponseContent$inboundSchema),
+    M.jsonErr(403, errors.ForbiddenErrorResponseContent$inboundSchema),
+    M.jsonErr(404, errors.NotFoundErrorResponseContent$inboundSchema),
+    M.jsonErr(408, errors.TimeoutErrorResponseContent$inboundSchema),
+    M.jsonErr(424, errors.FailedDependencyErrorResponseContent$inboundSchema),
+    M.jsonErr(429, errors.TooManyRequestsErrorResponseContent$inboundSchema),
+    M.jsonErr(500, errors.UnexpectedErrorResponseContent$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -49,8 +49,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.1.0",
-  genVersion: "2.907.0",
+  sdkVersion: "0.2.0",
+  genVersion: "2.926.8",
   userAgent:
-    "speakeasy-sdk/typescript 0.1.0 2.907.0 1.0.0 @redis-iris/agent-memory",
+    "speakeasy-sdk/typescript 0.2.0 2.926.8 1.0.0 @redis-iris/agent-memory",
 } as const;

package/src/lib/http.ts

@@ -46,8 +46,10 @@ export class HTTPClient {
   private requestHooks: BeforeRequestHook[] = [];
   private requestErrorHooks: RequestErrorHook[] = [];
   private responseHooks: ResponseHook[] = [];
+  private options: HTTPClientOptions;
 
-  constructor(private options: HTTPClientOptions = {}) {
+  constructor(options: HTTPClientOptions = {}) {
+    this.options = options;
     this.fetcher = options.fetcher || DEFAULT_FETCHER;
   }
 

package/src/lib/security.ts

@@ -14,17 +14,22 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export enum SecurityErrorCode {
-  Incomplete = "incomplete",
-  UnrecognisedSecurityType = "unrecognized_security_type",
-}
+export const SecurityErrorCode = {
+  Incomplete: "incomplete",
+  UnrecognisedSecurityType: "unrecognized_security_type",
+} as const;
+export type SecurityErrorCode =
+  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 
 export class SecurityError extends Error {
+  public code: SecurityErrorCode;
+
   constructor(
-    public code: SecurityErrorCode,
+    code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
+    this.code = code;
     this.name = "SecurityError";
   }
 

package/src/models/add-session-event-request-content.ts

@@ -20,6 +20,14 @@ export type AddSessionEventRequestContent = {
    * Unique actor identifier (1-255 chars). Can represent a user, agent, or any participant.
    */
   actorId: string;
+  /**
+   * Optional namespace for the session, used as the namespace of every long-term memory extracted from it.
+   *
+   * @remarks
+   *
+   * Like `ownerId`, this is a session-level value taken from the first event: the value sent with the first event of a session is stored on the session, and values sent with later events are ignored. Omit it to leave extracted memories without a namespace.
+   */
+  namespace?: string | undefined;
   /**
    * Message role for session events.
    */
@@ -42,6 +50,7 @@ export type AddSessionEventRequestContent = {
 export type AddSessionEventRequestContent$Outbound = {
   sessionId?: string | undefined;
   actorId: string;
+  namespace?: string | undefined;
   role: string;
   content: Array<Content$Outbound>;
   createdAt: string;
@@ -56,6 +65,7 @@ export const AddSessionEventRequestContent$outboundSchema: z.ZodType<
 > = z.object({
   sessionId: z.string().optional(),
   actorId: z.string(),
+  namespace: z.string().optional(),
   role: MessageRole$outboundSchema,
   content: z.array(Content$outboundSchema),
   createdAt: z.date().transform(v => v.toISOString()),

package/src/models/attribute-filter-clause.ts

@@ -0,0 +1,135 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9e2e283a0e23
+ */
+
+import * as z from "zod/v3";
+
+export type List = {
+  /**
+   * Match a list attribute that contains all of these values.
+   */
+  list: Array<string>;
+};
+
+export type Boolean = {
+  /**
+   * Match a boolean attribute equal to this value.
+   */
+  boolean: boolean;
+};
+
+export type NumberT = {
+  /**
+   * Match a numeric attribute equal to this value.
+   */
+  number: number;
+};
+
+export type String = {
+  /**
+   * Match a string attribute equal to this value.
+   */
+  string: string;
+};
+
+/**
+ * Filter clause for a single record attribute. Exactly one member is set; the member must match the attribute's declared field type.
+ */
+export type AttributeFilterClause = String | NumberT | Boolean | List;
+
+/** @internal */
+export type List$Outbound = {
+  list: Array<string>;
+};
+
+/** @internal */
+export const List$outboundSchema: z.ZodType<List$Outbound, z.ZodTypeDef, List> =
+  z.object({
+    list: z.array(z.string()),
+  });
+
+export function listToJSON(list: List): string {
+  return JSON.stringify(List$outboundSchema.parse(list));
+}
+
+/** @internal */
+export type Boolean$Outbound = {
+  boolean: boolean;
+};
+
+/** @internal */
+export const Boolean$outboundSchema: z.ZodType<
+  Boolean$Outbound,
+  z.ZodTypeDef,
+  Boolean
+> = z.object({
+  boolean: z.boolean(),
+});
+
+export function booleanToJSON(value: Boolean): string {
+  return JSON.stringify(Boolean$outboundSchema.parse(value));
+}
+
+/** @internal */
+export type NumberT$Outbound = {
+  number: number;
+};
+
+/** @internal */
+export const NumberT$outboundSchema: z.ZodType<
+  NumberT$Outbound,
+  z.ZodTypeDef,
+  NumberT
+> = z.object({
+  number: z.number(),
+});
+
+export function numberToJSON(numberT: NumberT): string {
+  return JSON.stringify(NumberT$outboundSchema.parse(numberT));
+}
+
+/** @internal */
+export type String$Outbound = {
+  string: string;
+};
+
+/** @internal */
+export const String$outboundSchema: z.ZodType<
+  String$Outbound,
+  z.ZodTypeDef,
+  String
+> = z.object({
+  string: z.string(),
+});
+
+export function stringToJSON(string: String): string {
+  return JSON.stringify(String$outboundSchema.parse(string));
+}
+
+/** @internal */
+export type AttributeFilterClause$Outbound =
+  | String$Outbound
+  | NumberT$Outbound
+  | Boolean$Outbound
+  | List$Outbound;
+
+/** @internal */
+export const AttributeFilterClause$outboundSchema: z.ZodType<
+  AttributeFilterClause$Outbound,
+  z.ZodTypeDef,
+  AttributeFilterClause
+> = z.union([
+  z.lazy(() => String$outboundSchema),
+  z.lazy(() => NumberT$outboundSchema),
+  z.lazy(() => Boolean$outboundSchema),
+  z.lazy(() => List$outboundSchema),
+]);
+
+export function attributeFilterClauseToJSON(
+  attributeFilterClause: AttributeFilterClause,
+): string {
+  return JSON.stringify(
+    AttributeFilterClause$outboundSchema.parse(attributeFilterClause),
+  );
+}

package/src/models/create-memory-record.ts

@@ -4,7 +4,6 @@
  */
 
 import * as z from "zod/v3";
-import { MemoryType, MemoryType$outboundSchema } from "./memory-type.js";
 
 /**
  * A memory record to create.
@@ -19,9 +18,9 @@ export type CreateMemoryRecord = {
    */
   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 (1-64 chars, alphanumeric and dashes).
    */
@@ -29,15 +28,19 @@ export type CreateMemoryRecord = {
   /**
    * Owner ID associated with this memory (1-64 chars, alphanumeric and dashes).
    */
-  ownerId?: string | undefined;
+  ownerId: string;
   /**
-   * Namespace for logical grouping (1-64 chars, alphanumeric and dashes).
+   * Optional namespace for logical grouping (1-64 chars, alphanumeric and dashes). Omit to create the record without a namespace. Records created here are explicit writes, so this value is taken as given; extraction instead inherits the source session's namespace.
    */
   namespace?: string | undefined;
   /**
    * Topic tags for categorization (max 50 topics, each 1-100 chars).
    */
   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;
 };
 
 /** @internal */
@@ -46,9 +49,10 @@ export type CreateMemoryRecord$Outbound = {
   text: string;
   memoryType?: string | undefined;
   sessionId?: string | undefined;
-  ownerId?: string | undefined;
+  ownerId: string;
   namespace?: string | undefined;
   topics?: Array<string> | undefined;
+  attributes?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
@@ -59,11 +63,12 @@ export const CreateMemoryRecord$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   text: z.string(),
-  memoryType: MemoryType$outboundSchema.optional(),
+  memoryType: z.string().optional(),
   sessionId: z.string().optional(),
-  ownerId: z.string().optional(),
+  ownerId: z.string(),
   namespace: z.string().optional(),
   topics: z.array(z.string()).optional(),
+  attributes: z.record(z.any()).optional(),
 });
 
 export function createMemoryRecordToJSON(

package/src/models/get-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 GetLongTermMemoryResponseContent = {
    */
   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 GetLongTermMemoryResponseContent = {
    */
   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 GetLongTermMemoryResponseContent$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/get-session-memory-response-content.ts

@@ -8,6 +8,10 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 import { SessionEvent, SessionEvent$inboundSchema } from "./session-event.js";
+import {
+  SessionSummary,
+  SessionSummary$inboundSchema,
+} from "./session-summary.js";
 
 /**
  * Session memory state for a session.
@@ -22,9 +26,21 @@ export type GetSessionMemoryResponseContent = {
    */
   ownerId: string;
   /**
-   * Events stored in this session.
+   * The namespace of the session, set from the namespace of the first event. Absent when the first event did not supply one; long-term memories extracted from this session then carry no namespace.
+   */
+  namespace?: string | undefined;
+  /**
+   * Conversation events retained for this session. When summarization is enabled, events already covered by the summary are excluded unless `includeSummarisedEvents` is set; the compacted summary is returned separately in `summary`.
    */
   events: Array<SessionEvent>;
+  /**
+   * 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.
+   */
+  summary?: SessionSummary | undefined;
 };
 
 /** @internal */
@@ -35,7 +51,9 @@ export const GetSessionMemoryResponseContent$inboundSchema: z.ZodType<
 > = z.object({
   sessionId: z.string(),
   ownerId: z.string(),
+  namespace: z.string().optional(),
   events: z.array(SessionEvent$inboundSchema),
+  summary: SessionSummary$inboundSchema.optional(),
 });
 
 export function getSessionMemoryResponseContentFromJSON(

package/src/models/index.ts

@@ -5,6 +5,7 @@
 
 export * from "./add-session-event-request-content.js";
 export * from "./add-session-event-response-content.js";
+export * from "./attribute-filter-clause.js";
 export * from "./authentication-error-type.js";
 export * from "./bad-request-error-type.js";
 export * from "./bulk-create-long-term-memories-request-content.js";
@@ -28,7 +29,6 @@ export * from "./list-sessions-response-content.js";
 export * from "./long-term-memory-filter.js";
 export * from "./memory-record.js";
 export * from "./memory-type-filter.js";
-export * from "./memory-type.js";
 export * from "./message-role.js";
 export * from "./namespace-filter.js";
 export * from "./not-found-error-type.js";
@@ -39,9 +39,14 @@ export * from "./search-long-term-memory-response-content.js";
 export * from "./security.js";
 export * from "./session-event.js";
 export * from "./session-id-filter.js";
+export * from "./session-summary.js";
+export * from "./store-health-feature.js";
+export * from "./store-health-response-content.js";
+export * from "./store-health-status.js";
 export * from "./timeout-error-type.js";
 export * from "./too-many-requests-error-type.js";
 export * from "./topics-filter.js";
 export * from "./unexpected-error-type.js";
+export * from "./update-long-term-memory-fields-request-content.js";
 export * from "./update-long-term-memory-request-content.js";
 export * from "./update-long-term-memory-response-content.js";