zeitlich 0.2.28 → 0.2.29

package/dist/workflow.d.ts

@@ -1,581 +1,7 @@
-import { k as SessionConfig, Z as ZeitlichSession, j as SandboxShutdown, B as ThreadInit, i as SandboxInit, r as SubagentDefinition, u as SubagentHooks, v as SubagentSandboxConfig, q as SubagentConfig, w as SubagentSandboxShutdown, x as SubagentSessionInput, s as SubagentFnResult, c as SkillMetadata, d as Skill } from './types-BtqbM1bO.js';
-export { A as AgentResponse, H as Hooks, a as ModelInvoker, M as ModelInvokerConfig, e as PostHumanMessageAppendHook, f as PostHumanMessageAppendHookContext, g as PreHumanMessageAppendHook, h as PreHumanMessageAppendHookContext, P as PrefixedThreadOps, R as RunAgentActivity, S as ScopedPrefix, l as SessionEndHook, m as SessionEndHookContext, n as SessionResult, o as SessionStartHook, p as SessionStartHookContext, b as SkillProvider, t as SubagentHandlerResponse, y as SubagentWorkflow, z as SubagentWorkflowInput, T as ThreadOps } from './types-BtqbM1bO.js';
-import { g as SandboxOps } from './types-ChAMwU3q.js';
-export { h as ExecOptions, E as ExecResult, P as PrefixedSandboxOps, S as Sandbox, c as SandboxCapabilities, d as SandboxCreateOptions, e as SandboxCreateResult, D as SandboxDirentEntry, F as SandboxFileStat, a as SandboxFileSystem, i as SandboxNotFoundError, j as SandboxNotSupportedError, b as SandboxProvider, f as SandboxSnapshot } from './types-ChAMwU3q.js';
-import { a as ToolMap, i as JsonSerializable, B as BaseAgentState, j as AgentStateManager, Q as ToolRouterOptions, M as ToolRouter, R as RouterContext, J as JsonValue, N as ToolWithHandler, r as ParsedToolCallUnion, K as ToolNames, T as ToolHandlerResponse, G as ToolHandler, W as WorkflowTask, A as ActivityToolHandler } from './types-BclYm5Ic.js';
-export { k as AgentConfig, l as AgentFile, m as AgentState, n as AgentStatus, o as AppendToolResultFn, I as InferToolResults, p as JsonPrimitive, q as ParsedToolCall, s as PostToolUseFailureHook, t as PostToolUseFailureHookContext, c as PostToolUseFailureHookResult, u as PostToolUseHook, v as PostToolUseHookContext, w as PreToolUseHook, x as PreToolUseHookContext, P as PreToolUseHookResult, y as ProcessToolCallsContext, d as RawToolCall, f as RunAgentConfig, z as SerializableToolDefinition, S as SessionExitReason, C as TaskStatus, e as TokenUsage, D as ToolArgs, E as ToolCallResult, h as ToolCallResultUnion, F as ToolDefinition, H as ToolHooks, L as ToolResult, g as ToolResultConfig, b as ToolRouterHooks, O as isTerminalStatus } from './types-BclYm5Ic.js';
-import z$1, { z } from 'zod';
-import { a as FileEntryMetadata, e as VirtualFileTree, T as TreeMutation, F as FileEntry } from './types-yU5AINiP.js';
-export { b as FileResolver, g as VirtualSandboxState } from './types-yU5AINiP.js';
-export { f as filesWithMimeType, h as hasDirectory, a as hasFileWithMimeType } from './queries-kjlvsUfz.js';
-import '@temporalio/common';
+export { A as AskUserQuestionArgs, B as BashArgs, F as FileEditArgs, a as FileReadArgs, b as FileWriteArgs, G as GlobArgs, d as GrepArgs, O as ObservabilityHooks, R as ReadSkillArgs, S as SessionEndedEvent, e as SessionStartedEvent, f as SubagentArgs, T as TaskCreateArgs, g as TaskGetArgs, h as TaskListArgs, i as TaskUpdateArgs, j as ToolExecutedEvent, k as TurnCompletedEvent, W as WorkflowConfig, l as WorkflowInput, m as WorkflowSessionInput, Z as ZeitlichObservabilitySinks, n as applyVirtualTreeMutations, o as askUserQuestionTool, p as bashTool, q as composeHooks, r as createAgentStateManager, s as createAskUserQuestionHandler, t as createBashToolDescription, u as createObservabilityHooks, v as createReadSkillHandler, w as createReadSkillTool, x as createSession, y as createTaskCreateHandler, z as createTaskGetHandler, C as createTaskListHandler, D as createTaskUpdateHandler, E as createToolRouter, H as defineSubagent, I as defineSubagentWorkflow, J as defineTool, K as defineWorkflow, L as editTool, M as filesWithMimeType, N as formatVirtualFileTree, P as getShortId, Q as globTool, U as grepTool, V as hasDirectory, X as hasFileWithMimeType, Y as hasNoOtherToolCalls, _ as parseSkillFile, $ as proxyVirtualFsOps, a0 as readFileTool, a1 as taskCreateTool, a2 as taskGetTool, a3 as taskListTool, a4 as taskUpdateTool, a5 as writeFileTool } from './workflow-DCmaXLZ_.js';
+export { c as ActivityToolHandler, l as AgentConfig, m as AgentFile, A as AgentResponse, n as AgentState, o as AgentStateManager, p as AgentStatus, q as AppendToolResultFn, B as BaseAgentState, r as FileEntry, F as FileEntryMetadata, i as FileResolver, H as Hooks, I as InferToolResults, s as JsonPrimitive, t as JsonSerializable, J as JsonValue, a as ModelInvoker, M as ModelInvokerConfig, u as ParsedToolCall, v as ParsedToolCallUnion, w as PostHumanMessageAppendHook, x as PostHumanMessageAppendHookContext, y as PostToolUseFailureHook, z as PostToolUseFailureHookContext, C as PostToolUseFailureHookResult, D as PostToolUseHook, E as PostToolUseHookContext, G as PreHumanMessageAppendHook, K as PreHumanMessageAppendHookContext, L as PreToolUseHook, N as PreToolUseHookContext, O as PreToolUseHookResult, P as PrefixedThreadOps, k as PrefixedVirtualFsOps, Q as ProcessToolCallsContext, U as RawToolCall, R as RouterContext, W as RunAgentActivity, e as RunAgentConfig, X as SandboxInit, Y as SandboxShutdown, S as ScopedPrefix, Z as SerializableToolDefinition, _ as SessionConfig, $ as SessionEndHook, a0 as SessionEndHookContext, a1 as SessionExitReason, a2 as SessionResult, a3 as SessionStartHook, a4 as SessionStartHookContext, h as Skill, g as SkillMetadata, f as SkillProvider, a5 as SubagentConfig, a6 as SubagentDefinition, a7 as SubagentFnResult, a8 as SubagentHandlerResponse, a9 as SubagentHooks, aa as SubagentSandboxConfig, ab as SubagentSandboxShutdown, ac as SubagentSessionInput, ad as SubagentWorkflow, ae as SubagentWorkflowInput, af as TaskStatus, ag as ThreadInit, T as ThreadOps, ah as TokenUsage, ai as ToolArgs, aj as ToolCallResult, ak as ToolCallResultUnion, al as ToolDefinition, am as ToolHandler, b as ToolHandlerResponse, an as ToolHooks, ao as ToolMap, ap as ToolNames, aq as ToolResult, d as ToolResultConfig, ar as ToolRouter, as as ToolRouterHooks, at as ToolWithHandler, j as TreeMutation, av as VirtualFileTree, aw as VirtualFsOps, ax as VirtualFsState, ay as WorkflowTask, az as ZeitlichSession, aA as isTerminalStatus } from './types-BkVoEyiH.js';
+export { h as ExecOptions, E as ExecResult, P as PrefixedSandboxOps, S as Sandbox, c as SandboxCapabilities, d as SandboxCreateOptions, e as SandboxCreateResult, D as SandboxDirentEntry, F as SandboxFileStat, a as SandboxFileSystem, i as SandboxNotFoundError, j as SandboxNotSupportedError, g as SandboxOps, b as SandboxProvider, f as SandboxSnapshot } from './types-ChAMwU3q.js';
+import 'zod';
 import '@temporalio/workflow';
