zeitlich 0.2.13 → 0.2.14

package/dist/workflow.d.cts

@@ -1,109 +1,89 @@
-import { QueryDefinition, proxyActivities } from '@temporalio/workflow';
-import { B as BaseAgentState, g as AgentStatus, a9 as WorkflowTask, Z as ToolDefinition, G as SessionStartHook, D as SessionEndHook, F as SessionExitReason, a2 as ToolMap, z as SessionConfig, e as AgentConfig, T as ThreadOps, c as SkillMetadata, d as Skill, a0 as ToolHandlerResponse, _ as ToolHandler, b as ActivityToolHandler } from './model-invoker-y_zlyMqu.cjs';
-export { f as AgentFile, A as AgentResponse, h as AppendToolResultFn, C as ContentPart, H as Hooks, I as InferToolResults, i as MessageContent, M as ModelInvoker, a as ModelInvokerConfig, P as ParsedToolCall, j as ParsedToolCallUnion, k as PostHumanMessageAppendHook, l as PostHumanMessageAppendHookContext, m as PostToolUseFailureHook, n as PostToolUseFailureHookContext, o as PostToolUseFailureHookResult, p as PostToolUseHook, q as PostToolUseHookContext, r as PreHumanMessageAppendHook, s as PreHumanMessageAppendHookContext, t as PreToolUseHook, u as PreToolUseHookContext, v as PreToolUseHookResult, w as ProcessToolCallsContext, x as RawToolCall, y as RunAgentActivity, R as RunAgentConfig, E as SessionEndHookContext, J as SessionStartHookContext, S as SkillProvider, K as SubagentArgs, L as SubagentConfig, N as SubagentHooks, O as SubagentInput, Q as SubagentWorkflow, U as TaskStatus, V as TokenUsage, W as ToolArgs, X as ToolCallResult, Y as ToolCallResultUnion, $ as ToolHandlerContext, a1 as ToolHooks, a3 as ToolMessageContent, a4 as ToolNames, a5 as ToolResult, a6 as ToolResultConfig, a7 as ToolRouter, a8 as ToolWithHandler, aa as agentQueryName, ab as agentStateChangeUpdateName, ac as createSubagentTool, ad as createToolRouter, ae as defineSubagent, af as defineTool, ag as hasNoOtherToolCalls, ah as isTerminalStatus } from './model-invoker-y_zlyMqu.cjs';
-import { UpdateDefinition } from '@temporalio/common/lib/interfaces';
-import z, { z as z$1 } from 'zod';
+import { proxyActivities } from '@temporalio/workflow';
+import { k as SessionConfig, Z as ZeitlichSession, T as ThreadOps, f as JsonSerializable, e as AgentStateManager, p as SubagentConfig, q as SubagentHandlerResponse, r as SubagentHooks, b as SkillMetadata, c as Skill } from './types-GpMU4b0w.cjs';
+export { A as AgentResponse, d as AgentState, H as Hooks, J as JsonPrimitive, g as JsonValue, M as ModelInvoker, a as ModelInvokerConfig, P as PostHumanMessageAppendHook, h as PostHumanMessageAppendHookContext, i as PreHumanMessageAppendHook, j as PreHumanMessageAppendHookContext, R as RunAgentActivity, l as SessionEndHook, m as SessionEndHookContext, n as SessionStartHook, o as SessionStartHookContext, S as SkillProvider, s as SubagentInput, t as SubagentWorkflow } from './types-GpMU4b0w.cjs';
+import { g as SandboxOps } from './types-CDubRtad.cjs';
+export { h as ExecOptions, E as ExecResult, 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-CDubRtad.cjs';
+import { a as ToolMap, B as BaseAgentState, N as ToolRouterOptions, J as ToolRouter, R as RouterContext, K as ToolWithHandler, p as ParsedToolCallUnion, G as ToolNames, c as ToolHandlerResponse, E as ToolHandler, W as WorkflowTask, A as ActivityToolHandler } from './types-BMXzv7TN.cjs';
+export { l as AgentConfig, m as AgentFile, h as AgentStatus, n as AppendToolResultFn, C as ContentPart, I as InferToolResults, M as MessageContent, o as ParsedToolCall, q as PostToolUseFailureHook, r as PostToolUseFailureHookContext, d as PostToolUseFailureHookResult, s as PostToolUseHook, t as PostToolUseHookContext, u as PreToolUseHook, v as PreToolUseHookContext, P as PreToolUseHookResult, w as ProcessToolCallsContext, e as RawToolCall, g as RunAgentConfig, x as SerializableToolDefinition, S as SessionExitReason, y as TaskStatus, f as TokenUsage, z as ToolArgs, D as ToolCallResult, k as ToolCallResultUnion, i as ToolDefinition, F as ToolHooks, T as ToolMessageContent, H as ToolResult, j as ToolResultConfig, b as ToolRouterHooks, L as isTerminalStatus } from './types-BMXzv7TN.cjs';
+import z$1, { z } from 'zod';
+import { F as FileEntryMetadata, e as VirtualFileTree, T as TreeMutation, c as FileEntry } from './types-BVP87m_W.cjs';
+export { a as FileResolver, g as VirtualSandboxState } from './types-BVP87m_W.cjs';
 import '@temporalio/common';
+import '@temporalio/common/lib/interfaces';
 
 /**
- * JSON primitive types that Temporal can serialize
- */
-type JsonPrimitive = string | number | boolean | null | undefined;
-/**
- * JSON-serializable value (recursive type for Temporal compatibility)
+ * Creates an agent session that manages the agent loop: LLM invocation,
+ * tool routing, subagent coordination, and lifecycle hooks.
+ *
+ * @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';
+ *
+ * const stateManager = createAgentStateManager({
+ *   initialState: { systemPrompt: "You are a helpful assistant." },
+ *   agentName: "my-agent",
+ * });
+ *
+ * const session = await createSession({
+ *   agentName: "my-agent",
+ *   maxTurns: 20,
+ *   threadId: runId,
+ *   runAgent: runAgentActivity,
+ *   buildContextMessage: () => [{ type: "text", text: prompt }],
+ *   subagents: [researcherSubagent],
+ *   tools: {
+ *     Bash: defineTool({ ...bashTool, handler: bashHandlerActivity }),
+ *   },
+ * });
+ *
+ * const { finalMessage, exitReason } = await session.runSession({ stateManager });
+ * ```
  */
-type JsonValue = JsonPrimitive | JsonValue[] | {
-    [key: string]: JsonValue;
-};
+declare const createSession: <T extends ToolMap, M = unknown>({ threadId: providedThreadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, skills, tools, processToolsInParallel, hooks, appendSystemPrompt, continueThread, waitForInputTimeout, sandbox: sandboxOps, sandboxId: inheritedSandboxId, }: SessionConfig<T, M>) => Promise<ZeitlichSession<M>>;
 /**
- * Type constraint ensuring T only contains JSON-serializable values.
- * Use this for custom state to ensure Temporal workflow compatibility.
+ * Proxy the adapter's thread operations as Temporal activities.
+ * Call this in workflow code to delegate thread operations to the
+ * adapter-provided activities registered on the worker.
  *
- * Allows: primitives, arrays, plain objects, and JsonValue
- * Rejects: functions, symbols, undefined, class instances with methods
+ * @example
+ * ```typescript
+ * const session = await createSession({
+ *   threadOps: proxyDefaultThreadOps(),
+ *   // ...
+ * });
+ * ```
  */
-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;
-};
+declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps;
 /**
- * Full state type combining base state with custom state
+ * Proxy sandbox lifecycle operations as Temporal activities.
+ * Call this in workflow code when the agent needs a sandbox.
+ *
+ * @example
+ * ```typescript
+ * const session = await createSession({
+ *   sandbox: proxySandboxOps(),
+ *   // ...
+ * });
+ * ```
  */
