import { z } from 'zod';
export declare const CONFIG_HOME: string;
export declare const TOOLS: {
    readonly SPAWN_SUBAGENT: "spawn_subagent";
    readonly CODE_REVIEW: "code_review";
    readonly SPAWN_AGENT_GROUP: "spawn_agent_group";
};
export type ToolName = (typeof TOOLS)[keyof typeof TOOLS];
export declare const PINNED_CODEX_MODEL: string;
export declare const REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh"];
export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
export declare function resolveReasoningEffort(requestedEffort: ReasoningEffort | undefined, model?: string): ReasoningEffort;
export declare const AGENT_ROLES: readonly ["coder", "planner", "tester", "researcher"];
export type AgentRole = (typeof AGENT_ROLES)[number];
export declare const ROLE_TO_TASK_TYPE: Record<AgentRole, string>;
export interface ContextFile {
    path: string;
    description?: string;
    start_line?: number;
    end_line?: number;
}
export interface ToolAnnotations {
    title?: string;
    readOnlyHint?: boolean;
    destructiveHint?: boolean;
    idempotentHint?: boolean;
    openWorldHint?: boolean;
}
export interface ToolDefinition {
    name: ToolName;
    description: string;
    inputSchema: {
        type: 'object';
        properties: Record<string, unknown>;
        required: string[];
    };
    outputSchema?: {
        type: 'object';
        properties?: Record<string, unknown>;
        required?: string[];
    };
    annotations?: ToolAnnotations;
}
export interface ToolResult {
    content: Array<{
        type: 'text';
        text: string;
        _meta?: Record<string, unknown>;
    }>;
    structuredContent?: Record<string, unknown>;
    isError?: boolean;
    _meta?: Record<string, unknown>;
}
export interface ServerConfig {
    name: string;
    version: string;
}
export declare const SandboxMode: z.ZodEnum<{
    "read-only": "read-only";
    "workspace-write": "workspace-write";
    "danger-full-access": "danger-full-access";
}>;
export declare const CodexToolSchema: z.ZodObject<{
    prompt: z.ZodString;
    role: z.ZodOptional<z.ZodEnum<{
        coder: "coder";
        planner: "planner";
        tester: "tester";
        researcher: "researcher";
    }>>;
    specialization: z.ZodOptional<z.ZodString>;
    context_files: z.ZodOptional<z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        start_line: z.ZodOptional<z.ZodNumber>;
        end_line: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>>;
    sessionId: z.ZodOptional<z.ZodString>;
    resetSession: z.ZodOptional<z.ZodBoolean>;
    reasoningEffort: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
        low: "low";
        medium: "medium";
        high: "high";
        xhigh: "xhigh";
    }>>>;
    sandbox: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
        "read-only": "read-only";
        "workspace-write": "workspace-write";
        "danger-full-access": "danger-full-access";
    }>>>;
    workingDirectory: z.ZodOptional<z.ZodString>;
    callbackUri: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export declare const ReviewToolSchema: z.ZodObject<{
    prompt: z.ZodOptional<z.ZodString>;
    uncommitted: z.ZodOptional<z.ZodBoolean>;
    base: z.ZodOptional<z.ZodString>;
    commit: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    workingDirectory: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export type CodexToolArgs = z.infer<typeof CodexToolSchema>;
export type ReviewToolArgs = z.infer<typeof ReviewToolSchema>;
export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed';
export interface CodexTask {
    id: string;
    status: TaskStatus;
    prompt: string;
    role?: string;
    specialization?: string;
    model: string;
    cwd: string;
    startTime: string;
    endTime?: string;
    outputFilePath?: string;
    outputLines: number;
    output: string[];
    error?: string;
    metadata?: Record<string, unknown>;
    pid?: number;
}
export interface CommandResult {
    stdout: string;
    stderr: string;
}
export type ProgressToken = string | number;
export interface ToolHandlerContext {
    progressToken?: ProgressToken;
    sendProgress: (message: string, progress?: number, total?: number) => Promise<void>;
}
export interface NotificationSender {
    sendNotification(notification: {
        method: string;
        params?: Record<string, unknown>;
    }): Promise<void>;
}
//# sourceMappingURL=types.d.ts.map