import { z } from "zod";
export type Role = "user" | "assistant" | "tool" | "system";
export interface ToolCallRequest {
    id: string;
    toolName: string;
    input: unknown;
}
export interface Message {
    role: Role;
    content: string;
    toolCalls?: ToolCallRequest[];
    toolCallId?: string;
    name?: string;
}
export interface ToolContext<TContext = Record<string, unknown>> {
    sessionId?: string;
    runId: string;
    signal?: AbortSignal;
    dryRun?: boolean;
    /** App-provided run context (e.g. { userId, roles }). Available to tools + tool guardrails. */
    context?: TContext;
}
export interface ToolDefinition<TInput = any, TOutput = any, TContext = Record<string, unknown>> {
    name: string;
    description: string;
    inputSchema: z.ZodType<TInput>;
    execute: (input: TInput, ctx: ToolContext<TContext>) => Promise<TOutput>;
    requiresApproval?: boolean;
}
export interface ToolResult {
    toolCallId: string;
    toolName: string;
    output?: unknown;
    error?: string;
    durationMs: number;
}
export type GuardrailVerdict = {
    allowed: true;
    modifiedContent?: string;
} | {
    allowed: false;
    reason: string;
};
export interface InputGuardrail {
    name: string;
    check: (input: string) => GuardrailVerdict | Promise<GuardrailVerdict>;
}
export interface OutputGuardrail {
    name: string;
    check: (output: string) => GuardrailVerdict | Promise<GuardrailVerdict>;
}
export interface ToolGuardrail<TContext = Record<string, unknown>> {
    name: string;
    check: (toolName: string, input: unknown, ctx: ToolContext<TContext>) => GuardrailVerdict | Promise<GuardrailVerdict>;
}
export interface GuardrailSet<TContext = Record<string, unknown>> {
    input?: InputGuardrail[];
    output?: OutputGuardrail[];
    tool?: ToolGuardrail<TContext>[];
}
export interface ModelRequest {
    messages: Message[];
    instructions: string;
    tools?: ToolDefinition[];
    responseSchema?: z.ZodTypeAny;
    signal?: AbortSignal;
}
export interface TokenUsage {
    inputTokens: number;
    outputTokens: number;
}
export interface ModelResponse {
    content: string;
    toolCalls: ToolCallRequest[];
    handoff?: string;
    usage: TokenUsage;
    raw?: unknown;
}
export type StreamChunk = {
    type: "text_delta";
    delta: string;
} | {
    type: "tool_call_delta";
    toolCall: Partial<ToolCallRequest> & {
        id: string;
    };
} | {
    type: "done";
    response: ModelResponse;
};
export interface ModelProvider {
    name: string;
    chat(request: ModelRequest): Promise<ModelResponse>;
    chatStream?(request: ModelRequest): AsyncIterable<StreamChunk>;
}
export interface SessionState {
    sessionId: string;
    messages: Message[];
    createdAt: number;
    updatedAt: number;
}
export interface StorageAdapter {
    get(sessionId: string): Promise<SessionState | null>;
    set(sessionId: string, state: SessionState): Promise<void>;
    delete(sessionId: string): Promise<void>;
}
export interface RunState<TContext = Record<string, unknown>> {
    runId: string;
    sessionId: string;
    turn: number;
    visitedAgents: Set<string>;
    tokensUsed: {
        input: number;
        output: number;
    };
    dryRun: boolean;
    /** Copied from RunOptions.context for the lifetime of this run. */
    context?: TContext;
}
export type RunStatus = "completed" | "paused" | "failed";
export interface PendingApproval {
    toolName: string;
    toolCallId: string;
    input: unknown;
    agentName: string;
}
/** Serializable pause snapshot for Runner.resume(). */
export interface RunCheckpoint<TContext = Record<string, unknown>> {
    runId: string;
    sessionId: string;
    rootAgentName: string;
    activeAgentName: string;
    messages: Message[];
    turn: number;
    visitedAgents: string[];
    tokensUsed: {
        input: number;
        output: number;
    };
    dryRun: boolean;
    context?: TContext;
    pendingApproval: PendingApproval;
    /** Full tool-call batch from the paused turn (stable order). */
    pendingToolCalls: ToolCallRequest[];
}
export interface ApprovalDecision {
    approved: boolean;
    note?: string;
}
export type ClearloopEvent = {
    type: "run_started";
    runId: string;
    agentName: string;
} | {
    type: "text_delta";
    delta: string;
} | {
    type: "tool_started";
    toolName: string;
    toolCallId: string;
    input: unknown;
} | {
    type: "tool_completed";
    toolName: string;
    toolCallId: string;
    output: unknown;
    durationMs: number;
} | {
    type: "tool_failed";
    toolName: string;
    toolCallId: string;
    error: string;
    durationMs: number;
} | {
    type: "handoff_started";
    from: string;
    to: string;
} | {
    type: "guardrail_triggered";
    guardrail: string;
    reason: string;
    phase: string;
} | {
    type: "retry";
    attempt: number;
    maxRetries: number;
    error: string;
    scope: string;
    delayMs: number;
} | {
    type: "approval_required";
    toolName: string;
    toolCallId: string;
    input: unknown;
} | {
    type: "run_paused";
    runId: string;
    toolName: string;
    toolCallId: string;
    reason: string;
} | {
    type: "run_completed";
    runId: string;
    output: unknown;
} | {
    type: "run_failed";
    runId: string;
    error: string;
    code: string;
};
/** Callback used when a tool sets `requiresApproval: true`. */
export interface ApprovalRequest {
    toolName: string;
    toolCallId: string;
    input: unknown;
    runId: string;
}
export declare class ClearloopError extends Error {
    readonly code: string;
    constructor(message: string, code: string);
}
export declare class MaxTurnsExceededError extends ClearloopError {
    constructor(maxTurns: number);
}
export declare class HandoffLoopError extends ClearloopError {
    constructor(agentName: string);
}
export declare class GuardrailViolationError extends ClearloopError {
    constructor(guardrail: string, reason: string);
}
export declare class OutputValidationError extends ClearloopError {
    readonly issues: string[];
    constructor(issues: string[]);
}
export declare class ToolExecutionError extends ClearloopError {
    constructor(toolName: string, message: string);
}
export declare class BudgetExceededError extends ClearloopError {
    constructor(limitName: string, actual: number, limit: number);
}
export declare class TimeoutError extends ClearloopError {
    constructor(scope: string, timeoutMs: number);
}
//# sourceMappingURL=index.d.ts.map