zeitlich 0.2.34 → 0.2.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

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

@@ -15,6 +15,7 @@ import type { ModelInvoker } from "../../../lib/model";
 import {
   createAnthropicThreadManager,
   type AnthropicContent,
+  type AnthropicSystemContent,
   type AnthropicThreadManagerHooks,
 } from "./thread-manager";
 import {
@@ -152,7 +153,7 @@ export function createAnthropicAdapter(
     async appendSystemMessage(
       threadId: string,
       id: string,
-      content: string,
+      content: AnthropicSystemContent,
       threadKey?: string,
     ): Promise<void> {
       const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });

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

@@ -13,6 +13,11 @@ export type AnthropicContent =
   | string
   | Anthropic.Messages.ContentBlockParam[];
 
+/** SDK-native content type for Anthropic system prompts (supports cache_control blocks) */
+export type AnthropicSystemContent =
+  | string
+  | Anthropic.Messages.TextBlockParam[];
+
 /** A MessageParam with a unique ID for idempotent Redis storage */
 export interface StoredMessage {
   id: string;
@@ -34,12 +39,12 @@ export interface AnthropicThreadManagerConfig {
 /** Prepared payload ready to send to the Anthropic API */
 export interface AnthropicInvocationPayload {
   messages: Anthropic.Messages.MessageParam[];
-  system?: string;
+  system?: string | Anthropic.Messages.TextBlockParam[];
 }
 
 /** Thread manager with Anthropic MessageParam convenience helpers */
 export interface AnthropicThreadManager
-  extends ProviderThreadManager<StoredMessage, AnthropicContent> {
+  extends ProviderThreadManager<StoredMessage, AnthropicContent, JsonValue, AnthropicSystemContent> {
   appendAssistantMessage(
     id: string,
     content: Anthropic.Messages.ContentBlock[],
@@ -120,11 +125,19 @@ export function createAnthropicThreadManager(
       }]);
     },
 
-    async appendSystemMessage(id: string, content: string): Promise<void> {
+    async appendSystemMessage(
+      id: string,
+      content: AnthropicSystemContent,
+    ): Promise<void> {
       await base.initialize();
       await base.append([{
         id,
-        message: { role: "user", content },
+        // 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,
       }]);
     },
@@ -174,15 +187,14 @@ export function createAnthropicThreadManager(
         ? stored.map((msg, i) => onPrepareMessage(msg, i, stored))
         : stored;
 
-      let system: string | undefined;
+      let system: string | Anthropic.Messages.TextBlockParam[] | undefined;
       const conversationMessages: Anthropic.Messages.MessageParam[] = [];
 
       for (const item of mapped) {
         if (item.isSystem) {
-          system =
-            typeof item.message.content === "string"
-              ? item.message.content
-              : undefined;
+          system = item.message.content as
+            | string
+            | Anthropic.Messages.TextBlockParam[];
         } else {
           conversationMessages.push(item.message);
         }

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

@@ -15,6 +15,7 @@ import type { ModelInvoker } from "../../../lib/model";
 import {
   createGoogleGenAIThreadManager,
   type GoogleGenAIContent,
+  type GoogleGenAISystemContent,
   type GoogleGenAIThreadManagerHooks,
 } from "./thread-manager";
 import { createGoogleGenAIModelInvoker } from "./model-invoker";
@@ -169,7 +170,7 @@ export function createGoogleGenAIAdapter(
     async appendSystemMessage(
       threadId: string,
       id: string,
-      content: string,
+      content: GoogleGenAISystemContent,
       threadKey?: string
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({

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

@@ -55,7 +55,7 @@ describe("Google GenAI thread manager hooks", () => {
 
       expect(hook).toHaveBeenCalledTimes(3);
       expect(hook).toHaveBeenCalledWith(systemContent, 0, [systemContent, userContent, modelContent]);
-      expect(systemInstruction).toBe("You are helpful.");
+      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!");
     });

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

@@ -11,6 +11,9 @@ import type { GoogleGenAIToolResponse } from "./activities";
 /** SDK-native content type for Google GenAI human messages */
 export type GoogleGenAIContent = string | Part[];
 
+/** SDK-native content type for Google GenAI system instructions */
+export type GoogleGenAISystemContent = string | Part[];
+
 /** A Content with a unique ID for idempotent Redis storage */
 export interface StoredContent {
   id: string;
@@ -30,12 +33,12 @@ export interface GoogleGenAIThreadManagerConfig {
 /** Prepared payload ready to send to the Google GenAI API */
 export interface GoogleGenAIInvocationPayload {
   contents: Content[];
-  systemInstruction?: string;
+  systemInstruction?: Part[];
 }
 
 /** Thread manager with Google GenAI Content convenience helpers */
 export interface GoogleGenAIThreadManager
-  extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse> {
+  extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse, GoogleGenAISystemContent> {
   appendModelContent(id: string, parts: Part[]): Promise<void>;
   prepareForInvocation(): Promise<GoogleGenAIInvocationPayload>;
 }
@@ -106,11 +109,16 @@ export function createGoogleGenAIThreadManager(
       }]);
     },
 
-    async appendSystemMessage(id: string, content: string): Promise<void> {
+    async appendSystemMessage(
+      id: string,
+      content: GoogleGenAISystemContent,
+    ): Promise<void> {
+      const parts: Part[] =
+        typeof content === "string" ? [{ text: content }] : content;
       await base.initialize();
       await base.append([{
         id,
-        content: { role: "system", parts: [{ text: content }] },
+        content: { role: "system", parts },
       }]);
     },
 
@@ -150,12 +158,12 @@ export function createGoogleGenAIThreadManager(
         ? stored.map((msg, i) => onPrepareMessage(msg, i, stored))
         : stored;
 
-      let systemInstruction: string | undefined;
+      let systemInstruction: Part[] | undefined;
       const conversationContents: Content[] = [];
 
       for (const item of mapped) {
         if (item.content.role === "system") {
-          systemInstruction = item.content.parts?.[0]?.text;
+          systemInstruction = item.content.parts ?? [];
         } else {
           conversationContents.push(item.content);
         }
@@ -166,7 +174,7 @@ export function createGoogleGenAIThreadManager(
         contents: onPreparedMessage
           ? contents.map((msg, i) => onPreparedMessage(msg, i, contents))
           : contents,
-        ...(systemInstruction ? { systemInstruction } : {}),
+        ...(systemInstruction && systemInstruction.length > 0 ? { systemInstruction } : {}),
       };
     },
   };

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

@@ -17,6 +17,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
 import {
   createLangChainThreadManager,
   type LangChainContent,
+  type LangChainSystemContent,
   type LangChainThreadManagerHooks,
 } from "./thread-manager";
 import { createLangChainModelInvoker } from "./model-invoker";
@@ -135,7 +136,7 @@ export function createLangChainAdapter(
     async appendSystemMessage(
       threadId: string,
       id: string,
-      content: string,
+      content: LangChainSystemContent,
       threadKey?: string,
     ): Promise<void> {
       const thread = createLangChainThreadManager({ redis, threadId, key: threadKey });

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

@@ -20,6 +20,9 @@ import type {
 /** SDK-native content type for LangChain human messages */
 export type LangChainContent = string | MessageContent;
 
+/** SDK-native content type for LangChain system messages */
+export type LangChainSystemContent = string | MessageContent;
+
 export type LangChainThreadManagerHooks = ThreadManagerHooks<StoredMessage, BaseMessage>;
 
 export interface LangChainThreadManagerConfig {
@@ -37,7 +40,7 @@ export interface LangChainInvocationPayload {
 
 /** Thread manager with LangChain StoredMessage convenience helpers */
 export interface LangChainThreadManager
-  extends ProviderThreadManager<StoredMessage, LangChainContent> {
+  extends ProviderThreadManager<StoredMessage, LangChainContent, JsonValue, LangChainSystemContent> {
   appendAIMessage(id: string, content: string | MessageContent): Promise<void>;
   prepareForInvocation(): Promise<LangChainInvocationPayload>;
 }
@@ -81,10 +84,16 @@ export function createLangChainThreadManager(
       ]);
     },
 
-    async appendSystemMessage(id: string, content: string): Promise<void> {
+    async appendSystemMessage(
+      id: string,
+      content: LangChainSystemContent,
+    ): Promise<void> {
       await base.initialize();
       await base.append([
-        new SystemMessage({ id, content }).toDict(),
+        new SystemMessage({
+          id,
+          content: content as MessageContent,
+        }).toDict(),
       ]);
     },
 

package/src/lib/session/session.ts

@@ -325,7 +325,10 @@ export async function createSession<
         // "continue" — thread already exists, just append the new message
       } else {
         if (appendSystemPrompt) {
-          if (!systemPrompt || systemPrompt.trim() === "") {
+          if (
+            systemPrompt == null ||
+            (typeof systemPrompt === "string" && systemPrompt.trim() === "")
+          ) {
             throw ApplicationFailure.create({
               message: "No system prompt in state",
               nonRetryable: true,

package/src/lib/session/types.ts

@@ -1,5 +1,8 @@
 import type { Duration } from "@temporalio/common";
-import type { ToolResultConfig, SessionExitReason } from "../types";
+import type {
+  SessionExitReason,
+  ToolResultConfig,
+} from "../types";
 import type {
   ToolMap,
   ToolCallResultUnion,
@@ -50,7 +53,7 @@ export interface ThreadOps<TContent = string> {
   appendSystemMessage(
     threadId: string,
     id: string,
-    content: string,
+    content: unknown,
     threadKey?: string
   ): Promise<void>;
   /** Copy all messages from sourceThreadId into a new thread at targetThreadId */

package/src/lib/state/manager.ts

@@ -108,7 +108,7 @@ export function createAgentStateManager<
       return status === "RUNNING";
     },
 
-    getSystemPrompt(): string | undefined {
+    getSystemPrompt(): unknown {
       return systemPrompt;
     },
 
@@ -202,7 +202,7 @@ export function createAgentStateManager<
       }));
     },
 
-    setSystemPrompt(newSystemPrompt: string): void {
+    setSystemPrompt(newSystemPrompt: unknown): void {
       systemPrompt = newSystemPrompt;
     },
 

package/src/lib/state/types.ts

@@ -90,10 +90,10 @@ export interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
   getTurns(): number;
 
   /** Get the system prompt */
-  getSystemPrompt(): string | undefined;
+  getSystemPrompt(): unknown;
 
   /** Set the system prompt */
-  setSystemPrompt(newSystemPrompt: string): void;
+  setSystemPrompt(newSystemPrompt: unknown): void;
 
   /** Get a custom state value by key */
   get<K extends keyof TCustom>(key: K): TCustom[K];

package/src/lib/thread/types.ts

@@ -1,6 +1,5 @@
 import type Redis from "ioredis";
 import type { JsonValue } from "../state/types";
-
 export interface ThreadManagerConfig<T> {
   redis: Redis;
   threadId: string;
@@ -71,9 +70,10 @@ export interface ProviderThreadManager<
   TStored,
   TContent = string,
   TToolContent = JsonValue,
+  TSystemContent = string,
 > extends BaseThreadManager<TStored> {
   appendUserMessage(id: string, content: TContent): Promise<void>;
-  appendSystemMessage(id: string, content: string): Promise<void>;
+  appendSystemMessage(id: string, content: TSystemContent): Promise<void>;
   appendToolResult(
     id: string,
     toolCallId: string,

package/src/lib/types.ts

@@ -28,7 +28,7 @@ export interface BaseAgentState {
   /** In-memory file contents keyed by path, bypassing the resolver (e.g. skill resources). */
   inlineFiles?: Record<string, string>;
   virtualFsCtx?: unknown;
-  systemPrompt?: string;
+  systemPrompt?: unknown;
   totalInputTokens: number;
   totalOutputTokens: number;
   cachedWriteTokens: number;

package/src/workflow.ts

@@ -119,7 +119,6 @@ export type {
   ToolResultConfig,
   SessionExitReason,
   SerializableToolDefinition,
-  // Task types
   TaskStatus,
   WorkflowTask,
 } from "./lib/types";