zeitlich 0.2.45 → 0.2.47

package/dist/adapters/thread/anthropic/index.cjs

@@ -16,6 +16,9 @@ function getThreadMetaKey(threadKey, threadId) {
 function getThreadStateKey(threadKey, threadId) {
   return `${threadKey}:state:thread:${threadId}`;
 }
+function getThreadDedupKey(threadId, dedupId) {
+  return `dedup:${dedupId}:thread:${threadId}`;
+}
 
 // src/lib/thread/manager.ts
 var APPEND_IDEMPOTENT_SCRIPT = `
@@ -29,9 +32,6 @@ redis.call('EXPIRE', KEYS[2], tonumber(ARGV[1]))
 redis.call('SET', KEYS[1], '1', 'EX', tonumber(ARGV[1]))
 return 1
 `;
-function getDedupKey(threadId, id) {
-  return `dedup:${id}:thread:${threadId}`;
-}
 function createThreadManager(config) {
   const {
     redis,
@@ -39,11 +39,13 @@ function createThreadManager(config) {
     key = "messages",
     serialize = (m) => JSON.stringify(m),
     deserialize = (raw) => JSON.parse(raw),
-    idOf
+    idOf,
+    ttlSeconds = THREAD_TTL_SECONDS
   } = config;
   const redisKey = getThreadListKey(key, threadId);
   const metaKey = getThreadMetaKey(key, threadId);
   const stateKey = getThreadStateKey(key, threadId);
+  const dedupKey = (id) => getThreadDedupKey(threadId, id);
   async function assertThreadExists() {
     const exists = await redis.exists(metaKey);
     if (!exists) {
@@ -53,7 +55,7 @@ function createThreadManager(config) {
   return {
     async initialize() {
       await redis.del(redisKey);
-      await redis.set(metaKey, "1", "EX", THREAD_TTL_SECONDS);
+      await redis.set(metaKey, "1", "EX", ttlSeconds);
     },
     async load() {
       await assertThreadExists();
@@ -65,18 +67,17 @@ function createThreadManager(config) {
       await assertThreadExists();
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
-        const dedupKey = getDedupKey(threadId, dedupId);
         await redis.eval(
           APPEND_IDEMPOTENT_SCRIPT,
           2,
-          dedupKey,
+          dedupKey(dedupId),
           redisKey,
-          String(THREAD_TTL_SECONDS),
+          String(ttlSeconds),
           ...messages.map(serialize)
         );
       } else {
         await redis.rpush(redisKey, ...messages.map(serialize));
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+        await redis.expire(redisKey, ttlSeconds);
       }
     },
     async fork(newThreadId) {
@@ -91,11 +92,11 @@ function createThreadManager(config) {
       if (data.length > 0) {
         const newKey = getThreadListKey(key, newThreadId);
         await redis.rpush(newKey, ...data);
-        await redis.expire(newKey, THREAD_TTL_SECONDS);
+        await redis.expire(newKey, ttlSeconds);
       }
       if (stateRaw != null) {
         const newStateKey = getThreadStateKey(key, newThreadId);
-        await redis.set(newStateKey, stateRaw, "EX", THREAD_TTL_SECONDS);
+        await redis.set(newStateKey, stateRaw, "EX", ttlSeconds);
       }
       return forked;
     },
@@ -110,15 +111,13 @@ function createThreadManager(config) {
       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((id) => getDedupKey(threadId, id))
-        );
+        await redis.del(...existingIds.map(dedupKey));
       }
       if (messages.length > 0) {
         await redis.rpush(redisKey, ...messages.map(serialize));
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+        await redis.expire(redisKey, ttlSeconds);
       }
-      await redis.expire(metaKey, THREAD_TTL_SECONDS);
+      await redis.expire(metaKey, ttlSeconds);
     },
     async delete() {
       await redis.del(redisKey, metaKey, stateKey);
@@ -130,12 +129,7 @@ function createThreadManager(config) {
     },
     async saveState(state) {
       await assertThreadExists();
-      await redis.set(
-        stateKey,
-        JSON.stringify(state),
-        "EX",
-        THREAD_TTL_SECONDS
-      );
+      await redis.set(stateKey, JSON.stringify(state), "EX", ttlSeconds);
     },
     async deleteState() {
       await redis.del(stateKey);
@@ -164,20 +158,133 @@ function createThreadManager(config) {
       if (idx === -1) return;
       if (idx === 0) {
         await redis.del(redisKey);
-        await redis.expire(metaKey, THREAD_TTL_SECONDS);
+        await redis.expire(metaKey, ttlSeconds);
       } else {
         await redis.ltrim(redisKey, 0, idx - 1);
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+        await redis.expire(redisKey, ttlSeconds);
       }
       if (removedIds.length > 0) {
-        await redis.del(
-          ...removedIds.map((id) => getDedupKey(threadId, id))
-        );
+        await redis.del(...removedIds.map(dedupKey));
       }
     }
   };
 }
 
+// src/lib/thread/snapshot.ts
+async function encodeSnapshot(config) {
+  const { redis, threadKey, threadId, idOf } = config;
+  const metaKey = getThreadMetaKey(threadKey, threadId);
+  if (await redis.exists(metaKey) === 0) {
+    return null;
+  }
+  const listKey = getThreadListKey(threadKey, threadId);
+  const stateKey = getThreadStateKey(threadKey, threadId);
+  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) : [];
+  return { v: 1, messages, state, dedupIds };
+}
+async function applySnapshot(config) {
+  const {
+    redis,
+    threadKey,
+    threadId,
+    snapshot,
+    ttlSeconds = THREAD_TTL_SECONDS
+  } = config;
+  const metaKey = getThreadMetaKey(threadKey, threadId);
+  if (await redis.exists(metaKey) === 1) {
+    return;
+  }
+  const listKey = getThreadListKey(threadKey, threadId);
+  const stateKey = getThreadStateKey(threadKey, threadId);
+  await redis.del(listKey, stateKey);
+  const pipeline = redis.pipeline();
+  if (snapshot.messages.length > 0) {
+    pipeline.rpush(listKey, ...snapshot.messages);
+    pipeline.expire(listKey, ttlSeconds);
+  }
+  if (snapshot.state != null) {
+    pipeline.set(stateKey, JSON.stringify(snapshot.state), "EX", ttlSeconds);
+  }
+  for (const id of snapshot.dedupIds) {
+    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;
+    }
+  }
+  await redis.set(metaKey, "1", "EX", ttlSeconds);
+}
+async function clearHotTier(config) {
+  const { redis, threadKey, threadId, dedupIds = [] } = config;
+  const keys = [
+    getThreadListKey(threadKey, threadId),
+    getThreadMetaKey(threadKey, threadId),
+    getThreadStateKey(threadKey, threadId),
+    ...dedupIds.map((id) => getThreadDedupKey(threadId, id))
+  ];
+  await redis.del(...keys);
+}
+
+// src/lib/thread/tiered.ts
+function createTieredThreadManager(config) {
+  const {
+    redis,
+    threadId,
+    key = "messages",
+    coldStore,
+    idOf,
+    deserialize = (raw) => JSON.parse(raw),
+    ttlSeconds = THREAD_TTL_SECONDS
+  } = config;
+  const base = createThreadManager(config);
+  const rawIdOf = idOf ? (raw) => idOf(deserialize(raw)) : void 0;
+  return Object.assign(base, {
+    async hydrate() {
+      if (!coldStore) return;
+      const snapshot = await coldStore.read(key, threadId);
+      if (!snapshot) return;
+      await applySnapshot({
+        redis,
+        threadKey: key,
+        threadId,
+        snapshot,
+        ttlSeconds
+      });
+    },
+    async flush(opts) {
+      if (!coldStore) return;
+      const snapshot = await encodeSnapshot({
+        redis,
+        threadKey: key,
+        threadId,
+        ...rawIdOf ? { idOf: rawIdOf } : {}
+      });
+      if (!snapshot) return;
+      await coldStore.write(key, threadId, snapshot);
+      const deleteHot = opts?.deleteHot ?? true;
+      if (deleteHot) {
+        await clearHotTier({
+          redis,
+          threadKey: key,
+          threadId,
+          dedupIds: snapshot.dedupIds
+        });
+      }
+    }
+  });
+}
+
 // src/adapters/thread/anthropic/thread-manager.ts
 function storedMessageId(msg) {
   return msg.id;
@@ -210,7 +317,8 @@ function createAnthropicThreadManager(config) {
     redis: config.redis,
     threadId: config.threadId,
     key: config.key,
-    idOf: storedMessageId
+    idOf: storedMessageId,
+    ...config.ttlSeconds !== void 0 && { ttlSeconds: config.ttlSeconds }
   };
   const base = createThreadManager(baseConfig);
   const helpers = {
@@ -310,6 +418,94 @@ function createAnthropicThreadManager(config) {
   };
   return manager;
 }
+
+// src/adapters/thread/anthropic/prompt-cache.ts
+var DEFAULT_MAX_CACHE_BREAKPOINTS = 4;
+var UNCACHEABLE_BLOCK_TYPES = /* @__PURE__ */ new Set(["thinking", "redacted_thinking"]);
+function resolvePromptCacheOptions(promptCache) {
+  if (promptCache === false) return void 0;
+  if (promptCache === true || promptCache === void 0) return {};
+  return promptCache;
+}
+function addPromptCacheControl(payload, options = {}) {
+  const maxBreakpoints = options.maxBreakpoints ?? DEFAULT_MAX_CACHE_BREAKPOINTS;
+  if (maxBreakpoints <= 0) return payload;
+  if (countCacheControls(payload) >= maxBreakpoints) return payload;
+  const cacheControl = {
+    type: "ephemeral",
+    ttl: options.ttl ?? "5m"
+  };
+  const messages = addCacheControlToLastMessageBlock(
+    payload.messages,
+    cacheControl
+  );
+  if (messages === payload.messages) return payload;
+  return { ...payload, messages };
+}
+function addCacheControlToLastMessageBlock(messages, cacheControl) {
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+    const message = messages[messageIndex];
+    if (!message) continue;
+    if (typeof message.content === "string") {
+      if (message.content.length === 0) continue;
+      return replaceMessage(messages, messageIndex, {
+        ...message,
+        content: [
+          { type: "text", text: message.content, cache_control: cacheControl }
+        ]
+      });
+    }
+    if (!Array.isArray(message.content)) continue;
+    for (let blockIndex = message.content.length - 1; blockIndex >= 0; blockIndex--) {
+      const block = message.content[blockIndex];
+      if (!isCacheableContentBlock(block)) continue;
+      if (hasCacheControl(block)) return messages;
+      const content = [...message.content];
+      content[blockIndex] = {
+        ...block,
+        cache_control: cacheControl
+      };
+      return replaceMessage(messages, messageIndex, { ...message, content });
+    }
+  }
+  return messages;
+}
+function replaceMessage(messages, index, message) {
+  const next = [...messages];
+  next[index] = message;
+  return next;
+}
+function isCacheableContentBlock(block) {
+  if (!isRecord(block)) return false;
+  const type = typeof block.type === "string" ? block.type : void 0;
+  if (type && UNCACHEABLE_BLOCK_TYPES.has(type)) return false;
+  if (type === "text" && block.text === "") return false;
+  return true;
+}
+function countCacheControls(payload) {
+  let count = 0;
+  for (const tool of payload.tools ?? []) {
+    if (hasCacheControl(tool)) count++;
+  }
+  if (Array.isArray(payload.system)) {
+    for (const block of payload.system) {
+      if (hasCacheControl(block)) count++;
+    }
+  }
+  for (const message of payload.messages) {
+    if (!Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (hasCacheControl(block)) count++;
+    }
+  }
+  return count;
+}
+function hasCacheControl(value) {
+  return isRecord(value) && value.cache_control != null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function getActivityContext() {
   try {
     const ctx = activity.Context.current();
@@ -332,6 +528,7 @@ function createAnthropicModelInvoker({
   client,
   model,
   maxTokens = 16384,
+  promptCache,
   hooks
 }) {
   return async function invokeAnthropicModel2(config) {
@@ -344,15 +541,20 @@ function createAnthropicModelInvoker({
       hooks
     });
     await thread.truncateFromId(assistantMessageId);
-    const { messages, system } = await thread.prepareForInvocation();
+    const prepared = await thread.prepareForInvocation();
     const anthropicTools = toAnthropicTools(state.tools);
-    const tools = anthropicTools.length > 0 ? anthropicTools : void 0;
+    const preparedPayload = {
+      ...prepared,
+      ...anthropicTools.length > 0 ? { tools: anthropicTools } : {}
+    };
+    const cacheOptions = resolvePromptCacheOptions(promptCache);
+    const payload = cacheOptions ? addPromptCacheControl(preparedPayload, cacheOptions) : preparedPayload;
     const params = {
       model,
       max_tokens: maxTokens,
-      messages,
-      ...system ? { system } : {},
-      ...tools ? { tools } : {}
+      messages: payload.messages,
+      ...payload.system ? { system: payload.system } : {},
+      ...payload.tools ? { tools: payload.tools } : {}
     };
     const stream = client.messages.stream(params, { signal });
     for await (const _event of stream) {
@@ -383,6 +585,7 @@ async function invokeAnthropicModel({
   client,
   model,
   maxTokens,
+  promptCache,
   hooks,
   config
 }) {
@@ -391,6 +594,7 @@ async function invokeAnthropicModel({
     client,
     model,
     maxTokens,
+    promptCache,
     hooks
   });
   return invoker(config);
@@ -399,46 +603,43 @@ async function invokeAnthropicModel({
 // src/adapters/thread/anthropic/activities.ts
 function createAnthropicAdapter(config) {
   const { redis, client } = config;
+  const baseExtras = {
+    ...config.ttlSeconds !== void 0 && { ttlSeconds: config.ttlSeconds }
+  };
+  const makeProviderThread = (threadId, threadKey) => createAnthropicThreadManager({
+    redis,
+    threadId,
+    key: threadKey,
+    ...baseExtras
+  });
+  const makeTieredBase = (threadId, threadKey) => createTieredThreadManager({
+    redis,
+    threadId,
+    key: threadKey,
+    idOf: storedMessageId,
+    ...baseExtras,
+    ...config.coldStore && { coldStore: config.coldStore }
+  });
   const threadOps = {
     async initializeThread(threadId, threadKey) {
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.initialize();
     },
     async appendHumanMessage(threadId, id, content, threadKey) {
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.appendUserMessage(id, content);
     },
     async appendSystemMessage(threadId, id, content, threadKey) {
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.appendSystemMessage(id, content);
     },
     async appendToolResult(id, cfg) {
       const { threadId, threadKey, toolCallId, toolName, content } = cfg;
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.appendToolResult(id, toolCallId, toolName, content);
     },
     async appendAgentMessage(threadId, id, message, threadKey) {
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.appendAssistantMessage(id, message.content);
     },
     async forkThread(sourceThreadId, targetThreadId, threadKey) {
@@ -446,29 +647,30 @@ function createAnthropicAdapter(config) {
         redis,
         threadId: sourceThreadId,
         key: threadKey,
-        hooks: config.hooks
+        hooks: config.hooks,
+        ...baseExtras
       });
       await thread.fork(targetThreadId);
     },
     async truncateThread(threadId, messageId, threadKey) {
-      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.truncateFromId(messageId);
     },
     async loadThreadState(threadId, threadKey) {
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       return thread.loadState();
     },
     async saveThreadState(threadId, state, threadKey) {
-      const thread = createAnthropicThreadManager({
-        redis,
-        threadId,
-        key: threadKey
-      });
+      const thread = makeProviderThread(threadId, threadKey);
       await thread.saveState(state);
+    },
+    async hydrateThread(threadId, threadKey) {
+      if (!config.coldStore) return;
+      await makeTieredBase(threadId, threadKey).hydrate();
+    },
+    async flushThread(threadId, threadKey) {
+      if (!config.coldStore) return;
+      await makeTieredBase(threadId, threadKey).flush();
     }
   };
   function createActivities(scope) {
@@ -478,13 +680,14 @@ function createAnthropicAdapter(config) {
       Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])
     );
   }
-  const makeInvoker = (model, maxTokens) => {
+  const makeInvoker = (model, maxTokens, promptCache) => {
     const invokerConfig = {
       redis,
       client,
       model,
       ...maxTokens !== void 0 ? { maxTokens } : {},
       ...config.maxTokens !== void 0 && maxTokens === void 0 ? { maxTokens: config.maxTokens } : {},
+      ...promptCache !== void 0 ? { promptCache } : config.promptCache !== void 0 ? { promptCache: config.promptCache } : {},
       hooks: config.hooks
     };
     return createAnthropicModelInvoker(invokerConfig);
@@ -503,9 +706,11 @@ function createAnthropicAdapter(config) {
 }
 
 exports.ADAPTER_ID = ADAPTER_ID;
+exports.addPromptCacheControl = addPromptCacheControl;
 exports.createAnthropicAdapter = createAnthropicAdapter;
 exports.createAnthropicModelInvoker = createAnthropicModelInvoker;
 exports.createAnthropicThreadManager = createAnthropicThreadManager;
 exports.invokeAnthropicModel = invokeAnthropicModel;
+exports.resolvePromptCacheOptions = resolvePromptCacheOptions;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map