zeitlich 0.2.9 → 0.2.12

package/dist/{workflow-C2ShwjC7.d.cts → model-invoker-C5-N-5TC.d.cts}

@@ -1,64 +1,47 @@
-import { Workflow, 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';
 
 /**
- * Content for a tool message response.
- * Can be a simple string or complex content parts (text, images, cache points, etc.)
+ * Skill metadata — the lightweight subset loaded at startup for all skills.
+ * Follows the agentskills.io specification frontmatter fields.
  */
-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;
-}
-/** 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 */
-    append(messages: T[]): Promise<void>;
-    /** Delete the thread */
-    delete(): Promise<void>;
+interface SkillMetadata {
+    /** Lowercase alphanumeric + hyphens, max 64 chars, must match directory name */
+    name: string;
+    /** What the skill does and when to use it (max 1024 chars) */
+    description: string;
+    /** License name or reference to a bundled license file */
+    license?: string;
+    /** Environment requirements (intended product, system packages, network access) */
+    compatibility?: string;
+    /** Arbitrary key-value pairs for additional metadata */
+    metadata?: Record<string, string>;
+    /** Space-delimited list of pre-approved tools the skill may use */
+    allowedTools?: string[];
 }
-/** Thread manager with StoredMessage convenience helpers */
-interface ThreadManager extends BaseThreadManager<StoredMessage> {
-    /** Create a HumanMessage (returns StoredMessage for storage) */
-    createHumanMessage(content: string | MessageContent): 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>;
+/**
+ * A fully-loaded skill including the SKILL.md instruction body.
+ * Progressive disclosure: metadata is always available, instructions
+ * are loaded on-demand via the ReadSkill tool.
+ */
+interface Skill extends SkillMetadata {
+    /** The markdown body of SKILL.md (everything after the frontmatter) */
+    instructions: string;
 }
 /**
- * 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>.
+ * Abstraction for discovering and loading skills.
+ *
+ * Implement this interface to provide skills from any source
+ * (filesystem, database, API, in-memory, etc.).
  */
-declare function createThreadManager(config: ThreadManagerConfig): ThreadManager;
-declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThreadManager<T>;
+interface SkillProvider {
+    /** Return lightweight metadata for all available skills */
+    listSkills(): Promise<SkillMetadata[]>;
+    /** Load a single skill with full instructions by name */
+    getSkill(name: string): Promise<Skill>;
+}
 
+declare const SUBAGENT_TOOL_NAME: "Subagent";
 /**
  * Creates a Subagent tool configured with the available subagents.
  *
@@ -76,13 +59,9 @@ declare function createThreadManager<T>(config: ThreadManagerConfig<T>): BaseThr
  * ]);
  */
 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)
@@ -91,6 +70,7 @@ type SubagentArgs = {
     subagent: string;
     description: string;
     prompt: string;
+    threadId?: string;
 };
 
 /**
@@ -116,7 +96,7 @@ interface ToolWithHandler<TName extends string = string, TSchema extends z$1.Zod
     strict?: boolean;
     max_uses?: number;
     /** Whether this tool is available to the agent (default: true). Disabled tools are excluded from definitions and rejected at parse time. */
-    enabled?: () => boolean;
+    enabled?: boolean;
     /** Per-tool lifecycle hooks (run in addition to global hooks) */
     hooks?: ToolHooks<z$1.infer<TSchema>, TResult>;
 }
@@ -135,7 +115,7 @@ type ToolMap = Record<string, {
     handler: ToolHandler<any, any, any>;
     strict?: boolean;
     max_uses?: number;
-    enabled?: () => boolean;
+    enabled?: boolean;
     hooks?: ToolHooks<any, any>;
 }>;
 /**
@@ -189,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.
@@ -257,6 +239,8 @@ interface ToolRouterOptions<T extends ToolMap> {
     hooks?: Hooks<T, ToolCallResultUnion<InferToolResults<T>>>;
     /** Subagent configurations */
     subagents?: SubagentConfig[];
