zeitlich 0.2.25 → 0.2.26

package/dist/{types-7PeMi1bD.d.cts → types-DSOefLpY.d.cts}

@@ -1,9 +1,8 @@
 import { Duration } from '@temporalio/common';
-import { a as ToolMap, b as ToolRouterHooks, M as MessageContent, S as SessionExitReason, c as ToolHandlerResponse, P as PreToolUseHookResult, d as PostToolUseFailureHookResult, e as RawToolCall, f as TokenUsage, B as BaseAgentState, g as RunAgentConfig, h as AgentStatus, W as WorkflowTask, i as ToolDefinition, j as ToolResultConfig, k as ToolCallResultUnion, I as InferToolResults } from './types-D_igp10o.cjs';
+import { a as ToolMap, b as ToolRouterHooks, S as SessionExitReason, J as JsonValue, T as ToolHandlerResponse, P as PreToolUseHookResult, c as PostToolUseFailureHookResult, d as RawToolCall, e as TokenUsage, B as BaseAgentState, f as RunAgentConfig, g as ToolResultConfig, h as ToolCallResultUnion, I as InferToolResults, i as JsonSerializable, j as AgentStateManager } from './types-mCVxKIZb.cjs';
 import { z } from 'zod';
 import { g as SandboxOps } from './types-ChAMwU3q.cjs';
-import { QueryDefinition, ActivityInterfaceFor } from '@temporalio/workflow';
-import { UpdateDefinition } from '@temporalio/common/lib/interfaces';
+import { ActivityInterfaceFor } from '@temporalio/workflow';
 
 /**
  * Context for SessionStart hook - called when session begins
@@ -34,35 +33,35 @@ type SessionEndHook = (ctx: SessionEndHookContext) => void | Promise<void>;
 /**
  * Context for PreHumanMessageAppend hook - called before each human message is appended to the thread
  */
