zeitlich 0.2.11 → 0.2.13

package/dist/{workflow-BhjsEQc1.d.cts → model-invoker-y_zlyMqu.d.cts}

@@ -1,76 +1,5 @@
-import { QueryDefinition, proxyActivities } from '@temporalio/workflow';
-import Redis from 'ioredis';
-import { $InferMessageContent, MessageStructure, StoredMessage, MessageContent } from '@langchain/core/messages';
 import z, { z as z$1 } from 'zod';
 import { Duration } from '@temporalio/common';
-import { UpdateDefinition } from '@temporalio/common/lib/interfaces';
-
-/**
- * Content for a tool message response.
- * Can be a simple string or complex content parts (text, images, cache points, etc.)
- */
-type ToolMessageContent = $InferMessageContent<MessageStructure, "tool">;
-interface ThreadManagerConfig<T = StoredMessage> {
-    redis: Redis;
-    threadId: string;
-    /** Thread key, defaults to 'messages' */
-    key?: string;
-    /** Custom serializer, defaults to JSON.stringify */
-    serialize?: (message: T) => string;
-    /** Custom deserializer, defaults to JSON.parse */
-    deserialize?: (raw: string) => T;
-    /**
-     * Extract a unique id from a message for idempotent appends.
-     * When provided, `append` uses an atomic Lua script to skip duplicate writes.
-     * Defaults to `StoredMessage.data.id` for the standard ThreadManager.
-     */
-    idOf?: (message: T) => string;
-}
-/** Generic thread manager for any message type */
-interface BaseThreadManager<T> {
-    /** Initialize an empty thread */
-    initialize(): Promise<void>;
-    /** Load all messages from the thread */
-    load(): Promise<T[]>;
-    /**
-     * Append messages to the thread.
-     * When `idOf` is configured, appends are idempotent — retries with the
-     * same message ids are atomically skipped via a Redis Lua script.
-     */
-    append(messages: T[]): Promise<void>;
-    /** Delete the thread */
-    delete(): Promise<void>;
-}
-/** Thread manager with StoredMessage convenience helpers */
-interface ThreadManager extends BaseThreadManager<StoredMessage> {
-    /** Create a HumanMessage (returns StoredMessage for storage) */
-    createHumanMessage(content: string | MessageContent): StoredMessage;
-    /** Create a SystemMessage (returns StoredMessage for storage) */
-    createSystemMessage(content: string): StoredMessage;
-    /** Create an AIMessage with optional additional kwargs */
-    createAIMessage(content: string | MessageContent, kwargs?: {
-        header?: string;
-        options?: string[];
-        multiSelect?: boolean;
-    }): StoredMessage;
-    /** Create a ToolMessage */
-    createToolMessage(content: ToolMessageContent, toolCallId: string): StoredMessage;
-    /** Create and append a HumanMessage */
-    appendHumanMessage(content: string | MessageContent): Promise<void>;
-    /** Create and append a SystemMessage */
-    appendSystemMessage(content: string): Promise<void>;
-    /** Create and append a ToolMessage */
-    appendToolMessage(content: ToolMessageContent, toolCallId: string): Promise<void>;
-    /** Create and append an AIMessage */
-    appendAIMessage(content: string | MessageContent): Promise<void>;
-}
-/**
- * Creates a thread manager for handling conversation state in Redis.
- * Without generic args, returns a full ThreadManager with StoredMessage helpers.
- * With a custom type T, returns a BaseThreadManager<T>.
- */
-declare function createThreadManager(config: ThreadManagerConfig): ThreadManager;
-declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThreadManager<T>;
 
 /**
  * Skill metadata — the lightweight subset loaded at startup for all skills.
@@ -112,6 +41,7 @@ interface SkillProvider {
     getSkill(name: string): Promise<Skill>;
 }
 
+declare const SUBAGENT_TOOL_NAME: "Subagent";
 /**
  * Creates a Subagent tool configured with the available subagents.
  *
@@ -129,13 +59,9 @@ interface SkillProvider {
  * ]);
  */
 declare function createSubagentTool<T extends SubagentConfig[]>(subagents: T): {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        subagent: z.ZodEnum<Record<string, string>>;
-        description: z.ZodString;
-        prompt: z.ZodString;
-    }>;
+    readonly name: typeof SUBAGENT_TOOL_NAME;
+    readonly description: string;
+    readonly schema: z.ZodObject<z.ZodRawShape>;
 };
 /**
  * Subagent tool args type (when subagent names are not known at compile time)
@@ -144,6 +70,7 @@ type SubagentArgs = {
     subagent: string;
     description: string;
     prompt: string;
+    threadId?: string;
 };
 
 /**
@@ -242,6 +169,8 @@ interface ToolHandlerResponse<TResult = null> {
     resultAppended?: boolean;
     /** Token usage from the tool execution (e.g. child agent invocations) */
     usage?: TokenUsage;
