@clinebot/agents 0.0.0

package/dist/teams/multi-agent.d.ts

@@ -0,0 +1,566 @@
+/**
+ * Multi-Agent Coordination
+ *
+ * Utilities for orchestrating multiple agents working together.
+ */
+import { type Agent } from "../agent.js";
+import type { AgentConfig, AgentEvent, AgentResult } from "../types.js";
+/**
+ * Configuration for a team member agent
+ */
+export interface TeamMemberConfig extends AgentConfig {
+    /** Optional role description for this agent */
+    role?: string;
+}
+/**
+ * Task to execute on a specific agent
+ */
+export interface AgentTask {
+    /** ID of the agent to run the task */
+    agentId: string;
+    /** Message to send to the agent */
+    message: string;
+    /** Optional metadata for the task */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result from a task execution
+ */
+export interface TaskResult {
+    /** ID of the agent that executed the task */
+    agentId: string;
+    /** The agent result */
+    result: AgentResult;
+    /** Any error that occurred */
+    error?: Error;
+    /** Task metadata */
+    metadata?: Record<string, unknown>;
+}
+export declare enum TeamMessageType {
+    TaskStart = "task_start",
+    TaskEnd = "task_end",
+    AgentEvent = "agent_event",
+    TeammateSpawned = "teammate_spawned",
+    TeammateShutdown = "teammate_shutdown",
+    TeamTaskUpdated = "team_task_updated",
+    TeamMessage = "team_message",
+    TeamMissionLog = "team_mission_log",
+    TeamTaskCompleted = "team_task_completed",
+    RunStarted = "run_started",
+    RunQueued = "run_queued",
+    RunProgress = "run_progress",
+    RunCompleted = "run_completed",
+    RunFailed = "run_failed",
+    RunCancelled = "run_cancelled",
+    RunInterrupted = "run_interrupted",
+    OutcomeCreated = "outcome_created",
+    OutcomeFragmentAttached = "outcome_fragment_attached",
+    OutcomeFragmentReviewed = "outcome_fragment_reviewed",
+    OutcomeFinalized = "outcome_finalized"
+}
+export interface TeammateLifecycleSpec {
+    rolePrompt: string;
+    modelId?: string;
+    maxIterations?: number;
+}
+/**
+ * Event emitted during team execution
+ */
+export type TeamEvent = {
+    type: TeamMessageType.TaskStart;
+    agentId: string;
+    message: string;
+} | {
+    type: TeamMessageType.TaskEnd;
+    agentId: string;
+    result?: AgentResult;
+    error?: Error;
+} | {
+    type: TeamMessageType.AgentEvent;
+    agentId: string;
+    event: AgentEvent;
+} | {
+    type: TeamMessageType.TeammateSpawned;
+    agentId: string;
+    role?: string;
+    teammate: TeammateLifecycleSpec;
+} | {
+    type: TeamMessageType.TeammateShutdown;
+    agentId: string;
+    reason?: string;
+} | {
+    type: TeamMessageType.TeamTaskUpdated;
+    task: TeamTask;
+} | {
+    type: TeamMessageType.TeamMessage;
+    message: TeamMailboxMessage;
+} | {
+    type: TeamMessageType.TeamMissionLog;
+    entry: MissionLogEntry;
+} | {
+    type: TeamMessageType.RunQueued;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunStarted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunProgress;
+    run: TeamRunRecord;
+    message: string;
+} | {
+    type: TeamMessageType.RunCompleted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunFailed;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunCancelled;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.RunInterrupted;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.OutcomeCreated;
+    outcome: TeamOutcome;
+} | {
+    type: TeamMessageType.OutcomeFragmentAttached;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFragmentReviewed;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFinalized;
+    outcome: TeamOutcome;
+};
+/**
+ * A team of agents that can work together
+ *
+ * @example
+ * ```typescript
+ * const team = createAgentTeam({
+ *   coder: {
+ *     providerId: "anthropic",
+ *     modelId: "claude-sonnet-4-20250514",
+ *     systemPrompt: "You are a coding expert.",
+ *     tools: [readFile, writeFile],
+ *   },
+ *   reviewer: {
+ *     providerId: "openai",
+ *     modelId: "gpt-4o",
+ *     systemPrompt: "You are a code reviewer.",
+ *     tools: [readFile],
+ *   }
+ * })
+ *
+ * const result = await team.routeTo("coder", "Write a function")
+ * ```
+ */
+export declare class AgentTeam {
+    private agents;
+    private configs;
+    private onTeamEvent?;
+    constructor(configs?: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void);
+    /**
+     * Add an agent to the team
+     *
+     * @param id - Unique identifier for the agent
+     * @param config - Agent configuration
+     */
+    addAgent(id: string, config: TeamMemberConfig): void;
+    /**
+     * Remove an agent from the team
+     */
+    removeAgent(id: string): boolean;
+    /**
+     * Get an agent by ID
+     */
+    getAgent(id: string): Agent | undefined;
+    /**
+     * Get all agent IDs in the team
+     */
+    getAgentIds(): string[];
+    /**
+     * Get the number of agents in the team
+     */
+    get size(): number;
+    /**
+     * Route a message to a specific agent
+     *
+     * @param agentId - ID of the agent to send the message to
+     * @param message - The message to send
+     * @returns The agent result
+     */
+    routeTo(agentId: string, message: string): Promise<AgentResult>;
+    /**
+     * Continue a conversation with a specific agent
+     *
+     * @param agentId - ID of the agent to continue with
+     * @param message - The message to send
+     * @returns The agent result
+     */
+    continueTo(agentId: string, message: string): Promise<AgentResult>;
+    /**
+     * Run multiple tasks in parallel across different agents
+     *
+     * @param tasks - Array of tasks to execute
+     * @returns Array of task results in the same order
+     *
+     * @example
+     * ```typescript
+     * const results = await team.runParallel([
+     *   { agentId: "coder", message: "Implement feature X" },
+     *   { agentId: "reviewer", message: "Review the code" },
+     * ])
+     * ```
+     */
+    runParallel(tasks: AgentTask[]): Promise<TaskResult[]>;
+    /**
+     * Run tasks sequentially across agents
+     *
+     * Tasks are executed in order, and the result of each task is available
+     * to the next task via the context parameter.
+     *
+     * @param tasks - Array of tasks to execute in order
+     * @returns Array of task results in the same order
+     */
+    runSequential(tasks: AgentTask[]): Promise<TaskResult[]>;
+    /**
+     * Run a pipeline of agents where output from one becomes input to the next
+     *
+     * @param pipeline - Array of agent IDs in pipeline order
+     * @param initialMessage - The starting message
+     * @param messageTransformer - Optional function to transform output to input
+     * @returns Array of all results from the pipeline
+     *
+     * @example
+     * ```typescript
+     * const results = await team.runPipeline(
+     *   ["planner", "coder", "reviewer"],
+     *   "Create a REST API for user management",
+     *   (prevResult, agentId) => {
+     *     if (agentId === "coder") {
+     *       return `Implement this plan:\n${prevResult.text}`
+     *     }
+     *     return `Review this code:\n${prevResult.text}`
+     *   }
+     * )
+     * ```
+     */
+    runPipeline(pipeline: string[], initialMessage: string, messageTransformer?: (prevResult: AgentResult, nextAgentId: string) => string): Promise<TaskResult[]>;
+    /**
+     * Abort all running agents
+     */
+    abortAll(): void;
+    /**
+     * Clear all agents from the team
+     */
+    clear(): void;
+    private emitEvent;
+}
+/**
+ * Create a new agent team
+ *
+ * @param configs - Map of agent ID to configuration
+ * @param onTeamEvent - Optional callback for team events
+ * @returns A new AgentTeam instance
+ *
+ * @example
+ * ```typescript
+ * const team = createAgentTeam({
+ *   coder: {
+ *     providerId: "anthropic",
+ *     modelId: "claude-sonnet-4-20250514",
+ *     systemPrompt: "You are a coding expert.",
+ *     tools: [readFile, writeFile],
+ *   },
+ *   reviewer: {
+ *     providerId: "anthropic",
+ *     modelId: "claude-sonnet-4-20250514",
+ *     systemPrompt: "You are a code reviewer.",
+ *     tools: [readFile],
+ *   }
+ * })
+ * ```
+ */
+export declare function createAgentTeam(configs: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void): AgentTeam;
+/**
+ * Create a simple two-agent team with a worker and reviewer
+ *
+ * @example
+ * ```typescript
+ * const team = createWorkerReviewerTeam({
+ *   worker: {
+ *     providerId: "anthropic",
+ *     modelId: "claude-sonnet-4-20250514",
+ *     systemPrompt: "You are a coding expert.",
+ *     tools: [...],
+ *   },
+ *   reviewer: {
+ *     providerId: "anthropic",
+ *     modelId: "claude-sonnet-4-20250514",
+ *     systemPrompt: "You review code for issues.",
+ *     tools: [...],
+ *   }
+ * })
+ *
+ * const result = await team.doAndReview("Implement feature X")
+ * ```
+ */
+export declare function createWorkerReviewerTeam(configs: {
+    worker: TeamMemberConfig;
+    reviewer: TeamMemberConfig;
+}): AgentTeam & {
+    doAndReview: (message: string) => Promise<{
+        workerResult: AgentResult;
+        reviewResult: AgentResult;
+    }>;
+};
+export type TeamTaskStatus = "pending" | "in_progress" | "blocked" | "completed";
+export interface TeamTask {
+    id: string;
+    title: string;
+    description: string;
+    status: TeamTaskStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string;
+    assignee?: string;
+    dependsOn: string[];
+    summary?: string;
+}
+export type MissionLogKind = "progress" | "handoff" | "blocked" | "decision" | "done" | "error";
+export interface MissionLogEntry {
+    id: string;
+    ts: Date;
+    teamId: string;
+    agentId: string;
+    taskId?: string;
+    kind: MissionLogKind;
+    summary: string;
+    evidence?: string[];
+    nextAction?: string;
+}
+export interface TeamMailboxMessage {
+    id: string;
+    teamId: string;
+    fromAgentId: string;
+    toAgentId: string;
+    subject: string;
+    body: string;
+    taskId?: string;
+    sentAt: Date;
+    readAt?: Date;
+}
+export interface TeamMemberSnapshot {
+    agentId: string;
+    role: "lead" | "teammate";
+    description?: string;
+    status: "idle" | "running" | "stopped";
+}
+export interface TeamRuntimeSnapshot {
+    teamId: string;
+    teamName: string;
+    members: TeamMemberSnapshot[];
+    taskCounts: Record<TeamTaskStatus, number>;
+    unreadMessages: number;
+    missionLogEntries: number;
+    activeRuns: number;
+    queuedRuns: number;
+    outcomeCounts: Record<TeamOutcomeStatus, number>;
+}
+export interface TeamRuntimeState {
+    teamId: string;
+    teamName: string;
+    members: TeamMemberSnapshot[];
+    tasks: TeamTask[];
+    mailbox: TeamMailboxMessage[];
+    missionLog: MissionLogEntry[];
+    runs: TeamRunRecord[];
+    outcomes: TeamOutcome[];
+    outcomeFragments: TeamOutcomeFragment[];
+}
+export interface AgentTeamsRuntimeOptions {
+    teamName: string;
+    leadAgentId?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    maxConcurrentRuns?: number;
+    onTeamEvent?: (event: TeamEvent) => void;
+}
+export interface SpawnTeammateOptions {
+    agentId: string;
+    config: TeamMemberConfig;
+}
+export interface RouteToTeammateOptions {
+    taskId?: string;
+    fromAgentId?: string;
+    continueConversation?: boolean;
+}
+export type TeamRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+export interface TeamRunRecord {
+    id: string;
+    agentId: string;
+    taskId?: string;
+    status: TeamRunStatus;
+    message: string;
+    priority: number;
+    retryCount: number;
+    maxRetries: number;
+    nextAttemptAt?: Date;
+    continueConversation?: boolean;
+    startedAt: Date;
+    endedAt?: Date;
+    leaseOwner?: string;
+    heartbeatAt?: Date;
+    result?: AgentResult;
+    error?: string;
+}
+export type TeamOutcomeStatus = "draft" | "in_review" | "finalized";
+export interface TeamOutcome {
+    id: string;
+    teamId: string;
+    title: string;
+    status: TeamOutcomeStatus;
+    requiredSections: string[];
+    createdBy: string;
+    createdAt: Date;
+    finalizedAt?: Date;
+}
+export type TeamOutcomeFragmentStatus = "draft" | "reviewed" | "rejected";
+export interface TeamOutcomeFragment {
+    id: string;
+    teamId: string;
+    outcomeId: string;
+    section: string;
+    sourceAgentId: string;
+    sourceRunId?: string;
+    content: string;
+    status: TeamOutcomeFragmentStatus;
+    reviewedBy?: string;
+    reviewedAt?: Date;
+    createdAt: Date;
+}
+export interface AppendMissionLogInput {
+    agentId: string;
+    taskId?: string;
+    kind: MissionLogKind;
+    summary: string;
+    evidence?: string[];
+    nextAction?: string;
+}
+export interface CreateTeamTaskInput {
+    title: string;
+    description: string;
+    createdBy: string;
+    dependsOn?: string[];
+    assignee?: string;
+}
+export interface CreateTeamOutcomeInput {
+    title: string;
+    requiredSections: string[];
+    createdBy: string;
+}
+export interface AttachTeamOutcomeFragmentInput {
+    outcomeId: string;
+    section: string;
+    sourceAgentId: string;
+    sourceRunId?: string;
+    content: string;
+}
+export interface ReviewTeamOutcomeFragmentInput {
+    fragmentId: string;
+    reviewedBy: string;
+    approved: boolean;
+}
+export declare class AgentTeamsRuntime {
+    private readonly teamId;
+    private readonly teamName;
+    private readonly onTeamEvent?;
+    private readonly members;
+    private readonly tasks;
+    private readonly missionLog;
+    private readonly mailbox;
+    private missionStepCounter;
+    private taskCounter;
+    private messageCounter;
+    private missionCounter;
+    private runCounter;
+    private outcomeCounter;
+    private outcomeFragmentCounter;
+    private readonly runs;
+    private readonly runQueue;
+    private readonly outcomes;
+    private readonly outcomeFragments;
+    private readonly missionLogIntervalSteps;
+    private readonly missionLogIntervalMs;
+    private readonly maxConcurrentRuns;
+    constructor(options: AgentTeamsRuntimeOptions);
+    getTeamId(): string;
+    getTeamName(): string;
+    getMemberRole(agentId: string): "lead" | "teammate" | undefined;
+    getMemberIds(): string[];
+    getTeammateIds(): string[];
+    getTask(taskId: string): TeamTask | undefined;
+    listTasks(): TeamTask[];
+    listMissionLog(limit?: number): MissionLogEntry[];
+    listMailbox(agentId: string, options?: {
+        unreadOnly?: boolean;
+        markRead?: boolean;
+        limit?: number;
+    }): TeamMailboxMessage[];
+    getSnapshot(): TeamRuntimeSnapshot;
+    exportState(): TeamRuntimeState;
+    hydrateState(state: TeamRuntimeState): void;
+    isTeammateActive(agentId: string): boolean;
+    spawnTeammate({ agentId, config }: SpawnTeammateOptions): TeamMemberSnapshot;
+    shutdownTeammate(agentId: string, reason?: string): void;
+    /**
+     * Update connection overrides (e.g. refreshed API key) on all active
+     * teammate agents so they stay in sync with the lead agent's credentials.
+     */
+    updateTeammateConnections(overrides: Partial<Pick<AgentConfig, "apiKey" | "baseUrl" | "headers">>): void;
+    createTask(input: CreateTeamTaskInput): TeamTask;
+    claimTask(taskId: string, agentId: string): TeamTask;
+    blockTask(taskId: string, agentId: string, reason: string): TeamTask;
+    completeTask(taskId: string, agentId: string, summary: string): TeamTask;
+    routeToTeammate(agentId: string, message: string, options?: RouteToTeammateOptions): Promise<AgentResult>;
+    startTeammateRun(agentId: string, message: string, options?: RouteToTeammateOptions & {
+        priority?: number;
+        maxRetries?: number;
+        leaseOwner?: string;
+    }): TeamRunRecord;
+    private dispatchQueuedRuns;
+    private selectNextQueuedRunIndex;
+    private countActiveRuns;
+    private executeQueuedRun;
+    listRuns(options?: {
+        status?: TeamRunStatus;
+        agentId?: string;
+        includeCompleted?: boolean;
+    }): TeamRunRecord[];
+    getRun(runId: string): TeamRunRecord | undefined;
+    awaitRun(runId: string, pollIntervalMs?: number): Promise<TeamRunRecord>;
+    awaitAllRuns(pollIntervalMs?: number): Promise<TeamRunRecord[]>;
+    cancelRun(runId: string, reason?: string): TeamRunRecord;
+    markStaleRunsInterrupted(reason?: string): TeamRunRecord[];
+    sendMessage(fromAgentId: string, toAgentId: string, subject: string, body: string, taskId?: string): TeamMailboxMessage;
+    broadcast(fromAgentId: string, subject: string, body: string, options?: {
+        includeLead?: boolean;
+        taskId?: string;
+    }): TeamMailboxMessage[];
+    appendMissionLog(input: AppendMissionLogInput): MissionLogEntry;
+    createOutcome(input: CreateTeamOutcomeInput): TeamOutcome;
+    listOutcomes(): TeamOutcome[];
+    attachOutcomeFragment(input: AttachTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    reviewOutcomeFragment(input: ReviewTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    listOutcomeFragments(outcomeId: string): TeamOutcomeFragment[];
+    finalizeOutcome(outcomeId: string): TeamOutcome;
+    cleanup(): void;
+    private requireTask;
+    private assertDependenciesResolved;
+    private trackMeaningfulEvent;
+    private recordProgressStep;
+    private emitEvent;
+}

package/dist/teams/spawn-agent-tool.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Reusable spawn_agent tool for delegating tasks to sub-agents.
+ */
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { Tool, ToolApprovalRequest, ToolApprovalResult, ToolContext, ToolPolicy } from "@clinebot/shared";
+import type { AgentEvent, AgentExtension, AgentFinishReason, AgentHooks, BasicLogger, HookErrorMode } from "../types.js";
+export interface SpawnAgentInput {
+    systemPrompt: string;
+    task: string;
+    maxIterations?: number;
+}
+export interface SpawnAgentOutput {
+    text: string;
+    iterations: number;
+    finishReason: AgentFinishReason;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface SubAgentStartContext {
+    subAgentId: string;
+    conversationId: string;
+    parentAgentId: string;
+    input: SpawnAgentInput;
+}
+export interface SubAgentEndContext {
+    subAgentId: string;
+    conversationId: string;
+    parentAgentId: string;
+    input: SpawnAgentInput;
+    result?: SpawnAgentOutput;
+    error?: Error;
+}
+export interface SpawnAgentToolConfig {
+    providerId: string;
+    modelId: string;
+    apiKey?: string;
+    baseUrl?: string;
+    providerConfig?: LlmsProviders.ProviderConfig;
+    knownModels?: Record<string, LlmsProviders.ModelInfo>;
+    thinking?: boolean;
+    defaultMaxIterations?: number;
+    subAgentTools?: Tool[];
+    createSubAgentTools?: (input: SpawnAgentInput, context: ToolContext) => Tool[] | Promise<Tool[]>;
+    onSubAgentEvent?: (event: AgentEvent) => void;
+    /**
+     * Lifecycle hooks forwarded to spawned sub-agent runs.
+     */
+    hooks?: AgentHooks;
+    /**
+     * Extension list forwarded to spawned sub-agent runs.
+     */
+    extensions?: AgentExtension[];
+    /**
+     * Error handling mode for forwarded lifecycle hooks.
+     */
+    hookErrorMode?: HookErrorMode;
+    /**
+     * Called after a sub-agent instance is created and before it starts running.
+     * Errors are ignored so lifecycle observers cannot break task execution.
+     */
+    onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+    /**
+     * Called once a sub-agent run finishes (success or error).
+     * Errors are ignored so lifecycle observers cannot break task execution.
+     */
+    onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+    /**
+     * Optional per-tool policy for spawned sub-agents.
+     */
+    toolPolicies?: Record<string, ToolPolicy>;
+    /**
+     * Optional approval callback for spawned sub-agent tool calls.
+     */
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    /**
+     * Optional logger forwarded to spawned sub-agent runs.
+     */
+    logger?: BasicLogger;
+}
+/**
+ * Create a spawn_agent tool that can run a delegated task with a focused sub-agent.
+ */
+export declare function createSpawnAgentTool(config: SpawnAgentToolConfig): Tool<SpawnAgentInput, SpawnAgentOutput>;

package/dist/teams/team-tools.d.ts

@@ -0,0 +1,51 @@
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import { type Tool } from "@clinebot/shared";
+import type { AgentConfig, AgentHooks, BasicLogger } from "../types.js";
+import type { AgentTeamsRuntime, TeamRuntimeState } from "./multi-agent.js";
+export interface TeamTeammateSpec {
+    agentId: string;
+    rolePrompt: string;
+    modelId?: string;
+    maxIterations?: number;
+}
+export interface TeamTeammateRuntimeConfig {
+    providerId: string;
+    modelId: string;
+    cwd?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    providerConfig?: LlmsProviders.ProviderConfig;
+    knownModels?: Record<string, LlmsProviders.ModelInfo>;
+    thinking?: boolean;
+    clineWorkspaceMetadata?: string;
+    clineIdeName?: string;
+    maxIterations?: number;
+    hooks?: AgentHooks;
+    extensions?: AgentConfig["extensions"];
+    logger?: BasicLogger;
+}
+export interface CreateAgentTeamsToolsOptions {
+    runtime: AgentTeamsRuntime;
+    requesterId: string;
+    teammateRuntime: TeamTeammateRuntimeConfig;
+    createBaseTools?: () => Tool[];
+    allowSpawn?: boolean;
+}
+export interface BootstrapAgentTeamsOptions {
+    runtime: AgentTeamsRuntime;
+    teammateRuntime: TeamTeammateRuntimeConfig;
+    createBaseTools?: () => Tool[];
+    leadAgentId?: string;
+    restoredTeammates?: TeamTeammateSpec[];
+    restoredFromPersistence?: boolean;
+}
+export interface BootstrapAgentTeamsResult {
+    tools: Tool[];
+    restoredFromPersistence: boolean;
+    restoredTeammates: string[];
+}
+export declare function bootstrapAgentTeams(options: BootstrapAgentTeamsOptions): BootstrapAgentTeamsResult;
+export declare function createAgentTeamsTools(options: CreateAgentTeamsToolsOptions): Tool[];
+export declare function reviveTeamStateDates(state: TeamRuntimeState): TeamRuntimeState;
+export declare function sanitizeTeamName(name: string): string;

package/dist/tools/ask-question.d.ts

@@ -0,0 +1,12 @@
+import { type Tool, type ToolContext } from "@clinebot/shared";
+import { z } from "zod";
+export declare const AskQuestionInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AskQuestionInput = z.infer<typeof AskQuestionInputSchema>;
+export type AskQuestionExecutor = (question: string, options: string[], context: ToolContext) => Promise<string>;
+export interface AskQuestionToolConfig {
+    askQuestionTimeoutMs?: number;
+}
+export declare function createAskQuestionTool(executor: AskQuestionExecutor, config?: AskQuestionToolConfig): Tool<AskQuestionInput, string>;