-interface PreHumanMessageAppendHookContext {
-    message: MessageContent;
+interface PreHumanMessageAppendHookContext<TContent = unknown> {
+    message: TContent;
     threadId: string;
 }
 /**
  * PreHumanMessageAppend hook - called before each human message is appended to the thread
  */
-type PreHumanMessageAppendHook = (ctx: PreHumanMessageAppendHookContext) => void | Promise<void>;
+type PreHumanMessageAppendHook<TContent = unknown> = (ctx: PreHumanMessageAppendHookContext<TContent>) => void | Promise<void>;
 /**
  * Context for PostHumanMessageAppend hook - called after each human message is appended to the thread
  */
-interface PostHumanMessageAppendHookContext {
-    message: MessageContent;
+interface PostHumanMessageAppendHookContext<TContent = unknown> {
+    message: TContent;
     threadId: string;
 }
 /**
  * PostHumanMessageAppend hook - called after each human message is appended to the thread
  */
-type PostHumanMessageAppendHook = (ctx: PostHumanMessageAppendHookContext) => void | Promise<void>;
+type PostHumanMessageAppendHook<TContent = unknown> = (ctx: PostHumanMessageAppendHookContext<TContent>) => void | Promise<void>;
 /**
  * Full hooks interface for a session — combines tool execution hooks
  * (consumed by the router) with session/message lifecycle hooks
  * (consumed directly by the session).
  */
-interface Hooks<T extends ToolMap, TResult = unknown> extends ToolRouterHooks<T, TResult> {
+interface Hooks<T extends ToolMap, TResult = unknown, TContent = unknown> extends ToolRouterHooks<T, TResult> {
     /** Called before each human message is appended to the thread */
-    onPreHumanMessageAppend?: PreHumanMessageAppendHook;
+    onPreHumanMessageAppend?: PreHumanMessageAppendHook<TContent>;
     /** Called after each human message is appended to the thread */
-    onPostHumanMessageAppend?: PostHumanMessageAppendHook;
+    onPostHumanMessageAppend?: PostHumanMessageAppendHook<TContent>;
     /** Called when session starts */
     onSessionStart?: SessionStartHook;
     /** Called when session ends */
@@ -129,7 +128,7 @@ type SandboxShutdown = "destroy" | "pause" | "keep";
 type SubagentSandboxShutdown = SandboxShutdown | "pause-until-parent-close";
 
 /** ToolHandlerResponse with threadId required (subagents must always surface their thread) */
-type SubagentHandlerResponse<TResult = null> = ToolHandlerResponse<TResult> & {
+type SubagentHandlerResponse<TResult = null, TToolResponse = JsonValue> = ToolHandlerResponse<TResult, TToolResponse> & {
     threadId: string;
     sandboxId?: string;
 };
@@ -335,6 +334,8 @@ type RunAgentActivity<M = unknown> = (config: RunAgentConfig) => Promise<AgentRe
  */
 interface ModelInvokerConfig {
     threadId: string;
+    /** Redis key suffix for thread storage. Defaults to 'messages'. */
+    threadKey?: string;
     agentName: string;
     state: BaseAgentState;
     metadata?: Record<string, unknown>;
@@ -349,117 +350,25 @@ interface ModelInvokerConfig {
  */
 type ModelInvoker<M = unknown> = (config: ModelInvokerConfig) => Promise<AgentResponse<M>>;
 
-/**
- * JSON primitive types that Temporal can serialize
- */
-type JsonPrimitive = string | number | boolean | null | undefined;
-/**
- * JSON-serializable value (recursive type for Temporal compatibility)
- */
-type JsonValue = JsonPrimitive | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/**
- * Type constraint ensuring T only contains JSON-serializable values.
- * Use this for custom state to ensure Temporal workflow compatibility.
- *
- * Allows: primitives, arrays, plain objects, and JsonValue
- * Rejects: functions, symbols, undefined, class instances with methods
- */
-type JsonSerializable<T> = {
-    [K in keyof T]: T[K] extends JsonValue ? T[K] : T[K] extends JsonPrimitive ? T[K] : T[K] extends (infer U)[] ? U extends JsonValue ? T[K] : JsonSerializable<U>[] : T[K] extends object ? JsonSerializable<T[K]> : never;
-};
-/**
- * Full state type combining base state with custom state
- */
-type AgentState<TCustom extends JsonSerializable<TCustom>> = BaseAgentState & TCustom;
-/**
- * Agent state manager interface
- * Note: Temporal handlers must be set up in the workflow file due to
- * Temporal's workflow isolation requirements. This manager provides
- * the state and helpers needed for those handlers.
- */
-interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
-    /** Typed query definition registered for this agent's state */
-    readonly stateQuery: QueryDefinition<AgentState<TCustom>>;
-    /** Typed update definition registered for waiting on this agent's state change */
-    readonly stateChangeUpdate: UpdateDefinition<AgentState<TCustom>, [number]>;
-    /** Get current status */
-    getStatus(): AgentStatus;
-    /** Check if agent is running */
-    isRunning(): boolean;
-    /** Check if agent is in terminal state */
-    isTerminal(): boolean;
-    /** Get current state version */
-    getVersion(): number;
-    /** Set status to RUNNING */
-    run(): void;
-    /** Set status to WAITING_FOR_INPUT */
-    waitForInput(): void;
-    /** Set status to COMPLETED */
-    complete(): void;
-    /** Set status to FAILED */
-    fail(): void;
-    /** Set status to CANCELLED */
-    cancel(): void;
-    /** Increment state version (call after state changes) */
-    incrementVersion(): void;
-    /** Increment turns (call after each turn) */
-    incrementTurns(): void;
-    /** Get current turns */
-    getTurns(): number;
-    /** Get the system prompt */
-    getSystemPrompt(): string | undefined;
-    /** Set the system prompt */
-    setSystemPrompt(newSystemPrompt: string): void;
-    /** Get a custom state value by key */
-    get<K extends keyof TCustom>(key: K): TCustom[K];
-    /** Set a custom state value by key */
-    set<K extends keyof TCustom>(key: K, value: TCustom[K]): void;
-    /** Bulk-merge a partial update into custom state (e.g. from sandbox stateUpdate) */
-    mergeUpdate(update: Partial<TCustom>): void;
-    /** Get full state for query handler */
-    getCurrentState(): AgentState<TCustom>;
-    /** Check if should return from waitForStateChange */
-    shouldReturnFromWait(lastKnownVersion: number): boolean;
-    /** Get all tasks */
-    getTasks(): WorkflowTask[];
-    /** Get a task by ID */
-    getTask(id: string): WorkflowTask | undefined;
-    /** Add or update a task */
-    setTask(task: WorkflowTask): void;
-    /** Delete a task by ID */
-    deleteTask(id: string): boolean;
-    /** Set the tools (converts Zod schemas to JSON Schema for serialization) */
-    setTools(newTools: ToolDefinition[]): void;
-    /** Update the usage */
-    updateUsage(usage: TokenUsage): void;
-    /** Get the total usage */
-    getTotalUsage(): {
-        totalInputTokens: number;
-        totalOutputTokens: number;
-        totalCachedWriteTokens: number;
-        totalCachedReadTokens: number;
-        totalReasonTokens: number;
-        turns: number;
-    };
-}
-
 /**
  * Thread operations required by a session.
  * Consumers provide these — typically by wrapping Temporal activities.
+ *
+ * `TContent` is the SDK-native content type for human messages.
+ * Each adapter supplies its own type (e.g. Anthropic ContentBlockParam[],
+ * Google GenAI Part[], LangChain MessageContent). Defaults to `string`.
  */
-interface ThreadOps {
+interface ThreadOps<TContent = string> {
     /** Initialize an empty thread */
-    initializeThread(threadId: string): Promise<void>;
+    initializeThread(threadId: string, threadKey?: string): Promise<void>;
     /** Append a human message to the thread */
-    appendHumanMessage(threadId: string, id: string, content: string | MessageContent): Promise<void>;
+    appendHumanMessage(threadId: string, id: string, content: TContent, threadKey?: string): Promise<void>;
     /** Append a tool result to the thread */
     appendToolResult(id: string, config: ToolResultConfig): Promise<void>;
     /** Append a system message to the thread */
-    appendSystemMessage(threadId: string, id: string, content: string): Promise<void>;
+    appendSystemMessage(threadId: string, id: string, content: string, threadKey?: string): Promise<void>;
     /** Copy all messages from sourceThreadId into a new thread at targetThreadId */
-    forkThread(sourceThreadId: string, targetThreadId: string): Promise<void>;
+    forkThread(sourceThreadId: string, targetThreadId: string, threadKey?: string): Promise<void>;
 }
 /**
  * Composes an adapter prefix + workflow scope for activity naming.
@@ -484,13 +393,17 @@ type ScopedPrefix<TScope extends string, TAdapter extends string> = TScope exten
  * // → { googleGenAIInitializeThread, googleGenAIAppendHumanMessage, … }
  * ```
  */
-type PrefixedThreadOps<TPrefix extends string> = {
-    [K in keyof ThreadOps as `${TPrefix}${Capitalize<K & string>}`]: ThreadOps[K];
+type PrefixedThreadOps<TPrefix extends string, TContent = string> = {
+    [K in keyof ThreadOps<TContent> as `${TPrefix}${Capitalize<K & string>}`]: ThreadOps<TContent>[K];
 };
 /**
- * Configuration for a Zeitlich agent session
+ * Configuration for a Zeitlich agent session.
+ *
+ * @typeParam T - Tool map
+ * @typeParam M - SDK-native message type returned by the model invoker
+ * @typeParam TContent - SDK-native content type for human messages (defaults to `string`)
  */
-interface SessionConfig<T extends ToolMap, M = unknown> {
+interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
     /** The name of the agent, should be unique within the workflows */
     agentName: string;
     /** Metadata for the session */
@@ -502,7 +415,7 @@ interface SessionConfig<T extends ToolMap, M = unknown> {
     /** Workflow-specific runAgent activity (with tools pre-bound) */
     runAgent: RunAgentActivity<M>;
     /** Thread operations (initialize, append messages, parse tool calls) */
-    threadOps: ActivityInterfaceFor<ThreadOps>;
+    threadOps: ActivityInterfaceFor<ThreadOps<TContent>>;
     /** Tool router for processing tool calls (optional if agent has no tools) */
     tools?: T;
     /** Subagent configurations */
@@ -510,14 +423,14 @@ interface SessionConfig<T extends ToolMap, M = unknown> {
     /** Skills available to this agent (metadata + instructions, loaded before session creation) */
     skills?: Skill[];
     /** Session lifecycle hooks */
-    hooks?: Hooks<T, ToolCallResultUnion<InferToolResults<T>>>;
+    hooks?: Hooks<T, ToolCallResultUnion<InferToolResults<T>>, TContent>;
     /** Whether to process tools in parallel */
     processToolsInParallel?: boolean;
     /**
      * Build context message content from agent-specific context.
-     * Returns MessageContent array for the initial HumanMessage.
+     * Returns SDK-native content for the initial human message.
      */
-    buildContextMessage: () => MessageContent | Promise<MessageContent>;
+    buildContextMessage: () => TContent | Promise<TContent>;
     /** How long to wait for input before cancelling the workflow */
     waitForInputTimeout?: Duration;
     /**
@@ -529,6 +442,14 @@ interface SessionConfig<T extends ToolMap, M = unknown> {
      * - `{ mode: "fork", threadId: "..." }` — fork an existing thread and continue in the copy.
      */
     thread?: ThreadInit;
+    /**
+     * Redis key suffix for thread storage. Defaults to `"messages"`.
+     *
+     * Controls the Redis key layout: `thread:${threadId}:${threadKey}`.
+     * Use different keys to isolate storage across sessions sharing the
+     * same adapter instance.
+     */
+    threadKey?: string;
     /** Sandbox lifecycle operations (optional — omit for agents that don't need a sandbox) */
     sandboxOps?: SandboxOps;
     /**
@@ -566,4 +487,4 @@ interface ZeitlichSession<M = unknown, HasSandbox extends boolean = boolean> {
     }): Promise<SessionResult<M, T, HasSandbox>>;
 }
 
-export type { AgentResponse as A, SubagentSandboxShutdown as B, SubagentSessionInput as C, SubagentWorkflow as D, SubagentWorkflowInput as E, ThreadInit as F, Hooks as H, JsonPrimitive as J, ModelInvoker as M, PrefixedThreadOps as P, RunAgentActivity as R, ScopedPrefix as S, ThreadOps as T, ZeitlichSession as Z, ModelInvokerConfig as a, SkillProvider as b, SkillMetadata as c, Skill as d, AgentState as e, AgentStateManager as f, JsonSerializable as g, JsonValue as h, PostHumanMessageAppendHook as i, PostHumanMessageAppendHookContext as j, PreHumanMessageAppendHook as k, PreHumanMessageAppendHookContext as l, SandboxInit as m, SandboxShutdown as n, SessionConfig as o, SessionEndHook as p, SessionEndHookContext as q, SessionResult as r, SessionStartHook as s, SessionStartHookContext as t, SubagentConfig as u, SubagentDefinition as v, SubagentFnResult as w, SubagentHandlerResponse as x, SubagentHooks as y, SubagentSandboxConfig as z };
+export type { AgentResponse as A, ThreadInit as B, Hooks as H, ModelInvokerConfig as M, PrefixedThreadOps as P, RunAgentActivity as R, ScopedPrefix as S, ThreadOps as T, ZeitlichSession as Z, ModelInvoker as a, SkillProvider as b, SkillMetadata as c, Skill as d, PostHumanMessageAppendHook as e, PostHumanMessageAppendHookContext as f, PreHumanMessageAppendHook as g, PreHumanMessageAppendHookContext as h, SandboxInit as i, SandboxShutdown as j, SessionConfig as k, SessionEndHook as l, SessionEndHookContext as m, SessionResult as n, SessionStartHook as o, SessionStartHookContext as p, SubagentConfig as q, SubagentDefinition as r, SubagentFnResult as s, SubagentHandlerResponse as t, SubagentHooks as u, SubagentSandboxConfig as v, SubagentSandboxShutdown as w, SubagentSessionInput as x, SubagentWorkflow as y, SubagentWorkflowInput as z };

package/dist/{types-35POpVfa.d.cts → types-WNSeZbWa.d.ts}

@@ -1,4 +1,5 @@
 import Redis from 'ioredis';
+import { J as JsonValue } from './types-mCVxKIZb.js';
 
 interface ThreadManagerConfig<T> {
     redis: Redis;
@@ -36,5 +37,25 @@ interface BaseThreadManager<T> {
     /** Delete the thread */
     delete(): Promise<void>;
 }
+/**
+ * Shared contract for provider-specific thread managers.
+ *
+ * Extends {@link BaseThreadManager} with the append operations that the
+ * session layer calls via {@link ThreadOps} activities. Each adapter
+ * implements this interface to translate generic append calls into
+ * SDK-native stored messages.
+ *
+ * `appendAssistantMessage` / `appendModelContent` are intentionally NOT
+ * part of this interface — they are adapter-specific and only called by
+ * the model invoker inside the adapter.
+ *
+ * @typeParam TStored - The stored message envelope (includes id + SDK payload)
+ * @typeParam TContent - SDK-native content type for human messages
+ */
+interface ProviderThreadManager<TStored, TContent = string, TToolContent = JsonValue> extends BaseThreadManager<TStored> {
+    appendUserMessage(id: string, content: TContent): Promise<void>;
+    appendSystemMessage(id: string, content: string): Promise<void>;
+    appendToolResult(id: string, toolCallId: string, toolName: string, content: TToolContent): Promise<void>;
+}
 
-export type { BaseThreadManager as B, ThreadManagerConfig as T };
+export type { BaseThreadManager as B, ProviderThreadManager as P, ThreadManagerConfig as T };