+    /** Thread ID used by the handler (surfaced to the LLM for subagent thread continuation) */
+    threadId?: string;
 }
 /**
  * Context passed to tool handlers for additional data beyond tool args.
@@ -494,14 +423,14 @@ declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType, TCont
     workflow: string | ((input: {
         prompt: string;
         context: TContext;
-    }) => Promise<any>);
+    }) => Promise<ToolHandlerResponse<z$1.infer<TResult> | null>>);
     context: TContext;
     hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType>(config: Omit<SubagentConfig<TResult>, "hooks" | "workflow"> & {
     workflow: string | ((input: {
         prompt: string;
-    }) => Promise<any>);
+    }) => Promise<ToolHandlerResponse<z$1.infer<TResult> | null>>);
     hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 /**
@@ -509,6 +438,15 @@ declare function defineSubagent<TResult extends z$1.ZodType = z$1.ZodType>(confi
  */
 declare function hasNoOtherToolCalls<T extends ToolMap>(toolCalls: ParsedToolCallUnion<T>[], excludeName: ToolNames<T>): boolean;
 
+/** A single content part within a structured message (text, image, etc.) */
+type ContentPart = {
+    type: string;
+    [key: string]: unknown;
+};
+/** Message content — plain string or an array of structured content parts */
+type MessageContent = string | ContentPart[];
+/** Content returned by a tool handler */
+type ToolMessageContent = MessageContent;
 /**
  * Agent execution status
  */
@@ -526,7 +464,7 @@ interface BaseAgentState {
     totalInputTokens: number;
     totalOutputTokens: number;
     cachedWriteTokens: number;
-    cachedReadtTokens: number;
+    cachedReadTokens: number;
 }
 /**
  * File representation for agent workflows
@@ -553,7 +491,7 @@ interface TokenUsage {
 /**
  * Agent response from LLM invocation
  */
