import type { LanguageModel, LanguageModelCallOptions, ModelMessage, Output, SystemModelMessage, TelemetryOptions, ToolCallRepairFunction, ToolSet } from 'ai';
import type { FinishReason, SerializableAgentState, TokenUsage } from '../../types';
import type { ExecutionOptions, RunOptions } from '../../types/sdk/agent';
import type { AgentMessage } from '../../types/sdk/message';
import type { JSONObject } from '../../types/utils/json';
import type { AgentMessageList } from '../model/message-list';
import type { ToolCallBatchResult, ToolCallSuspension } from '../tools/tool-call-executor';
type RunCallOptions = (RunOptions & ExecutionOptions) | undefined;
export type ModelTurnErrorType = 'prompt_blocked' | 'no_output';
export interface ModelTurnError {
    type: ModelTurnErrorType;
    message: string;
}
export interface ModelTurnResult {
    aiFinishReason: string;
    finishReason: FinishReason;
    usage: TokenUsage | undefined;
    newMessages: AgentMessage[];
    toolCalls: Array<{
        toolCallId: string;
        toolName: string;
        input: unknown;
        providerExecuted?: boolean;
    }>;
    structuredOutput: unknown;
    errorReason?: ModelTurnError;
}
export interface ModelCallContext {
    model: LanguageModel;
    system: SystemModelMessage | SystemModelMessage[];
    messages: ModelMessage[];
    abortSignal: AbortSignal;
    hasTools: boolean;
    aiTools: ToolSet;
    reasoning?: LanguageModelCallOptions['reasoning'];
    providerOptions?: Record<string, JSONObject>;
    outputSpec?: ReturnType<typeof Output.object>;
    maxOutputTokens?: number;
    aiSdkOptions: {
        telemetry?: TelemetryOptions;
        repairToolCall?: ToolCallRepairFunction<NoInfer<ToolSet>>;
    };
}
export interface SuspendEmission {
    suspendRunId: string;
    list: AgentMessageList;
    usage: TokenUsage | undefined;
    suspensions: ToolCallSuspension[];
}
export interface CompleteEmission {
    list: AgentMessageList;
    options: RunCallOptions;
    finishReason: FinishReason;
    usage: TokenUsage | undefined;
    structuredOutput: unknown;
}
export interface RunServices {
    readonly runId: string;
    readonly modelId: string;
    applyCost(usage: TokenUsage | undefined): TokenUsage | undefined;
    saveToMemory(list: AgentMessageList, options: RunCallOptions): Promise<void>;
    maybeGenerateTitle(list: AgentMessageList, options: RunCallOptions): Promise<void>;
    flushTelemetry(options: RunCallOptions): Promise<void>;
    cleanupRun(): Promise<void>;
    updateState(patch: Partial<SerializableAgentState>): void;
    emitAgentEnd(messages: AgentMessage[]): void;
    getState(): SerializableAgentState;
}
export interface RunOutputSink<TResult> {
    callModel(ctx: ModelCallContext): Promise<ModelTurnResult>;
    reportUsage(usage: TokenUsage | undefined): void;
    onTurnFolded?(): void;
    emitToolBatch(batch: ToolCallBatchResult): Promise<void>;
    finishSuspended(emission: SuspendEmission): Promise<TResult>;
    finishComplete(emission: CompleteEmission): Promise<TResult>;
}
export {};