@redis-iris/agent-memory 0.0.4 → 0.1.0

package/src/funcs/bulk-create-long-term-memories.ts

@@ -189,7 +189,7 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(200, models.BulkCreateLongTermMemoriesResponseContent$inboundSchema),
+    M.json(201, models.BulkCreateLongTermMemoriesResponseContent$inboundSchema),
     M.jsonErr(400, errors.BadRequestErrorResponseContent$inboundSchema),
     M.jsonErr(401, errors.AuthenticationErrorResponseContent$inboundSchema),
     M.jsonErr(403, errors.ForbiddenErrorResponseContent$inboundSchema),

package/src/hooks/types.ts

@@ -16,6 +16,7 @@ export type HookContext = {
   retryConfig: RetryConfig;
   resolvedSecurity: SecurityState | null;
   options: SDKOptions;
+  timeoutMs?: number;
 };
 
 export type Awaitable<T> = T | Promise<T>;

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.0.4",
-  genVersion: "2.884.0",
+  sdkVersion: "0.1.0",
+  genVersion: "2.907.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.0.4 2.884.0 1.0.0 @redis-iris/agent-memory",
+    "speakeasy-sdk/typescript 0.1.0 2.907.0 1.0.0 @redis-iris/agent-memory",
 } as const;

package/src/lib/encodings.ts

@@ -4,7 +4,7 @@
  */
 
 import { bytesToBase64 } from "./base64.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export class EncodingError extends Error {
   constructor(message: string) {

package/src/lib/env.ts

@@ -5,7 +5,6 @@
 
 import * as z from "zod/v3";
 import { SDKOptions } from "./config.js";
-import { dlv } from "./dlv.js";
 
 export interface Env {
   AGENT_MEMORY_API_KEY?: string | undefined;
@@ -47,11 +46,16 @@ export function env(): Env {
     return envMemo;
   }
 
+  const globals = globalThis as {
+    Deno?: { env?: { toObject?: () => Record<string, string | undefined> } };
+    process?: { env?: Record<string, string | undefined> };
+  };
+
   let envObject: Record<string, unknown> = {};
   if (isDeno()) {
-    envObject = (globalThis as any).Deno?.env?.toObject?.() ?? {};
+    envObject = globals.Deno?.env?.toObject?.() ?? {};
   } else {
-    envObject = dlv(globalThis, "process.env") ?? {};
+    envObject = globals.process?.env ?? {};
   }
 
   envMemo = envSchema.parse(envObject);

package/src/lib/matchers.ts

@@ -7,7 +7,7 @@ import { AgentMemoryDefaultError } from "../models/errors/agent-memory-default-e
 import { ResponseValidationError } from "../models/errors/response-validation-error.js";
 import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export type Encoding =
   | "jsonl"

package/src/lib/primitives.ts

@@ -149,3 +149,19 @@ export function allRequired<V extends Record<string, unknown>>(
 
   return v as ReturnType<typeof allRequired<V>>;
 }
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype) return true;
+  // cross-realm plain objects (vm contexts, iframes) inherit from a
+  // different realm's Object.prototype, which itself has a null prototype
+  try {
+    return Object.getPrototypeOf(proto) === null;
+  } catch {
+    return false;
+  }
+}

package/src/lib/retries.ts