+import '@temporalio/common';
 import '@temporalio/common/lib/interfaces';
-
-/**
- * Creates an agent session that manages the agent loop: LLM invocation,
- * tool routing, subagent coordination, and lifecycle hooks.
- *
- * When `sandboxOps` is provided the returned session result is guaranteed to
- * include `sandboxId: string`. Without it, `sandboxId` is `undefined`.
- *
- * @param config - Session and agent configuration (merged `SessionConfig` and `AgentConfig`)
- * @returns A session object with `runSession()` to start the agent loop
- *
- * @example
- * ```typescript
- * import { createSession, createAgentStateManager, defineTool, bashTool } from 'zeitlich/workflow';
- * import { proxyGoogleGenAIThreadOps } from 'zeitlich/adapters/thread/google-genai/workflow';
- *
- * const session = await createSession({
- *   agentName: "my-agent",
- *   maxTurns: 20,
- *   thread: { mode: "new" },
- *   threadOps: proxyGoogleGenAIThreadOps(),
- *   runAgent: runAgentActivity,
- *   buildContextMessage: () => [{ type: "text", text: prompt }],
- *   subagents: [researcherSubagent],
- *   tools: {
- *     Bash: defineTool({ ...bashTool, handler: bashHandlerActivity }),
- *   },
- * });
- *
- * const { finalMessage, exitReason } = await session.runSession({ stateManager });
- * ```
- */
-declare function createSession<T extends ToolMap, M = unknown, TContent = string>(config: SessionConfig<T, M, TContent> & {
-    sandboxOps: SandboxOps;
-}): Promise<ZeitlichSession<M, true>>;
-declare function createSession<T extends ToolMap, M = unknown, TContent = string>(config: SessionConfig<T, M, TContent>): Promise<ZeitlichSession<M, false>>;
-
-/**
- * Session config fields derived from a main workflow input, ready to spread
- * into `createSession`.
- */
-interface WorkflowSessionInput {
-    /** Agent name — spread directly into `createSession` */
-    agentName: string;
-    /** Thread initialization strategy */
-    thread?: ThreadInit;
-    /** Sandbox initialization strategy */
-    sandbox?: SandboxInit;
-    /** Sandbox shutdown policy (default: "destroy") */
-    sandboxShutdown?: SandboxShutdown;
-}
-/** Raw workflow input fields that map into `WorkflowSessionInput`. */
-interface WorkflowInput {
-    /** Thread initialization strategy (default: `{ mode: "new" }`) */
-    thread?: ThreadInit;
-    /** Sandbox initialization strategy */
-    sandbox?: SandboxInit;
-}
-interface WorkflowConfig {
-    /** Workflow name — used as the Temporal workflow function name */
-    name: string;
-    /**
-     * Sandbox shutdown policy applied when the main agent session exits.
-     *
-     * - `"destroy"` (default) — destroy the sandbox on exit.
-     * - `"pause"` — pause the sandbox so it can be resumed later.
-     * - `"keep"` — leave the sandbox running (no-op on exit).
-     */
-    sandboxShutdown?: SandboxShutdown;
-}
-/**
- * Wraps a main workflow function, translating workflow input fields into
- * session-compatible fields that can be spread directly into `createSession`.
- *
- * The wrapper:
- * - Accepts a `config` with at least a `name` (used for Temporal workflow naming)
- * - Accepts a handler `fn` receiving `(input, sessionInput)`
- * - Derives thread / sandbox init from `workflowInput`
- * - Applies the configured `sandboxShutdown` policy
- */
-declare function defineWorkflow<TInput, TResult>(config: WorkflowConfig, fn: (input: TInput, sessionInput: WorkflowSessionInput) => Promise<TResult>): (input: TInput, workflowInput?: WorkflowInput) => Promise<TResult>;
-
-/**
- * Generate a compact, workflow-deterministic identifier.
- *
- * Uses Temporal's `uuid4()` internally (seeded by the workflow's RNG),
- * then re-encodes the hex bytes into a base-62 alphabet for a shorter,
- * more token-efficient identifier (~3 tokens vs ~10 for a full UUID).
- *
- * Suitable for thread IDs, child workflow IDs, or any workflow-scoped identifier.
- *
- * @param length - Number of base-62 characters (default 12, ~71 bits of entropy)
- */
-declare function getShortId(length?: number): string;
-
-/**
- * Creates an agent state manager for tracking workflow state.
- * Automatically registers Temporal query and update handlers for the agent.
- *
- * @param options.agentName - Unique agent name, used to derive query/update handler names
- * @param options.initialState - Optional initial values for base and custom state.
- *   Use `systemPrompt` here to set the agent's system prompt.
- *   Base state defaults: status="RUNNING", version=0, turns=0, tasks=empty
- *
- * @example
- * ```typescript
- * const stateManager = createAgentStateManager({
- *   initialState: {
- *     systemPrompt: "You are a helpful assistant.",
- *   },
- *   agentName: "my-agent",
- * });
- *
- * // With custom state fields
- * const stateManager = createAgentStateManager({
- *   initialState: {
- *     systemPrompt: agentConfig.systemPrompt,
- *     customField: "value",
- *   },
- *   agentName: agentConfig.agentName,
- * });
- * ```
- */
-declare function createAgentStateManager<TCustom extends JsonSerializable<TCustom> = Record<string, never>>({ initialState, }: {
-    initialState?: Partial<BaseAgentState> & TCustom;
-}): AgentStateManager<TCustom>;
-
-/**
- * Creates a tool router for declarative tool call processing.
- * Combines tool definitions with handlers in a single API.
- *
- * @example
- * ```typescript
- * const router = createToolRouter({
- *   threadId,
- *   tools: {
- *     Read: {
- *       name: "FileRead",
- *       description: "Read file contents",
- *       schema: z.object({ path: z.string() }),
- *       handler: async (args, ctx) => ({
- *         content: `Read ${args.path}`,
- *         result: { path: args.path, content: "..." },
- *       }),
- *     },
- *   },
- *   hooks: { onPreToolUse, onPostToolUse },
- * });
- *
- * // Parse raw tool calls from LLM
- * const parsed = router.parseToolCall(rawToolCall);
- *
- * // Process tool calls
- * const results = await router.processToolCalls([parsed]);
- * ```
- */
-declare function createToolRouter<T extends ToolMap>(options: ToolRouterOptions<T>): ToolRouter<T>;
-/**
- * Identity function that creates a generic inference context for a tool definition.
- * TypeScript infers TResult from the handler and flows it to hooks automatically.
- *
- * @example
- * ```typescript
- * tools: {
- *   AskUser: defineTool({
- *     ...askUserTool,
- *     handler: handleAskUser,
- *     hooks: {
- *       onPostToolUse: ({ result }) => {
- *         // result is correctly typed as the handler's return data type
- *       },
- *     },
- *   }),
- * }
- * ```
- */
-declare function defineTool<TName extends string, TSchema extends z.ZodType, TResult, TContext extends RouterContext = RouterContext, TToolResponse = JsonValue>(tool: ToolWithHandler<TName, TSchema, TResult, TContext, TToolResponse>): ToolWithHandler<TName, TSchema, TResult, TContext, TToolResponse>;
-/**
- * Utility to check if there were no tool calls besides a specific one
- */
-declare function hasNoOtherToolCalls<T extends ToolMap>(toolCalls: ParsedToolCallUnion<T>[], excludeName: ToolNames<T>): boolean;
-
-/**
- * Subagent tool args type (when subagent names are not known at compile time)
- */
-type SubagentArgs = {
-    subagent: string;
-    description: string;
-    prompt: string;
-    threadId?: string | null;
-};
-
-/**
- * Creates a `SubagentConfig` from a `SubagentDefinition` (returned by `defineSubagentWorkflow`).
- * Metadata (name, description, resultSchema) is read from the definition — only configure
- * what's specific to this usage in the parent workflow.
- *
- * @example
- * ```ts
- * // Minimal — all metadata comes from the definition
- * export const researcher = defineSubagent(researcherWorkflow);
- *
- * // With parent-specific overrides
- * export const researcher = defineSubagent(researcherWorkflow, {
- *   thread: "fork",
- *   sandbox: { source: "own", shutdown: "pause" },
- *   hooks: {
- *     onPostExecution: ({ result }) => console.log(result),
- *   },
- * });
- *
- * // With typed context
- * export const researcher = defineSubagent(researcherWorkflow, {
- *   context: { apiKey: "..." },
- * });
- * ```
- */
-declare function defineSubagent<TResult extends z.ZodType = z.ZodType, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: SubagentDefinition<TResult, TContext>, overrides?: {
-    context?: TContext | (() => TContext);
-    hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
-    enabled?: boolean | (() => boolean);
-    taskQueue?: string;
-    thread?: "new" | "fork" | "continue";
-    sandbox?: SubagentSandboxConfig;
-}): SubagentConfig<TResult>;
-
-/**
- * Defines a subagent workflow with embedded metadata (name, description, resultSchema).
- * The returned value can be passed directly to `defineSubagent` — no need to repeat
- * the name, description, or resultSchema in the parent workflow.
- *
- * Internally maps `SubagentWorkflowInput` fields to session-compatible `SubagentSessionInput`.
- *
- * @example
- * ```ts
- * import {
- *   defineSubagentWorkflow,
- *   defineSubagent,
- *   createSession,
- *   createAgentStateManager,
- * } from 'zeitlich/workflow';
- *
- * // Define once — carries name, description, resultSchema
- * export const researcherWorkflow = defineSubagentWorkflow(
- *   {
- *     name: "researcher",
- *     description: "Researches topics on the web",
- *     resultSchema: z.object({ findings: z.string() }),
- *   },
- *   async (prompt, sessionInput) => {
- *     const stateManager = createAgentStateManager({
- *       initialState: { systemPrompt: "You are a researcher." },
- *     });
- *
- *     const session = await createSession({
- *       ...sessionInput,
- *       agentName: "researcher",
- *       runAgent: runAgentActivity,
- *       buildContextMessage: () => [{ type: "text", text: prompt }],
- *     });
- *
- *     const { finalMessage, threadId } = await session.runSession({ stateManager });
- *     return { toolResponse: finalMessage ?? "No response", data: null, threadId };
- *   },
- * );
- *
- * // Use in parent — only configure what's parent-specific
- * export const researcher = defineSubagent(researcherWorkflow, {
- *   hooks: { onPostExecution: ({ result }) => console.log(result) },
- * });
- * ```
- */
-declare function defineSubagentWorkflow<TSandboxShutdown extends SubagentSandboxShutdown = "destroy", TContext extends Record<string, unknown> = Record<string, unknown>>(config: {
-    name: string;
-    description: string;
-    sandboxShutdown?: TSandboxShutdown;
-}, fn: (prompt: string, sessionInput: SubagentSessionInput, context: TContext) => Promise<SubagentFnResult<null, TSandboxShutdown>>): SubagentDefinition<z.ZodNull, TContext>;
-declare function defineSubagentWorkflow<TResult extends z.ZodType, TSandboxShutdown extends SubagentSandboxShutdown = "destroy", TContext extends Record<string, unknown> = Record<string, unknown>>(config: {
-    name: string;
-    description: string;
-    resultSchema: TResult;
-    sandboxShutdown?: TSandboxShutdown;
-}, fn: (prompt: string, sessionInput: SubagentSessionInput, context: TContext) => Promise<SubagentFnResult<z.infer<TResult> | null, TSandboxShutdown>>): SubagentDefinition<TResult, TContext>;
-
-/**
- * Apply a list of {@link TreeMutation}s to the `fileTree` stored in a state
- * manager instance, updating it in place and returning the new tree.
- *
- * The `stateManager` parameter is structurally typed so any
- * {@link AgentStateManager} whose custom state includes
- * `fileTree: VirtualFileTree<TMeta>` will satisfy it.
- */
-declare function applyVirtualTreeMutations<TMeta = FileEntryMetadata>(stateManager: {
-    get(key: "fileTree"): VirtualFileTree<TMeta>;
-    set(key: "fileTree", value: VirtualFileTree<TMeta>): void;
-}, mutations: TreeMutation<TMeta>[]): VirtualFileTree<TMeta>;
-
-/**
- * Generates a formatted file tree string from a flat {@link FileEntry} list.
- * Directories are inferred from file paths — no filesystem access needed.
- *
- * @param entries - Flat list of file entries
- * @param opts - Optional configuration
- * @param opts.sort - Sort entries alphabetically with directories first (defaults to true)
- * @returns Formatted file tree string
- *
- * @example
- * ```typescript
- * const tree = formatVirtualFileTree(state.fileTree);
- * // /
- * // ├─ src/
- * // │  ├─ index.ts
- * // │  └─ utils.ts
- * // └─ package.json
- * ```
- */
-declare function formatVirtualFileTree<T>(entries: FileEntry<T>[], opts?: {
-    sort?: boolean;
-}): string;
-
-/**
- * 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$1.ZodObject<{
-        skill_name: z$1.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.
- *
- * The response uses structured wrapping per the agentskills.io spec:
- * instructions are enclosed in `<skill_content>` tags, the skill directory
- * is included, and bundled resources are listed so the agent can load them
- * individually via its file-read tool.
- */
-declare function createReadSkillHandler(skills: Skill[]): (args: ReadSkillArgs) => ToolHandlerResponse<null>;
-
-declare const globTool: {
-    name: "Glob";
-    description: string;
-    schema: z.ZodObject<{
-        pattern: z.ZodString;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    strict: true;
-};
-type GlobArgs = z.infer<typeof globTool.schema>;
-
-declare const grepTool: {
-    name: "Grep";
-    description: string;
-    schema: z.ZodObject<{
-        pattern: z.ZodString;
-        ignoreCase: z.ZodOptional<z.ZodBoolean>;
-        maxMatches: z.ZodOptional<z.ZodNumber>;
-        includePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        contextLines: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    strict: true;
-};
-type GrepArgs = z.infer<typeof grepTool.schema>;
-
-declare const readFileTool: {
-    name: "FileRead";
-    description: string;
-    schema: z.ZodObject<{
-        path: z.ZodString;
-        offset: z.ZodOptional<z.ZodNumber>;
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    strict: true;
-};
-type FileReadArgs = z.infer<typeof readFileTool.schema>;
-
-declare const writeFileTool: {
-    name: "FileWrite";
-    description: string;
-    schema: z.ZodObject<{
-        file_path: z.ZodString;
-        content: z.ZodString;
-    }, z.core.$strip>;
-    strict: true;
-};
-type FileWriteArgs = z.infer<typeof writeFileTool.schema>;
-
-declare const editTool: {
-    name: "FileEdit";
-    description: string;
-    schema: z.ZodObject<{
-        file_path: z.ZodString;
-        old_string: z.ZodString;
-        new_string: z.ZodString;
-        replace_all: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
-    strict: true;
-};
-type FileEditArgs = z.infer<typeof editTool.schema>;
-
-declare const taskCreateTool: {
-    name: "TaskCreate";
-    description: string;
-    schema: z$1.ZodObject<{
-        subject: z$1.ZodString;
-        description: z$1.ZodString;
-        activeForm: z$1.ZodString;
-        metadata: z$1.ZodRecord<z$1.ZodString, z$1.ZodString>;
-    }, z$1.core.$strip>;
-};
-type TaskCreateArgs = z$1.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$1.ZodObject<{
-        taskId: z$1.ZodString;
-    }, z$1.core.$strip>;
-};
-type TaskGetArgs = z$1.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$1.ZodObject<{}, z$1.core.$strip>;
-};
-type TaskListArgs = z$1.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$1.ZodObject<{
-        taskId: z$1.ZodString;
-        status: z$1.ZodEnum<{
-            pending: "pending";
-            in_progress: "in_progress";
-            completed: "completed";
-        }>;
-        addBlockedBy: z$1.ZodArray<z$1.ZodString>;
-        addBlocks: z$1.ZodArray<z$1.ZodString>;
-    }, z$1.core.$strip>;
-};
-type TaskUpdateArgs = z$1.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$1.ZodObject<{
-        command: z$1.ZodString;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type BashArgs = z$1.infer<typeof bashTool.schema>;
-
-declare const askUserQuestionTool: {
-    name: "AskUserQuestion";
-    description: string;
-    schema: z$1.ZodObject<{
-        questions: z$1.ZodArray<z$1.ZodObject<{
-            question: z$1.ZodString;
-            header: z$1.ZodString;
-            options: z$1.ZodArray<z$1.ZodObject<{
-                label: z$1.ZodString;
-                description: z$1.ZodString;
-            }, z$1.core.$strip>>;
-            multiSelect: z$1.ZodBoolean;
-        }, z$1.core.$strip>>;
-    }, z$1.core.$strip>;
-    strict: true;
-};
-type AskUserQuestionArgs = z$1.infer<typeof askUserQuestionTool.schema>;
-
-/**
- * Creates a handler for the AskUserQuestion tool.
- * Returns question data for display to the user via your UI layer.
- *
- * Typically paired with `stateManager.waitForInput()` in a `hooks.onPostToolUse`
- * callback to pause the agent loop until the user responds.
- *
- * @example
- * ```typescript
- * import { createAskUserQuestionHandler } from 'zeitlich';
- * import { askUserQuestionTool, defineTool } from 'zeitlich/workflow';
- *
- * // In activities
- * const askUserQuestionHandlerActivity = createAskUserQuestionHandler();
- *
- * // In workflow
- * tools: {
- *   AskUserQuestion: defineTool({
- *     ...askUserQuestionTool,
- *     handler: askUserQuestionHandlerActivity,
- *     hooks: {
- *       onPostToolUse: () => { stateManager.waitForInput(); },
- *     },
- *   }),
- * }
- * ```
- */
-declare const createAskUserQuestionHandler: () => ActivityToolHandler<AskUserQuestionArgs, {
-    questions: {
-        question: string;
-        header: string;
-        options: {
-            label: string;
-            description: string;
-        }[];
-        multiSelect: boolean;
-    }[];
-}>;
-
-export { ActivityToolHandler, AgentStateManager, type AskUserQuestionArgs, BaseAgentState, type BashArgs, type FileEditArgs, FileEntry, FileEntryMetadata, type FileReadArgs, type FileWriteArgs, type GlobArgs, type GrepArgs, JsonSerializable, JsonValue, ParsedToolCallUnion, type ReadSkillArgs, RouterContext, SandboxInit, SandboxOps, SandboxShutdown, SessionConfig, Skill, SkillMetadata, type SubagentArgs, SubagentConfig, SubagentDefinition, SubagentFnResult, SubagentHooks, SubagentSandboxConfig, SubagentSandboxShutdown, SubagentSessionInput, type TaskCreateArgs, type TaskGetArgs, type TaskListArgs, type TaskUpdateArgs, ThreadInit, ToolHandler, ToolHandlerResponse, ToolMap, ToolNames, ToolRouter, ToolWithHandler, TreeMutation, VirtualFileTree, type WorkflowConfig, type WorkflowInput, type WorkflowSessionInput, WorkflowTask, ZeitlichSession, applyVirtualTreeMutations, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createReadSkillHandler, createReadSkillTool, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createToolRouter, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editTool, formatVirtualFileTree, getShortId, globTool, grepTool, hasNoOtherToolCalls, parseSkillFile, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeFileTool };