zeitlich 0.2.13 → 0.2.14

package/dist/model-invoker-y_zlyMqu.d.cts

@@ -1,892 +0,0 @@
-import z, { z as z$1 } from 'zod';
-import { Duration } from '@temporalio/common';
-
-/**
- * Skill metadata — the lightweight subset loaded at startup for all skills.
- * Follows the agentskills.io specification frontmatter fields.
- */
-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[];
-}
-/**
- * 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;
-}
-/**
- * Abstraction for discovering and loading skills.
- *
- * Implement this interface to provide skills from any source
- * (filesystem, database, API, in-memory, etc.).
- */
-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.
- *
- * @param subagents - Array of subagent configurations (must have at least one)
- * @returns A tool definition with dynamic schema based on available subagents
- *
- * @example
- * const subagentTool = createSubagentTool([
- *   {
- *     agentName: "researcher",
- *     description: "Researches topics and gathers information",
- *     workflow: "researcherWorkflow",
- *     resultSchema: z.object({ findings: z.string() }),
- *   },
- * ]);
- */
-declare function createSubagentTool<T extends SubagentConfig[]>(subagents: T): {
-    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)
- */
-type SubagentArgs = {
-    subagent: string;
-    description: string;
-    prompt: string;
-    threadId?: string;
-};
-
-/**
- * A tool definition with a name, description, and Zod schema for arguments.
- * Does not include a handler - use ToolWithHandler for tools with handlers.
- */
-interface ToolDefinition<TName extends string = string, TSchema extends z$1.ZodType = z$1.ZodType> {
-    name: TName;
-    description: string;
-    schema: TSchema;
-    strict?: boolean;
-    max_uses?: number;
-}
-/**
- * A tool definition with an integrated handler function.
- * This is the primary type for defining tools in the router.
- */
-interface ToolWithHandler<TName extends string = string, TSchema extends z$1.ZodType = z$1.ZodType, TResult = unknown, TContext = ToolHandlerContext> {
-    name: TName;
-    description: string;
-    schema: TSchema;
-    handler: ToolHandler<z$1.infer<TSchema>, TResult, TContext>;
-    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;
-    /** Per-tool lifecycle hooks (run in addition to global hooks) */
-    hooks?: ToolHooks<z$1.infer<TSchema>, TResult>;
-}
-/**
- * A map of tool keys to tool definitions with handlers.
- *
- * Handler uses `any` intentionally — this is a type-system boundary where heterogeneous
- * tool types are stored together. Type safety for individual tools is enforced by
- * `defineTool()` at the definition site and generic inference utilities like
- * `InferToolResults<T>` at the consumption site.
- */
-type ToolMap = Record<string, {
-    name: string;
-    description: string;
-    schema: z$1.ZodType;
-    handler: ToolHandler<any, any, any>;
-    strict?: boolean;
-    max_uses?: number;
-    enabled?: boolean;
-    hooks?: ToolHooks<any, any>;
-}>;
-/**
- * Extract the tool names from a tool map (uses the tool's name property, not the key).
- */
-type ToolNames<T extends ToolMap> = T[keyof T]["name"];
-/**
- * A raw tool call as received from the LLM before parsing.
- */
-interface RawToolCall {
-    id?: string;
-    name: string;
-    args: unknown;
-}
-/**
- * A parsed tool call with validated arguments for a specific tool.
- */
-interface ParsedToolCall<TName extends string = string, TArgs = unknown> {
-    id: string;
-    name: TName;
-    args: TArgs;
-}
-/**
- * Union type of all possible parsed tool calls from a tool map.
- */
-type ParsedToolCallUnion<T extends ToolMap> = {
-    [K in keyof T]: ParsedToolCall<T[K]["name"], z$1.infer<T[K]["schema"]>>;
-}[keyof T];
-/**
- * Function signature for appending tool results to a thread.
- */
-type AppendToolResultFn = (config: ToolResultConfig) => Promise<void>;
-/**
- * The response from a tool handler.
- * Contains the content for the tool message and the result to return from processToolCalls.
- *
- * Tools that don't return additional data should use `data: null` (TResult defaults to null).
- * Tools that may fail to produce data should type TResult as `SomeType | null`.
- */
-interface ToolHandlerResponse<TResult = null> {
-    /** Content sent back to the LLM as the tool call response */
-    toolResponse: ToolMessageContent;
-    /** Data returned to the workflow and hooks for further processing */
-    data: TResult;
-    /**
-     * When true, the tool result has already been appended to the thread
-     * by the handler itself (e.g. via `withAutoAppend`), so the router
-     * will skip the `appendToolResult` call. This avoids sending large
-     * payloads through Temporal's activity payload limit.
-     */
-    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.
- * Use this to pass workflow state like file trees, user context, etc.
- * Generic so callers can type the context shape, e.g. ToolHandlerContext<ControlTestFsParams>.
- */
-type ToolHandlerContext<T = Record<string, unknown>> = T;
-/**
- * A handler function for a specific tool.
- * Receives the parsed args and context, returns a response with content and result.
- * Context always has a value (defaults to empty object if not provided).
- */
-type ToolHandler<TArgs, TResult, TContext = ToolHandlerContext> = (args: TArgs, context: TContext) => ToolHandlerResponse<TResult> | Promise<ToolHandlerResponse<TResult>>;
-/**
- * Activity-compatible tool handler that always returns a Promise.
- * Use this for tool handlers registered as Temporal activities.
- * Context always has a value (defaults to empty object if not provided).
- *
- * @example
- * ```typescript
- * // Filesystem handler with context
- * const readHandler: ActivityToolHandler<
- *   FileReadArgs,
- *   ReadResult,
- *   { scopedNodes: FileNode[]; provider: FileSystemProvider }
- * > = async (args, context) => {
- *   return readHandler(args, context.scopedNodes, context.provider);
- * };
- * ```
- */
-type ActivityToolHandler<TArgs, TResult, TContext = ToolHandlerContext> = (args: TArgs, context: TContext) => Promise<ToolHandlerResponse<TResult>>;
-/**
- * Extract the args type for a specific tool name from a tool map.
- */
-type ToolArgs<T extends ToolMap, TName extends ToolNames<T>> = z$1.infer<Extract<T[keyof T], {
-    name: TName;
-}>["schema"]>;
-/**
- * Extract the result type for a specific tool name from a tool map.
- */
-type ToolResult<T extends ToolMap, TName extends ToolNames<T>> = Extract<T[keyof T], {
-    name: TName;
-}>["handler"] extends ToolHandler<unknown, infer R, unknown> ? Awaited<R> : never;
-/**
- * The result of processing a tool call.
- */
-interface ToolCallResult<TName extends string = string, TResult = unknown> {
-    toolCallId: string;
-    name: TName;
-    data: TResult;
-    usage?: TokenUsage;
-}
-/**
- * Options for creating a tool router.
- */
-interface ToolRouterOptions<T extends ToolMap> {
-    /** Map of tools with their handlers */
-    tools: T;
-    /** Thread ID for appending tool results */
-    threadId: string;
-    /** Function to append tool results to the thread (called automatically after each handler) */
-    appendToolResult: AppendToolResultFn;
-    /** Whether to process tools in parallel (default: true) */
-    parallel?: boolean;
-    /** Lifecycle hooks for tool execution */
-    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.
- */
-type InferToolResults<T extends ToolMap> = {
-    [K in keyof T as T[K]["name"]]: T[K]["handler"] extends ToolHandler<any, infer R, any> ? Awaited<R> : never;
-};
-/**
- * Union of all possible tool call results based on handler return types.
- */
-type ToolCallResultUnion<TResults extends Record<string, unknown>> = {
-    [TName in keyof TResults & string]: ToolCallResult<TName, TResults[TName]>;
-}[keyof TResults & string];
-/**
- * Context passed to processToolCalls for hook execution and handler invocation
- */
-interface ProcessToolCallsContext<THandlerContext = ToolHandlerContext> {
-    /** Current turn number (for hooks) */
-    turn?: number;
-    /** Context passed to each tool handler (scopedNodes, provider, etc.) */
-    handlerContext?: THandlerContext;
-}
-/**
- * The tool router interface with full type inference for both args and results.
- */
-interface ToolRouter<T extends ToolMap> {
-    /** Check if the router has any tools */
-    hasTools(): boolean;
-    /**
-     * Parse and validate a raw tool call against the router's tools.
-     * Returns a typed tool call with validated arguments.
-     */
-    parseToolCall(toolCall: RawToolCall): ParsedToolCallUnion<T>;
-    /**
-     * Check if a tool with the given name exists in the router.
-     */
-    hasTool(name: string): boolean;
-    /**
-     * Get all tool names in the router.
-     */
-    getToolNames(): ToolNames<T>[];
-    /**
-     * Get all tool definitions (without handlers) for passing to LLM.
-     */
-    getToolDefinitions(): ToolDefinition[];
-    /**
-     * Process all tool calls using the registered handlers.
-     * Returns typed results based on handler return types.
-     * @param toolCalls - Array of parsed tool calls to process
-     * @param context - Optional context including turn number for hooks
-     */
-    processToolCalls(toolCalls: ParsedToolCallUnion<T>[], context?: ProcessToolCallsContext): Promise<ToolCallResultUnion<InferToolResults<T>>[]>;
-    /**
-     * Process tool calls matching a specific name with a custom handler.
-     * Useful for overriding the default handler for specific cases.
-     */
-    processToolCallsByName<TName extends ToolNames<T>, TResult, TContext = ToolHandlerContext>(toolCalls: ParsedToolCallUnion<T>[], toolName: TName, handler: ToolHandler<ToolArgs<T, TName>, TResult, TContext>, context?: ProcessToolCallsContext<TContext>): Promise<ToolCallResult<TName, TResult>[]>;
-    /**
-     * Filter tool calls by name.
-     */
-    filterByName<TName extends ToolNames<T>>(toolCalls: ParsedToolCallUnion<T>[], name: TName): ParsedToolCall<TName, ToolArgs<T, TName>>[];
-    /**
-     * Check if any tool call matches the given name.
-     */
-    hasToolCall(toolCalls: ParsedToolCallUnion<T>[], name: ToolNames<T>): boolean;
-    /**
-     * Filter results by tool name.
-     */
-    getResultsByName<TName extends ToolNames<T>>(results: ToolCallResultUnion<InferToolResults<T>>[], name: TName): ToolCallResult<TName, ToolResult<T, TName>>[];
-}
-/**
- * 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>;
-/**
- * Wraps a tool handler to automatically append its result directly to the
- * thread and sets `resultAppended: true` on the response.
- *
- * Use this for tools whose responses may exceed Temporal's activity payload
- * limit. The wrapper appends to the thread inside the activity (where Redis
- * is available), then replaces `toolResponse` with an empty string so the
- * large payload never travels through the Temporal workflow boundary.
- *
- * @param getThread - Factory that returns a thread manager for the given threadId
- * @param handler   - The original tool handler
- * @returns A wrapped handler that auto-appends and flags the response
- *
- * @example
- * ```typescript
- * import { withAutoAppend } from '@bead-ai/zeitlich/workflow';
- * import { createThreadManager } from '@bead-ai/zeitlich';
- *
- * const handler = withAutoAppend(
- *   (threadId) => createThreadManager({ redis, threadId }),
- *   async (args, ctx) => ({
- *     toolResponse: JSON.stringify(largeResult), // appended directly to Redis
- *     data: { summary: "..." },                  // small data for workflow
- *   }),
- * );
- * ```
- */
-declare function withAutoAppend<TArgs, TResult, TContext extends ToolHandlerContext = ToolHandlerContext>(threadHandler: (config: ToolResultConfig) => Promise<void>, handler: ActivityToolHandler<TArgs, TResult, TContext>): ActivityToolHandler<TArgs, TResult, TContext>;
-/**
- * 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$1.ZodType, TResult, TContext = ToolHandlerContext>(tool: ToolWithHandler<TName, TSchema, TResult, TContext>): ToolWithHandler<TName, TSchema, TResult, TContext>;
-/**
- * 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 defineSubagent<TResult extends z$1.ZodType = z$1.ZodType, TContext extends Record<string, unknown> = Record<string, unknown>>(config: Omit<SubagentConfig<TResult>, "hooks" | "workflow" | "context"> & {
-    workflow: string | ((input: {
-        prompt: string;
-        context: TContext;
-    }) => 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<ToolHandlerResponse<z$1.infer<TResult> | null>>);
-    hooks?: SubagentHooks<SubagentArgs, z$1.infer<TResult>>;
-}): SubagentConfig<TResult>;
-/**
- * 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;
-
-/** 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
- */
-type AgentStatus = "RUNNING" | "WAITING_FOR_INPUT" | "COMPLETED" | "FAILED" | "CANCELLED";
-/**
- * Base state that all agents must have
- */
-interface BaseAgentState {
-    tools: SerializableToolDefinition[];
-    status: AgentStatus;
-    version: number;
-    turns: number;
-    tasks: Map<string, WorkflowTask>;
-    systemPrompt?: string;
-    totalInputTokens: number;
-    totalOutputTokens: number;
-    cachedWriteTokens: number;
-    cachedReadTokens: number;
-}
-/**
- * File representation for agent workflows
- */
-interface AgentFile {
-    /** Database/S3 file ID */
-    id: string;
-    /** Virtual path for agent (e.g., "evidence/invoice.pdf") */
-    path: string;
-    /** Original filename */
-    filename: string;
-    /** Generic description for prompt */
-    description?: string;
-    /** MIME type of the file */
-    mimeType?: string;
-}
-interface TokenUsage {
-    inputTokens?: number;
-    outputTokens?: number;
-    cachedWriteTokens?: number;
-    cachedReadTokens?: number;
-    reasonTokens?: number;
-}
-/**
- * Agent response from LLM invocation
- */
-interface AgentResponse<M = unknown> {
-    message: M;
-    rawToolCalls: RawToolCall[];
-    usage?: TokenUsage;
-}
-/**
- * Thread operations required by a session.
- * Consumers provide these — typically by wrapping Temporal activities.
- */
-interface ThreadOps {
-    /** Initialize an empty thread */
-    initializeThread(threadId: string): Promise<void>;
-    /** Append a human message to the thread */
-    appendHumanMessage(threadId: string, content: string | MessageContent): Promise<void>;
-    /** Append a tool result to the thread */
-    appendToolResult(config: ToolResultConfig): Promise<void>;
-    /** Append a system message to the thread */
-    appendSystemMessage(threadId: string, content: string): Promise<void>;
-}
-/**
- * Configuration for a Zeitlich agent
- */
-interface AgentConfig {
-    /** The name of the agent, should be unique within the workflows, ideally Pascal Case */
-    agentName: string;
-    /** Description, used for sub agents */
-    description?: string;
-}
-/**
- * Configuration for a Zeitlich agent session
- */
-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 */
-    appendSystemPrompt?: boolean;
-    /** How many turns to run the session for */
-    maxTurns?: number;
-    /** Workflow-specific runAgent activity (with tools pre-bound) */
-    runAgent: RunAgentActivity<M>;
-    /** Thread operations (initialize, append messages, parse tool calls) */
-    threadOps?: ThreadOps;
-    /** Tool router for processing tool calls (optional if agent has no tools) */
-    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 */
-    processToolsInParallel?: boolean;
-    /**
-     * Build context message content from agent-specific context.
-     * 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;
-}
-/**
- * A JSON-serializable tool definition for state storage.
- * Uses a plain JSON Schema object instead of a live Zod instance,
- * so it survives Temporal serialization without losing constraints (min, max, etc.).
- */
-interface SerializableToolDefinition {
-    name: string;
-    description: string;
-    schema: Record<string, unknown>;
-    strict?: boolean;
-    max_uses?: number;
-}
-/**
- * Configuration passed to runAgent activity
- */
-interface RunAgentConfig extends AgentConfig {
-    /** The thread ID to use for the session */
-    threadId: string;
-    /** Metadata for the session */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Type signature for workflow-specific runAgent activity
- */
-type RunAgentActivity<M = unknown> = (config: RunAgentConfig) => Promise<AgentResponse<M>>;
-/**
- * Configuration for appending a tool result
- */
-interface ToolResultConfig {
-    threadId: string;
-    toolCallId: string;
-    /** The name of the tool that produced this result */
-    toolName: string;
-    /** 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<z$1.infer<TResult> | null>>;
-/**
- * Configuration for a subagent that can be spawned by the parent workflow.
- *
- * @template TResult - Zod schema type for validating the child workflow's result
- */
-interface SubagentConfig<TResult extends z$1.ZodType = z$1.ZodType> {
-    /** Identifier used in Task tool's subagent parameter */
-    agentName: string;
-    /** 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;
-    /** Temporal workflow function or type name (used with executeChild) */
-    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;
-}
-/**
- * Per-subagent lifecycle hooks - defined on a SubagentConfig.
- * Runs in addition to global hooks (global pre → subagent pre → execute → subagent post → global post).
- */
-interface SubagentHooks<TArgs = unknown, TResult = unknown> {
-    /** Called before this subagent executes - can skip or modify args */
-    onPreExecution?: (ctx: {
-        args: TArgs;
-        threadId: string;
-        turn: number;
-    }) => PreToolUseHookResult | Promise<PreToolUseHookResult>;
-    /** Called after this subagent executes successfully */
-    onPostExecution?: (ctx: {
-        args: TArgs;
-        result: TResult;
-        threadId: string;
-        turn: number;
-        durationMs: number;
-    }) => void | Promise<void>;
-    /** Called when this subagent execution fails */
-    onExecutionFailure?: (ctx: {
-        args: TArgs;
-        error: Error;
-        threadId: string;
-        turn: number;
-    }) => PostToolUseFailureHookResult | Promise<PostToolUseFailureHookResult>;
-}
-/**
- * Input passed to child workflows when spawned as subagents
- */
-interface SubagentInput {
-    /** The prompt/task from the parent agent */
-    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
- */
-type TaskStatus = "pending" | "in_progress" | "completed";
-/**
- * A task managed within a workflow for tracking work items
- */
-interface WorkflowTask {
-    /** Unique task identifier */
-    id: string;
-    /** Brief, actionable title in imperative form */
-    subject: string;
-    /** Detailed description of what needs to be done */
-    description: string;
-    /** Present continuous form shown in spinner when in_progress */
-    activeForm: string;
-    /** Current status of the task */
-    status: TaskStatus;
-    /** Arbitrary key-value pairs for tracking */
-    metadata: Record<string, string>;
-    /** IDs of tasks that must complete before this one can start */
-    blockedBy: string[];
-    /** IDs of tasks that are waiting for this one to complete */
-    blocks: string[];
-}
-/**
- * Exit reasons for session termination
- */
-type SessionExitReason = "completed" | "max_turns" | "waiting_for_input" | "failed" | "cancelled";
-/**
- * Context for PreToolUse hook - called before tool execution
- */
-interface PreToolUseHookContext<T extends ToolMap> {
-    /** The tool call about to be executed */
-    toolCall: ParsedToolCallUnion<T>;
-    /** Thread identifier */
-    threadId: string;
-    /** Current turn number */
-    turn: number;
-}
-/**
- * Result from PreToolUse hook - can block or modify execution
- */
-interface PreToolUseHookResult {
-    /** Skip this tool call entirely */
-    skip?: boolean;
-    /** Modified args to use instead (must match schema) */
-    modifiedArgs?: unknown;
-}
-/**
- * PreToolUse hook - called before tool execution, can block or modify
- */
-type PreToolUseHook<T extends ToolMap> = (ctx: PreToolUseHookContext<T>) => PreToolUseHookResult | Promise<PreToolUseHookResult>;
-/**
- * Context for PostToolUse hook - called after successful tool execution
- */
-interface PostToolUseHookContext<T extends ToolMap, TResult = unknown> {
-    /** The tool call that was executed */
-    toolCall: ParsedToolCallUnion<T>;
-    /** The result from the tool handler */
-    result: TResult;
-    /** Thread identifier */
-    threadId: string;
-    /** Current turn number */
-    turn: number;
-    /** Execution duration in milliseconds */
-    durationMs: number;
-}
-/**
- * PostToolUse hook - called after successful tool execution
- */
-type PostToolUseHook<T extends ToolMap, TResult = unknown> = (ctx: PostToolUseHookContext<T, TResult>) => void | Promise<void>;
-/**
- * Context for PostToolUseFailure hook - called when tool execution fails
- */
-interface PostToolUseFailureHookContext<T extends ToolMap> {
-    /** The tool call that failed */
-    toolCall: ParsedToolCallUnion<T>;
-    /** The error that occurred */
-    error: Error;
-    /** Thread identifier */
-    threadId: string;
-    /** Current turn number */
-    turn: number;
-}
-/**
- * Result from PostToolUseFailure hook - can recover from errors
- */
-interface PostToolUseFailureHookResult {
-    /** Provide a fallback result instead of throwing */
-    fallbackContent?: ToolMessageContent;
-    /** Whether to suppress the error (still logs, but continues) */
-    suppress?: boolean;
-}
-/**
- * PostToolUseFailure hook - called when tool execution fails
- */
-type PostToolUseFailureHook<T extends ToolMap> = (ctx: PostToolUseFailureHookContext<T>) => PostToolUseFailureHookResult | Promise<PostToolUseFailureHookResult>;
-/**
- * Context for SessionStart hook - called when session begins
- */
-interface SessionStartHookContext {
-    /** Thread identifier */
-    threadId: string;
-    /** Name of the agent */
-    agentName: string;
-    /** Session metadata */
-    metadata: Record<string, unknown>;
-}
-/**
- * SessionStart hook - called when session begins
- */
-type SessionStartHook = (ctx: SessionStartHookContext) => void | Promise<void>;
-/**
- * Context for PreHumanMessageAppend hook - called before each human message is appended to the thread
- */
-interface PreHumanMessageAppendHookContext {
-    /** The message about to be appended */
-    message: MessageContent;
-    /** Thread identifier */
-    threadId: string;
-}
-/**
- * PreHumanMessageAppend hook - called before each human message is appended to the thread
- */
-type PreHumanMessageAppendHook = (ctx: PreHumanMessageAppendHookContext) => void | Promise<void>;
-/**
- * PostHumanMessageAppend hook - called after each human message is appended to the thread
- */
-type PostHumanMessageAppendHook = (ctx: PostHumanMessageAppendHookContext) => void | Promise<void>;
-/**
- * Context for PostHumanMessageAppend hook - called after each human message is appended to the thread
- */
-interface PostHumanMessageAppendHookContext {
-    /** The message that was appended */
-    message: MessageContent;
-    /** Thread identifier */
-    threadId: string;
-}
-/**
- * Context for SessionEnd hook - called when session ends
- */
-interface SessionEndHookContext {
-    /** Thread identifier */
-    threadId: string;
-    /** Name of the agent */
-    agentName: string;
-    /** Reason the session ended */
-    exitReason: SessionExitReason;
-    /** Total turns executed */
-    turns: number;
-    /** Session metadata */
-    metadata: Record<string, unknown>;
-}
-/**
- * SessionEnd hook - called when session ends
- */
-type SessionEndHook = (ctx: SessionEndHookContext) => void | Promise<void>;
-/**
- * Per-tool lifecycle hooks - defined directly on a tool definition.
- * Runs in addition to global hooks (global pre → tool pre → execute → tool post → global post).
- */
-interface ToolHooks<TArgs = unknown, TResult = unknown> {
-    /** Called before this tool executes - can skip or modify args */
-    onPreToolUse?: (ctx: {
-        args: TArgs;
-        threadId: string;
-        turn: number;
-    }) => PreToolUseHookResult | Promise<PreToolUseHookResult>;
-    /** Called after this tool executes successfully */
-    onPostToolUse?: (ctx: {
-        args: TArgs;
-        result: TResult;
-        threadId: string;
-        turn: number;
-        durationMs: number;
-    }) => void | Promise<void>;
-    /** Called when this tool execution fails */
-    onPostToolUseFailure?: (ctx: {
-        args: TArgs;
-        error: Error;
-        threadId: string;
-        turn: number;
-    }) => PostToolUseFailureHookResult | Promise<PostToolUseFailureHookResult>;
-}
-/**
- * Combined hooks interface for session lifecycle
- */
-interface Hooks<T extends ToolMap, TResult = unknown> {
-    /** Called before each human message is appended to the thread */
-    onPreHumanMessageAppend?: PreHumanMessageAppendHook;
-    /** Called after each human message is appended to the thread */
-    onPostHumanMessageAppend?: PostHumanMessageAppendHook;
-    /** Called before each tool execution - can block or modify */
-    onPreToolUse?: PreToolUseHook<T>;
-    /** Called after each successful tool execution */
-    onPostToolUse?: PostToolUseHook<T, TResult>;
-    /** Called when tool execution fails */
-    onPostToolUseFailure?: PostToolUseFailureHook<T>;
-    /** Called when session starts */
-    onSessionStart?: SessionStartHook;
-    /** 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;
-
-/**
- * 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.
- */
-interface ModelInvokerConfig {
-    threadId: string;
-    agentName: string;
-    state: BaseAgentState;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Generic model invocation contract.
- * Implementations load the thread, call the LLM, append the response,
- * and return a normalised AgentResponse.
- *
- * Framework adapters (e.g. `zeitlich/langchain`) provide concrete
- * implementations of this type.
- */
-type ModelInvoker<M = unknown> = (config: ModelInvokerConfig) => Promise<AgentResponse<M>>;
-
-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 };