@@ -195,6 +195,14 @@ async function retryBackoff(
 }
 
 function retryIntervalFromResponse(res: Response): number {
+  const retryAfterMsVal = res.headers.get("retry-after-ms");
+  if (retryAfterMsVal) {
+    const parsedMs = Number(retryAfterMsVal);
+    if (Number.isFinite(parsedMs) && parsedMs >= 0) {
+      return parsedMs;
+    }
+  }
+
   const retryVal = res.headers.get("retry-after") || "";
   if (!retryVal) {
     return 0;

package/src/lib/sdks.ts

@@ -25,6 +25,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -132,27 +133,55 @@ export class ClientSDK {
     if (path) {
       baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
       reqURL = new URL(path, baseURL);
+      if (!reqURL.search && baseURL.search) {
+        reqURL.search = baseURL.search;
+      }
     } else {
       reqURL = baseURL;
     }
     reqURL.hash = "";
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
+    // Appends already-encoded query pairs to a query string, replacing any
+    // existing pairs with the same key so later sources take precedence.
+    const mergeQuery = (current: string, additions: string): string => {
+      if (!additions) {
+        return current;
       }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
+      const additionKeys = new Set(
+        additions
+          .split("&")
+          .filter((pair) => pair !== "")
+          .map((pair) => pair.split("=")[0] ?? ""),
+      );
+      const kept = current.split("&").filter((pair) => {
+        return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+      });
+      return [...kept, additions].join("&");
+    };
+
+    const encodeQueryRecord = (record: Record<string, unknown>): string => {
+      return Object.entries(record)
+        .map(([k, v]) => {
+          if (v == null) {
+            return undefined;
+          }
+          const value = v;
+          return encodeForm(k, value, {
+            explode: Array.isArray(value),
+            charEncoding: "percent",
+          });
+        })
+        .filter((pair): pair is string => typeof pair !== "undefined")
+        .join("&");
+    };
+
+    const finalQuery = [
+      query || "",
+      encodeQueryRecord(security?.queryParams || {}),
+    ].reduce(mergeQuery, reqURL.search.slice(1));
 
     if (finalQuery) {
-      const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-      reqURL.search = `?${q}`;
+      reqURL.search = `?${finalQuery}`;
     }
 
     const headers = new Headers(opHeaders);
@@ -198,9 +227,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -247,10 +275,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );

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

@@ -29,9 +29,9 @@ export type AddSessionEventRequestContent = {
    */
   content: Array<Content>;
   /**
-   * Timestamp when the event was created in milliseconds.
+   * Client-supplied timestamp for when the event happened (UTC).
    */
-  createdAt: number;
+  createdAt: Date;
   /**
    * Optional metadata as any valid JSON value.
    */
@@ -44,7 +44,7 @@ export type AddSessionEventRequestContent$Outbound = {
   actorId: string;
   role: string;
   content: Array<Content$Outbound>;
-  createdAt: number;
+  createdAt: string;
   metadata?: any | undefined;
 };
 
@@ -58,7 +58,7 @@ export const AddSessionEventRequestContent$outboundSchema: z.ZodType<
   actorId: z.string(),
   role: MessageRole$outboundSchema,
   content: z.array(Content$outboundSchema),
-  createdAt: z.number().int(),
+  createdAt: z.date().transform(v => v.toISOString()),
   metadata: z.any().optional(),
 });
 

package/src/models/created-at-filter.ts

@@ -10,34 +10,34 @@ import * as z from "zod/v3";
  */
 export type CreatedAtFilter = {
   /**
-   * Greater than the given value.
+   * After the given timestamp.
    */
-  gt?: number | undefined;
+  gt?: Date | undefined;
   /**
-   * Less than the given value.
+   * At or after the given timestamp.
    */
-  lt?: number | undefined;
+  gte?: Date | undefined;
   /**
-   * Greater than or equal to the given value.
+   * Before the given timestamp.
    */
-  gte?: number | undefined;
+  lt?: Date | undefined;
   /**
-   * Less than or equal to the given value.
+   * At or before the given timestamp.
    */
-  lte?: number | undefined;
+  lte?: Date | undefined;
   /**
-   * Equals the given value.
+   * Exactly at the given timestamp.
    */
-  eq?: number | undefined;
+  eq?: Date | undefined;
 };
 
 /** @internal */
 export type CreatedAtFilter$Outbound = {
-  gt?: number | undefined;
-  lt?: number | undefined;
-  gte?: number | undefined;
-  lte?: number | undefined;
-  eq?: number | undefined;
+  gt?: string | undefined;
+  gte?: string | undefined;
+  lt?: string | undefined;
+  lte?: string | undefined;
+  eq?: string | undefined;
 };
 
 /** @internal */
@@ -46,11 +46,11 @@ export const CreatedAtFilter$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreatedAtFilter
 > = z.object({
-  gt: z.number().int().optional(),
-  lt: z.number().int().optional(),
-  gte: z.number().int().optional(),
-  lte: z.number().int().optional(),
-  eq: z.number().int().optional(),
+  gt: z.date().transform(v => v.toISOString()).optional(),
+  gte: z.date().transform(v => v.toISOString()).optional(),
+  lt: z.date().transform(v => v.toISOString()).optional(),
+  lte: z.date().transform(v => v.toISOString()).optional(),
+  eq: z.date().transform(v => v.toISOString()).optional(),
 });
 
 export function createdAtFilterToJSON(

package/src/models/failed-dependency-error-type.ts

@@ -4,7 +4,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * Problem type URI for failed-dependency errors.
@@ -16,11 +17,13 @@ export const FailedDependencyErrorType = {
 /**
  * Problem type URI for failed-dependency errors.
  */
-export type FailedDependencyErrorType = ClosedEnum<
+export type FailedDependencyErrorType = OpenEnum<
   typeof FailedDependencyErrorType
 >;
 
 /** @internal */
-export const FailedDependencyErrorType$inboundSchema: z.ZodNativeEnum<
-  typeof FailedDependencyErrorType
-> = z.nativeEnum(FailedDependencyErrorType);
+export const FailedDependencyErrorType$inboundSchema: z.ZodType<
+  FailedDependencyErrorType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FailedDependencyErrorType);

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

@@ -42,13 +42,13 @@ export type GetLongTermMemoryResponseContent = {
    */
   topics?: Array<string> | undefined;
   /**
-   * Timestamp when the memory was created (Unix milliseconds).
+   * Timestamp when the memory was created (UTC).
    */
-  createdAt: number;
+  createdAt: Date;
   /**
-   * Timestamp when the memory was last updated (Unix milliseconds).
+   * Timestamp when the memory was last updated (UTC).
    */
-  updatedAt: number;
+  updatedAt: Date;
 };
 
 /** @internal */
@@ -64,8 +64,8 @@ export const GetLongTermMemoryResponseContent$inboundSchema: z.ZodType<
   ownerId: z.string().optional(),
   namespace: z.string().optional(),
   topics: z.array(z.string()).optional(),
-  createdAt: z.number().int(),
-  updatedAt: z.number().int(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });
 
 export function getLongTermMemoryResponseContentFromJSON(

package/src/models/list-sessions-response-content.ts

@@ -15,7 +15,7 @@ export type ListSessionsResponseContent = {
   /**
    * List of session IDs. Always returned; empty when the store has no sessions.
    */
-  sessions: Array<string>;
+  items: Array<string>;
   /**
    * Total number of matching sessions.
    */
@@ -32,7 +32,7 @@ export const ListSessionsResponseContent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  sessions: z.array(z.string()),
+  items: z.array(z.string()),
   total: z.number().int(),
   nextPageToken: z.string().optional(),
 });

package/src/models/memory-record.ts

@@ -42,13 +42,13 @@ export type MemoryRecord = {
    */
   topics?: Array<string> | undefined;
   /**
-   * Timestamp when the memory was created (Unix milliseconds).
+   * Timestamp when the memory was created (UTC).
    */
-  createdAt: number;
+  createdAt: Date;
   /**
-   * Timestamp when the memory was last updated (Unix milliseconds).
+   * Timestamp when the memory was last updated (UTC).
    */
-  updatedAt: number;
+  updatedAt: Date;
 };
 
 /** @internal */
@@ -64,8 +64,8 @@ export const MemoryRecord$inboundSchema: z.ZodType<
   ownerId: z.string().optional(),
   namespace: z.string().optional(),
   topics: z.array(z.string()).optional(),
-  createdAt: z.number().int(),
-  updatedAt: z.number().int(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });
 
 export function memoryRecordFromJSON(

package/src/models/memory-type.ts

@@ -4,7 +4,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * Type of long-term memory.
@@ -17,11 +18,17 @@ export const MemoryType = {
 /**
  * Type of long-term memory.
  */
-export type MemoryType = ClosedEnum<typeof MemoryType>;
+export type MemoryType = OpenEnum<typeof MemoryType>;
 
 /** @internal */
-export const MemoryType$inboundSchema: z.ZodNativeEnum<typeof MemoryType> = z
-  .nativeEnum(MemoryType);
+export const MemoryType$inboundSchema: z.ZodType<
+  MemoryType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(MemoryType);
 /** @internal */
-export const MemoryType$outboundSchema: z.ZodNativeEnum<typeof MemoryType> =
-  MemoryType$inboundSchema;
+export const MemoryType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  MemoryType
+> = openEnums.outboundSchema(MemoryType);

package/src/models/message-role.ts

@@ -4,7 +4,8 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * Message role for session events.
@@ -17,11 +18,17 @@ export const MessageRole = {
 /**
  * Message role for session events.
  */
-export type MessageRole = ClosedEnum<typeof MessageRole>;
+export type MessageRole = OpenEnum<typeof MessageRole>;
 
 /** @internal */
-export const MessageRole$inboundSchema: z.ZodNativeEnum<typeof MessageRole> = z
-  .nativeEnum(MessageRole);
+export const MessageRole$inboundSchema: z.ZodType<
+  MessageRole,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(MessageRole);
 /** @internal */
-export const MessageRole$outboundSchema: z.ZodNativeEnum<typeof MessageRole> =
-  MessageRole$inboundSchema;
+export const MessageRole$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  MessageRole
+> = openEnums.outboundSchema(MessageRole);

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

@@ -16,7 +16,7 @@ export type SearchLongTermMemoryResponseContent = {
   /**
    * List of matching memory records. Always returned; empty when no records match.
    */
-  memories: Array<MemoryRecord>;
+  items: Array<MemoryRecord>;
   /**
    * Opaque token for fetching the next page. Omitted when no more results.
    */
@@ -29,7 +29,7 @@ export const SearchLongTermMemoryResponseContent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  memories: z.array(MemoryRecord$inboundSchema),
+  items: z.array(MemoryRecord$inboundSchema),
   nextPageToken: z.string().optional(),
 });
 

package/src/models/session-event.ts

@@ -35,9 +35,13 @@ export type SessionEvent = {
    */
   content: Array<Content>;
   /**
-   * Timestamp when the event was created in milliseconds.
+   * Client-supplied timestamp for when the event happened (UTC).
    */
-  createdAt: number;
+  createdAt: Date;
+  /**
+   * Server-set timestamp for when the dataplane ingested the event (UTC).
+   */
+  systemTimestamp: Date;
   /**
    * Optional metadata as any valid JSON value.
    */
@@ -55,7 +59,10 @@ export const SessionEvent$inboundSchema: z.ZodType<
   sessionId: z.string(),
   role: MessageRole$inboundSchema,
   content: z.array(Content$inboundSchema),
-  createdAt: z.number().int(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  systemTimestamp: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
   metadata: z.any().optional(),
 });
 

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

@@ -42,13 +42,13 @@ export type UpdateLongTermMemoryResponseContent = {
    */
   topics?: Array<string> | undefined;
   /**
-   * Timestamp when the memory was created (Unix milliseconds).
+   * Timestamp when the memory was created (UTC).
    */
-  createdAt: number;
+  createdAt: Date;
   /**
-   * Timestamp when the memory was last updated (Unix milliseconds).
+   * Timestamp when the memory was last updated (UTC).
    */
-  updatedAt: number;
+  updatedAt: Date;
 };
 
 /** @internal */
@@ -64,8 +64,8 @@ export const UpdateLongTermMemoryResponseContent$inboundSchema: z.ZodType<
   ownerId: z.string().optional(),
   namespace: z.string().optional(),
   topics: z.array(z.string()).optional(),
-  createdAt: z.number().int(),
-  updatedAt: z.number().int(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });
 
 export function updateLongTermMemoryResponseContentFromJSON(

package/src/types/async.ts

@@ -22,16 +22,17 @@ export type APICall =
 
 export class APIPromise<T> implements Promise<T> {
   readonly #promise: Promise<[T, APICall]>;
-  readonly #unwrapped: Promise<T>;
+  #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
-        ? this.#promise.then(([value]) => value)
-        : Promise.resolve(p[0]);
+    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>(
@@ -56,11 +57,11 @@ export class APIPromise<T> implements Promise<T> {
       | null
       | undefined,
   ): Promise<T | TResult> {
-    return this.#unwrapped.catch(onrejected);
+    return this.#getUnwrapped().catch(onrejected);
   }
 
   finally(onfinally?: (() => void) | null | undefined): Promise<T> {
-    return this.#unwrapped.finally(onfinally);
+    return this.#getUnwrapped().finally(onfinally);
   }
 
   $inspect(): Promise<[T, APICall]> {

package/dist/commonjs/lib/dlv.d.ts

@@ -1,14 +0,0 @@
-/**
- * @param obj The object to walk
- * @param key The key path to walk the object with
- * @param def A default value to return if the result is undefined
- *
- * @example
- * dlv(obj, "a.b.c.d")
- * @example
- * dlv(object, ["a", "b", "c", "d"])
- * @example
- * dlv(object, "foo.bar.baz", "Hello, default value!")
- */
-export declare function dlv<T = any>(obj: any, key: string | string[], def?: T, p?: number, undef?: never): T | undefined;
-//# sourceMappingURL=dlv.d.ts.map

package/dist/commonjs/lib/dlv.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dlv.d.ts","sourceRoot":"","sources":["../../../src/lib/dlv.ts"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH,wBAAgB,GAAG,CAAC,CAAC,GAAG,GAAG,EACzB,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,EACtB,GAAG,CAAC,EAAE,CAAC,EACP,CAAC,CAAC,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,KAAK,GACZ,CAAC,GAAG,SAAS,CAOf"}