zeitlich 0.2.48 → 0.2.50

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

@@ -813,6 +813,204 @@ describe("createSubagentHandler", () => {
     expect(workflowInput.thread).toBeUndefined();
   });
 
+  // --- persistThreadState: parent slice flush before child loads ---
+
+  it("calls persistThreadState before executeChild when forking parent's thread", async () => {
+    const { executeChild } = await import("@temporalio/workflow");
+    const execMock = executeChild as ReturnType<typeof vi.fn>;
+    const persistThreadState = vi.fn(async () => undefined);
+
+    const subagent: SubagentConfig = {
+      agentName: "parent-fork-persist",
+      description: "Forks parent thread",
+      workflow: mockWorkflow(),
+      thread: "fork",
+      newThreadSource: "from-parent",
+    };
+
+    const { handler } = createSubagentHandler([subagent]);
+
+    await handler(
+      {
+        subagent: "parent-fork-persist",
+        description: "test",
+        prompt: "test",
+      },
+      {
+        threadId: "parent-t",
+        toolCallId: "tc",
+        toolName: "Subagent",
+        persistThreadState,
+      }
+    );
+
+    expect(persistThreadState).toHaveBeenCalledTimes(1);
+    const lastExecOrder =
+      execMock.mock.invocationCallOrder[
+        execMock.mock.invocationCallOrder.length - 1
+      ] ?? Infinity;
+    expect(persistThreadState.mock.invocationCallOrder[0]).toBeLessThan(
+      lastExecOrder
+    );
+  });
+
+  it("calls persistThreadState before executeChild when continuing parent's thread", async () => {
+    const { executeChild } = await import("@temporalio/workflow");
+    const execMock = executeChild as ReturnType<typeof vi.fn>;
+    const persistThreadState = vi.fn(async () => undefined);
+
+    const subagent: SubagentConfig = {
+      agentName: "parent-continue-persist",
+      description: "Continues parent thread",
+      workflow: mockWorkflow(),
+      thread: "continue",
+      newThreadSource: "from-parent",
+    };
+
+    const { handler } = createSubagentHandler([subagent]);
+
+    await handler(
+      {
+        subagent: "parent-continue-persist",
+        description: "test",
+        prompt: "test",
+      },
+      {
+        threadId: "parent-t",
+        toolCallId: "tc",
+        toolName: "Subagent",
+        persistThreadState,
+      }
+    );
+
+    expect(persistThreadState).toHaveBeenCalledTimes(1);
+    const lastExecOrder =
+      execMock.mock.invocationCallOrder[
+        execMock.mock.invocationCallOrder.length - 1
+      ] ?? Infinity;
+    expect(persistThreadState.mock.invocationCallOrder[0]).toBeLessThan(
+      lastExecOrder
+    );
+  });
+
+  it("calls persistThreadState when args.threadId points at the parent's thread", async () => {
+    const persistThreadState = vi.fn(async () => undefined);
+
+    const subagent: SubagentConfig = {
+      agentName: "explicit-parent",
+      description: "Explicit parent threadId",
+      workflow: mockWorkflow(),
+      thread: "continue",
+    };
+
+    const { handler } = createSubagentHandler([subagent]);
+
+    await handler(
+      {
+        subagent: "explicit-parent",
+        description: "test",
+        prompt: "test",
+        threadId: "parent-t",
+      },
+      {
+        threadId: "parent-t",
+        toolCallId: "tc",
+        toolName: "Subagent",
+        persistThreadState,
+      }
+    );
+
+    expect(persistThreadState).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not call persistThreadState when child thread is independent of the parent", async () => {
+    const persistThreadState = vi.fn(async () => undefined);
+
+    const subagent: SubagentConfig = {
+      agentName: "independent-thread",
+      description: "Continues a sibling thread",
+      workflow: mockWorkflow(),
+      thread: "continue",
+    };
+
+    const { handler } = createSubagentHandler([subagent]);
+
+    await handler(
+      {
+        subagent: "independent-thread",
+        description: "test",
+        prompt: "test",
+        threadId: "sibling-thread",
+      },
+      {
+        threadId: "parent-t",
+        toolCallId: "tc",
+        toolName: "Subagent",
+        persistThreadState,
+      }
+    );
+
+    expect(persistThreadState).not.toHaveBeenCalled();
+  });
+
+  it("does not call persistThreadState when the child starts a fresh thread", async () => {
+    const persistThreadState = vi.fn(async () => undefined);
+
+    const subagent: SubagentConfig = {
+      agentName: "fresh-thread",
+      description: "Always starts fresh",
+      workflow: mockWorkflow(),
+    };
+
+    const { handler } = createSubagentHandler([subagent]);
+
+    await handler(
+      { subagent: "fresh-thread", description: "test", prompt: "test" },
+      {
+        threadId: "parent-t",
+        toolCallId: "tc",
+        toolName: "Subagent",
+        persistThreadState,
+      }
+    );
+
+    expect(persistThreadState).not.toHaveBeenCalled();
+  });
+
+  it("still spawns the child when persistThreadState throws", async () => {
+    const { executeChild } = await import("@temporalio/workflow");
+    const execMock = executeChild as ReturnType<typeof vi.fn>;
+    const persistThreadState = vi.fn(async () => {
+      throw new Error("redis down");
+    });
+    const callsBefore = execMock.mock.calls.length;
+
+    const subagent: SubagentConfig = {
+      agentName: "persist-fails",
+      description: "Persist failure should not block child",
+      workflow: mockWorkflow(),
+      thread: "fork",
+      newThreadSource: "from-parent",
+    };
+
+    const { handler } = createSubagentHandler([subagent]);
+
+    await expect(
+      handler(
+        { subagent: "persist-fails", description: "test", prompt: "test" },
+        {
+          threadId: "parent-t",
+          toolCallId: "tc",
+          toolName: "Subagent",
+          persistThreadState,
+        }
+      )
+    ).resolves.toBeDefined();
+
+    expect(persistThreadState).toHaveBeenCalledTimes(1);
+    expect(execMock.mock.calls.length).toBe(callsBefore + 1);
+  });
+
   // --- Sandbox continuation ---
 
   it("does not pass sandbox when thread is fork (own sandbox)", async () => {

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

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

@@ -1,45 +1,53 @@
 import { describe, expect, it, beforeEach } from "vitest";
-import type Redis from "ioredis";
+import type { RedisClientType } from "redis";
 import { createThreadManager } from "./manager";
 import type { PersistedThreadState } from "../state/types";
 
+type Keys = string | string[];
+const toKeys = (keys: Keys): string[] => (Array.isArray(keys) ? keys : [keys]);
+
 /**
- * Minimal in-memory Redis stub exposing just the commands used by
+ * Minimal in-memory node-redis stub exposing just the commands used by
  * `createThreadManager`'s state methods (get/set/del/exists/expire) plus
- * the list helpers needed for `initialize`.
+ * the list helpers needed for `initialize`/`fork`. Uses the node-redis
+ * (`redis`) camelCase API and array-or-variadic keys.
  */
-function createFakeRedis(): Redis {
+function createFakeRedis(): RedisClientType {
   const store = new Map<string, string>();
 
   const redis = {
     async get(key: string): Promise<string | null> {
       return store.has(key) ? (store.get(key) as string) : null;
     },
-    async set(key: string, value: string): Promise<"OK"> {
+    async set(
+      key: string,
+      value: string,
+      _options?: { EX?: number }
+    ): Promise<"OK"> {
       store.set(key, String(value));
       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++;
       }
       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> {
       return 1;
     },
-    async lrange(): Promise<string[]> {
+    async lRange(): Promise<string[]> {
       return [];
     },
-    async rpush(): Promise<number> {
+    async rPush(): Promise<number> {
       return 0;
     },
     _store: store,
-  } as unknown as Redis & { _store: Map<string, string> };
+  } as unknown as RedisClientType & { _store: Map<string, string> };
 
   return redis;
 }
@@ -64,10 +72,12 @@ const baseSlice: PersistedThreadState = {
 };
 
 describe("createThreadManager state persistence", () => {
-  let redis: Redis & { _store: Map<string, string> };
+  let redis: RedisClientType & { _store: Map<string, string> };
 
   beforeEach(() => {
-    redis = createFakeRedis() as Redis & { _store: Map<string, string> };
+    redis = createFakeRedis() as RedisClientType & {
+      _store: Map<string, string>;
+    };
   });
 
   async function initThread(threadId: string): Promise<void> {

package/src/lib/thread/manager.ts

@@ -60,12 +60,12 @@ export function createThreadManager<T>(
   return {
     async initialize(): Promise<void> {
       await redis.del(redisKey);
-      await redis.set(metaKey, "1", "EX", ttlSeconds);
+      await redis.set(metaKey, "1", { EX: ttlSeconds });
     },
 
     async load(): Promise<T[]> {
       await assertThreadExists();
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       return data.map(deserialize);
     },
 
@@ -75,23 +75,19 @@ export function createThreadManager<T>(
 
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
-        await redis.eval(
-          APPEND_IDEMPOTENT_SCRIPT,
-          2,
-          dedupKey(dedupId),
-          redisKey,
-          String(ttlSeconds),
-          ...messages.map(serialize)
-        );
+        await redis.eval(APPEND_IDEMPOTENT_SCRIPT, {
+          keys: [dedupKey(dedupId), redisKey],
+          arguments: [String(ttlSeconds), ...messages.map(serialize)],
+        });
       } else {
-        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.rPush(redisKey, messages.map(serialize));
         await redis.expire(redisKey, ttlSeconds);
       }
     },
 
     async fork(newThreadId: string): Promise<BaseThreadManager<T>> {
       await assertThreadExists();
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       const stateRaw = await redis.get(stateKey);
       const forked = createThreadManager({
         ...config,
@@ -100,12 +96,12 @@ export function createThreadManager<T>(
       await forked.initialize();
       if (data.length > 0) {
         const newKey = getThreadListKey(key, newThreadId);
-        await redis.rpush(newKey, ...data);
+        await redis.rPush(newKey, data);
         await redis.expire(newKey, ttlSeconds);
       }
       if (stateRaw != null) {
         const newStateKey = getThreadStateKey(key, newThreadId);
-        await redis.set(newStateKey, stateRaw, "EX", ttlSeconds);
+        await redis.set(newStateKey, stateRaw, { EX: ttlSeconds });
       }
       return forked;
     },
@@ -117,23 +113,23 @@ export function createThreadManager<T>(
           "replaceAll requires the thread manager to be configured with `idOf`"
         );
       }
-      const existing = await redis.lrange(redisKey, 0, -1);
+      const existing = await redis.lRange(redisKey, 0, -1);
       const existingIds = existing
         .map((raw) => idOf(deserialize(raw)))
         .filter((id): id is string => typeof id === "string");
       await redis.del(redisKey);
       if (existingIds.length > 0) {
-        await redis.del(...existingIds.map(dedupKey));
+        await redis.del(existingIds.map(dedupKey));
       }
       if (messages.length > 0) {
-        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.rPush(redisKey, messages.map(serialize));
         await redis.expire(redisKey, ttlSeconds);
       }
       await redis.expire(metaKey, ttlSeconds);
     },
 
     async delete(): Promise<void> {
-      await redis.del(redisKey, metaKey, stateKey);
+      await redis.del([redisKey, metaKey, stateKey]);
     },
 
     async loadState(): Promise<PersistedThreadState | null> {
@@ -144,7 +140,7 @@ export function createThreadManager<T>(
 
     async saveState(state: PersistedThreadState): Promise<void> {
       await assertThreadExists();
-      await redis.set(stateKey, JSON.stringify(state), "EX", ttlSeconds);
+      await redis.set(stateKey, JSON.stringify(state), { EX: ttlSeconds });
     },
 
     async deleteState(): Promise<void> {
@@ -153,7 +149,7 @@ export function createThreadManager<T>(
 
     async length(): Promise<number> {
       await assertThreadExists();
-      return redis.llen(redisKey);
+      return redis.lLen(redisKey);
     },
 
     async truncateFromId(messageId: string): Promise<void> {
@@ -163,7 +159,7 @@ export function createThreadManager<T>(
           "truncateFromId requires the thread manager to be configured with `idOf`"
         );
       }
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       let idx = -1;
       const removedIds: string[] = [];
       for (let i = 0; i < data.length; i++) {
@@ -178,7 +174,7 @@ export function createThreadManager<T>(
         await redis.del(redisKey);
         await redis.expire(metaKey, ttlSeconds);
       } else {
-        await redis.ltrim(redisKey, 0, idx - 1);
+        await redis.lTrim(redisKey, 0, idx - 1);
         await redis.expire(redisKey, ttlSeconds);
       }
       // Clear dedup markers for the removed messages so that a rewind
@@ -186,7 +182,7 @@ export function createThreadManager<T>(
       // re-append without the idempotent-append Lua script treating it
       // as a duplicate.
       if (removedIds.length > 0) {
-        await redis.del(...removedIds.map(dedupKey));
+        await redis.del(removedIds.map(dedupKey));
       }
     },
   };