zeitlich 0.2.49 → 0.2.51

package/src/adapters/thread/langchain/activities.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from "vitest";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { createLangChainAdapter } from "./activities";
+import { THREAD_TTL_SECONDS } from "../../../lib/thread/keys";
+
+function createMockRedis(stored: unknown[]) {
+  return {
+    exists: vi.fn().mockResolvedValue(1),
+    lRange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    lTrim: vi.fn().mockResolvedValue("OK"),
+    del: vi.fn().mockResolvedValue(1),
+    set: vi.fn().mockResolvedValue("OK"),
+    rPush: vi.fn().mockResolvedValue(1),
+    expire: vi.fn().mockResolvedValue(1),
+    eval: vi.fn().mockResolvedValue(1),
+  };
+}
+
+function createMockModel() {
+  const response = {
+    tool_calls: [],
+    response_metadata: {},
+    usage_metadata: { input_tokens: 1, output_tokens: 1 },
+    toDict: () => ({ type: "ai", data: { content: "ok" } }),
+  };
+  return { invoke: vi.fn().mockResolvedValue(response) };
+}
+
+// Tail stored under the `assistantMessageId`, so the invoker's
+// `truncateFromId` trims it and re-stamps the surviving list key's TTL.
+const retriedThread = [
+  new HumanMessage({ id: "msg-1", content: "hi" }).toDict(),
+  new AIMessage({ id: "assistant-1", content: "prior" }).toDict(),
+];
+const listKey = "messages:thread:thread-1";
+const metaKey = "messages:meta:thread:thread-1";
+const invokerCall = {
+  threadId: "thread-1",
+  assistantMessageId: "assistant-1",
+  state: { tools: [] } as never,
+  agentName: "TestAgent",
+};
+
+describe("createLangChainAdapter — TTL propagation", () => {
+  it("forwards adapter ttlSeconds to a created invoker's writes", async () => {
+    const redis = createMockRedis(retriedThread);
+    const model = createMockModel();
+    const adapter = createLangChainAdapter({
+      redis: redis as never,
+      ttlSeconds: 3600,
+    });
+
+    await adapter.createModelInvoker(model as never)(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, 3600);
+    expect(redis.expire).not.toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+
+  it("forwards adapter ttlSeconds to thread-op writes", async () => {
+    const redis = createMockRedis([]);
+    const adapter = createLangChainAdapter({
+      redis: redis as never,
+      ttlSeconds: 3600,
+    });
+    const acts = adapter.createActivities() as unknown as Record<
+      string,
+      (threadId: string, threadKey?: string) => Promise<void>
+    >;
+    const initialize = Object.entries(acts).find(([k]) =>
+      k.endsWith("InitializeThread")
+    )?.[1];
+    if (!initialize) throw new Error("initializeThread activity not found");
+
+    await initialize("thread-1");
+
+    expect(redis.set).toHaveBeenCalledWith(metaKey, "1", { EX: 3600 });
+  });
+
+  it("defaults to THREAD_TTL_SECONDS when adapter ttlSeconds is omitted", async () => {
+    const redis = createMockRedis(retriedThread);
+    const model = createMockModel();
+    const adapter = createLangChainAdapter({ redis: redis as never });
+
+    await adapter.createModelInvoker(model as never)(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+});

package/src/adapters/thread/langchain/activities.ts

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type { ToolResultConfig } from "../../../lib/types";
 import type { PersistedThreadState } from "../../../lib/state/types";
 import type { MessageContent } from "@langchain/core/messages";
@@ -46,9 +46,8 @@ export interface LangChainAdapterConfig {
    */
   coldStore?: ColdThreadStore;
   /**
-   * Override the default Redis TTL (90 days). When pairing the
-   * adapter with a `coldStore`, a shorter TTL (hours) is typically
-   * more appropriate.
+   * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+   * value (hours) with a cold tier.
    */
   ttlSeconds?: number;
 }
@@ -133,25 +132,26 @@ export function createLangChainAdapter(
 ): LangChainAdapter {
   const { redis } = config;
 
-  const baseExtras = {
+  // Single source for the adapter's `redis` handle and configured TTL, spread
+  // into every internal thread manager so all of them share one configuration.
+  const base = {
+    redis,
     ...(config.ttlSeconds !== undefined && { ttlSeconds: config.ttlSeconds }),
   };
 
   const makeProviderThread = (threadId: string, threadKey?: string) =>
     createLangChainThreadManager({
-      redis,
+      ...base,
       threadId,
       key: threadKey,
-      ...baseExtras,
     });
 
   const makeTieredBase = (threadId: string, threadKey?: string) =>
     createTieredThreadManager<StoredMessage>({
-      redis,
+      ...base,
       threadId,
       key: threadKey,
       idOf: storedMessageId,
-      ...baseExtras,
       ...(config.coldStore && { coldStore: config.coldStore }),
     });
 
@@ -207,11 +207,10 @@ export function createLangChainAdapter(
       threadKey?: string
     ): Promise<void> {
       const thread = createLangChainThreadManager({
-        redis,
+        ...base,
         threadId: sourceThreadId,
         key: threadKey,
         hooks: config.hooks,
-        ...baseExtras,
       });
       await thread.fork(targetThreadId);
     },
@@ -275,7 +274,11 @@ export function createLangChainAdapter(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     model: BaseChatModel<any>
   ): ModelInvoker<StoredMessage> =>
-    createLangChainModelInvoker({ redis, model, hooks: config.hooks });
+    createLangChainModelInvoker({
+      ...base,
+      model,
+      hooks: config.hooks,
+    });
 
   const invoker: ModelInvoker<StoredMessage> = config.model
     ? makeInvoker(config.model)

package/src/adapters/thread/langchain/fork-transform.test.ts

@@ -11,27 +11,27 @@ function createStatefulRedis() {
   const strings = new Map<string, string>();
 
   return {
-    exists: vi.fn(async (...keys: string[]) =>
-      keys.reduce(
+    exists: vi.fn(async (keys: string | string[]) =>
+      (Array.isArray(keys) ? keys : [keys]).reduce(
         (acc, k) => acc + (lists.has(k) || strings.has(k) ? 1 : 0),
         0
       )
     ),
-    lrange: vi.fn(async (key: string, start: number, stop: number) => {
+    lRange: vi.fn(async (key: string, start: number, stop: number) => {
       const list = lists.get(key) ?? [];
       const end = stop === -1 ? list.length : stop + 1;
       return list.slice(start, end);
     }),
-    rpush: vi.fn(async (key: string, ...values: string[]) => {
+    rPush: vi.fn(async (key: string, element: string | string[]) => {
       const list = lists.get(key) ?? [];
-      list.push(...values);
+      list.push(...(Array.isArray(element) ? element : [element]));
       lists.set(key, list);
       return list.length;
     }),
-    ltrim: vi.fn(async () => "OK"),
-    del: vi.fn(async (...keys: string[]) => {
+    lTrim: vi.fn(async () => "OK"),
+    del: vi.fn(async (keys: string | string[]) => {
       let removed = 0;
-      for (const k of keys) {
+      for (const k of Array.isArray(keys) ? keys : [keys]) {
         if (lists.delete(k)) removed++;
         if (strings.delete(k)) removed++;
       }
@@ -43,10 +43,16 @@ function createStatefulRedis() {
     }),
     get: vi.fn(async (key: string) => strings.get(key) ?? null),
     expire: vi.fn(async () => 1),
-    llen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
+    lLen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
     eval: vi.fn(
-      async (_script: string, _numKeys: number, ...args: string[]) => {
-        const [dedupKey, listKey, , ...serialised] = args;
+      async (
+        _script: string,
+        options: { keys?: string[]; arguments?: string[] }
+      ) => {
+        const keys = options.keys ?? [];
+        const argv = options.arguments ?? [];
+        const [dedupKey, listKey] = keys;
+        const serialised = argv.slice(1);
         if (!dedupKey || !listKey) return 0;
         if (strings.has(dedupKey)) return 0;
         const list = lists.get(listKey) ?? [];

package/src/adapters/thread/langchain/model-invoker.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from "vitest";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { createLangChainModelInvoker } from "./model-invoker";
+import { THREAD_TTL_SECONDS } from "../../../lib/thread/keys";
+
+function createMockRedis(stored: unknown[]) {
+  return {
+    exists: vi.fn().mockResolvedValue(1),
+    lRange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    lTrim: vi.fn().mockResolvedValue("OK"),
+    del: vi.fn().mockResolvedValue(1),
+    set: vi.fn().mockResolvedValue("OK"),
+    rPush: vi.fn().mockResolvedValue(1),
+    expire: vi.fn().mockResolvedValue(1),
+    eval: vi.fn().mockResolvedValue(1),
+  };
+}
+
+function createMockModel() {
+  const response = {
+    tool_calls: [],
+    response_metadata: {},
+    usage_metadata: { input_tokens: 1, output_tokens: 1 },
+    toDict: () => ({ type: "ai", data: { content: "ok" } }),
+  };
+  return { invoke: vi.fn().mockResolvedValue(response) };
+}
+
+describe("createLangChainModelInvoker thread TTL", () => {
+  // The tail message is stored under `assistant-1`, so the invoker's
+  // `truncateFromId(assistant-1)` trims it and re-stamps the surviving
+  // list key's TTL.
+  const retriedThread = [
+    new HumanMessage({ id: "msg-1", content: "hi" }).toDict(),
+    new AIMessage({ id: "assistant-1", content: "prior" }).toDict(),
+  ];
+  const listKey = "messages:thread:thread-1";
+  const invokerConfig = {
+    threadId: "thread-1",
+    assistantMessageId: "assistant-1",
+    state: { tools: [] } as never,
+    agentName: "Agent",
+  };
+
+  it("re-stamps trimmed hot keys at the configured ttlSeconds", async () => {
+    const redis = createMockRedis(retriedThread);
+    const model = createMockModel();
+    const invoker = createLangChainModelInvoker({
+      redis: redis as never,
+      model: model as never,
+      ttlSeconds: 3600,
+    });
+
+    await invoker(invokerConfig);
+
+    expect(redis.lTrim).toHaveBeenCalledWith(listKey, 0, 0);
+    expect(redis.expire).toHaveBeenCalledWith(listKey, 3600);
+    expect(redis.expire).not.toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+
+  it("defaults to THREAD_TTL_SECONDS when ttlSeconds is omitted", async () => {
+    const redis = createMockRedis(retriedThread);
+    const model = createMockModel();
+    const invoker = createLangChainModelInvoker({
+      redis: redis as never,
+      model: model as never,
+    });
+
+    await invoker(invokerConfig);
+
+    expect(redis.lTrim).toHaveBeenCalledWith(listKey, 0, 0);
+    expect(redis.expire).toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+});

package/src/adapters/thread/langchain/model-invoker.ts

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type { AgentResponse, ModelInvokerConfig } from "../../../lib/model";
 import type { StoredMessage } from "@langchain/core/messages";
 import { v4 as uuidv4 } from "uuid";
@@ -16,6 +16,11 @@ export interface LangChainModelInvokerConfig<
   redis: Redis;
   model: TModel;
   hooks?: LangChainThreadManagerHooks;
+  /**
+   * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+   * value (hours) with a cold tier.
+   */
+  ttlSeconds?: number;
 }
 
 /**
@@ -43,7 +48,7 @@ export interface LangChainModelInvokerConfig<
  
 export function createLangChainModelInvoker<
   TModel extends BaseChatModel<any> = BaseChatModel<any>,
->({ redis, model, hooks }: LangChainModelInvokerConfig<TModel>) {
+>({ redis, model, hooks, ttlSeconds }: LangChainModelInvokerConfig<TModel>) {
   return async function invokeLangChainModel(
     config: ModelInvokerConfig
   ): Promise<AgentResponse<StoredMessage>> {
@@ -56,6 +61,7 @@ export function createLangChainModelInvoker<
       threadId,
       key: threadKey,
       hooks,
+      ...(ttlSeconds !== undefined && { ttlSeconds }),
     });
     const runId = uuidv4();
 
@@ -122,13 +128,20 @@ export async function invokeLangChainModel<
   redis,
   model,
   hooks,
+  ttlSeconds,
   config,
 }: {
   redis: Redis;
   config: ModelInvokerConfig;
   model: TModel;
   hooks?: LangChainThreadManagerHooks;
+  ttlSeconds?: number;
 }): Promise<AgentResponse<StoredMessage>> {
-  const invoker = createLangChainModelInvoker({ redis, model, hooks });
+  const invoker = createLangChainModelInvoker({
+    redis,
+    model,
+    hooks,
+    ...(ttlSeconds !== undefined && { ttlSeconds }),
+  });
   return invoker(config);
 }

package/src/adapters/thread/langchain/thread-manager.test.ts

@@ -9,10 +9,10 @@ import { createLangChainThreadManager } from "./thread-manager";
 function createMockRedis(stored: StoredMessage[]) {
   return {
     exists: vi.fn().mockResolvedValue(1),
-    lrange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    lRange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
     del: vi.fn().mockResolvedValue(1),
     set: vi.fn().mockResolvedValue("OK"),
-    rpush: vi.fn().mockResolvedValue(1),
+    rPush: vi.fn().mockResolvedValue(1),
     expire: vi.fn().mockResolvedValue(1),
     eval: vi.fn().mockResolvedValue(1),
   };

package/src/adapters/thread/langchain/thread-manager.ts

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type { JsonValue } from "../../../lib/state/types";
 import {
   AIMessage,
@@ -35,9 +35,8 @@ export interface LangChainThreadManagerConfig {
   key?: string;
   hooks?: LangChainThreadManagerHooks;
   /**
-   * Override the default thread TTL (90 days). When pairing the
-   * adapter with a durable cold tier, a shorter TTL (hours) is
-   * typically more appropriate.
+   * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+   * value (hours) with a cold tier.
    */
   ttlSeconds?: number;
 }

package/src/index.ts

@@ -17,8 +17,8 @@
  *   toTree,
  * } from 'zeitlich';
  *
- * // In-memory sandbox adapter
- * import { InMemorySandboxProvider } from 'zeitlich/adapters/sandbox/inmemory';
+ * // Sandbox adapter
+ * import { DaytonaSandboxProvider } from 'zeitlich/adapters/sandbox/daytona';
  *
  * // LangChain adapter
  * import { createLangChainAdapter } from 'zeitlich/adapters/thread/langchain';

package/src/lib/sandbox/capability-types.test.ts

@@ -27,7 +27,7 @@ import type {
   SandboxProvider,
   SandboxSnapshot,
 } from "./types";
-import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
+import { InMemorySandboxProvider } from "../../test-utils/in-memory-sandbox";
 import { DaytonaSandboxProvider } from "../../adapters/sandbox/daytona/index";
 import type { E2bSandboxProvider } from "../../adapters/sandbox/e2b/index";
 
@@ -303,7 +303,7 @@ class _ImplWithoutDeclProvider {
 import type { SubagentSandboxConfig } from "../subagent/types";
 import { proxyDaytonaSandboxOps } from "../../adapters/sandbox/daytona/proxy";
 import { proxyE2bSandboxOps } from "../../adapters/sandbox/e2b/proxy";
-import { proxyInMemorySandboxOps } from "../../adapters/sandbox/inmemory/proxy";
+import { proxyInMemorySandboxOps } from "../../test-utils/in-memory-sandbox-proxy";
 
 // Helper that pins the matrix cell type to `SubagentSandboxConfig` so
 // `@ts-expect-error` directives consistently land on the call line. The

package/src/lib/sandbox/manager.ts

@@ -102,12 +102,12 @@ export interface SandboxManagerHooks<
  *
  * @example
  * ```typescript
- * const manager = new SandboxManager(new InMemorySandboxProvider());
+ * const manager = new SandboxManager(new DaytonaSandboxProvider(config));
  * const activities = {
  *   ...manager.createActivities("CodingAgent"),
  *   bashHandler: withSandbox(manager, bashHandler),
  * };
- * // registers: inMemoryCodingAgentCreateSandbox, …
+ * // registers: daytonaCodingAgentCreateSandbox, …
  * ```
  *
  * @example
@@ -336,10 +336,6 @@ export class SandboxManager<
    *
    * @example
    * ```typescript
-   * const manager = new SandboxManager(new InMemorySandboxProvider());
-   * manager.createActivities("CodingAgent");
-   * // registers: inMemoryCodingAgentCreateSandbox, inMemoryCodingAgentDestroySandbox, …
-   *
    * const dmgr = new SandboxManager(new DaytonaSandboxProvider(config));
    * dmgr.createActivities("CodingAgent");
    * // registers: daytonaCodingAgentCreateSandbox, daytonaCodingAgentDestroySandbox

package/src/lib/sandbox/sandbox.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, beforeEach } from "vitest";
 import { SandboxManager } from "./manager";
-import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
+import { InMemorySandboxProvider } from "../../test-utils/in-memory-sandbox";
 import {
   SandboxNotFoundError,
   type Sandbox,

package/src/lib/sandbox/types.ts

@@ -342,8 +342,8 @@ export type SandboxOps<
  *
  * @example
  * ```typescript
- * type InMemOps = PrefixedSandboxOps<"inMemory">;
- * // → { inMemoryCreateSandbox, inMemoryDestroySandbox, inMemorySnapshotSandbox, … }
+ * type E2bOps = PrefixedSandboxOps<"e2b">;
+ * // → { e2bCreateSandbox, e2bDestroySandbox, e2bSnapshotSandbox, … }
  * ```
  */
 export type PrefixedSandboxOps<

package/src/lib/session/session.integration.test.ts

@@ -681,6 +681,98 @@ describe("createSession integration", () => {
     expect(capturedSandboxId).toBe("my-sandbox");
   });
 
+  // --- persistThreadState dedupe ---
+
+  it("memoizes persistThreadState across parallel tool calls in one turn", async () => {
+    const { ops, log } = createMockThreadOps();
+
+    const persistTool = defineTool({
+      name: "Persist" as const,
+      description: "calls persistThreadState",
+      schema: z.object({}),
+      handler: async (_args: Record<string, never>, ctx: RouterContext) => {
+        await ctx.persistThreadState?.();
+        return { toolResponse: "ok", data: null };
+      },
+    });
+
+    const session = await createSession({
+      agentName: "TestAgent",
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([
+        {
+          message: "fan out",
+          toolCalls: [
+            { id: "tc-1", name: "Persist", args: {} },
+            { id: "tc-2", name: "Persist", args: {} },
+            { id: "tc-3", name: "Persist", args: {} },
+          ],
+        },
+        { message: "done", toolCalls: [] },
+      ]),
+      threadOps: ops,
+      tools: { Persist: persistTool },
+      buildContextMessage: () => "go",
+    });
+
+    const stateManager = createAgentStateManager({
+      initialState: { systemPrompt: "test" },
+    });
+
+    await session.runSession({ stateManager });
+
+    const saves = log.filter((l) => l.op === "saveThreadState");
+    expect(saves).toHaveLength(2);
+  });
+
+  it("re-persists across separate turns even when handlers call persistThreadState", async () => {
+    const { ops, log } = createMockThreadOps();
+
+    const persistTool = defineTool({
+      name: "Persist" as const,
+      description: "calls persistThreadState",
+      schema: z.object({}),
+      handler: async (_args: Record<string, never>, ctx: RouterContext) => {
+        await ctx.persistThreadState?.();
+        return { toolResponse: "ok", data: null };
+      },
+    });
+
+    const session = await createSession({
+      agentName: "TestAgent",
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([
+        {
+          message: "turn 1",
+          toolCalls: [
+            { id: "tc-1", name: "Persist", args: {} },
+            { id: "tc-2", name: "Persist", args: {} },
+          ],
+        },
+        {
+          message: "turn 2",
+          toolCalls: [
+            { id: "tc-3", name: "Persist", args: {} },
+            { id: "tc-4", name: "Persist", args: {} },
+          ],
+        },
+        { message: "done", toolCalls: [] },
+      ]),
+      threadOps: ops,
+      tools: { Persist: persistTool },
+      buildContextMessage: () => "go",
+    });
+
+    const stateManager = createAgentStateManager({
+      initialState: { systemPrompt: "test" },
+    });
+
+    await session.runSession({ stateManager });
+
+    const saves = log.filter((l) => l.op === "saveThreadState");
+    expect(saves).toHaveLength(3);
+  });
+
   // --- Error propagation ---
 
   it("propagates runAgent errors and calls onSessionEnd with failed reason", async () => {

package/src/lib/session/session.ts

@@ -577,6 +577,28 @@ export async function createSession<
             }
           }
 
+          // Hand handlers a way to persist the parent's slice mid-loop
+          // (subagents that fork or continue the parent's thread need
+          // this — otherwise the child loads a stale snapshot from the
+          // prior session, since `saveThreadState` would otherwise only
+          // run in the `finally` below).
+          //
+          // Memoized per-batch so a single assistant message that emits
+          // N parallel subagent calls only writes the slice once.
+          // Persisting again later in the same turn is a no-op anyway
+          // (the slice doesn't mutate between handler dispatch and the
+          // batch's last `executeChild`), and Redis/cold-store writes
+          // aren't free.
+          let persistInflight: Promise<void> | undefined;
+          const persistThreadStateOnce = (): Promise<void> => {
+            persistInflight ??= saveThreadState(
+              threadId,
+              stateManager.getPersistedSlice(),
+              threadKey
+            );
+            return persistInflight;
+          };
+
           const toolCallResults = await toolRouter.processToolCalls(
             parsedToolCalls,
             {
@@ -585,17 +607,7 @@ export async function createSession<
               ...(assistantId !== undefined && {
                 assistantMessageId: assistantId,
               }),
-              // Hand handlers a way to persist the parent's slice
-              // mid-loop (subagents that fork or continue the parent's
-              // thread need this — otherwise the child loads a stale
-              // snapshot from the prior session, since `saveThreadState`
-              // would otherwise only run in the `finally` below).
-              persistThreadState: () =>
-                saveThreadState(
-                  threadId,
-                  stateManager.getPersistedSlice(),
-                  threadKey
-                ),
+              persistThreadState: persistThreadStateOnce,
             }
           );
 

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

@@ -35,29 +35,29 @@ describe("createThreadManager ↔ public key helpers round-trip", () => {
     const redis = {
       exists: vi.fn(async (k: string) => (meta.has(k) ? 1 : 0)),
       set: vi.fn(
-        async (k: string, v: string, _ex: string, ttl: number) => {
+        async (k: string, v: string, options?: { EX?: number }) => {
           meta.set(k, v);
-          writtenMetaExpires.set(k, ttl);
+          if (options?.EX !== undefined) writtenMetaExpires.set(k, options.EX);
           return "OK";
         }
       ),
-      del: vi.fn(async (...keys: string[]) => {
+      del: vi.fn(async (keys: string | string[]) => {
         let n = 0;
-        for (const k of keys) {
+        for (const k of Array.isArray(keys) ? keys : [keys]) {
           if (store.delete(k)) n++;
           if (meta.delete(k)) n++;
         }
         return n;
       }),
-      rpush: vi.fn(async (k: string, ...values: string[]) => {
+      rPush: vi.fn(async (k: string, element: string | string[]) => {
         const list = store.get(k) ?? [];
-        list.push(...values);
+        list.push(...(Array.isArray(element) ? element : [element]));
         store.set(k, list);
         return list.length;
       }),
-      lrange: vi.fn(async (k: string) => store.get(k) ?? []),
-      llen: vi.fn(async (k: string) => (store.get(k) ?? []).length),
-      ltrim: vi.fn(async () => "OK"),
+      lRange: vi.fn(async (k: string) => store.get(k) ?? []),
+      lLen: vi.fn(async (k: string) => (store.get(k) ?? []).length),
+      lTrim: vi.fn(async () => "OK"),
       expire: vi.fn(async (k: string, ttl: number) => {
         if (store.has(k)) writtenListExpires.set(k, ttl);
         if (meta.has(k)) writtenMetaExpires.set(k, ttl);

package/src/lib/thread/keys.ts

@@ -38,7 +38,7 @@ export const THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
  * Build the Redis list key that holds a thread's serialized messages.
  *
  * Mirrors the exact key used internally by zeitlich's thread manager,
- * so a consumer calling `redis.lrange(getThreadListKey(key, id), 0, -1)`
+ * so a consumer calling `redis.lRange(getThreadListKey(key, id), 0, -1)`
  * sees the same data the writer wrote.
  *
  * @param threadKey - Thread key (defaults to `"messages"` inside the