+    /** Skills available to the agent (auto-adds ReadSkill tool when non-empty) */
+    skills?: Skill[];
 }
 /**
  * Infer result types from a tool map based on handler return types.
@@ -439,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<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<TResult | null>>);
     hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
 }): SubagentConfig<TResult>;
 /**
@@ -454,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 = string;
 /**
  * Agent execution status
  */
@@ -467,11 +460,11 @@ interface BaseAgentState {
     version: number;
     turns: number;
     tasks: Map<string, WorkflowTask>;
-    systemPrompt: string;
+    systemPrompt?: string;
     totalInputTokens: number;
     totalOutputTokens: number;
     cachedWriteTokens: number;
-    cachedReadtTokens: number;
+    cachedReadTokens: number;
 }
 /**
  * File representation for agent workflows
@@ -498,7 +491,7 @@ interface TokenUsage {
 /**
  * Agent response from LLM invocation
  */
-interface AgentResponse<M = StoredMessage> {
+interface AgentResponse<M = unknown> {
     message: M;
     rawToolCalls: RawToolCall[];
     usage?: TokenUsage;
@@ -506,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 */
@@ -526,15 +518,13 @@ interface AgentConfig {
     agentName: string;
     /** Description, used for sub agents */
     description?: string;
-    /** The system prompt to append to the thread */
-    systemPrompt?: string;
 }
 /**
  * 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 */
@@ -549,6 +539,8 @@ interface SessionConfig<T extends ToolMap, M = StoredMessage> {
     tools?: T;
     /** Subagent configurations */
     subagents?: SubagentConfig[];
+    /** Skills available to this agent (metadata + instructions, loaded activity-side) */
+    skills?: Skill[];
     /** Session lifecycle hooks */
     hooks?: Hooks<T, ToolCallResultUnion<InferToolResults<T>>>;
     /** Whether to process tools in parallel */
@@ -558,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;
 }
@@ -585,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
  */
@@ -597,6 +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>>;
 /**
  * Configuration for a subagent that can be spawned by the parent workflow.
  *
@@ -608,15 +603,17 @@ interface SubagentConfig<TResult extends z$1.ZodType = z$1.ZodType> {
     /** Description shown to the parent agent explaining what this subagent does */
     description: string;
     /** Whether this subagent is available (default: true). Disabled subagents are excluded from the Subagent tool. */
-    enabled?: () => boolean;
+    enabled?: boolean;
     /** Temporal workflow function or type name (used with executeChild) */
-    workflow: string | Workflow;
+    workflow: string | SubagentWorkflow<TResult>;
     /** Optional task queue - defaults to parent's queue if not specified */
     taskQueue?: string;
     /** Optional Zod schema to validate the child workflow's result. If omitted, result is passed through as-is. */
     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;
 }
@@ -655,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
@@ -860,376 +859,34 @@ interface Hooks<T extends ToolMap, TResult = unknown> {
     /** Called when session ends */
     onSessionEnd?: SessionEndHook;
 }
+/** Derives the query name for an agent's state (usable in both workflow and activity code) */
+declare const agentQueryName: (agentName: string) => `get${string}State`;
+/** Derives the update name for waiting on an agent's state change */
+declare const agentStateChangeUpdateName: (agentName: string) => `waitFor${string}StateChange`;
 /**
  * Helper to check if status is terminal
  */
 declare function isTerminalStatus(status: AgentStatus): boolean;
 
 /**
- * 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>> {
-    /** 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 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, agentConfig, }: {
-    initialState?: Partial<BaseAgentState> & TCustom;
-    agentConfig: AgentConfig;
-}): AgentStateManager<TCustom>;
-/**
- * Handler names used across agents
+ * 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.
  */
-declare const AGENT_HANDLER_NAMES: {
-    readonly getAgentState: "getAgentState";
-    readonly waitForStateChange: "waitForStateChange";
-    readonly addMessage: "addMessage";
-};
-
-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, description, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, tools, processToolsInParallel, hooks, appendSystemPrompt, systemPrompt, 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;
-
-/**
- * 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>;
+interface ModelInvokerConfig {
+    threadId: string;
+    agentName: string;
+    state: BaseAgentState;
+    metadata?: Record<string, unknown>;
 }
 /**
- * Creates shared Temporal activities for thread management
- *
- * @returns An object containing the shared activity functions
- *
- * @experimental The Zeitlich integration is an experimental feature; APIs may change without notice.
- */
-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.
+ * Generic model invocation contract.
+ * Implementations load the thread, call the LLM, append the response,
+ * and return a normalised AgentResponse.
  *
- * @param stateManager - State manager containing tasks state
- * @returns A ToolHandler for TaskCreate tool calls
+ * Framework adapters (e.g. `zeitlich/langchain`) provide concrete
+ * implementations of this type.
  */
-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 ThreadOps as $, type AgentResponse as A, type BashArgs as B, type RunAgentActivity as C, type RunAgentConfig as D, type SessionEndHookContext as E, type FileEditArgs as F, type GlobArgs as G, type SessionExitReason as H, type InferToolResults as I, type JsonPrimitive as J, type SessionLifecycleHooks as K, type SessionStartHook as L, type SessionStartHookContext as M, type SubagentArgs as N, type SubagentConfig as O, type ParsedToolCall as P, type SubagentHooks as Q, type RawToolCall as R, type SessionEndHook as S, type SubagentInput as T, type TaskCreateArgs as U, type TaskGetArgs as V, type TaskListArgs as W, type TaskStatus as X, type TaskUpdateArgs as Y, type ThreadManager as Z, type ThreadManagerConfig as _, type ActivityToolHandler as a, type ToolArgs as a0, type ToolCallResult as a1, type ToolCallResultUnion as a2, type ToolDefinition as a3, type ToolHandler as a4, type ToolHandlerContext as a5, type ToolHandlerResponse as a6, type ToolHooks as a7, type ToolMap as a8, type ToolMessageContent as a9, grepTool as aA, hasNoOtherToolCalls as aB, isTerminalStatus as aC, proxyDefaultThreadOps as aD, readFileTool as aE, taskCreateTool as aF, taskGetTool as aG, taskListTool as aH, taskUpdateTool as aI, withAutoAppend as aJ, writeFileTool as aK, type ToolNames as aa, type ToolResult as ab, type ToolResultConfig as ac, type ToolRouter as ad, type ToolWithHandler as ae, type WorkflowTask as af, type ZeitlichSession as ag, type ZeitlichSharedActivities as ah, askUserQuestionTool as ai, bashTool as aj, createAgentStateManager as ak, createAskUserQuestionHandler as al, createBashToolDescription as am, createSession as an, createSharedActivities as ao, createSubagentTool as ap, createTaskCreateHandler as aq, createTaskGetHandler as ar, createTaskListHandler as as, createTaskUpdateHandler as at, createThreadManager as au, createToolRouter as av, defineSubagent as aw, defineTool as ax, editTool as ay, globTool as az, AGENT_HANDLER_NAMES as b, type AgentConfig as c, type AgentFile as d, type AgentState as e, type AgentStateManager as f, type AgentStatus as g, type AppendToolResultFn as h, type AskUserQuestionArgs as i, type BaseAgentState as j, type BaseThreadManager as k, type FileReadArgs as l, type FileWriteArgs as m, type GrepArgs as n, type JsonSerializable as o, type JsonValue as p, type ParsedToolCallUnion as q, type PostToolUseFailureHook as r, type PostToolUseFailureHookContext as s, type PostToolUseFailureHookResult as t, type PostToolUseHook as u, type PostToolUseHookContext as v, type PreToolUseHook as w, type PreToolUseHookContext as x, type PreToolUseHookResult as y, type ProcessToolCallsContext 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 };