-interface AgentResponse<M = StoredMessage> {
+interface AgentResponse<M = unknown> {
     message: M;
     rawToolCalls: RawToolCall[];
     usage?: TokenUsage;
@@ -561,7 +499,6 @@ interface AgentResponse<M = StoredMessage> {
 /**
  * Thread operations required by a session.
  * Consumers provide these — typically by wrapping Temporal activities.
- * Use `proxyDefaultThreadOps()` for the default StoredMessage implementation.
  */
 interface ThreadOps {
     /** Initialize an empty thread */
@@ -585,9 +522,9 @@ interface AgentConfig {
 /**
  * Configuration for a Zeitlich agent session
  */
-interface SessionConfig<T extends ToolMap, M = StoredMessage> {
-    /** The thread ID to use for the session */
-    threadId: string;
+interface SessionConfig<T extends ToolMap, M = unknown> {
+    /** The thread ID to use for the session (defaults to a short generated ID) */
+    threadId?: string;
     /** Metadata for the session */
     metadata?: Record<string, unknown>;
     /** Whether to append the system prompt as message to the thread */
@@ -613,6 +550,8 @@ interface SessionConfig<T extends ToolMap, M = StoredMessage> {
      * Returns MessageContent array for the initial HumanMessage.
      */
     buildContextMessage: () => MessageContent | Promise<MessageContent>;
+    /** When true, skip thread initialization and system prompt — append only the new human message to the existing thread. */
+    continueThread?: boolean;
     /** How long to wait for input before cancelling the workflow */
     waitForInputTimeout?: Duration;
 }
@@ -640,7 +579,7 @@ interface RunAgentConfig extends AgentConfig {
 /**
  * Type signature for workflow-specific runAgent activity
  */
-type RunAgentActivity<M = StoredMessage> = (config: RunAgentConfig) => Promise<AgentResponse<M>>;
+type RunAgentActivity<M = unknown> = (config: RunAgentConfig) => Promise<AgentResponse<M>>;
 /**
  * Configuration for appending a tool result
  */
@@ -652,7 +591,7 @@ interface ToolResultConfig {
     /** Content for the tool message (string or complex content parts) */
     content: ToolMessageContent;
 }
-type SubagentWorkflow<TResult extends z$1.ZodType = z$1.ZodType> = (input: SubagentInput) => Promise<ToolHandlerResponse<TResult | null>>;
+type SubagentWorkflow<TResult extends z$1.ZodType = z$1.ZodType> = (input: SubagentInput) => Promise<ToolHandlerResponse<z$1.infer<TResult> | null>>;
 /**
  * Configuration for a subagent that can be spawned by the parent workflow.
  *
@@ -673,6 +612,8 @@ interface SubagentConfig<TResult extends z$1.ZodType = z$1.ZodType> {
     resultSchema?: TResult;
     /** Optional static context passed to the subagent on every invocation */
     context?: Record<string, unknown>;
+    /** Allow the parent agent to pass a threadId for this subagent to continue (default: false) */
+    allowThreadContinuation?: boolean;
     /** Per-subagent lifecycle hooks */
     hooks?: SubagentHooks;
 }
@@ -711,6 +652,8 @@ interface SubagentInput {
     prompt: string;
     /** Optional context parameters passed from the parent agent */
     context?: Record<string, unknown>;
+    /** When set, the subagent should continue this thread instead of starting a new one */
+    threadId?: string;
 }
 /**
  * Status of a workflow task
@@ -926,404 +869,24 @@ declare const agentStateChangeUpdateName: (agentName: string) => `waitFor${strin
 declare function isTerminalStatus(status: AgentStatus): boolean;
 
 /**
- * JSON primitive types that Temporal can serialize
+ * Configuration passed to a ModelInvoker.
+ * Includes the full agent state so adapters can read tools, system prompt,
+ * token usage, or any custom state fields for model configuration.
  */
-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;
-    /** 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: {
-        inputTokens?: number;
-        outputTokens?: number;
-        cachedWriteTokens?: number;
-        cachedReadTokens?: number;
-        reasonTokens?: number;
-    }): void;
-    /** Get the total usage */
-    getTotalUsage(): {
-        totalInputTokens: number;
-        totalOutputTokens: number;
-        totalCachedWriteTokens: number;
-        totalCachedReadTokens: number;
-        totalReasonTokens: number;
-        turns: number;
-    };
-}
-/**
- * Creates an agent state manager for tracking workflow state.
- *
- * @param initialState - Optional initial values for base and custom state
- *   Base state defaults: status="RUNNING", version=0, turns=0, tasks=empty, fileTree=[]
- *
- * Note: Due to Temporal's workflow isolation, handlers must be set up
- * in the workflow file using defineQuery/defineUpdate and setHandler.
- * This manager provides the state and logic needed for those handlers.
- */
-declare function createAgentStateManager<TCustom extends JsonSerializable<TCustom> = Record<string, never>>({ initialState, agentName, }: {
-    initialState?: Partial<BaseAgentState> & TCustom;
+interface ModelInvokerConfig {
+    threadId: string;
     agentName: string;
-}): AgentStateManager<TCustom>;
-
-interface ZeitlichSession<M = unknown> {
-    runSession<T extends JsonSerializable<T>>(args: {
-        stateManager: AgentStateManager<T>;
-    }): Promise<{
-        finalMessage: M | null;
-        exitReason: SessionExitReason;
-        usage: ReturnType<AgentStateManager<T>["getTotalUsage"]>;
-    }>;
-}
-/**
- * Session-level hooks for lifecycle events
- */
-interface SessionLifecycleHooks {
-    /** Called when session starts */
-    onSessionStart?: SessionStartHook;
-    /** Called when session ends */
-    onSessionEnd?: SessionEndHook;
-}
-declare const createSession: <T extends ToolMap, M = unknown>({ threadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, skills, tools, processToolsInParallel, hooks, appendSystemPrompt, waitForInputTimeout, }: SessionConfig<T, M> & AgentConfig) => Promise<ZeitlichSession<M>>;
-/**
- * Proxy the default ZeitlichSharedActivities as ThreadOps<StoredMessage>.
- * Call this in workflow code for the standard LangChain/StoredMessage setup.
- *
- * @example
- * ```typescript
- * const session = await createSession({
- *   threadOps: proxyDefaultThreadOps(),
- *   // ...
- * });
- * ```
- */
-declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps;
-
-/**
- * Parse a SKILL.md file into its frontmatter fields and markdown body.
- *
- * Handles the limited YAML subset used by the agentskills.io spec:
- * flat key-value pairs plus one-level nested `metadata` map.
- * No external YAML dependency required.
- */
-declare function parseSkillFile(raw: string): {
-    frontmatter: SkillMetadata;
-    body: string;
-};
-
-/**
- * Creates a ReadSkill tool configured with the available skills.
- * The tool description embeds skill metadata so the agent discovers
- * skills purely through the tool definition.
- */
-declare function createReadSkillTool(skills: Skill[]): {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        skill_name: z.ZodEnum<Record<string, string>>;
-    }>;
-};
-type ReadSkillArgs = {
-    skill_name: string;
-};
-
-/**
- * Creates a ReadSkill handler that looks up skills from an in-memory array.
- * Runs directly in the workflow (like task tools) — no activity needed.
- */
-declare function createReadSkillHandler(skills: Skill[]): (args: ReadSkillArgs) => ToolHandlerResponse<null>;
-
-/**
- * Shared Zeitlich activities - thread management and message handling
- * Note: runAgent is workflow-specific and should be created per-workflow
- */
-interface ZeitlichSharedActivities {
-    /**
-     * Append a tool result to the thread.
-     * Handles JSON serialization and optional cache points.
-     */
-    appendToolResult(config: ToolResultConfig): Promise<void>;
-    /**
-     * Initialize an empty thread.
-     */
-    initializeThread(threadId: string): Promise<void>;
-    /**
-     * Append messages to a thread.
-     */
-    appendThreadMessages(threadId: string, messages: StoredMessage[]): Promise<void>;
-    /**
-     * Append a human message to a thread.
-     */
-    appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
-    /**
-     * Append a system message to a thread.
-     */
-    appendSystemMessage(threadId: string, content: string): Promise<void>;
+    state: BaseAgentState;
+    metadata?: Record<string, unknown>;
 }
 /**
- * Creates shared Temporal activities for thread management
- *
- * @returns An object containing the shared activity functions
+ * Generic model invocation contract.
+ * Implementations load the thread, call the LLM, append the response,
+ * and return a normalised AgentResponse.
  *
- * @experimental The Zeitlich integration is an experimental feature; APIs may change without notice.
+ * Framework adapters (e.g. `zeitlich/langchain`) provide concrete
+ * implementations of this type.
  */
-declare function createSharedActivities(redis: Redis): ZeitlichSharedActivities;
-
-declare const globTool: {
-    name: "Glob";
-    description: string;
-    schema: z$1.ZodObject<{
-        pattern: z$1.ZodString;
-        root: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type GlobArgs = z$1.infer<typeof globTool.schema>;
-
-declare const grepTool: {
-    name: "Grep";
-    description: string;
-    schema: z$1.ZodObject<{
-        pattern: z$1.ZodString;
-        ignoreCase: z$1.ZodOptional<z$1.ZodBoolean>;
-        maxMatches: z$1.ZodOptional<z$1.ZodNumber>;
-        includePatterns: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-        excludePatterns: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-        contextLines: z$1.ZodOptional<z$1.ZodNumber>;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type GrepArgs = z$1.infer<typeof grepTool.schema>;
-
-declare const readFileTool: {
-    name: "FileRead";
-    description: string;
-    schema: z$1.ZodObject<{
-        path: z$1.ZodString;
-        offset: z$1.ZodOptional<z$1.ZodNumber>;
-        limit: z$1.ZodOptional<z$1.ZodNumber>;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type FileReadArgs = z$1.infer<typeof readFileTool.schema>;
-
-declare const writeFileTool: {
-    name: "FileWrite";
-    description: string;
-    schema: z$1.ZodObject<{
-        file_path: z$1.ZodString;
-        content: z$1.ZodString;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type FileWriteArgs = z$1.infer<typeof writeFileTool.schema>;
-
-declare const editTool: {
-    name: "FileEdit";
-    description: string;
-    schema: z$1.ZodObject<{
-        file_path: z$1.ZodString;
-        old_string: z$1.ZodString;
-        new_string: z$1.ZodString;
-        replace_all: z$1.ZodOptional<z$1.ZodBoolean>;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type FileEditArgs = z$1.infer<typeof editTool.schema>;
-
-declare const taskCreateTool: {
-    name: "TaskCreate";
-    description: string;
-    schema: z.ZodObject<{
-        subject: z.ZodString;
-        description: z.ZodString;
-        activeForm: z.ZodString;
-        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
-    }, z.core.$strip>;
-};
-type TaskCreateArgs = z.infer<typeof taskCreateTool.schema>;
-
-/**
- * Creates a TaskCreate handler that adds tasks to the workflow state.
- *
- * @param stateManager - State manager containing tasks state
- * @returns A ToolHandler for TaskCreate tool calls
- */
-declare function createTaskCreateHandler<TCustom extends JsonSerializable<TCustom>>(stateManager: AgentStateManager<TCustom>): ToolHandler<TaskCreateArgs, WorkflowTask>;
-
-declare const taskGetTool: {
-    name: "TaskGet";
-    description: string;
-    schema: z.ZodObject<{
-        taskId: z.ZodString;
-    }, z.core.$strip>;
-};
-type TaskGetArgs = z.infer<typeof taskGetTool.schema>;
-
-/**
- * Creates a TaskGet handler that retrieves a task by ID.
- *
- * @param stateManager - State manager containing tasks state
- * @returns A ToolHandler for TaskGet tool calls
- */
-declare function createTaskGetHandler<TCustom extends JsonSerializable<TCustom>>(stateManager: AgentStateManager<TCustom>): ToolHandler<TaskGetArgs, WorkflowTask | null>;
-
-declare const taskListTool: {
-    name: "TaskList";
-    description: string;
-    schema: z.ZodObject<{}, z.core.$strip>;
-};
-type TaskListArgs = z.infer<typeof taskListTool.schema>;
-
-/**
- * Creates a TaskList handler that returns all tasks.
- *
- * @param stateManager - State manager containing tasks state
- * @returns A ToolHandler for TaskList tool calls
- */
-declare function createTaskListHandler<TCustom extends JsonSerializable<TCustom>>(stateManager: AgentStateManager<TCustom>): ToolHandler<TaskListArgs, WorkflowTask[]>;
-
-declare const taskUpdateTool: {
-    name: "TaskUpdate";
-    description: string;
-    schema: z.ZodObject<{
-        taskId: z.ZodString;
-        status: z.ZodEnum<{
-            pending: "pending";
-            in_progress: "in_progress";
-            completed: "completed";
-        }>;
-        addBlockedBy: z.ZodArray<z.ZodString>;
-        addBlocks: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
-};
-type TaskUpdateArgs = z.infer<typeof taskUpdateTool.schema>;
-
-/**
- * Creates a TaskUpdate handler that modifies task status and dependencies.
- *
- * @param stateManager - State manager containing tasks state
- * @returns A ToolHandler for TaskUpdate tool calls
- */
-declare function createTaskUpdateHandler<TCustom extends JsonSerializable<TCustom>>(stateManager: AgentStateManager<TCustom>): ToolHandler<TaskUpdateArgs, WorkflowTask | null>;
-
-declare const createBashToolDescription: ({ fileTree, }: {
-    fileTree: string;
-}) => string;
-declare const bashTool: {
-    name: "Bash";
-    description: string;
-    schema: z.ZodObject<{
-        command: z.ZodString;
-    }, z.core.$strip>;
-    strict: true;
-};
-type BashArgs = z.infer<typeof bashTool.schema>;
-
-declare const askUserQuestionTool: {
-    name: "AskUserQuestion";
-    description: string;
-    schema: z.ZodObject<{
-        questions: z.ZodArray<z.ZodObject<{
-            question: z.ZodString;
-            header: z.ZodString;
-            options: z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                description: z.ZodString;
-            }, z.core.$strip>>;
-            multiSelect: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    strict: true;
-};
-type AskUserQuestionArgs = z.infer<typeof askUserQuestionTool.schema>;
-
-/**
- * Creates handler for user interaction tool - creates AI messages for display.
- */
-declare const createAskUserQuestionHandler: () => ActivityToolHandler<AskUserQuestionArgs, {
-    questions: {
-        question: string;
-        header: string;
-        options: {
-            label: string;
-            description: string;
-        }[];
-        multiSelect: boolean;
-    }[];
-}>;
+type ModelInvoker<M = unknown> = (config: ModelInvokerConfig) => Promise<AgentResponse<M>>;
 
-export { type TaskStatus as $, type AgentResponse as A, type BashArgs as B, type ProcessToolCallsContext as C, type ReadSkillArgs as D, type RunAgentActivity as E, type FileEditArgs as F, type GlobArgs as G, type RunAgentConfig as H, type InferToolResults as I, type JsonPrimitive as J, type SessionEndHook as K, type SessionEndHookContext as L, type SessionExitReason as M, type SessionLifecycleHooks as N, type SessionStartHook as O, type ParsedToolCall as P, type SessionStartHookContext as Q, type RawToolCall as R, type SkillProvider as S, type SubagentArgs as T, type SubagentConfig as U, type SubagentHooks as V, type SubagentInput as W, type SubagentWorkflow as X, type TaskCreateArgs as Y, type TaskGetArgs as Z, type TaskListArgs as _, type ActivityToolHandler as a, type TaskUpdateArgs as a0, type ThreadManager as a1, type ThreadManagerConfig as a2, type ThreadOps as a3, type ToolArgs as a4, type ToolCallResult as a5, type ToolCallResultUnion as a6, type ToolDefinition as a7, type ToolHandler as a8, type ToolHandlerContext as a9, createTaskListHandler as aA, createTaskUpdateHandler as aB, createThreadManager as aC, createToolRouter as aD, defineSubagent as aE, defineTool as aF, editTool as aG, globTool as aH, grepTool as aI, hasNoOtherToolCalls as aJ, isTerminalStatus as aK, parseSkillFile as aL, proxyDefaultThreadOps as aM, readFileTool as aN, taskCreateTool as aO, taskGetTool as aP, taskListTool as aQ, taskUpdateTool as aR, withAutoAppend as aS, writeFileTool as aT, type ToolHandlerResponse as aa, type ToolHooks as ab, type ToolMap as ac, type ToolMessageContent as ad, type ToolNames as ae, type ToolResult as af, type ToolResultConfig as ag, type ToolRouter as ah, type ToolWithHandler as ai, type WorkflowTask as aj, type ZeitlichSession as ak, type ZeitlichSharedActivities as al, agentQueryName as am, agentStateChangeUpdateName as an, askUserQuestionTool as ao, bashTool as ap, createAgentStateManager as aq, createAskUserQuestionHandler as ar, createBashToolDescription as as, createReadSkillHandler as at, createReadSkillTool as au, createSession as av, createSharedActivities as aw, createSubagentTool as ax, createTaskCreateHandler as ay, createTaskGetHandler as az, type SkillMetadata as b, type Skill as c, type AgentConfig as d, type AgentFile as e, type AgentState as f, type AgentStateManager as g, type AgentStatus as h, type AppendToolResultFn as i, type AskUserQuestionArgs as j, type BaseAgentState as k, type BaseThreadManager as l, type FileReadArgs as m, type FileWriteArgs as n, type GrepArgs as o, type JsonSerializable as p, type JsonValue as q, type ParsedToolCallUnion as r, type PostToolUseFailureHook as s, type PostToolUseFailureHookContext as t, type PostToolUseFailureHookResult as u, type PostToolUseHook as v, type PostToolUseHookContext as w, type PreToolUseHook as x, type PreToolUseHookContext as y, type PreToolUseHookResult as z };
+export { type ToolHandlerContext as $, type AgentResponse as A, type BaseAgentState as B, type ContentPart as C, type SessionEndHook as D, type SessionEndHookContext as E, type SessionExitReason as F, type SessionStartHook as G, type Hooks as H, type InferToolResults as I, type SessionStartHookContext as J, type SubagentArgs as K, type SubagentConfig as L, type ModelInvoker as M, type SubagentHooks as N, type SubagentInput as O, type ParsedToolCall as P, type SubagentWorkflow as Q, type RunAgentConfig as R, type SkillProvider as S, type ThreadOps as T, type TaskStatus as U, type TokenUsage as V, type ToolArgs as W, type ToolCallResult as X, type ToolCallResultUnion as Y, type ToolDefinition as Z, type ToolHandler as _, type ModelInvokerConfig as a, type ToolHandlerResponse as a0, type ToolHooks as a1, type ToolMap as a2, type ToolMessageContent as a3, type ToolNames as a4, type ToolResult as a5, type ToolResultConfig as a6, type ToolRouter as a7, type ToolWithHandler as a8, type WorkflowTask as a9, agentQueryName as aa, agentStateChangeUpdateName as ab, createSubagentTool as ac, createToolRouter as ad, defineSubagent as ae, defineTool as af, hasNoOtherToolCalls as ag, isTerminalStatus as ah, withAutoAppend as ai, type ActivityToolHandler as b, type SkillMetadata as c, type Skill as d, type AgentConfig as e, type AgentFile as f, type AgentStatus as g, type AppendToolResultFn as h, type MessageContent as i, type ParsedToolCallUnion as j, type PostHumanMessageAppendHook as k, type PostHumanMessageAppendHookContext as l, type PostToolUseFailureHook as m, type PostToolUseFailureHookContext as n, type PostToolUseFailureHookResult as o, type PostToolUseHook as p, type PostToolUseHookContext as q, type PreHumanMessageAppendHook as r, type PreHumanMessageAppendHookContext as s, type PreToolUseHook as t, type PreToolUseHookContext as u, type PreToolUseHookResult as v, type ProcessToolCallsContext as w, type RawToolCall as x, type RunAgentActivity as y, type SessionConfig as z };