-type AgentState<TCustom extends JsonSerializable<TCustom>> = BaseAgentState & TCustom;
+declare function proxySandboxOps(options?: Parameters<typeof proxyActivities>[0]): SandboxOps;
+
 /**
- * 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.
+ * 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)
  */
-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;
-    };
-}
+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.
@@ -132,88 +112,157 @@ interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
  * });
  * ```
  */
-declare function createAgentStateManager<TCustom extends JsonSerializable<TCustom> = Record<string, never>>({ initialState, agentName, }: {
+declare function createAgentStateManager<TCustom extends JsonSerializable<TCustom> = Record<string, never>>({ initialState, }: {
     initialState?: Partial<BaseAgentState> & TCustom;
-    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;
-}
 /**
- * Creates an agent session that manages the agent loop: LLM invocation,
- * tool routing, subagent coordination, and lifecycle hooks.
- *
- * @param config - Session and agent configuration (merged `SessionConfig` and `AgentConfig`)
- * @returns A session object with `runSession()` to start the agent loop
+ * Creates a tool router for declarative tool call processing.
+ * Combines tool definitions with handlers in a single API.
  *
  * @example
  * ```typescript
- * import { createSession, createAgentStateManager, defineTool, bashTool } from 'zeitlich/workflow';
- *
- * const stateManager = createAgentStateManager({
- *   initialState: { systemPrompt: "You are a helpful assistant." },
- *   agentName: "my-agent",
- * });
- *
- * const session = await createSession({
- *   agentName: "my-agent",
- *   maxTurns: 20,
- *   threadId: runId,
- *   runAgent: runAgentActivity,
- *   buildContextMessage: () => [{ type: "text", text: prompt }],
- *   subagents: [researcherSubagent],
+ * const router = createToolRouter({
+ *   threadId,
  *   tools: {
- *     Bash: defineTool({ ...bashTool, handler: bashHandlerActivity }),
+ *     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 },
  * });
  *
- * const { finalMessage, exitReason } = await session.runSession({ stateManager });
+ * // Parse raw tool calls from LLM
+ * const parsed = router.parseToolCall(rawToolCall);
+ *
+ * // Process tool calls
+ * const results = await router.processToolCalls([parsed]);
  * ```
  */
-declare const createSession: <T extends ToolMap, M = unknown>({ threadId: providedThreadId, agentName, maxTurns, metadata, runAgent, threadOps, buildContextMessage, subagents, skills, tools, processToolsInParallel, hooks, appendSystemPrompt, continueThread, waitForInputTimeout, }: SessionConfig<T, M> & AgentConfig) => Promise<ZeitlichSession<M>>;
+declare function createToolRouter<T extends ToolMap>(options: ToolRouterOptions<T>): ToolRouter<T>;
 /**
- * Proxy the adapter's thread operations as Temporal activities.
- * Call this in workflow code to delegate thread operations to the
- * adapter-provided activities registered on the worker.
+ * 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
- * const session = await createSession({
- *   threadOps: proxyDefaultThreadOps(),
- *   // ...
+ * 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>(tool: ToolWithHandler<TName, TSchema, TResult, TContext>): ToolWithHandler<TName, TSchema, TResult, TContext>;
+/**
+ * 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;
+};
+
+/**
+ * Identity function that provides full type inference for subagent configurations.
+ * Verifies the workflow function's input parameters match the configured context,
+ * and properly types the lifecycle hooks with Task tool args and inferred result type.
+ *
+ * @example
+ * ```ts
+ * // With typed context — workflow must accept { prompt, context }
+ * const researcher = defineSubagent({
+ *   name: "researcher",
+ *   description: "Researches topics",
+ *   workflow: researcherWorkflow, // (input: { prompt: string; context: { apiKey: string } }) => Promise<...>
+ *   context: { apiKey: "..." },
+ *   resultSchema: z.object({ findings: z.string() }),
+ *   hooks: {
+ *     onPostExecution: ({ result }) => {
+ *       // result is typed as { findings: string }
+ *     },
+ *   },
+ * });
+ *
+ * // Without context — workflow only needs { prompt }
+ * const writer = defineSubagent({
+ *   name: "writer",
+ *   description: "Writes content",
+ *   workflow: writerWorkflow, // (input: { prompt: string }) => Promise<...>
+ *   resultSchema: z.object({ content: z.string() }),
  * });
  * ```
  */
-declare function proxyDefaultThreadOps(options?: Parameters<typeof proxyActivities>[0]): ThreadOps;
+declare function defineSubagent<TResult extends z.ZodType = z.ZodType, TContext extends Record<string, unknown> = Record<string, unknown>>(config: Omit<SubagentConfig<TResult>, "hooks" | "workflow" | "context"> & {
+    workflow: string | ((input: {
+        prompt: string;
+        previousThreadId?: string;
+        context: TContext;
+    }) => Promise<SubagentHandlerResponse<z.infer<TResult> | null>>);
+    context: TContext;
+    hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
+}): SubagentConfig<TResult>;
+declare function defineSubagent<TResult extends z.ZodType = z.ZodType>(config: Omit<SubagentConfig<TResult>, "hooks" | "workflow"> & {
+    workflow: string | ((input: {
+        prompt: string;
+        previousThreadId?: string;
+    }) => Promise<SubagentHandlerResponse<z.infer<TResult> | null>>);
+    hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
+}): SubagentConfig<TResult>;
 
 /**
- * Generate a compact, workflow-deterministic identifier.
+ * 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.
  *
- * 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).
+ * 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.
  *
- * Suitable for thread IDs, child workflow IDs, or any workflow-scoped identifier.
+ * @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
  *
- * @param length - Number of base-62 characters (default 12, ~71 bits of entropy)
+ * @example
+ * ```typescript
+ * const tree = formatVirtualFileTree(state.fileTree);
+ * // /
+ * // ├─ src/
+ * // │  ├─ index.ts
+ * // │  └─ utils.ts
+ * // └─ package.json
+ * ```
  */
-declare function getShortId(length?: number): string;
+declare function formatVirtualFileTree<T>(entries: FileEntry<T>[], opts?: {
+    sort?: boolean;
+}): string;
 
 /**
  * Parse a SKILL.md file into its frontmatter fields and markdown body.
@@ -235,8 +284,8 @@ declare function parseSkillFile(raw: string): {
 declare function createReadSkillTool(skills: Skill[]): {
     name: string;
     description: string;
-    schema: z.ZodObject<{
-        skill_name: z.ZodEnum<Record<string, string>>;
+    schema: z$1.ZodObject<{
+        skill_name: z$1.ZodEnum<Record<string, string>>;
     }>;
 };
 type ReadSkillArgs = {
@@ -252,76 +301,76 @@ declare function createReadSkillHandler(skills: Skill[]): (args: ReadSkillArgs)
 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>;
+    schema: z.ZodObject<{
+        pattern: z.ZodString;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
     strict: true;
 };
-type GlobArgs = z$1.infer<typeof globTool.schema>;
+type GlobArgs = z.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>;
+    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$1.infer<typeof grepTool.schema>;
+type GrepArgs = z.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>;
+    schema: z.ZodObject<{
+        path: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
     strict: true;
 };
-type FileReadArgs = z$1.infer<typeof readFileTool.schema>;
+type FileReadArgs = z.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>;
+    schema: z.ZodObject<{
+        file_path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
     strict: true;
 };
-type FileWriteArgs = z$1.infer<typeof writeFileTool.schema>;
+type FileWriteArgs = z.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>;
+    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$1.infer<typeof editTool.schema>;
+type FileEditArgs = z.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>;
+    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.infer<typeof taskCreateTool.schema>;
+type TaskCreateArgs = z$1.infer<typeof taskCreateTool.schema>;
 
 /**
  * Creates a TaskCreate handler that adds tasks to the workflow state.
@@ -334,11 +383,11 @@ declare function createTaskCreateHandler<TCustom extends JsonSerializable<TCusto
 declare const taskGetTool: {
     name: "TaskGet";
     description: string;
-    schema: z.ZodObject<{
-        taskId: z.ZodString;
-    }, z.core.$strip>;
+    schema: z$1.ZodObject<{
+        taskId: z$1.ZodString;
+    }, z$1.core.$strip>;
 };
-type TaskGetArgs = z.infer<typeof taskGetTool.schema>;
+type TaskGetArgs = z$1.infer<typeof taskGetTool.schema>;
 
 /**
  * Creates a TaskGet handler that retrieves a task by ID.
@@ -351,9 +400,9 @@ declare function createTaskGetHandler<TCustom extends JsonSerializable<TCustom>>
 declare const taskListTool: {
     name: "TaskList";
     description: string;
-    schema: z.ZodObject<{}, z.core.$strip>;
+    schema: z$1.ZodObject<{}, z$1.core.$strip>;
 };
-type TaskListArgs = z.infer<typeof taskListTool.schema>;
+type TaskListArgs = z$1.infer<typeof taskListTool.schema>;
 
 /**
  * Creates a TaskList handler that returns all tasks.
@@ -366,18 +415,18 @@ declare function createTaskListHandler<TCustom extends JsonSerializable<TCustom>
 declare const taskUpdateTool: {
     name: "TaskUpdate";
     description: string;
-    schema: z.ZodObject<{
-        taskId: z.ZodString;
-        status: z.ZodEnum<{
+    schema: z$1.ZodObject<{
+        taskId: z$1.ZodString;
+        status: z$1.ZodEnum<{
             pending: "pending";
             in_progress: "in_progress";
             completed: "completed";
         }>;
-        addBlockedBy: z.ZodArray<z.ZodString>;
-        addBlocks: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
+        addBlockedBy: z$1.ZodArray<z$1.ZodString>;
+        addBlocks: z$1.ZodArray<z$1.ZodString>;
+    }, z$1.core.$strip>;
 };
-type TaskUpdateArgs = z.infer<typeof taskUpdateTool.schema>;
+type TaskUpdateArgs = z$1.infer<typeof taskUpdateTool.schema>;
 
 /**
  * Creates a TaskUpdate handler that modifies task status and dependencies.
@@ -393,30 +442,30 @@ declare const createBashToolDescription: ({ fileTree, }: {
 declare const bashTool: {
     name: "Bash";
     description: string;
-    schema: z.ZodObject<{
-        command: z.ZodString;
-    }, z.core.$strip>;
+    schema: z$1.ZodObject<{
+        command: z$1.ZodString;
+    }, z$1.core.$strip>;
     strict: true;
 };
-type BashArgs = z.infer<typeof bashTool.schema>;
+type BashArgs = z$1.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>;
+    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.infer<typeof askUserQuestionTool.schema>;
+type AskUserQuestionArgs = z$1.infer<typeof askUserQuestionTool.schema>;
 
 /**
  * Creates a handler for the AskUserQuestion tool.
@@ -457,4 +506,4 @@ declare const createAskUserQuestionHandler: () => ActivityToolHandler<AskUserQue
     }[];
 }>;
 
-export { ActivityToolHandler, AgentConfig, type AgentState, type AgentStateManager, AgentStatus, type AskUserQuestionArgs, BaseAgentState, type BashArgs, type FileEditArgs, type FileReadArgs, type FileWriteArgs, type GlobArgs, type GrepArgs, type JsonPrimitive, type JsonSerializable, type JsonValue, type ReadSkillArgs, SessionConfig, SessionEndHook, SessionExitReason, type SessionLifecycleHooks, SessionStartHook, Skill, SkillMetadata, type TaskCreateArgs, type TaskGetArgs, type TaskListArgs, type TaskUpdateArgs, ThreadOps, ToolDefinition, ToolHandler, ToolHandlerResponse, ToolMap, WorkflowTask, type ZeitlichSession, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createReadSkillHandler, createReadSkillTool, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, editTool, getShortId, globTool, grepTool, parseSkillFile, proxyDefaultThreadOps, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeFileTool };
+export { ActivityToolHandler, AgentStateManager, type AskUserQuestionArgs, BaseAgentState, type BashArgs, type FileEditArgs, FileEntry, FileEntryMetadata, type FileReadArgs, type FileWriteArgs, type GlobArgs, type GrepArgs, JsonSerializable, ParsedToolCallUnion, type ReadSkillArgs, RouterContext, SandboxOps, SessionConfig, Skill, SkillMetadata, type SubagentArgs, SubagentConfig, SubagentHandlerResponse, SubagentHooks, type TaskCreateArgs, type TaskGetArgs, type TaskListArgs, type TaskUpdateArgs, ThreadOps, ToolHandler, ToolHandlerResponse, ToolMap, ToolNames, ToolRouter, ToolWithHandler, TreeMutation, VirtualFileTree, WorkflowTask, ZeitlichSession, applyVirtualTreeMutations, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createReadSkillHandler, createReadSkillTool, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createToolRouter, defineSubagent, defineTool, editTool, formatVirtualFileTree, getShortId, globTool, grepTool, hasNoOtherToolCalls, parseSkillFile, proxyDefaultThreadOps, proxySandboxOps, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeFileTool };