@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/task/types.d.ts

@@ -0,0 +1,251 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Usage } from "@oh-my-pi/pi-ai";
+import * as z from "zod/v4";
+import { type TaskSimpleMode } from "./simple-mode";
+import type { NestedRepoPatch } from "./worktree";
+/** Source of an agent definition */
+export type AgentSource = "bundled" | "user" | "project";
+/** Maximum output bytes per agent */
+export declare const MAX_OUTPUT_BYTES: number;
+/** Maximum output lines per agent */
+export declare const MAX_OUTPUT_LINES: number;
+/** EventBus channel for raw subagent events */
+export declare const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
+/** EventBus channel for aggregated subagent progress */
+export declare const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
+/** EventBus channel for subagent lifecycle (start/end) */
+export declare const TASK_SUBAGENT_LIFECYCLE_CHANNEL = "task:subagent:lifecycle";
+/** Payload emitted on TASK_SUBAGENT_PROGRESS_CHANNEL */
+export interface SubagentProgressPayload {
+    index: number;
+    agent: string;
+    agentSource: AgentSource;
+    task: string;
+    assignment?: string;
+    progress: AgentProgress;
+    sessionFile?: string;
+}
+/** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
+export interface SubagentLifecyclePayload {
+    id: string;
+    agent: string;
+    agentSource: AgentSource;
+    description?: string;
+    status: "started" | "completed" | "failed" | "aborted";
+    sessionFile?: string;
+    index: number;
+}
+/** Single task item for parallel execution (default shape with context enabled). */
+export declare const taskItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    assignment: z.ZodString;
+}, z.core.$strip>;
+export type TaskItem = z.infer<typeof taskItemSchema>;
+export declare const taskSchema: z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const taskSchemaNoIsolation: z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    agent: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        assignment: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>];
+type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
+export type TaskSchema = typeof taskSchema;
+/** Active task tool parameter schema for the current simple-mode / isolation flags */
+export type TaskToolSchemaInstance = DynamicTaskSchema;
+export declare function getTaskSchema(options: {
+    isolationEnabled: boolean;
+    simpleMode: TaskSimpleMode;
+}): DynamicTaskSchema;
+export interface TaskParams {
+    agent: string;
+    context?: string;
+    schema?: string;
+    tasks: TaskItem[];
+    isolated?: boolean;
+}
+/** A code review finding reported by the reviewer agent */
+export interface ReviewFinding {
+    title: string;
+    body: string;
+    priority: number;
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}
+/** Review summary submitted by the reviewer agent */
+export interface ReviewSummary {
+    overall_correctness: "correct" | "incorrect";
+    explanation: string;
+    confidence: number;
+}
+/** Structured review data extracted from reviewer agent */
+export interface ReviewData {
+    findings: ReviewFinding[];
+    summary?: ReviewSummary;
+}
+/** Agent definition (bundled or discovered) */
+export interface AgentDefinition {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools?: string[];
+    spawns?: string[] | "*";
+    model?: string[];
+    thinkingLevel?: ThinkingLevel;
+    output?: unknown;
+    blocking?: boolean;
+    source: AgentSource;
+    filePath?: string;
+}
+/** Progress tracking for a single agent */
+export interface AgentProgress {
+    index: number;
+    id: string;
+    agent: string;
+    agentSource: AgentSource;
+    status: "pending" | "running" | "completed" | "failed" | "aborted";
+    task: string;
+    assignment?: string;
+    description?: string;
+    lastIntent?: string;
+    currentTool?: string;
+    currentToolArgs?: string;
+    currentToolStartMs?: number;
+    recentTools: Array<{
+        tool: string;
+        args: string;
+        endMs: number;
+    }>;
+    recentOutput: string[];
+    toolCount: number;
+    /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
+    tokens: number;
+    /**
+     * Current per-turn context size: latest assistant message's `usage.totalTokens`.
+     * This is the number to compare against `contextWindow` — what compaction
+     * decides on, what the user typically reads as "how full is the context".
+     * Distinct from `tokens`, which is a lifetime billing-volume counter.
+     */
+    contextTokens?: number;
+    /** Model's context window in tokens, when known. Lets the UI render `<curr>/<window>` gauges. */
+    contextWindow?: number;
+    /** Cumulative billing cost in USD, accumulated incrementally from message_end events. */
+    cost: number;
+    durationMs: number;
+    modelOverride?: string | string[];
+    /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
+    extractedToolData?: Record<string, unknown[]>;
+}
+/** Result from a single agent execution */
+export interface SingleResult {
+    index: number;
+    id: string;
+    agent: string;
+    agentSource: AgentSource;
+    task: string;
+    assignment?: string;
+    description?: string;
+    lastIntent?: string;
+    exitCode: number;
+    output: string;
+    stderr: string;
+    truncated: boolean;
+    durationMs: number;
+    /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
+    tokens: number;
+    /** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
+    contextTokens?: number;
+    /** Model's context window in tokens, when known. */
+    contextWindow?: number;
+    modelOverride?: string | string[];
+    error?: string;
+    aborted?: boolean;
+    abortReason?: string;
+    /** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
+    usage?: Usage;
+    /** Output path for the task result */
+    outputPath?: string;
+    /** Patch path for isolated worktree output */
+    patchPath?: string;
+    /** Branch name for isolated branch-mode output */
+    branchName?: string;
+    /** Nested repo patches to apply after parent merge */
+    nestedPatches?: NestedRepoPatch[];
+    /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
+    extractedToolData?: Record<string, unknown[]>;
+    /** Output metadata for agent:// URL integration */
+    outputMeta?: {
+        lineCount: number;
+        charCount: number;
+    };
+}
+/** Tool details for TUI rendering */
+export interface TaskToolDetails {
+    projectAgentsDir: string | null;
+    results: SingleResult[];
+    totalDurationMs: number;
+    /** Aggregated usage across all subagents. */
+    usage?: Usage;
+    outputPaths?: string[];
+    progress?: AgentProgress[];
+    async?: {
+        state: "running" | "completed" | "failed";
+        jobId: string;
+        type: "task";
+    };
+}
+export {};

package/dist/types/task/worktree.d.ts

@@ -0,0 +1,95 @@
+import * as natives from "@oh-my-pi/pi-natives";
+declare const IsoBackendKind: typeof natives.IsoBackendKind;
+type IsoBackendKind = natives.IsoBackendKind;
+/** Baseline state for a single git repository. */
+export interface RepoBaseline {
+    repoRoot: string;
+    headCommit: string;
+    staged: string;
+    unstaged: string;
+    untracked: string[];
+    untrackedPatch: string;
+}
+/** Baseline state for the project, including any nested git repos. */
+export interface WorktreeBaseline {
+    root: RepoBaseline;
+    /** Nested git repos (path relative to root.repoRoot). */
+    nested: Array<{
+        relativePath: string;
+        baseline: RepoBaseline;
+    }>;
+}
+export declare function getEncodedProjectName(cwd: string): string;
+export declare function getRepoRoot(cwd: string): Promise<string>;
+export declare function getGitNoIndexNullPath(): string;
+export declare function captureBaseline(repoRoot: string): Promise<WorktreeBaseline>;
+export interface NestedRepoPatch {
+    relativePath: string;
+    patch: string;
+}
+export interface DeltaPatchResult {
+    rootPatch: string;
+    nestedPatches: NestedRepoPatch[];
+}
+export declare function captureDeltaPatch(isolationDir: string, baseline: WorktreeBaseline): Promise<DeltaPatchResult>;
+/**
+ * Apply nested repo patches directly to their working directories after parent merge.
+ * @param commitMessage Optional async function to generate a commit message from the combined diff.
+ *                      If omitted or returns null, falls back to a generic message.
+ */
+export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[], commitMessage?: (diff: string) => Promise<string | null>): Promise<void>;
+/**
+ * User-facing isolation mode names exposed by the `task.isolation.mode`
+ * setting. Mapped to a backend-kind hint via {@link parseIsolationMode};
+ * the PAL's `iso_resolve` then falls back through the kind order
+ * whenever the hint isn't available on the current host.
+ */
+export type TaskIsolationMode = "none" | "auto" | "apfs" | "btrfs" | "zfs" | "reflink" | "overlayfs" | "projfs" | "block-clone" | "rcopy" | "worktree" | "fuse-overlay" | "fuse-projfs";
+/**
+ * Translate a {@link TaskIsolationMode} string to an [`IsoBackendKind`]
+ * the PAL can act on. `"none"` returns `null` (caller skips isolation
+ * entirely); `"auto"` returns `undefined` (no hint — let the resolver
+ * pick). Anything else returns the matching kind.
+ */
+export declare function parseIsolationMode(mode: TaskIsolationMode): IsoBackendKind | undefined;
+export interface IsolationHandle {
+    /** Merged view materialised by the backend; pass this to the task. */
+    mergedDir: string;
+    /** Backend the PAL actually used. */
+    backend: IsoBackendKind;
+    /** True when the resolver downgraded from `preferred` to `backend`. */
+    fellBack: boolean;
+    /** Optional reason associated with `fellBack`. */
+    fallbackReason: string | null;
+}
+export declare function ensureIsolation(baseCwd: string, id: string, preferred?: IsoBackendKind): Promise<IsolationHandle>;
+/** Tear down a handle returned by {@link ensureIsolation}. */
+export declare function cleanupIsolation(handle: IsolationHandle): Promise<void>;
+export interface CommitToBranchResult {
+    branchName?: string;
+    nestedPatches: NestedRepoPatch[];
+}
+/**
+ * Commit task-only changes to a new branch.
+ * Only root repo changes go on the branch. Nested repo patches are returned
+ * separately since the parent git can't track files inside gitlinks.
+ */
+export declare function commitToBranch(isolationDir: string, baseline: WorktreeBaseline, taskId: string, description: string | undefined, commitMessage?: (diff: string) => Promise<string | null>): Promise<CommitToBranchResult | null>;
+export interface MergeBranchResult {
+    merged: string[];
+    failed: string[];
+    conflict?: string;
+}
+/**
+ * Cherry-pick task branch commits sequentially onto HEAD.
+ * Each branch has a single commit that gets replayed cleanly.
+ * Stops on first conflict and reports which branches succeeded.
+ */
+export declare function mergeTaskBranches(repoRoot: string, branches: Array<{
+    branchName: string;
+    taskId: string;
+    description?: string;
+}>): Promise<MergeBranchResult>;
+/** Clean up temporary task branches. */
+export declare function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void>;
+export {};

package/dist/types/thinking.d.ts

@@ -0,0 +1,30 @@
+import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { type Effort, type Model } from "@oh-my-pi/pi-ai";
+/**
+ * Metadata used to render thinking selector values in the coding-agent UI.
+ */
+export interface ThinkingLevelMetadata {
+    value: ThinkingLevel;
+    label: string;
+    description: string;
+}
+/**
+ * Parses a provider-facing effort value.
+ */
+export declare function parseEffort(value: string | null | undefined): Effort | undefined;
+/**
+ * Parses an agent-local thinking selector.
+ */
+export declare function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined;
+/**
+ * Returns display metadata for a thinking selector.
+ */
+export declare function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata;
+/**
+ * Converts an agent-local selector into the effort sent to providers.
+ */
+export declare function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined;
+/**
+ * Resolves a selector against the current model while preserving explicit "off".
+ */
+export declare function resolveThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ResolvedThinkingLevel | undefined;

package/dist/types/tool-discovery/tool-index.d.ts

@@ -0,0 +1,107 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+export type DiscoverableToolSource = "builtin" | "mcp" | "extension" | "custom";
+export interface DiscoverableTool {
+    name: string;
+    label: string;
+    /** Short BM25 corpus entry; falls back to description first 200 chars */
+    summary: string;
+    source: DiscoverableToolSource;
+    /** MCP only */
+    serverName?: string;
+    /** MCP only */
+    mcpToolName?: string;
+    schemaKeys: string[];
+}
+export interface DiscoverableToolServerSummary {
+    name: string;
+    toolCount: number;
+}
+export interface DiscoverableToolSummary {
+    servers: DiscoverableToolServerSummary[];
+    toolCount: number;
+}
+export interface DiscoverableToolSearchDocument {
+    tool: DiscoverableTool;
+    termFrequencies: Map<string, number>;
+    length: number;
+}
+export interface DiscoverableToolSearchIndex {
+    documents: DiscoverableToolSearchDocument[];
+    averageLength: number;
+    documentFrequencies: Map<string, number>;
+}
+export interface DiscoverableToolSearchResult {
+    tool: DiscoverableTool;
+    score: number;
+}
+/** @deprecated Use DiscoverableTool with source === "mcp" */
+export type DiscoverableMCPTool = Pick<DiscoverableTool, "name" | "label" | "schemaKeys" | "serverName" | "mcpToolName"> & {
+    description: string;
+};
+/** @deprecated Use DiscoverableToolServerSummary */
+export type DiscoverableMCPToolServerSummary = DiscoverableToolServerSummary;
+/** @deprecated Use DiscoverableToolSummary */
+export type DiscoverableMCPToolSummary = DiscoverableToolSummary;
+/** Tool object stored on legacy MCP index documents. Carries both legacy `description` and the
+ *  generic `summary`/`source` so the legacy index is structurally assignable to
+ *  DiscoverableToolSearchIndex (search functions read termFrequencies, not the tool fields). */
+export type DiscoverableMCPSearchTool = DiscoverableTool & {
+    description: string;
+};
+/** @deprecated Use DiscoverableToolSearchDocument */
+export interface DiscoverableMCPSearchDocument {
+    tool: DiscoverableMCPSearchTool;
+    termFrequencies: Map<string, number>;
+    length: number;
+}
+/** @deprecated Use DiscoverableToolSearchIndex.
+ *  Documents on this index expose `tool.description` (legacy MCP shape) while still being
+ *  searchable via `searchDiscoverableTools`. */
+export interface DiscoverableMCPSearchIndex {
+    documents: DiscoverableMCPSearchDocument[];
+    averageLength: number;
+    documentFrequencies: Map<string, number>;
+}
+/** @deprecated Use DiscoverableToolSearchResult */
+export interface DiscoverableMCPSearchResult {
+    tool: DiscoverableMCPSearchTool;
+    score: number;
+}
+export declare function isMCPToolName(name: string): boolean;
+/**
+ * Convert a raw AgentTool into a DiscoverableTool generic descriptor.
+ * source: "mcp" if name starts with "mcp__", else "builtin" (caller may override).
+ */
+export declare function getDiscoverableTool(tool: AgentTool, overrides?: {
+    source?: DiscoverableToolSource;
+    summary?: string;
+}): DiscoverableTool | null;
+/** Collect all DiscoverableTools from a tool iterable. Skips tools that return null. */
+export declare function collectDiscoverableTools(tools: Iterable<AgentTool>, options?: {
+    source?: DiscoverableToolSource;
+    summaryMap?: Map<string, string>;
+}): DiscoverableTool[];
+/** Filter discoverable tools by source */
+export declare function filterBySource(tools: DiscoverableTool[], source: DiscoverableToolSource): DiscoverableTool[];
+export declare function formatDiscoverableToolServerSummary(server: DiscoverableToolServerSummary): string;
+export declare function selectDiscoverableToolNamesByServer(tools: Iterable<DiscoverableTool>, serverNames: ReadonlySet<string>): string[];
+export declare function summarizeDiscoverableTools(tools: DiscoverableTool[]): DiscoverableToolSummary;
+export declare function buildDiscoverableToolSearchIndex(tools: Iterable<DiscoverableTool>): DiscoverableToolSearchIndex;
+export declare function searchDiscoverableTools(index: DiscoverableToolSearchIndex, query: string, limit: number): DiscoverableToolSearchResult[];
+/** @deprecated Use getDiscoverableTool */
+export declare function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null;
+/** @deprecated Use collectDiscoverableTools with source filter */
+export declare function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[];
+/** @deprecated Use selectDiscoverableToolNamesByServer */
+export declare function selectDiscoverableMCPToolNamesByServer(tools: Iterable<DiscoverableMCPTool>, serverNames: ReadonlySet<string>): string[];
+/** @deprecated Use summarizeDiscoverableTools */
+export declare function summarizeDiscoverableMCPTools(tools: DiscoverableMCPTool[]): DiscoverableMCPToolSummary;
+/** @deprecated Use buildDiscoverableToolSearchIndex.
+ *  Builds an index whose documents preserve the legacy `description` field on each tool while
+ *  also carrying the generic `summary` (set from `description`) so the index remains usable
+ *  with `searchDiscoverableTools`. */
+export declare function buildDiscoverableMCPSearchIndex(tools: Iterable<DiscoverableMCPTool>): DiscoverableMCPSearchIndex;
+/** @deprecated Use searchDiscoverableTools */
+export declare function searchDiscoverableMCPTools(index: DiscoverableMCPSearchIndex | DiscoverableToolSearchIndex, query: string, limit: number): DiscoverableMCPSearchResult[];
+/** @deprecated Use formatDiscoverableToolServerSummary */
+export declare const formatDiscoverableMCPToolServerSummary: typeof formatDiscoverableToolServerSummary;

