import type { ProviderOptions } from '@ai-sdk/provider-utils';
import type { GenerateTextStepEndEvent, GenerateTextStepStartEvent, LanguageModel, smoothStream } from 'ai';
import type { JsonSchema7Type } from 'zod-to-json-schema';
import type { AgentMessage, ContentMetadata } from './message';
import type { ProviderId, ProviderCredentials } from '../../runtime/model/provider-credentials';
import type { AgentEvent, AgentEventHandler, SubAgentChunkPayload, SubAgentCompletedPayload, SubAgentStartedPayload } from '../runtime/event';
import type { SerializedMessageList } from '../runtime/message-list';
import type { BuiltTelemetry } from '../telemetry';
import type { JSONObject, JSONValue } from '../utils/json';
export type SmoothStreamOptions = NonNullable<Parameters<typeof smoothStream>[0]>;
export type FinishReason = 'stop' | 'max-iterations' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other';
export type TokenUsage<T extends Record<string, unknown> = Record<string, unknown>> = {
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
    cost?: number;
    inputTokenDetails?: {
        noCache?: number;
        cacheRead?: number;
        cacheWrite?: number;
    };
    outputTokenDetails?: {
        reasoning?: number;
    };
    additionalMetadata?: T;
};
export type TypedModelConfig = {
    [P in ProviderId]: {
        id: `${P}/${string}`;
    } & ProviderCredentials<P>;
}[ProviderId];
export type ModelConfig = string | TypedModelConfig | {
    id: string;
    [k: string]: unknown;
} | LanguageModel;
export interface AgentResult {
    id?: string;
    finishReason?: FinishReason;
    usage?: TokenUsage;
    messages: AgentMessage[];
    providerMetadata?: Record<string, unknown>;
    rawResponse?: unknown;
    output?: unknown;
}
export type StreamChunk = ContentMetadata & ({
    type: 'start-step';
} | {
    type: 'finish-step';
} | {
    type: 'text-start';
    id: string;
} | {
    type: 'text-delta';
    id: string;
    delta: string;
} | {
    type: 'text-end';
    id: string;
} | {
    type: 'reasoning-start';
    id: string;
} | {
    type: 'reasoning-delta';
    id: string;
    delta: string;
} | {
    type: 'reasoning-end';
    id: string;
} | {
    type: 'tool-input-start';
    toolCallId: string;
    toolName: string;
} | {
    type: 'tool-input-delta';
    toolCallId: string;
    delta: string;
} | {
    type: 'tool-call';
    toolCallId: string;
    toolName: string;
    input: unknown;
} | {
    type: 'tool-execution-start';
    toolCallId: string;
    toolName: string;
    startTime: number;
} | {
    type: 'tool-execution-end';
    toolCallId: string;
    toolName: string;
    isError: boolean;
    endTime: number;
} | {
    type: 'tool-result';
    toolCallId: string;
    toolName: string;
    output: unknown;
    isError?: boolean;
    canceled?: boolean;
} | {
    type: 'tool-call-suspended';
    runId: string;
    toolCallId: string;
    toolName: string;
    input?: unknown;
    suspendPayload?: unknown;
    resumeSchema?: JsonSchema7Type;
} | {
    type: 'message';
    message: AgentMessage;
} | ({
    type: 'subagent-started';
} & SubAgentStartedPayload) | ({
    type: 'subagent-completed';
} & SubAgentCompletedPayload) | ({
    type: 'subagent-chunk';
} & SubAgentChunkPayload) | {
    type: 'finish';
    finishReason: FinishReason;
    usage?: TokenUsage;
    model?: string;
    structuredOutput?: unknown;
} | {
    type: 'error';
    error: unknown;
} | {
    type: 'warning';
    message: string;
    code?: string;
    source?: 'mcp';
    server?: string;
});
export interface RunOptions {
    persistence?: AgentPersistenceOptions;
}
export interface AgentExecutionCounter {
    incrementMessageCount(): void;
    incrementToolCallCount(): void;
    incrementTokenCount(tokenCount: number): void;
}
export interface ExecutionOptions {
    maxIterations?: number;
    abortSignal?: AbortSignal;
    providerOptions?: ProviderOptions;
    maxOutputTokens?: number;
    smoothStream?: SmoothStreamOptions | false;
    recoverUsageOnAbort?: boolean;
    modelStreamIdleTimeoutMs?: number;
    modelStreamFirstOutputTimeoutMs?: number;
    telemetry?: BuiltTelemetry;
    executionCounter?: AgentExecutionCounter;
    onStepStart?: (event: GenerateTextStepStartEvent) => void | Promise<void>;
    onStepEnd?: (event: GenerateTextStepEndEvent) => void | Promise<void>;
    onStepFinish?: (event: GenerateTextStepEndEvent) => void | Promise<void>;
    stepCheckpoints?: boolean;
}
export interface PersistedExecutionOptions {
    maxIterations?: number;
}
export interface AnthropicPromptCachingConfig {
    ttl?: '5m' | '1h';
}
export interface OpenAIPromptCachingConfig {
    promptCacheKey?: string;
    promptCacheRetention?: 'in_memory' | '24h';
}
export interface PromptCachingConfig {
    enabled?: boolean;
    anthropic?: false | AnthropicPromptCachingConfig;
    openai?: false | OpenAIPromptCachingConfig;
}
export interface ToolResultEntry {
    tool: string;
    input: unknown;
    output: unknown;
    transformed?: boolean;
    canceled?: boolean;
}
export interface GenerateResult {
    runId: string;
    messages: AgentMessage[];
    structuredOutput?: unknown;
    usage?: TokenUsage;
    model?: string;
    finishReason?: FinishReason;
    providerMetadata?: Record<string, unknown>;
    toolCalls?: ToolResultEntry[];
    pendingSuspend?: Array<{
        runId: string;
        toolCallId: string;
        toolName: string;
        input: unknown;
        suspendPayload: unknown;
        resumeSchema?: JsonSchema7Type;
    }>;
    error?: unknown;
    getState(): SerializableAgentState;
}
export interface StreamResult {
    runId: string;
    stream: ReadableStream<StreamChunk>;
    getState(): SerializableAgentState;
}
export interface ResumeOptions {
    runId: string;
    toolCallId: string;
    onResumeClaimed?: () => void | Promise<void>;
}
export interface BuiltAgent {
    readonly name: string;
    generate(input: AgentMessage[] | string, options?: RunOptions & ExecutionOptions): Promise<GenerateResult>;
    stream(input: AgentMessage[] | string, options?: RunOptions & ExecutionOptions): Promise<StreamResult>;
    on(event: AgentEvent, handler: AgentEventHandler): void;
    abort(): void;
    close(): Promise<void>;
    resume(method: 'generate', data: unknown, options: ResumeOptions & ExecutionOptions): Promise<GenerateResult>;
    resume(method: 'stream', data: unknown, options: ResumeOptions & ExecutionOptions): Promise<StreamResult>;
    approve(method: 'generate', options: ResumeOptions & ExecutionOptions): Promise<GenerateResult>;
    approve(method: 'stream', options: ResumeOptions & ExecutionOptions): Promise<StreamResult>;
    deny(method: 'generate', options: ResumeOptions & ExecutionOptions): Promise<GenerateResult>;
    deny(method: 'stream', options: ResumeOptions & ExecutionOptions): Promise<StreamResult>;
}
export type AgentRunState = 'idle' | 'running' | 'success' | 'failed' | 'suspended' | 'waiting' | 'cancelled';
export interface AgentResumeData {
    resumeToolCall?: {
        toolCallId: string;
    };
    resumeData: unknown;
}
export type PendingToolCall = {
    toolCallId: string;
    toolName: string;
    input: JSONValue;
} & ({
    suspended: true;
    suspendPayload: unknown;
    resumeSchema: JsonSchema7Type;
    continuation?: JSONValue;
    runId: string;
} | {
    suspended: false;
});
export interface SerializableAgentState {
    persistence?: AgentPersistenceOptions;
    status: AgentRunState;
    messageList: SerializedMessageList;
    resumeData?: AgentResumeData;
    pendingToolCalls: Record<string, PendingToolCall>;
    finishReason?: FinishReason;
    usage?: TokenUsage;
    executionOptions?: PersistedExecutionOptions;
    iterationCount?: number;
}
export type AgentPersistenceOptions = {
    threadId: string;
    resourceId: string;
    hostMetadata?: JSONObject;
    delegated?: true;
    hostRunId?: string;
};