import type { Prompt } from '@effect/ai';
export type StreamEventType = 'run-start' | 'message-start' | 'step-start' | 'token' | 'tool-call' | 'tool-result' | 'tool-error' | 'usage' | 'message-end' | 'step-end' | 'step-complete' | 'stream-error' | 'run-end' | 'handoff-start';
export interface StreamEventBase {
    type: StreamEventType;
    sequence: number;
    emittedAt: number;
    runId: string;
    threadId?: string;
}
export interface RunStartEvent extends StreamEventBase {
    type: 'run-start';
    startedAt: number;
    input: {
        message: string;
        previousMessages: Prompt.MessageEncoded[];
    };
}
export interface MessageStartEvent extends StreamEventBase {
    type: 'message-start';
    messageId: string;
    step: number;
    role: 'assistant';
}
export interface StepStartEvent extends StreamEventBase {
    type: 'step-start';
    stepIndex: number;
}
export interface StepEndEvent extends StreamEventBase {
    type: 'step-end';
    stepIndex: number;
}
export interface StepCompleteEvent extends StreamEventBase {
    type: 'step-complete';
    stepIndex: number;
}
export interface TokenEvent extends StreamEventBase {
    type: 'token';
    messageId: string;
    step: number;
    delta: string;
    accumulated: string;
}
export interface ToolCallEvent extends StreamEventBase {
    type: 'tool-call';
    messageId: string;
    step: number;
    toolCallId: string;
    toolName: string;
    input: Record<string, unknown>;
    startedAt: number;
    originAgentId?: string;
}
/**
 * Tool result error structure (OpenAI API standard)
 * Stack traces included only in development (NODE_ENV=development)
 */
export interface ToolResultError {
    code: string;
    message: string;
    stack?: string;
}
export interface ToolResultEvent extends StreamEventBase {
    type: 'tool-result';
    messageId: string;
    step: number;
    toolCallId: string;
    toolName: string;
    output: unknown;
    completedAt: number;
    durationMs: number;
    metadata?: Record<string, unknown>;
    /**
     * Error field for failed tool execution (OpenAI API standard).
     * When present, the tool execution failed and output may contain error details.
     * Stack traces are included only in development environment.
     */
    error?: ToolResultError;
}
export interface ToolErrorEvent extends StreamEventBase {
    type: 'tool-error';
    messageId: string;
    step: number;
    toolCallId: string;
    toolName: string;
    error: {
        message: string;
        name?: string;
        stack?: string;
    };
    completedAt: number;
    durationMs: number;
}
export interface UsageEvent extends StreamEventBase {
    type: 'usage';
    messageId: string;
    step: number;
    usage: {
        inputTokens?: number;
        outputTokens?: number;
        totalTokens?: number;
    };
}
export interface MessageEndEvent extends StreamEventBase {
    type: 'message-end';
    messageId: string;
    step: number;
    finishedAt: number;
    finishReason?: string;
}
export interface StreamErrorEvent extends StreamEventBase {
    type: 'stream-error';
    stepIndex: number;
    messageId?: string;
    error: string;
    partialText?: string;
}
export interface RunEndEvent extends StreamEventBase {
    type: 'run-end';
    finishedAt: number;
    durationMs: number;
    result: {
        content: string;
        /** Decoded structured value for schema-backed agents. */
        output?: unknown;
        toolCalls?: Array<{
            toolId: string;
            args: Record<string, unknown>;
            result?: unknown;
            error?: {
                message: string;
                name?: string;
                stack?: string;
            };
            metadata?: Record<string, unknown>;
        }>;
        handoff?: {
            type: 'handoff';
            agentId: string;
            message: string;
            context?: Record<string, unknown>;
        };
        usage?: {
            inputTokens?: number;
            outputTokens?: number;
            totalTokens?: number;
        };
    };
}
export interface HandoffStartEvent extends StreamEventBase {
    type: 'handoff-start';
    fromAgentId: string;
    toAgentId: string;
    message: string;
    context?: Record<string, unknown>;
    handoffDepth: number;
}
export type StreamEvent = RunStartEvent | MessageStartEvent | StepStartEvent | TokenEvent | ToolCallEvent | ToolResultEvent | ToolErrorEvent | UsageEvent | MessageEndEvent | StepEndEvent | StepCompleteEvent | StreamErrorEvent | RunEndEvent | HandoffStartEvent;
export interface StreamEventEnvelope {
    events: StreamEvent[];
    lastSequence: number;
}
export declare const makeStepStartEvent: ({ runId, threadId, stepIndex, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    stepIndex: number;
    sequence: number;
    emittedAt: number;
}) => StepStartEvent;
export declare const makeStepEndEvent: ({ runId, threadId, stepIndex, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    stepIndex: number;
    sequence: number;
    emittedAt: number;
}) => StepEndEvent;
export declare const makeStepCompleteEvent: ({ runId, threadId, stepIndex, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    stepIndex: number;
    sequence: number;
    emittedAt: number;
}) => StepCompleteEvent;
export declare const makeTokenEvent: ({ runId, threadId, messageId, step, delta, accumulated, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    messageId: string;
    step: number;
    delta: string;
    accumulated: string;
    sequence: number;
    emittedAt: number;
}) => TokenEvent;
export declare const makeToolCallEvent: ({ runId, threadId, messageId, step, toolCallId, toolName, input, startedAt, sequence, emittedAt, originAgentId, }: {
    runId: string;
    threadId?: string;
    messageId: string;
    step: number;
    toolCallId: string;
    toolName: string;
    input: Record<string, unknown>;
    startedAt: number;
    sequence: number;
    emittedAt: number;
    originAgentId?: string;
}) => ToolCallEvent;
export declare const makeToolResultEvent: ({ runId, threadId, messageId, step, toolCallId, toolName, output, completedAt, durationMs, metadata, sequence, emittedAt, error, }: {
    runId: string;
    threadId?: string;
    messageId: string;
    step: number;
    toolCallId: string;
    toolName: string;
    output: unknown;
    completedAt: number;
    durationMs: number;
    metadata?: Record<string, unknown>;
    sequence: number;
    emittedAt: number;
    error?: ToolResultError;
}) => ToolResultEvent;
export declare const makeToolErrorEvent: ({ runId, threadId, messageId, step, toolCallId, toolName, error, completedAt, durationMs, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    messageId: string;
    step: number;
    toolCallId: string;
    toolName: string;
    error: {
        message: string;
        name?: string;
        stack?: string;
    };
    completedAt: number;
    durationMs: number;
    sequence: number;
    emittedAt: number;
}) => ToolErrorEvent;
export declare const makeStreamErrorEvent: ({ runId, threadId, stepIndex, messageId, error, partialText, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    stepIndex: number;
    messageId?: string;
    error: string;
    partialText?: string;
    sequence: number;
    emittedAt: number;
}) => StreamErrorEvent;
export declare const makeHandoffStartEvent: ({ runId, threadId, fromAgentId, toAgentId, message, context, handoffDepth, sequence, emittedAt, }: {
    runId: string;
    threadId?: string;
    fromAgentId: string;
    toAgentId: string;
    message: string;
    context?: Record<string, unknown>;
    handoffDepth: number;
    sequence: number;
    emittedAt: number;
}) => HandoffStartEvent;
//# sourceMappingURL=events.d.ts.map