zeitlich 0.2.36 → 0.2.37

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;
@@ -43,11 +44,15 @@ export interface AnthropicInvocationPayload {
 }
 
 /** 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 +63,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 +77,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 +93,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 +106,7 @@ function mergeConsecutiveMessages(
  * appending typed messages.
  */
 export function createAnthropicThreadManager(
-  config: AnthropicThreadManagerConfig,
+  config: AnthropicThreadManagerConfig
 ): AnthropicThreadManager {
   const baseConfig: ThreadManagerConfig<StoredMessage> = {
     redis: config.redis,
@@ -117,49 +120,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 +177,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> {

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,
@@ -240,7 +240,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,14 +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 } =
-      await thread.prepareForInvocation();
+    const thread = createGoogleGenAIThreadManager({
+      redis,
+      threadId,
+      key: threadKey,
+      hooks,
+    });
+    const { contents, systemInstruction } = await thread.prepareForInvocation();
 
     const functionDeclarations = toFunctionDeclarations(state.tools);
     const tools =
@@ -125,6 +138,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;
@@ -37,8 +40,12 @@ export interface GoogleGenAIInvocationPayload {
 }
 
 /** 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 +63,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 +96,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 +110,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 +193,9 @@ export function createGoogleGenAIThreadManager(
         contents: onPreparedMessage
           ? contents.map((msg, i) => onPreparedMessage(msg, i, contents))
           : contents,
-        ...(systemInstruction && systemInstruction.length > 0 ? { systemInstruction } : {}),
+        ...(systemInstruction && systemInstruction.length > 0
+          ? { systemInstruction }
+          : {}),
       };
     },
   };

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

@@ -24,8 +24,10 @@ import { createLangChainModelInvoker } from "./model-invoker";
 
 const ADAPTER_PREFIX = "langChain" as const;
 
-export type LangChainThreadOps<TScope extends string = ""> =
-  PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_PREFIX>, LangChainContent>;
+export type LangChainThreadOps<TScope extends string = ""> = PrefixedThreadOps<
+  ScopedPrefix<TScope, typeof ADAPTER_PREFIX>,
+  LangChainContent
+>;
 
 export interface LangChainAdapterConfig {
   redis: Redis;
@@ -61,9 +63,7 @@ export interface LangChainAdapter {
    * // → { langChainCodingAgentInitializeThread, langChainCodingAgentAppendHumanMessage, … }
    * ```
    */
-  createActivities<S extends string = "">(
-    scope?: S,
-  ): LangChainThreadOps<S>;
+  createActivities<S extends string = "">(scope?: S): LangChainThreadOps<S>;
 
   /**
    * Identity wrapper that types a tool handler for this adapter.
@@ -72,8 +72,8 @@ export interface LangChainAdapter {
   wrapHandler<TArgs, TResult, TContext extends RouterContext = RouterContext>(
     handler: (
       args: TArgs,
-      context: TContext,
-    ) => Promise<ToolHandlerResponse<TResult, LangChainToolResponse>>,
+      context: TContext
+    ) => Promise<ToolHandlerResponse<TResult, LangChainToolResponse>>
   ): ActivityToolHandler<TArgs, TResult, TContext, LangChainToolResponse>;
 }
 
@@ -113,13 +113,20 @@ export interface LangChainAdapter {
  * ```
  */
 export function createLangChainAdapter(
-  config: LangChainAdapterConfig,
+  config: LangChainAdapterConfig
 ): LangChainAdapter {
   const { redis } = config;
 
   const threadOps: ThreadOps<LangChainContent> = {
-    async initializeThread(threadId: string, threadKey?: string): Promise<void> {
-      const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });
+    async initializeThread(
+      threadId: string,
+      threadKey?: string
+    ): Promise<void> {
+      const thread = createLangChainThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.initialize();
     },
 
@@ -127,9 +134,13 @@ export function createLangChainAdapter(
       threadId: string,
       id: string,
       content: LangChainContent,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
-      const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });
+      const thread = createLangChainThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendUserMessage(id, content);
     },
 
@@ -137,15 +148,23 @@ export function createLangChainAdapter(
       threadId: string,
       id: string,
       content: LangChainSystemContent,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
-      const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });
+      const thread = createLangChainThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendSystemMessage(id, content);
     },
 
     async appendToolResult(id: string, cfg: ToolResultConfig): Promise<void> {
       const { threadId, threadKey, toolCallId, content } = cfg;
-      const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });
+      const thread = createLangChainThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendToolResult(id, toolCallId, "", content);
     },
 
@@ -153,9 +172,13 @@ export function createLangChainAdapter(
       threadId: string,
       id: string,
       message: StoredMessage,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
-      const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });
+      const thread = createLangChainThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       const patched = { ...message, data: { ...message.data, id } };
       await thread.append([patched]);
     },
@@ -163,7 +186,7 @@ export function createLangChainAdapter(
     async forkThread(
       sourceThreadId: string,
       targetThreadId: string,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
       const thread = createLangChainThreadManager({
         redis,
@@ -175,21 +198,20 @@ export function createLangChainAdapter(
   };
 
   function createActivities<S extends string = "">(
-    scope?: S,
+    scope?: S
   ): LangChainThreadOps<S> {
     const prefix = scope
       ? `${ADAPTER_PREFIX}${scope.charAt(0).toUpperCase()}${scope.slice(1)}`
       : ADAPTER_PREFIX;
-    const cap = (s: string): string =>
-      s.charAt(0).toUpperCase() + s.slice(1);
+    const cap = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1);
     return Object.fromEntries(
-      Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v]),
+      Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])
     ) as LangChainThreadOps<S>;
   }
 
   const makeInvoker = (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    model: BaseChatModel<any>,
+    model: BaseChatModel<any>
   ): ModelInvoker<StoredMessage> =>
     createLangChainModelInvoker({ redis, model, hooks: config.hooks });
 
@@ -198,7 +220,7 @@ export function createLangChainAdapter(
     : () => {
         throw new Error(
           "No default model provided to createLangChainAdapter. " +
-            "Either pass `model` in the config or use `createModelInvoker(model)` instead.",
+            "Either pass `model` in the config or use `createModelInvoker(model)` instead."
         );
       };