package/dist/types/tools/archive-reader.d.ts

@@ -0,0 +1,40 @@
+export type ArchiveFormat = "zip" | "tar" | "tar.gz";
+export interface ArchivePathCandidate {
+    archivePath: string;
+    subPath: string;
+}
+export interface ArchiveNode {
+    path: string;
+    isDirectory: boolean;
+    size: number;
+    mtimeMs?: number;
+}
+export interface ArchiveDirectoryEntry extends ArchiveNode {
+    name: string;
+}
+export interface ExtractedArchiveFile extends ArchiveNode {
+    bytes: Uint8Array;
+}
+interface TarStorage {
+    type: "tar";
+    file: File;
+}
+interface ZipStorage {
+    type: "zip";
+    bytes: Uint8Array;
+}
+type EntryStorage = TarStorage | ZipStorage;
+interface ArchiveIndexEntry extends ArchiveNode {
+    storage?: EntryStorage;
+}
+export declare function parseArchivePathCandidates(filePath: string): ArchivePathCandidate[];
+export declare class ArchiveReader {
+    #private;
+    readonly format: ArchiveFormat;
+    constructor(format: ArchiveFormat, entries: ArchiveIndexEntry[]);
+    getNode(subPath?: string): ArchiveNode | undefined;
+    listDirectory(subPath?: string): ArchiveDirectoryEntry[];
+    readFile(subPath: string): Promise<ExtractedArchiveFile>;
+}
+export declare function openArchive(filePath: string): Promise<ArchiveReader>;
+export {};

