zeitlich 0.2.36 → 0.2.38

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

@@ -2,7 +2,10 @@ import type Redis from "ioredis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { SerializableToolDefinition } from "../../../lib/types";
 import type { AgentResponse, ModelInvokerConfig } from "../../../lib/model";
-import { createAnthropicThreadManager, type AnthropicThreadManagerHooks } from "./thread-manager";
+import {
+  createAnthropicThreadManager,
+  type AnthropicThreadManagerHooks,
+} from "./thread-manager";
 import { getActivityContext } from "../../../lib/activity";
 
 export interface AnthropicModelInvokerConfig {
@@ -15,7 +18,7 @@ export interface AnthropicModelInvokerConfig {
 }
 
 function toAnthropicTools(
-  tools: SerializableToolDefinition[],
+  tools: SerializableToolDefinition[]
 ): Anthropic.Messages.Tool[] {
   return tools.map((t) => ({
     name: t.name,
@@ -56,13 +59,19 @@ export function createAnthropicModelInvoker({
   hooks,
 }: AnthropicModelInvokerConfig) {
   return async function invokeAnthropicModel(
-    config: ModelInvokerConfig,
+    config: ModelInvokerConfig
   ): Promise<AgentResponse<Anthropic.Messages.Message>> {
     const { threadId, threadKey, state } = config;
     const { heartbeat, signal } = getActivityContext();
 
-    const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey, hooks });
-    const { messages, system } = await thread.prepareForInvocation();
+    const thread = createAnthropicThreadManager({
+      redis,
+      threadId,
+      key: threadKey,
+      hooks,
+    });
+    const { messages, system, storedLength } =
+      await thread.prepareForInvocation();
 
     const anthropicTools = toAnthropicTools(state.tools);
     const tools = anthropicTools.length > 0 ? anthropicTools : undefined;
@@ -85,7 +94,7 @@ export function createAnthropicModelInvoker({
 
     const toolCalls = response.content.filter(
       (block): block is Anthropic.Messages.ToolUseBlock =>
-        block.type === "tool_use",
+        block.type === "tool_use"
     );
 
     return {
@@ -98,9 +107,11 @@ export function createAnthropicModelInvoker({
       usage: {
         inputTokens: response.usage.input_tokens,
         outputTokens: response.usage.output_tokens,
-        cachedWriteTokens: response.usage.cache_creation_input_tokens ?? undefined,
+        cachedWriteTokens:
+          response.usage.cache_creation_input_tokens ?? undefined,
         cachedReadTokens: response.usage.cache_read_input_tokens ?? undefined,
       },
+      threadLengthAtCall: storedLength,
     };
   };
 }

package/src/adapters/thread/anthropic/proxy.ts

@@ -27,7 +27,11 @@ const ADAPTER_PREFIX = "anthropic";
 
 export function proxyAnthropicThreadOps(
   scope?: string,
-  options?: Parameters<typeof createThreadOpsProxy>[2],
+  options?: Parameters<typeof createThreadOpsProxy>[2]
 ): ActivityInterfaceFor<ThreadOps<AnthropicContent>> {
-  return createThreadOpsProxy(ADAPTER_PREFIX, scope, options) as ActivityInterfaceFor<ThreadOps<AnthropicContent>>;
+  return createThreadOpsProxy(
+    ADAPTER_PREFIX,
+    scope,
+    options
+  ) as ActivityInterfaceFor<ThreadOps<AnthropicContent>>;
 }

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

@@ -27,7 +27,10 @@ const userMsg: StoredMessage = {
 
 const assistantMsg: StoredMessage = {
   id: "msg-2",
-  message: { role: "assistant", content: [{ type: "text", text: "Hi there!" }] },
+  message: {
+    role: "assistant",
+    content: [{ type: "text", text: "Hi there!" }],
+  },
 };
 
 describe("Anthropic thread manager hooks", () => {
@@ -40,7 +43,9 @@ describe("Anthropic thread manager hooks", () => {
           ...msg,
           message: {
             ...msg.message,
-            content: [{ type: "text" as const, text: `[modified] ${firstBlock?.text}` }],
+            content: [
+              { type: "text" as const, text: `[modified] ${firstBlock?.text}` },
+            ],
           },
         };
       });
@@ -55,10 +60,18 @@ describe("Anthropic thread manager hooks", () => {
       const { messages, system } = await tm.prepareForInvocation();
 
       expect(hook).toHaveBeenCalledTimes(3);
-      expect(hook).toHaveBeenCalledWith(systemMsg, 0, [systemMsg, userMsg, assistantMsg]);
+      expect(hook).toHaveBeenCalledWith(systemMsg, 0, [
+        systemMsg,
+        userMsg,
+        assistantMsg,
+      ]);
       expect(system).toBe("You are helpful.");
-      expect(messages[0]?.content).toEqual([{ type: "text", text: "[modified] Hello" }]);
-      expect(messages[1]?.content).toEqual([{ type: "text", text: "[modified] Hi there!" }]);
+      expect(messages[0]?.content).toEqual([
+        { type: "text", text: "[modified] Hello" },
+      ]);
+      expect(messages[1]?.content).toEqual([
+        { type: "text", text: "[modified] Hi there!" },
+      ]);
     });
 
     it("is not called when not configured", async () => {
@@ -90,7 +103,9 @@ describe("Anthropic thread manager hooks", () => {
       const { messages } = await tm.prepareForInvocation();
 
       expect(hook).toHaveBeenCalledTimes(2);
-      expect(messages[0]?.content).toEqual([{ type: "text", text: "[post] done" }]);
+      expect(messages[0]?.content).toEqual([
+        { type: "text", text: "[post] done" },
+      ]);
     });
 
     it("receives the full prepared messages array", async () => {
@@ -105,7 +120,11 @@ describe("Anthropic thread manager hooks", () => {
 
       await tm.prepareForInvocation();
 
-      const args = hook.mock.calls[0] as unknown as [unknown, number, unknown[]];
+      const args = hook.mock.calls[0] as unknown as [
+        unknown,
+        number,
+        unknown[],
+      ];
       expect(args[2]).toHaveLength(2);
     });
   });

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

@@ -9,9 +9,7 @@ import type {
 } from "../../../lib/thread/types";
 
 /** SDK-native content type for Anthropic human messages */
-export type AnthropicContent =
-  | string
-  | Anthropic.Messages.ContentBlockParam[];
+export type AnthropicContent = string | Anthropic.Messages.ContentBlockParam[];
 
 /** SDK-native content type for Anthropic system prompts (supports cache_control blocks) */
 export type AnthropicSystemContent =
@@ -26,7 +24,10 @@ export interface StoredMessage {
   isSystem?: boolean;
 }
 
-export type AnthropicThreadManagerHooks = ThreadManagerHooks<StoredMessage, Anthropic.Messages.MessageParam>;
+export type AnthropicThreadManagerHooks = ThreadManagerHooks<
+  StoredMessage,
+  Anthropic.Messages.MessageParam
+>;
 
 export interface AnthropicThreadManagerConfig {
   redis: Redis;
@@ -40,14 +41,20 @@ export interface AnthropicThreadManagerConfig {
 export interface AnthropicInvocationPayload {
   messages: Anthropic.Messages.MessageParam[];
   system?: string | Anthropic.Messages.TextBlockParam[];
+  /** Number of stored messages loaded from Redis before preparation. */
+  storedLength: number;
 }
 
 /** Thread manager with Anthropic MessageParam convenience helpers */
-export interface AnthropicThreadManager
-  extends ProviderThreadManager<StoredMessage, AnthropicContent, JsonValue, AnthropicSystemContent> {
+export interface AnthropicThreadManager extends ProviderThreadManager<
+  StoredMessage,
+  AnthropicContent,
+  JsonValue,
+  AnthropicSystemContent
+> {
   appendAssistantMessage(
     id: string,
-    content: Anthropic.Messages.ContentBlock[],
+    content: Anthropic.Messages.ContentBlock[]
   ): Promise<void>;
   prepareForInvocation(): Promise<AnthropicInvocationPayload>;
 }
@@ -58,7 +65,7 @@ function storedMessageId(msg: StoredMessage): string {
 
 /** Normalise content into an array of ContentBlockParam */
 function toContentBlocks(
-  content: AnthropicContent,
+  content: AnthropicContent
 ): Anthropic.Messages.ContentBlockParam[] {
   if (typeof content === "string") {
     return [{ type: "text", text: content }];
@@ -72,7 +79,7 @@ function toContentBlocks(
  * merging, multiple sequential tool-result messages would violate this.
  */
 function mergeConsecutiveMessages(
-  messages: Anthropic.Messages.MessageParam[],
+  messages: Anthropic.Messages.MessageParam[]
 ): Anthropic.Messages.MessageParam[] {
   const merged: Anthropic.Messages.MessageParam[] = [];
   for (const msg of messages) {
@@ -88,9 +95,7 @@ function mergeConsecutiveMessages(
     } else {
       merged.push({
         ...msg,
-        content: Array.isArray(msg.content)
-          ? [...msg.content]
-          : msg.content,
+        content: Array.isArray(msg.content) ? [...msg.content] : msg.content,
       });
     }
   }
@@ -103,7 +108,7 @@ function mergeConsecutiveMessages(
  * appending typed messages.
  */
 export function createAnthropicThreadManager(
-  config: AnthropicThreadManagerConfig,
+  config: AnthropicThreadManagerConfig
 ): AnthropicThreadManager {
   const baseConfig: ThreadManagerConfig<StoredMessage> = {
     redis: config.redis,
@@ -117,49 +122,56 @@ export function createAnthropicThreadManager(
   const helpers: Omit<AnthropicThreadManager, keyof typeof base> = {
     async appendUserMessage(
       id: string,
-      content: AnthropicContent,
+      content: AnthropicContent
     ): Promise<void> {
-      await base.append([{
-        id,
-        message: { role: "user", content: toContentBlocks(content) },
-      }]);
+      await base.append([
+        {
+          id,
+          message: { role: "user", content: toContentBlocks(content) },
+        },
+      ]);
     },
 
     async appendSystemMessage(
       id: string,
-      content: AnthropicSystemContent,
+      content: AnthropicSystemContent
     ): Promise<void> {
       await base.initialize();
-      await base.append([{
-        id,
-        // Stored under a user-role placeholder to satisfy the MessageParam
-        // shape; the `isSystem` flag steers extraction in prepareForInvocation.
-        message: {
-          role: "user",
-          content: content as Anthropic.Messages.MessageParam["content"],
+      await base.append([
+        {
+          id,
+          // Stored under a user-role placeholder to satisfy the MessageParam
+          // shape; the `isSystem` flag steers extraction in prepareForInvocation.
+          message: {
+            role: "user",
+            content: content as Anthropic.Messages.MessageParam["content"],
+          },
+          isSystem: true,
         },
-        isSystem: true,
-      }]);
+      ]);
     },
 
     async appendAssistantMessage(
       id: string,
-      content: Anthropic.Messages.ContentBlock[],
+      content: Anthropic.Messages.ContentBlock[]
     ): Promise<void> {
-      await base.append([{
-        id,
-        message: {
-          role: "assistant",
-          content: content as unknown as Anthropic.Messages.ContentBlockParam[],
+      await base.append([
+        {
+          id,
+          message: {
+            role: "assistant",
+            content:
+              content as unknown as Anthropic.Messages.ContentBlockParam[],
+          },
         },
-      }]);
+      ]);
     },
 
     async appendToolResult(
       id: string,
       toolCallId: string,
       _toolName: string,
-      content: JsonValue,
+      content: JsonValue
     ): Promise<void> {
       const toolContent =
         typeof content === "string"
@@ -167,17 +179,21 @@ export function createAnthropicThreadManager(
           : Array.isArray(content)
             ? (content as unknown as Anthropic.Messages.ToolResultBlockParam["content"])
             : JSON.stringify(content);
-      await base.append([{
-        id,
-        message: {
-          role: "user",
-          content: [{
-            type: "tool_result" as const,
-            tool_use_id: toolCallId,
-            content: toolContent,
-          }],
+      await base.append([
+        {
+          id,
+          message: {
+            role: "user",
+            content: [
+              {
+                type: "tool_result" as const,
+                tool_use_id: toolCallId,
+                content: toolContent,
+              },
+            ],
+          },
         },
-      }]);
+      ]);
     },
 
     async prepareForInvocation(): Promise<AnthropicInvocationPayload> {
@@ -206,6 +222,7 @@ export function createAnthropicThreadManager(
           ? messages.map((msg, i) => onPreparedMessage(msg, i, messages))
           : messages,
         ...(system ? { system } : {}),
+        storedLength: stored.length,
       };
     },
   };

package/src/adapters/thread/google-genai/activities.ts

@@ -200,7 +200,7 @@ export function createGoogleGenAIAdapter(
       threadId: string,
       id: string,
       message: Content,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({
         redis,
@@ -222,6 +222,19 @@ export function createGoogleGenAIAdapter(
       });
       await thread.fork(targetThreadId);
     },
+
+    async truncateThread(
+      threadId: string,
+      length: number,
+      threadKey?: string,
+    ): Promise<void> {
+      const thread = createGoogleGenAIThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
+      await thread.truncate(length);
+    },
   };
 
   function createActivities<S extends string = "">(
@@ -240,7 +253,12 @@ export function createGoogleGenAIAdapter(
     model: string,
     client: GoogleGenAI
   ): ModelInvoker<Content> =>
-    createGoogleGenAIModelInvoker({ redis, client, model, hooks: config.hooks });
+    createGoogleGenAIModelInvoker({
+      redis,
+      client,
+      model,
+      hooks: config.hooks,
+    });
 
   const invoker: ModelInvoker<Content> =
     config.model && config.client

package/src/adapters/thread/google-genai/model-invoker.ts

@@ -1,8 +1,17 @@
 import type Redis from "ioredis";
-import type { GoogleGenAI, Content, FunctionDeclaration, Part, GenerateContentResponse } from "@google/genai";
+import type {
+  GoogleGenAI,
+  Content,
+  FunctionDeclaration,
+  Part,
+  GenerateContentResponse,
+} from "@google/genai";
 import type { SerializableToolDefinition } from "../../../lib/types";
 import type { AgentResponse, ModelInvokerConfig } from "../../../lib/model";
-import { createGoogleGenAIThreadManager, type GoogleGenAIThreadManagerHooks } from "./thread-manager";
+import {
+  createGoogleGenAIThreadManager,
+  type GoogleGenAIThreadManagerHooks,
+} from "./thread-manager";
 import { getActivityContext } from "../../../lib/activity";
 
 export interface GoogleGenAIModelInvokerConfig {
@@ -13,7 +22,7 @@ export interface GoogleGenAIModelInvokerConfig {
 }
 
 function toFunctionDeclarations(
-  tools: SerializableToolDefinition[],
+  tools: SerializableToolDefinition[]
 ): FunctionDeclaration[] {
   return tools.map((t) => ({
     name: t.name,
@@ -53,13 +62,18 @@ export function createGoogleGenAIModelInvoker({
   hooks,
 }: GoogleGenAIModelInvokerConfig) {
   return async function invokeGoogleGenAIModel(
-    config: ModelInvokerConfig,
+    config: ModelInvokerConfig
   ): Promise<AgentResponse<Content>> {
     const { threadId, threadKey, state } = config;
     const { heartbeat, signal } = getActivityContext();
 
-    const thread = createGoogleGenAIThreadManager({ redis, threadId, key: threadKey, hooks });
-    const { contents, systemInstruction } =
+    const thread = createGoogleGenAIThreadManager({
+      redis,
+      threadId,
+      key: threadKey,
+      hooks,
+    });
+    const { contents, systemInstruction, storedLength } =
       await thread.prepareForInvocation();
 
     const functionDeclarations = toFunctionDeclarations(state.tools);
@@ -103,6 +117,7 @@ export function createGoogleGenAIModelInvoker({
         outputTokens: lastChunk.usageMetadata?.candidatesTokenCount,
         cachedReadTokens: lastChunk.usageMetadata?.cachedContentTokenCount,
       },
+      threadLengthAtCall: storedLength,
     };
   };
 }
@@ -125,6 +140,11 @@ export async function invokeGoogleGenAIModel({
   hooks?: GoogleGenAIThreadManagerHooks;
   config: ModelInvokerConfig;
 }): Promise<AgentResponse<Content>> {
-  const invoker = createGoogleGenAIModelInvoker({ redis, client, model, hooks });
+  const invoker = createGoogleGenAIModelInvoker({
+    redis,
+    client,
+    model,
+    hooks,
+  });
   return invoker(config);
 }

package/src/adapters/thread/google-genai/proxy.ts

@@ -27,7 +27,11 @@ const ADAPTER_PREFIX = "googleGenAI";
 
 export function proxyGoogleGenAIThreadOps(
   scope?: string,
-  options?: Parameters<typeof createThreadOpsProxy>[2],
+  options?: Parameters<typeof createThreadOpsProxy>[2]
 ): ActivityInterfaceFor<ThreadOps<GoogleGenAIContent>> {
-  return createThreadOpsProxy(ADAPTER_PREFIX, scope, options) as ActivityInterfaceFor<ThreadOps<GoogleGenAIContent>>;
+  return createThreadOpsProxy(
+    ADAPTER_PREFIX,
+    scope,
+    options
+  ) as ActivityInterfaceFor<ThreadOps<GoogleGenAIContent>>;
 }

package/src/adapters/thread/google-genai/thread-manager.test.ts

@@ -39,7 +39,9 @@ describe("Google GenAI thread manager hooks", () => {
           ...msg,
           content: {
             ...msg.content,
-            parts: [{ text: `[modified] ${msg.content.parts?.[0]?.text ?? ""}` }],
+            parts: [
+              { text: `[modified] ${msg.content.parts?.[0]?.text ?? ""}` },
+            ],
           },
         };
       });
@@ -54,7 +56,11 @@ describe("Google GenAI thread manager hooks", () => {
       const { contents, systemInstruction } = await tm.prepareForInvocation();
 
       expect(hook).toHaveBeenCalledTimes(3);
-      expect(hook).toHaveBeenCalledWith(systemContent, 0, [systemContent, userContent, modelContent]);
+      expect(hook).toHaveBeenCalledWith(systemContent, 0, [
+        systemContent,
+        userContent,
+        modelContent,
+      ]);
       expect(systemInstruction).toEqual([{ text: "You are helpful." }]);
       expect(contents[0]?.parts?.[0]?.text).toBe("[modified] Hello");
       expect(contents[1]?.parts?.[0]?.text).toBe("[modified] Hi there!");
@@ -106,7 +112,11 @@ describe("Google GenAI thread manager hooks", () => {
 
       await tm.prepareForInvocation();
 
-      const args = hook.mock.calls[0] as unknown as [Content, number, Content[]];
+      const args = hook.mock.calls[0] as unknown as [
+        Content,
+        number,
+        Content[],
+      ];
       expect(args[2]).toHaveLength(2);
     });
   });

package/src/adapters/thread/google-genai/thread-manager.ts

@@ -20,7 +20,10 @@ export interface StoredContent {
   content: Content;
 }
 
-export type GoogleGenAIThreadManagerHooks = ThreadManagerHooks<StoredContent, Content>;
+export type GoogleGenAIThreadManagerHooks = ThreadManagerHooks<
+  StoredContent,
+  Content
+>;
 
 export interface GoogleGenAIThreadManagerConfig {
   redis: Redis;
@@ -34,11 +37,17 @@ export interface GoogleGenAIThreadManagerConfig {
 export interface GoogleGenAIInvocationPayload {
   contents: Content[];
   systemInstruction?: Part[];
+  /** Number of stored messages loaded from Redis before preparation. */
+  storedLength: number;
 }
 
 /** Thread manager with Google GenAI Content convenience helpers */
-export interface GoogleGenAIThreadManager
-  extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse, GoogleGenAISystemContent> {
+export interface GoogleGenAIThreadManager extends ProviderThreadManager<
+  StoredContent,
+  GoogleGenAIContent,
+  GoogleGenAIToolResponse,
+  GoogleGenAISystemContent
+> {
   appendModelContent(id: string, parts: Part[]): Promise<void>;
   prepareForInvocation(): Promise<GoogleGenAIInvocationPayload>;
 }
@@ -56,7 +65,9 @@ function toParts(content: GoogleGenAIContent): Part[] {
 }
 
 /** Convert a string or object into a Record suitable for functionResponse.response */
-function toFunctionResponse(content: string | Record<string, unknown>): Record<string, unknown> {
+function toFunctionResponse(
+  content: string | Record<string, unknown>
+): Record<string, unknown> {
   if (typeof content === "object") {
     return content;
   }
@@ -87,7 +98,7 @@ function mergeConsecutiveContents(contents: Content[]): Content[] {
  * appending typed Content messages.
  */
 export function createGoogleGenAIThreadManager(
-  config: GoogleGenAIThreadManagerConfig,
+  config: GoogleGenAIThreadManagerConfig
 ): GoogleGenAIThreadManager {
   const baseConfig: ThreadManagerConfig<StoredContent> = {
     redis: config.redis,
@@ -101,54 +112,64 @@ export function createGoogleGenAIThreadManager(
   const helpers: Omit<GoogleGenAIThreadManager, keyof typeof base> = {
     async appendUserMessage(
       id: string,
-      content: GoogleGenAIContent,
+      content: GoogleGenAIContent
     ): Promise<void> {
-      await base.append([{
-        id,
-        content: { role: "user", parts: toParts(content) },
-      }]);
+      await base.append([
+        {
+          id,
+          content: { role: "user", parts: toParts(content) },
+        },
+      ]);
     },
 
     async appendSystemMessage(
       id: string,
-      content: GoogleGenAISystemContent,
+      content: GoogleGenAISystemContent
     ): Promise<void> {
       const parts: Part[] =
         typeof content === "string" ? [{ text: content }] : content;
       await base.initialize();
-      await base.append([{
-        id,
-        content: { role: "system", parts },
-      }]);
+      await base.append([
+        {
+          id,
+          content: { role: "system", parts },
+        },
+      ]);
     },
 
     async appendModelContent(id: string, parts: Part[]): Promise<void> {
-      await base.append([{
-        id,
-        content: { role: "model", parts },
-      }]);
+      await base.append([
+        {
+          id,
+          content: { role: "model", parts },
+        },
+      ]);
     },
 
     async appendToolResult(
       id: string,
       toolCallId: string,
       toolName: string,
-      content: GoogleGenAIToolResponse,
+      content: GoogleGenAIToolResponse
     ): Promise<void> {
       const parts: Part[] = Array.isArray(content)
-        ? content as Part[]
-        : [{
-            functionResponse: {
-              id: toolCallId,
-              name: toolName,
-              response: toFunctionResponse(content),
+        ? (content as Part[])
+        : [
+            {
+              functionResponse: {
+                id: toolCallId,
+                name: toolName,
+                response: toFunctionResponse(content),
+              },
             },
-          }];
-
-      await base.append([{
-        id,
-        content: { role: "user", parts },
-      }]);
+          ];
+
+      await base.append([
+        {
+          id,
+          content: { role: "user", parts },
+        },
+      ]);
     },
 
     async prepareForInvocation(): Promise<GoogleGenAIInvocationPayload> {
@@ -174,7 +195,10 @@ export function createGoogleGenAIThreadManager(
         contents: onPreparedMessage
           ? contents.map((msg, i) => onPreparedMessage(msg, i, contents))
           : contents,
-        ...(systemInstruction && systemInstruction.length > 0 ? { systemInstruction } : {}),
+        ...(systemInstruction && systemInstruction.length > 0
+          ? { systemInstruction }
+          : {}),
+        storedLength: stored.length,
       };
     },
   };