zeitlich 0.2.48 → 0.2.50

package/src/lib/thread/snapshot.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, beforeEach } from "vitest";
-import type Redis from "ioredis";
+import type { RedisClientType } from "redis";
 import {
   applySnapshot,
   clearHotTier,
@@ -14,7 +14,7 @@ import {
 } from "./keys";
 import type { PersistedThreadState } from "../state/types";
 import type { ThreadSnapshot } from "./cold-store";
-import { createFakeRedis } from "./test-utils";
+import { createFakeRedis, makeMultiError } from "./test-utils";
 
 const sampleState: PersistedThreadState = {
   tasks: [
@@ -36,7 +36,7 @@ const sampleState: PersistedThreadState = {
 };
 
 describe("encodeSnapshot", () => {
-  let redis: Redis & { _store: Map<string, unknown> };
+  let redis: RedisClientType & { _store: Map<string, unknown> };
 
   beforeEach(() => {
     redis = createFakeRedis();
@@ -97,7 +97,7 @@ describe("encodeSnapshot", () => {
 });
 
 describe("applySnapshot", () => {
-  let redis: Redis & { _store: Map<string, unknown> };
+  let redis: RedisClientType & { _store: Map<string, unknown> };
 
   beforeEach(() => {
     redis = createFakeRedis();
@@ -178,7 +178,7 @@ describe("applySnapshot", () => {
     const metaKey = getThreadMetaKey("messages", "t-1");
     expect(await redis.exists(metaKey)).toBe(1);
     expect(
-      await redis.lrange(getThreadListKey("messages", "t-1"), 0, -1)
+      await redis.lRange(getThreadListKey("messages", "t-1"), 0, -1)
     ).toEqual([]);
   });
 
@@ -190,7 +190,7 @@ describe("applySnapshot", () => {
     const wrapped = new Proxy(redis, {
       get(target, prop, receiver): unknown {
         if (prop === "del") {
-          return async (..._keys: string[]): Promise<number> => {
+          return async (_keys: string | string[]): Promise<number> => {
             throw new Error("NOPERM: DEL denied by ACL");
           };
         }
@@ -206,7 +206,7 @@ describe("applySnapshot", () => {
     };
     await expect(
       applySnapshot({
-        redis: wrapped as unknown as Redis,
+        redis: wrapped as unknown as RedisClientType,
         threadKey: "messages",
         threadId: "t-del-fail",
         snapshot: snap,
@@ -230,42 +230,44 @@ describe("applySnapshot", () => {
   });
 
   it("clears list/state/dedup residue when a pipelined write fails partway", async () => {
-    // Pipeline stub that *applies* non-failing commands to the
-    // underlying fake (so residue is observable) and errors on rpush
+    // `multi()` stub that *applies* non-failing commands to the
+    // underlying fake (so residue is observable) and errors on rPush
     // — mimicking a partial OOM where the list write fails but the
     // dedup SETs queued after it still land. Without compensating
     // cleanup, those stale dedup keys could silently skip a future
-    // append with the same id.
+    // append with the same id. node-redis rejects `execAsPipeline`
+    // with a `MultiErrorReply` carrying per-command errors.
     const wrapped = new Proxy(redis, {
       get(target, prop, receiver): unknown {
-        if (prop === "pipeline") {
+        if (prop === "multi") {
           return (): Record<string, unknown> => {
             type Op = { method: string; args: unknown[] };
             const ops: Op[] = [];
             const chain: Record<string, unknown> = {};
-            for (const m of ["set", "del", "rpush", "expire"]) {
+            for (const m of ["set", "del", "rPush", "expire"]) {
               chain[m] = (...args: unknown[]): Record<string, unknown> => {
                 ops.push({ method: m, args });
                 return chain;
               };
             }
-            chain.exec = async (): Promise<Array<[Error | null, unknown]>> => {
-              const out: Array<[Error | null, unknown]> = [];
+            chain.execAsPipeline = async (): Promise<unknown[]> => {
+              const replies: unknown[] = [];
+              const errorIndexes: number[] = [];
               const callable = target as unknown as Record<
                 string,
                 (...a: unknown[]) => Promise<unknown>
               >;
-              for (const op of ops) {
-                if (op.method === "rpush") {
-                  out.push([new Error("OOM"), null]);
+              for (const [i, op] of ops.entries()) {
+                if (op.method === "rPush") {
+                  replies.push(new Error("OOM"));
+                  errorIndexes.push(i);
                   continue;
                 }
                 const fn = callable[op.method];
                 if (!fn) throw new Error(`stub: unknown ${op.method}`);
-                const result = await fn(...op.args);
-                out.push([null, result]);
+                replies.push(await fn(...op.args));
               }
-              return out;
+              throw makeMultiError(replies, errorIndexes);
             };
             return chain;
           };
@@ -282,7 +284,7 @@ describe("applySnapshot", () => {
     };
     await expect(
       applySnapshot({
-        redis: wrapped as unknown as Redis,
+        redis: wrapped as unknown as RedisClientType,
         threadKey: "messages",
         threadId: "t-residue",
         snapshot: snap,
@@ -305,30 +307,36 @@ describe("applySnapshot", () => {
   });
 
   it("throws and leaves the meta key unset when a pipelined command fails", async () => {
-    // Wrap the fake's `pipeline()` so `exec()` returns a tuple list
-    // containing a per-command error — mimicking ioredis's behaviour
-    // when Redis runtime errors (OOM, ACL, WRONGTYPE) occur inside a
-    // pipeline. The top-level promise resolves; the error lives in the
-    // result tuple, and applySnapshot must surface it.
+    // Wrap the fake's `multi()` so `execAsPipeline()` rejects with a
+    // `MultiErrorReply` — mimicking node-redis's behaviour when Redis
+    // runtime errors (OOM, ACL, WRONGTYPE) occur inside a pipeline.
+    // `applySnapshot` must surface the underlying error.
     const wrapped = new Proxy(redis, {
       get(target, prop, receiver): unknown {
-        if (prop === "pipeline") {
+        if (prop === "multi") {
           return (): Record<string, unknown> => {
             type Op = { method: string; args: unknown[] };
             const ops: Op[] = [];
             const chain: Record<string, unknown> = {};
-            for (const m of ["set", "del", "rpush", "expire"]) {
+            for (const m of ["set", "del", "rPush", "expire"]) {
               chain[m] = (...args: unknown[]): Record<string, unknown> => {
                 ops.push({ method: m, args });
                 return chain;
               };
             }
-            chain.exec = async (): Promise<Array<[Error | null, unknown]>> =>
-              ops.map((op, i) =>
-                op.method === "rpush"
-                  ? [new Error("OOM command not allowed"), null]
-                  : [null, i]
-              );
+            chain.execAsPipeline = async (): Promise<unknown[]> => {
+              const replies: unknown[] = [];
+              const errorIndexes: number[] = [];
+              ops.forEach((op, i) => {
+                if (op.method === "rPush") {
+                  replies.push(new Error("OOM command not allowed"));
+                  errorIndexes.push(i);
+                } else {
+                  replies.push(i);
+                }
+              });
+              throw makeMultiError(replies, errorIndexes);
+            };
             return chain;
           };
         }
@@ -344,7 +352,7 @@ describe("applySnapshot", () => {
     };
     await expect(
       applySnapshot({
-        redis: wrapped as unknown as Redis,
+        redis: wrapped as unknown as RedisClientType,
         threadKey: "messages",
         threadId: "t-fail",
         snapshot: snap,
@@ -354,14 +362,14 @@ describe("applySnapshot", () => {
     expect(await redis.exists(getThreadMetaKey("messages", "t-fail"))).toBe(0);
   });
 
-  it("issues a single pipeline.exec() rather than per-key writes", async () => {
-    let pipelineCalls = 0;
+  it("issues a single multi().execAsPipeline() rather than per-key writes", async () => {
+    let multiCalls = 0;
     const wrapped = new Proxy(redis, {
       get(target, prop, receiver): unknown {
-        if (prop === "pipeline") {
+        if (prop === "multi") {
           return (): unknown => {
-            pipelineCalls++;
-            return (target as unknown as { pipeline: () => unknown }).pipeline();
+            multiCalls++;
+            return (target as unknown as { multi: () => unknown }).multi();
           };
         }
         return Reflect.get(target, prop, receiver) as unknown;
@@ -377,19 +385,19 @@ describe("applySnapshot", () => {
       dedupIds: Array.from({ length: 10 }, (_, i) => `m${i}`),
     };
     await applySnapshot({
-      redis: wrapped as unknown as Redis,
+      redis: wrapped as unknown as RedisClientType,
       threadKey: "messages",
       threadId: "t-1",
       snapshot: snap,
     });
 
-    expect(pipelineCalls).toBe(1);
+    expect(multiCalls).toBe(1);
   });
 
   it("clears any partial residue from a previous failed restore", async () => {
     const listKey = getThreadListKey("messages", "t-1");
     const stateKey = getThreadStateKey("messages", "t-1");
-    await redis.rpush(listKey, "stale-message");
+    await redis.rPush(listKey, "stale-message");
     await redis.set(stateKey, JSON.stringify({ stale: true }));
     // Note: meta is intentionally absent — simulates a half-written restore.
 

package/src/lib/thread/snapshot.ts

@@ -8,7 +8,7 @@
  * tiered thread manager in `tiered.ts` is the only consumer.
  */
 
-import type Redis from "ioredis";
+import type { RedisClientType } from "redis";
 import type { PersistedThreadState } from "../state/types";
 import type { ThreadSnapshot } from "./cold-store";
 import {
@@ -21,7 +21,7 @@ import {
 
 /** Inputs shared by every snapshot operation. */
 interface SnapshotCommon {
-  redis: Redis;
+  redis: RedisClientType;
   threadKey: string;
   threadId: string;
 }
@@ -53,7 +53,7 @@ export async function encodeSnapshot(
   }
   const listKey = getThreadListKey(threadKey, threadId);
   const stateKey = getThreadStateKey(threadKey, threadId);
-  const messages = await redis.lrange(listKey, 0, -1);
+  const messages = await redis.lRange(listKey, 0, -1);
   const stateRaw = await redis.get(stateKey);
   const state =
     stateRaw == null ? null : (JSON.parse(stateRaw) as PersistedThreadState);
@@ -99,43 +99,65 @@ export async function applySnapshot(
   // CROSSSLOT, …) short-circuits before any writes hit the wire —
   // pipelines are non-atomic, so a queued DEL wouldn't stop later
   // commands from accumulating data behind a missing meta marker.
-  await redis.del(listKey, stateKey);
+  await redis.del([listKey, stateKey]);
 
-  // Pipeline the data writes (list/state/dedup) in one round-trip.
-  // Meta is written separately, only after every queued command
-  // succeeded, preserving the "meta-last" crash-safety invariant —
-  // a partial restore must leave meta absent so the next hydrate
-  // retries cleanly.
-  const pipeline = redis.pipeline();
+  // Pipeline the data writes (list/state/dedup) in one round-trip via a
+  // non-transactional `MULTI` (`execAsPipeline`). Meta is written
+  // separately, only after every queued command succeeded, preserving
+  // the "meta-last" crash-safety invariant — a partial restore must
+  // leave meta absent so the next hydrate retries cleanly.
+  const pipeline = redis.multi();
   if (snapshot.messages.length > 0) {
-    pipeline.rpush(listKey, ...snapshot.messages);
+    pipeline.rPush(listKey, snapshot.messages);
     pipeline.expire(listKey, ttlSeconds);
   }
   if (snapshot.state != null) {
-    pipeline.set(stateKey, JSON.stringify(snapshot.state), "EX", ttlSeconds);
+    pipeline.set(stateKey, JSON.stringify(snapshot.state), { EX: ttlSeconds });
   }
   for (const id of snapshot.dedupIds) {
-    pipeline.set(getThreadDedupKey(threadId, id), "1", "EX", ttlSeconds);
+    pipeline.set(getThreadDedupKey(threadId, id), "1", { EX: ttlSeconds });
   }
-  const results = await pipeline.exec();
-  if (results) {
-    const firstErr = results.find(([err]) => err)?.[0] ?? null;
-    if (firstErr) {
-      // Compensate: pipelines are non-atomic, so writes queued after
-      // a failing command (notably dedup SETs) may have landed. Best-
-      // effort clear every key we touched so a leftover dedup marker
-      // can't silently skip a future append with the same id.
-      await redis
-        .del(
-          listKey,
-          stateKey,
-          ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id))
-        )
-        .catch(() => undefined);
-      throw firstErr;
-    }
+  try {
+    await pipeline.execAsPipeline();
+  } catch (err) {
+    // Compensate: pipelines are non-atomic, so writes queued after a
+    // failing command (notably dedup SETs) may have landed. Best-effort
+    // clear every key we touched so a leftover dedup marker can't
+    // silently skip a future append with the same id. node-redis
+    // surfaces per-command failures by rejecting `execAsPipeline` with a
+    // `MultiErrorReply`; we unwrap it to rethrow the first real error.
+    await redis
+      .del([
+        listKey,
+        stateKey,
+        ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id)),
+      ])
+      .catch(() => undefined);
+    throw firstPipelineError(err);
   }
-  await redis.set(metaKey, "1", "EX", ttlSeconds);
+  await redis.set(metaKey, "1", { EX: ttlSeconds });
+}
+
+/**
+ * Unwrap node-redis's `MultiErrorReply` (thrown by `execAsPipeline` when
+ * one or more queued commands fail) to the first underlying error so
+ * callers see the actual Redis error (OOM, WRONGTYPE, …) rather than the
+ * generic aggregate wrapper. The structural check avoids a hard runtime
+ * dependency on the `redis` error class.
+ */
+function firstPipelineError(err: unknown): unknown {
+  if (
+    err != null &&
+    typeof err === "object" &&
+    "replies" in err &&
+    Array.isArray((err as { replies: unknown }).replies)
+  ) {
+    const firstErr = (err as { replies: unknown[] }).replies.find(
+      (r): r is Error => r instanceof Error
+    );
+    if (firstErr) return firstErr;
+  }
+  return err;
 }
 
 /** Configuration for {@link clearHotTier}. */
@@ -159,5 +181,5 @@ export async function clearHotTier(
     getThreadStateKey(threadKey, threadId),
     ...dedupIds.map((id) => getThreadDedupKey(threadId, id)),
   ];
-  await redis.del(...keys);
+  await redis.del(keys);
 }

package/src/lib/thread/test-utils.ts

@@ -7,19 +7,35 @@
  * picks it up directly.
  */
 
-import type Redis from "ioredis";
+import type { RedisClientType } from "redis";
 import type { ColdThreadStore, ThreadSnapshot } from "./cold-store";
 
 type Value = string | string[];
 
+/** node-redis `SetOptions` subset the stub understands. */
+interface FakeSetOptions {
+  EX?: number;
+  NX?: boolean;
+  expiration?: { type: "EX" | "PX" | "EXAT" | "PXAT"; value: number } | "KEEPTTL";
+  condition?: "NX" | "XX";
+}
+
+/** node-redis accepts a single key or an array (`RedisVariadicArgument`). */
+type Keys = string | string[];
+const toKeys = (keys: Keys): string[] => (Array.isArray(keys) ? keys : [keys]);
+
 /**
- * Minimal in-memory Redis stub covering the commands the thread
+ * Minimal in-memory node-redis stub covering the commands the thread
  * manager + snapshot helpers use: get/set/del/exists/expire,
- * lrange/rpush/llen/ltrim, and the `eval`-based idempotent-append Lua
- * script. Behaviour matches Redis closely enough for unit tests; TTLs
- * are stored but never expire automatically.
+ * lRange/rPush/lLen/lTrim, and the `eval`-based idempotent-append Lua
+ * script. Mirrors the node-redis (`redis`) v4+ API surface — camelCase
+ * commands, an options object for `set`, variadic-or-array keys for
+ * `del`/`exists`, and a `multi().execAsPipeline()` pipeline that rejects
+ * with a `MultiErrorReply`-shaped error when a queued command fails.
+ * Behaviour matches Redis closely enough for unit tests; TTLs are stored
+ * but never expire automatically.
  */
-export function createFakeRedis(): Redis & {
+export function createFakeRedis(): RedisClientType & {
   _store: Map<string, Value>;
   _ttls: Map<string, number>;
 } {
@@ -48,56 +64,60 @@ export function createFakeRedis(): Redis & {
     async set(
       key: string,
       value: string,
-      ..._rest: (string | number)[]
-    ): Promise<"OK"> {
-      // NX guard: when the args contain "NX" and the key already exists,
+      options?: FakeSetOptions
+    ): Promise<"OK" | null> {
+      // NX guard: when the condition is NX and the key already exists,
       // Redis returns null. We follow the same contract for tests that
-      // need it; existing call sites use this for compare-and-set.
-      const rest = _rest.map((x) => (typeof x === "string" ? x.toUpperCase() : x));
-      if (rest.includes("NX") && store.has(key)) {
-        return null as unknown as "OK";
+      // need it.
+      const nx = options?.NX === true || options?.condition === "NX";
+      if (nx && store.has(key)) {
+        return null;
       }
       store.set(key, String(value));
-      const exIdx = rest.indexOf("EX");
-      if (exIdx >= 0 && typeof _rest[exIdx + 1] === "number") {
-        ttls.set(key, _rest[exIdx + 1] as number);
+      const ttl =
+        options?.EX ??
+        (options?.expiration && options.expiration !== "KEEPTTL"
+          ? options.expiration.value
+          : undefined);
+      if (typeof ttl === "number") {
+        ttls.set(key, ttl);
       }
       return "OK";
     },
-    async del(...keys: string[]): Promise<number> {
+    async del(keys: Keys): Promise<number> {
       let removed = 0;
-      for (const k of keys) {
+      for (const k of toKeys(keys)) {
         if (store.delete(k)) removed++;
         ttls.delete(k);
       }
       return removed;
     },
-    async exists(...keys: string[]): Promise<number> {
-      return keys.reduce((acc, k) => acc + (store.has(k) ? 1 : 0), 0);
+    async exists(keys: Keys): Promise<number> {
+      return toKeys(keys).reduce((acc, k) => acc + (store.has(k) ? 1 : 0), 0);
     },
     async expire(key: string, ttl: number): Promise<number> {
       if (!store.has(key)) return 0;
       ttls.set(key, ttl);
       return 1;
     },
-    async lrange(key: string, start: number, end: number): Promise<string[]> {
+    async lRange(key: string, start: number, end: number): Promise<string[]> {
       if (!store.has(key)) return [];
       if (!isList(key)) return [];
       const list = store.get(key) as string[];
       const last = end === -1 ? list.length - 1 : end;
       return list.slice(start, last + 1);
     },
-    async rpush(key: string, ...values: string[]): Promise<number> {
+    async rPush(key: string, element: Keys): Promise<number> {
       const list = ensureList(key);
-      list.push(...values);
+      list.push(...toKeys(element));
       return list.length;
     },
-    async llen(key: string): Promise<number> {
+    async lLen(key: string): Promise<number> {
       if (!store.has(key)) return 0;
       const list = store.get(key) as string[];
       return list.length;
     },
-    async ltrim(key: string, start: number, end: number): Promise<"OK"> {
+    async lTrim(key: string, start: number, end: number): Promise<"OK"> {
       if (!store.has(key)) return "OK";
       const list = store.get(key) as string[];
       const last = end === -1 ? list.length - 1 : end;
@@ -106,12 +126,11 @@ export function createFakeRedis(): Redis & {
     },
     async eval(
       _script: string,
-      numKeys: number,
-      ...args: (string | number)[]
+      options: { keys?: string[]; arguments?: string[] }
     ): Promise<number> {
       // Mirrors APPEND_IDEMPOTENT_SCRIPT in src/lib/thread/manager.ts.
-      const keys = args.slice(0, numKeys) as string[];
-      const argv = args.slice(numKeys) as string[];
+      const keys = options.keys ?? [];
+      const argv = options.arguments ?? [];
       const dedupKey = keys[0];
       const listKey = keys[1];
       const ttl = Number(argv[0]);
@@ -127,54 +146,64 @@ export function createFakeRedis(): Redis & {
       ttls.set(dedupKey, ttl);
       return 1;
     },
-    // Chainable pipeline stub. Defers each command to the underlying
-    // sync fake methods on `.exec()`, so TTL tracking and store
-    // semantics stay identical to the non-pipelined path. `fake` is
-    // typed as `Redis` after the cast below, so we narrow it back to
-    // the concrete impl shape here to avoid Redis's callback overloads.
-    pipeline(): FakePipeline {
+    // Chainable `multi()` stub. Defers each command to the underlying
+    // sync fake methods on `.execAsPipeline()`, so TTL tracking and store
+    // semantics stay identical to the non-pipelined path. Mirrors
+    // node-redis: per-command failures reject the pipeline with a
+    // `MultiErrorReply`-shaped error (`{ replies, errorIndexes }`).
+    multi(): FakeMulti {
       const impl = fake as unknown as {
-        set: (key: string, value: string, ...rest: (string | number)[]) => Promise<"OK">;
-        del: (...keys: string[]) => Promise<number>;
-        rpush: (key: string, ...values: string[]) => Promise<number>;
+        set: (
+          key: string,
+          value: string,
+          options?: FakeSetOptions
+        ) => Promise<"OK" | null>;
+        del: (keys: Keys) => Promise<number>;
+        rPush: (key: string, element: Keys) => Promise<number>;
         expire: (key: string, ttl: number) => Promise<number>;
       };
       const ops: Array<() => Promise<unknown>> = [];
-      const chain: FakePipeline = {
-        set: (...args) => {
-          const [key, value, ...rest] = args as [string, string, ...(string | number)[]];
-          ops.push(() => impl.set(key, value, ...rest));
+      const chain: FakeMulti = {
+        set: (key, value, options) => {
+          ops.push(() => impl.set(key, value, options));
           return chain;
         },
-        del: (...keys) => {
-          ops.push(() => impl.del(...keys));
+        del: (keys) => {
+          ops.push(() => impl.del(keys));
           return chain;
         },
-        rpush: (key, ...values) => {
-          ops.push(() => impl.rpush(key, ...values));
+        rPush: (key, element) => {
+          ops.push(() => impl.rPush(key, element));
           return chain;
         },
         expire: (key, ttl) => {
           ops.push(() => impl.expire(key, ttl));
           return chain;
         },
-        exec: async () => {
-          const results: Array<[Error | null, unknown]> = [];
+        execAsPipeline: async () => {
+          const replies: unknown[] = [];
+          const errorIndexes: number[] = [];
+          let i = 0;
           for (const op of ops) {
             try {
-              results.push([null, await op()]);
+              replies.push(await op());
             } catch (e) {
-              results.push([e as Error, null]);
+              replies.push(e);
+              errorIndexes.push(i);
             }
+            i++;
+          }
+          if (errorIndexes.length > 0) {
+            throw makeMultiError(replies, errorIndexes);
           }
-          return results;
+          return replies;
         },
       };
       return chain;
     },
     _store: store,
     _ttls: ttls,
-  } as unknown as Redis & {
+  } as unknown as RedisClientType & {
     _store: Map<string, Value>;
     _ttls: Map<string, number>;
   };
@@ -182,13 +211,31 @@ export function createFakeRedis(): Redis & {
   return fake;
 }
 
-/** Minimal chainable surface used by the fake-redis pipeline stub. */
-interface FakePipeline {
-  set: (...args: (string | number)[]) => FakePipeline;
-  del: (...keys: string[]) => FakePipeline;
-  rpush: (key: string, ...values: string[]) => FakePipeline;
-  expire: (key: string, ttl: number) => FakePipeline;
-  exec: () => Promise<Array<[Error | null, unknown]>>;
+/** Minimal chainable surface used by the fake-redis `multi()` stub. */
+interface FakeMulti {
+  set: (key: string, value: string, options?: FakeSetOptions) => FakeMulti;
+  del: (keys: Keys) => FakeMulti;
+  rPush: (key: string, element: Keys) => FakeMulti;
+  expire: (key: string, ttl: number) => FakeMulti;
+  execAsPipeline: () => Promise<unknown[]>;
+}
+
+/**
+ * Build a node-redis `MultiErrorReply`-shaped error: an `Error` carrying
+ * `replies` (per-command results, with failures as `Error`s) and
+ * `errorIndexes`. `applySnapshot` unwraps this to surface the first real
+ * error.
+ */
+export function makeMultiError(
+  replies: unknown[],
+  errorIndexes: number[]
+): Error & { replies: unknown[]; errorIndexes: number[] } {
+  return Object.assign(
+    new Error(
+      `${errorIndexes.length} commands failed, see .replies and .errorIndexes for more information`
+    ),
+    { replies, errorIndexes }
+  );
 }
 
 /**

package/src/lib/thread/tiered.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, beforeEach } from "vitest";
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import { createTieredThreadManager } from "./tiered";
 import { createThreadManager } from "./manager";
 import {

package/src/lib/thread/types.ts

@@ -1,7 +1,7 @@
-import type Redis from "ioredis";
+import type { RedisClientType } from "redis";
 import type { JsonValue, PersistedThreadState } from "../state/types";
 export interface ThreadManagerConfig<T> {
-  redis: Redis;
+  redis: RedisClientType;
   threadId: string;
   /** Thread key, defaults to 'messages' */
   key?: string;