zeitlich 0.2.49 → 0.2.51

package/dist/adapters/thread/langchain/index.js

@@ -55,11 +55,11 @@ function createThreadManager(config) {
   return {
     async initialize() {
       await redis.del(redisKey);
-      await redis.set(metaKey, "1", "EX", ttlSeconds);
+      await redis.set(metaKey, "1", { EX: ttlSeconds });
     },
     async load() {
       await assertThreadExists();
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       return data.map(deserialize);
     },
     async append(messages) {
@@ -67,22 +67,18 @@ function createThreadManager(config) {
       await assertThreadExists();
       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) {
       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,
@@ -91,12 +87,12 @@ function createThreadManager(config) {
       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;
     },
@@ -107,20 +103,20 @@ function createThreadManager(config) {
           "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) => 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() {
-      await redis.del(redisKey, metaKey, stateKey);
+      await redis.del([redisKey, metaKey, stateKey]);
     },
     async loadState() {
       const raw = await redis.get(stateKey);
@@ -129,14 +125,14 @@ function createThreadManager(config) {
     },
     async saveState(state) {
       await assertThreadExists();
-      await redis.set(stateKey, JSON.stringify(state), "EX", ttlSeconds);
+      await redis.set(stateKey, JSON.stringify(state), { EX: ttlSeconds });
     },
     async deleteState() {
       await redis.del(stateKey);
     },
     async length() {
       await assertThreadExists();
-      return redis.llen(redisKey);
+      return redis.lLen(redisKey);
     },
     async truncateFromId(messageId) {
       await assertThreadExists();
@@ -145,7 +141,7 @@ function createThreadManager(config) {
           "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 = [];
       for (let i = 0; i < data.length; i++) {
@@ -160,11 +156,11 @@ function createThreadManager(config) {
         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);
       }
       if (removedIds.length > 0) {
-        await redis.del(...removedIds.map(dedupKey));
+        await redis.del(removedIds.map(dedupKey));
       }
     }
   };
@@ -179,7 +175,7 @@ async function encodeSnapshot(config) {
   }
   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);
   const dedupIds = idOf ? messages.map(idOf) : [];
@@ -199,31 +195,38 @@ async function applySnapshot(config) {
   }
   const listKey = getThreadListKey(threadKey, threadId);
   const stateKey = getThreadStateKey(threadKey, threadId);
-  await redis.del(listKey, stateKey);
-  const pipeline = redis.pipeline();
+  await redis.del([listKey, stateKey]);
+  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) {
-      await redis.del(
-        listKey,
-        stateKey,
-        ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id))
-      ).catch(() => void 0);
-      throw firstErr;
-    }
+  try {
+    await pipeline.execAsPipeline();
+  } catch (err) {
+    await redis.del([
+      listKey,
+      stateKey,
+      ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id))
+    ]).catch(() => void 0);
+    throw firstPipelineError(err);
   }
-  await redis.set(metaKey, "1", "EX", ttlSeconds);
+  await redis.set(metaKey, "1", { EX: ttlSeconds });
+}
+function firstPipelineError(err) {
+  if (err != null && typeof err === "object" && "replies" in err && Array.isArray(err.replies)) {
+    const firstErr = err.replies.find(
+      (r) => r instanceof Error
+    );
+    if (firstErr) return firstErr;
+  }
+  return err;
 }
 async function clearHotTier(config) {
   const { redis, threadKey, threadId, dedupIds = [] } = config;
@@ -233,7 +236,7 @@ async function clearHotTier(config) {
     getThreadStateKey(threadKey, threadId),
     ...dedupIds.map((id) => getThreadDedupKey(threadId, id))
   ];
-  await redis.del(...keys);
+  await redis.del(keys);
 }
 
 // src/lib/thread/tiered.ts
@@ -420,7 +423,7 @@ function getActivityContext() {
 }
 
 // src/adapters/thread/langchain/model-invoker.ts
-function createLangChainModelInvoker({ redis, model, hooks }) {
+function createLangChainModelInvoker({ redis, model, hooks, ttlSeconds }) {
   return async function invokeLangChainModel2(config) {
     const { threadId, threadKey, agentName, state, metadata, assistantMessageId } = config;
     const { heartbeat, signal } = getActivityContext();
@@ -428,7 +431,8 @@ function createLangChainModelInvoker({ redis, model, hooks }) {
       redis,
       threadId,
       key: threadKey,
-      hooks
+      hooks,
+      ...ttlSeconds !== void 0 && { ttlSeconds }
     });
     const runId = v4_default();
     await thread.truncateFromId(assistantMessageId);
@@ -468,30 +472,35 @@ async function invokeLangChainModel({
   redis,
   model,
   hooks,
+  ttlSeconds,
   config
 }) {
-  const invoker = createLangChainModelInvoker({ redis, model, hooks });
+  const invoker = createLangChainModelInvoker({
+    redis,
+    model,
+    hooks,
+    ...ttlSeconds !== void 0 && { ttlSeconds }
+  });
   return invoker(config);
 }
 
 // src/adapters/thread/langchain/activities.ts
 function createLangChainAdapter(config) {
   const { redis } = config;
-  const baseExtras = {
+  const base = {
+    redis,
     ...config.ttlSeconds !== void 0 && { ttlSeconds: config.ttlSeconds }
   };
   const makeProviderThread = (threadId, threadKey) => createLangChainThreadManager({
-    redis,
+    ...base,
     threadId,
-    key: threadKey,
-    ...baseExtras
+    key: threadKey
   });
   const makeTieredBase = (threadId, threadKey) => createTieredThreadManager({
-    redis,
+    ...base,
     threadId,
     key: threadKey,
     idOf: storedMessageId,
-    ...baseExtras,
     ...config.coldStore && { coldStore: config.coldStore }
   });
   const threadOps = {
@@ -519,11 +528,10 @@ function createLangChainAdapter(config) {
     },
     async forkThread(sourceThreadId, targetThreadId, threadKey) {
       const thread = createLangChainThreadManager({
-        redis,
+        ...base,
         threadId: sourceThreadId,
         key: threadKey,
-        hooks: config.hooks,
-        ...baseExtras
+        hooks: config.hooks
       });
       await thread.fork(targetThreadId);
     },
@@ -555,7 +563,11 @@ function createLangChainAdapter(config) {
       Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])
     );
   }
-  const makeInvoker = (model) => createLangChainModelInvoker({ redis, model, hooks: config.hooks });
+  const makeInvoker = (model) => createLangChainModelInvoker({
+    ...base,
+    model,
+    hooks: config.hooks
+  });
   const invoker = config.model ? makeInvoker(config.model) : () => {
     throw new Error(
       "No default model provided to createLangChainAdapter. Either pass `model` in the config or use `createModelInvoker(model)` instead."