package/dist/types/tools/ask.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Ask Tool - Interactive user prompting during execution
+ *
+ * Use this tool when you need to ask the user questions during execution.
+ * This allows you to:
+ *   1. Gather user preferences or requirements
+ *   2. Clarify ambiguous instructions
+ *   3. Get decisions on implementation choices as you work
+ *   4. Offer choices to the user about what direction to take
+ *
+ * Usage notes:
+ *   - Users will always be able to select "Other" to provide custom text input
+ *   - Use multi: true to allow multiple answers to be selected for a question
+ *   - Use recommended: <index> to mark the default option; "(Recommended)" suffix is added automatically
+ *   - Questions may time out and auto-select the recommended option (configurable, disabled in plan mode)
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+declare const askSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        multi: z.ZodOptional<z.ZodBoolean>;
+        recommended: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AskToolInput = z.infer<typeof askSchema>;
+/** Result for a single question */
+export interface QuestionResult {
+    id: string;
+    question: string;
+    options: string[];
+    multi: boolean;
+    selectedOptions: string[];
+    customInput?: string;
+}
+export interface AskToolDetails {
+    question?: string;
+    options?: string[];
+    multi?: boolean;
+    selectedOptions?: string[];
+    customInput?: string;
+    /** Multi-part question mode */
+    results?: QuestionResult[];
+}
+type AskParams = AskToolInput;
+/**
+ * Ask tool for interactive user prompting during execution.
+ *
+ * Allows gathering user preferences, clarifying instructions, and getting decisions
+ * on implementation choices as the agent works.
+ */
+export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "ask";
+    readonly label = "Ask";
+    readonly summary = "Ask the user a clarifying question";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            multi: z.ZodOptional<z.ZodBoolean>;
+            recommended: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): AskTool | null;
+    execute(_toolCallId: string, params: AskParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AskToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<AskToolDetails>>;
+}
+interface AskRenderArgs {
+    question?: string;
+    options?: Array<{
+        label: string;
+    }>;
+    multi?: boolean;
+    questions?: Array<{
+        id: string;
+        question: string;
+        options: Array<{
+            label: string;
+        }>;
+        multi?: boolean;
+    }>;
+}
+export declare const askToolRenderer: {
+    renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: AskToolDetails;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+};
+export {};