@crewai-ts/core 0.1.1 → 0.1.3

package/dist/events.d.ts

@@ -0,0 +1,2657 @@
+import type { LiteAgentOutput } from "./lite-agent-output.js";
+import type { CrewOutput, TaskOutput } from "./outputs.js";
+import { type TraceEventsPayload, type TraceFinalizePayload } from "./plus-api.js";
+import { RuntimeState } from "./state.js";
+import { Telemetry } from "./telemetry.js";
+import type { InputValues, MaybePromise } from "./types.js";
+export type EventType = "crew_kickoff_started" | "crew_kickoff_completed" | "crew_kickoff_failed" | "crew_train_started" | "crew_train_completed" | "crew_train_failed" | "crew_test_started" | "crew_test_completed" | "crew_test_failed" | "task_started" | "task_completed" | "task_failed" | "task_evaluation" | "crew_test_result" | "agent_execution_started" | "agent_execution_completed" | "agent_execution_error" | "agent_evaluation_started" | "agent_evaluation_completed" | "agent_evaluation_failed" | "agent_reasoning_started" | "agent_reasoning_completed" | "agent_reasoning_failed" | "a2a_delegation_started" | "a2a_delegation_completed" | "a2a_conversation_started" | "a2a_message_sent" | "a2a_response_received" | "a2a_conversation_completed" | "a2a_polling_started" | "a2a_polling_status" | "a2a_push_notification_registered" | "a2a_push_notification_received" | "a2a_push_notification_sent" | "a2a_push_notification_timeout" | "a2a_streaming_started" | "a2a_streaming_chunk" | "a2a_agent_card_fetched" | "a2a_authentication_failed" | "a2a_artifact_received" | "a2a_connection_error" | "a2a_server_task_started" | "a2a_server_task_completed" | "a2a_server_task_canceled" | "a2a_server_task_failed" | "a2a_parallel_delegation_started" | "a2a_parallel_delegation_completed" | "a2a_transport_negotiated" | "a2a_content_type_negotiated" | "a2a_context_created" | "a2a_context_expired" | "a2a_context_idle" | "a2a_context_completed" | "a2a_context_pruned" | "mcp_connection_started" | "mcp_connection_completed" | "mcp_connection_failed" | "mcp_tool_execution_started" | "mcp_tool_execution_completed" | "mcp_tool_execution_failed" | "mcp_config_fetch_failed" | "skill_discovery_started" | "skill_discovery_completed" | "skill_loaded" | "skill_activated" | "skill_load_failed" | "skill_download_started" | "skill_download_completed" | "llm_call_started" | "llm_call_completed" | "llm_call_failed" | "llm_stream_chunk" | "llm_thinking_chunk" | "llm_guardrail_started" | "llm_guardrail_completed" | "knowledge_search_query_started" | "knowledge_search_query_completed" | "knowledge_query_started" | "knowledge_query_failed" | "knowledge_query_completed" | "knowledge_search_query_failed" | "tool_usage_started" | "tool_usage_finished" | "tool_usage_error" | "tool_validate_input_error" | "tool_selection_error" | "tool_execution_error" | "lite_agent_execution_started" | "lite_agent_execution_completed" | "lite_agent_execution_error" | "human_feedback_requested" | "human_feedback_received" | "memory_save_started" | "memory_save_completed" | "memory_save_failed" | "memory_query_started" | "memory_query_completed" | "memory_query_failed" | "memory_retrieval_started" | "memory_retrieval_completed" | "memory_retrieval_failed" | "flow_started" | "flow_created" | "flow_finished" | "flow_failed" | "flow_paused" | "flow_plot" | "flow_input_requested" | "flow_input_received" | "method_execution_started" | "method_execution_finished" | "method_execution_failed" | "method_execution_paused" | "checkpoint_started" | "checkpoint_completed" | "checkpoint_failed" | "checkpoint_pruned" | "checkpoint_fork_started" | "checkpoint_fork_completed" | "checkpoint_restore_started" | "checkpoint_restore_completed" | "checkpoint_restore_failed" | "step_observation_started" | "step_observation_completed" | "step_observation_failed" | "plan_refinement" | "plan_replan_triggered" | "goal_achieved_early" | "SIGTERM" | "SIGINT" | "SIGHUP" | "SIGTSTP" | "SIGCONT" | "agent_logs_started" | "agent_logs_execution" | "cc_env" | "codex_env" | "cursor_env" | "default_env";
+type EventClass<TEvent extends CrewAIEvent = CrewAIEvent> = abstract new (...args: unknown[]) => TEvent;
+type EventRegistrationKey = EventType | EventClass;
+export type BaseEventOptions = {
+    type: EventType;
+    sourceType?: string | null;
+    sourceFingerprint?: string | null;
+    parentEventId?: string | null;
+    previousEventId?: string | null;
+    triggeredByEventId?: string | null;
+    startedEventId?: string | null;
+};
+export declare class BaseEvent {
+    readonly timestamp: Date;
+    readonly type: EventType;
+    readonly eventId: string;
+    readonly emissionSequence: number;
+    sourceType: string | null;
+    sourceFingerprint: string | null;
+    fingerprintMetadata: Record<string, unknown> | null;
+    fingerprint_metadata: Record<string, unknown> | null;
+    taskId: string | null;
+    task_id: string | null;
+    taskName: string | null;
+    task_name: string | null;
+    agentId: string | null;
+    agent_id: string | null;
+    agentRole: string | null;
+    agent_role: string | null;
+    parentEventId: string | null;
+    previousEventId: string | null;
+    triggeredByEventId: string | null;
+    startedEventId: string | null;
+    constructor(options: BaseEventOptions);
+    toJSON(): Record<string, unknown>;
+    to_json(exclude?: Set<string> | readonly string[] | null): Record<string, unknown>;
+    _set_task_params(data: Record<string, unknown>): void;
+    _set_agent_params(data: Record<string, unknown>): void;
+}
+export declare abstract class FlowEvent extends BaseEvent {
+}
+export declare abstract class ReasoningEvent extends BaseEvent {
+}
+export declare abstract class ToolUsageEvent extends BaseEvent {
+}
+export type CrewBaseEventOptions = Omit<BaseEventOptions, "sourceType" | "sourceFingerprint"> & {
+    sourceType?: string | null | undefined;
+    sourceFingerprint?: string | null | undefined;
+    crewName?: string | null | undefined;
+    crew_name?: string | null | undefined;
+    crew?: unknown;
+    fingerprintMetadata?: Record<string, unknown> | null | undefined;
+    fingerprint_metadata?: Record<string, unknown> | null | undefined;
+};
+export declare abstract class CrewBaseEvent extends BaseEvent {
+    readonly crewName: string | null;
+    readonly crew_name: string | null;
+    readonly crew: unknown;
+    fingerprintMetadata: Record<string, unknown> | null;
+    fingerprint_metadata: Record<string, unknown> | null;
+    constructor(options: CrewBaseEventOptions);
+    _set_crew_fingerprint(): void;
+    toJSON(): Record<string, unknown>;
+    to_json(exclude?: Set<string> | readonly string[] | null): Record<string, unknown>;
+}
+export declare abstract class MemoryBaseEvent extends BaseEvent {
+}
+export declare class CrewKickoffStartedEvent extends CrewBaseEvent {
+    readonly inputs: InputValues | null;
+    constructor(options?: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        inputs?: InputValues | null;
+        startedEventId?: string | null;
+        started_event_id?: string | null;
+    });
+}
+export declare class CrewKickoffCompletedEvent extends CrewBaseEvent {
+    readonly output: CrewOutput;
+    readonly totalTokens: number;
+    readonly total_tokens: number;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        output: CrewOutput;
+        totalTokens?: number;
+        total_tokens?: number;
+        startedEventId?: string | null;
+        started_event_id?: string | null;
+    });
+}
+export declare class CrewKickoffFailedEvent extends CrewBaseEvent {
+    readonly error: string;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        error: unknown;
+        startedEventId?: string | null;
+        started_event_id?: string | null;
+    });
+}
+export declare class CrewTrainStartedEvent extends CrewBaseEvent {
+    readonly n_iterations: number;
+    readonly filename: string;
+    readonly inputs: InputValues | null;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        n_iterations: number;
+        filename: string;
+        inputs?: InputValues | null;
+    });
+}
+export declare class CrewTrainCompletedEvent extends CrewBaseEvent {
+    readonly n_iterations: number;
+    readonly filename: string;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        n_iterations: number;
+        filename: string;
+    });
+}
+export declare class CrewTrainFailedEvent extends CrewBaseEvent {
+    readonly error: string;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        error: unknown;
+    });
+}
+export declare class CrewTestStartedEvent extends CrewBaseEvent {
+    readonly n_iterations: number;
+    readonly eval_llm: unknown;
+    readonly inputs: InputValues | null;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        n_iterations: number;
+        eval_llm?: unknown;
+        inputs?: InputValues | null;
+    });
+}
+export declare class CrewTestCompletedEvent extends CrewBaseEvent {
+    constructor(options?: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+    });
+}
+export declare class CrewTestFailedEvent extends CrewBaseEvent {
+    readonly error: string;
+    constructor(options: {
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+        error: unknown;
+    });
+}
+export declare class TaskStartedEvent extends BaseEvent {
+    readonly taskName: string | null;
+    readonly taskDescription: string;
+    readonly context: string | null;
+    constructor(options: {
+        taskName?: string | null;
+        taskDescription: string;
+        context?: string | null;
+    });
+}
+export declare class TaskCompletedEvent extends BaseEvent {
+    readonly taskName: string | null;
+    readonly taskDescription: string;
+    readonly output: TaskOutput;
+    constructor(options: {
+        taskName?: string | null;
+        taskDescription: string;
+        output: TaskOutput;
+    });
+}
+export declare class TaskFailedEvent extends BaseEvent {
+    readonly taskName: string | null;
+    readonly taskDescription: string;
+    readonly error: string;
+    constructor(options: {
+        taskName?: string | null;
+        taskDescription: string;
+        error: unknown;
+    });
+}
+export declare class TaskEvaluationEvent extends BaseEvent {
+    readonly evaluationType: string;
+    readonly evaluation_type: string;
+    readonly task: unknown;
+    constructor(options?: {
+        evaluationType?: string;
+        evaluation_type?: string;
+        task?: unknown;
+    });
+}
+export declare class CrewTestResultEvent extends CrewBaseEvent {
+    readonly quality: number;
+    readonly executionDuration: number | null;
+    readonly execution_duration: number | null;
+    readonly model: string | null;
+    constructor(options: {
+        quality: number;
+        executionDuration?: number | null;
+        execution_duration?: number | null;
+        model?: string | null;
+        crewName?: string | null;
+        crew_name?: string | null;
+        crew?: unknown;
+    });
+}
+export declare function _set_agent_fingerprint(event: BaseEvent, agent: unknown): void;
+export declare function _set_task_fingerprint(event: BaseEvent, task: unknown): void;
+export declare class AgentExecutionStartedEvent extends BaseEvent {
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly tools: readonly unknown[] | null;
+    readonly taskPrompt: string;
+    readonly task_prompt: string;
+    readonly fingerprintMetadata: Record<string, unknown> | null;
+    readonly fingerprint_metadata: Record<string, unknown> | null;
+    constructor(options: {
+        agent: unknown;
+        task: unknown;
+        tools?: readonly unknown[] | null;
+        taskPrompt?: string;
+        task_prompt?: string;
+    });
+    setFingerprintData(): this;
+    set_fingerprint_data(): this;
+}
+export declare class AgentExecutionCompletedEvent extends BaseEvent {
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly output: string;
+    readonly fingerprintMetadata: Record<string, unknown> | null;
+    readonly fingerprint_metadata: Record<string, unknown> | null;
+    constructor(options: {
+        agent: unknown;
+        task: unknown;
+        output: string;
+    });
+    setFingerprintData(): this;
+    set_fingerprint_data(): this;
+}
+export declare class AgentExecutionErrorEvent extends BaseEvent {
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly error: string;
+    readonly fingerprintMetadata: Record<string, unknown> | null;
+    readonly fingerprint_metadata: Record<string, unknown> | null;
+    constructor(options: {
+        agent: unknown;
+        task: unknown;
+        error: unknown;
+    });
+    setFingerprintData(): this;
+    set_fingerprint_data(): this;
+}
+export declare class AgentEvaluationStartedEvent extends BaseEvent {
+    readonly agent_id: string;
+    readonly agent_role: string;
+    readonly task_id: string | null;
+    readonly iteration: number;
+    constructor(options: {
+        agent_id: string;
+        agent_role: string;
+        task_id?: string | null;
+        iteration: number;
+    });
+}
+export declare class AgentEvaluationCompletedEvent extends BaseEvent {
+    readonly agent_id: string;
+    readonly agent_role: string;
+    readonly task_id: string | null;
+    readonly iteration: number;
+    readonly metric_category: unknown;
+    readonly score: unknown;
+    constructor(options: {
+        agent_id: string;
+        agent_role: string;
+        task_id?: string | null;
+        iteration: number;
+        metric_category: unknown;
+        score: unknown;
+    });
+}
+export declare class AgentEvaluationFailedEvent extends BaseEvent {
+    readonly agent_id: string;
+    readonly agent_role: string;
+    readonly task_id: string | null;
+    readonly iteration: number;
+    readonly error: string;
+    constructor(options: {
+        agent_id: string;
+        agent_role: string;
+        task_id?: string | null;
+        iteration: number;
+        error: unknown;
+    });
+}
+export declare class AgentReasoningStartedEvent extends BaseEvent {
+    readonly agentRole: string;
+    readonly agent_role: string;
+    readonly taskId: string;
+    readonly task_id: string;
+    readonly attempt: number;
+    readonly fromTask: unknown;
+    readonly from_task: unknown;
+    constructor(options?: {
+        agentRole?: string;
+        agent_role?: string;
+        taskId?: string;
+        task_id?: string;
+        attempt?: number;
+        fromTask?: unknown;
+        from_task?: unknown;
+    });
+}
+export declare class AgentReasoningCompletedEvent extends BaseEvent {
+    readonly agentRole: string;
+    readonly agent_role: string;
+    readonly taskId: string;
+    readonly task_id: string;
+    readonly plan: string;
+    readonly ready: boolean;
+    readonly attempt: number;
+    readonly fromTask: unknown;
+    readonly from_task: unknown;
+    readonly fromAgent: unknown;
+    readonly from_agent: unknown;
+    constructor(options: {
+        agentRole?: string;
+        agent_role?: string;
+        taskId?: string;
+        task_id?: string;
+        plan: string;
+        ready: boolean;
+        attempt?: number;
+        fromTask?: unknown;
+        from_task?: unknown;
+        fromAgent?: unknown;
+        from_agent?: unknown;
+    });
+}
+export declare class AgentReasoningFailedEvent extends BaseEvent {
+    readonly agentRole: string;
+    readonly agent_role: string;
+    readonly taskId: string;
+    readonly task_id: string;
+    readonly error: string;
+    readonly attempt: number;
+    readonly fromTask: unknown;
+    readonly from_task: unknown;
+    readonly fromAgent: unknown;
+    readonly from_agent: unknown;
+    constructor(options: {
+        agentRole?: string;
+        agent_role?: string;
+        taskId?: string;
+        task_id?: string;
+        error: unknown;
+        attempt?: number;
+        fromTask?: unknown;
+        from_task?: unknown;
+        fromAgent?: unknown;
+        from_agent?: unknown;
+    });
+}
+export declare class HumanFeedbackRequestedEvent extends BaseEvent {
+    readonly taskName: string | null;
+    readonly task_name: string | null;
+    readonly taskDescription: string | null;
+    readonly task_description: string | null;
+    readonly output: unknown;
+    readonly flowName: string | null;
+    readonly flow_name: string | null;
+    readonly methodName: string | null;
+    readonly method_name: string | null;
+    readonly message: string | null;
+    readonly emit: readonly string[] | null;
+    readonly request_id: string | null;
+    constructor(options: {
+        taskName?: string | null;
+        task_name?: string | null;
+        taskDescription?: string | null;
+        task_description?: string | null;
+        output: unknown;
+        flowName?: string | null;
+        flow_name?: string | null;
+        methodName?: string | null;
+        method_name?: string | null;
+        message?: string | null;
+        emit?: readonly string[] | null;
+        request_id?: string | null;
+    });
+}
+export declare class HumanFeedbackReceivedEvent extends BaseEvent {
+    readonly taskName: string | null;
+    readonly task_name: string | null;
+    readonly taskDescription: string | null;
+    readonly task_description: string | null;
+    readonly feedback: string;
+    readonly accepted: boolean;
+    readonly flowName: string | null;
+    readonly flow_name: string | null;
+    readonly methodName: string | null;
+    readonly method_name: string | null;
+    readonly outcome: string | null;
+    readonly request_id: string | null;
+    constructor(options: {
+        taskName?: string | null;
+        task_name?: string | null;
+        taskDescription?: string | null;
+        task_description?: string | null;
+        feedback: string;
+        accepted?: boolean;
+        flowName?: string | null;
+        flow_name?: string | null;
+        methodName?: string | null;
+        method_name?: string | null;
+        outcome?: string | null;
+        request_id?: string | null;
+    });
+}
+export declare class ToolUsageStartedEvent extends BaseEvent {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly toolArgs: Record<string, unknown> | string;
+    readonly tool_args: Record<string, unknown> | string;
+    readonly toolClass: string | null;
+    readonly tool_class: string | null;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolArgs?: Record<string, unknown> | string;
+        tool_args?: Record<string, unknown> | string;
+        toolClass?: string | null;
+        tool_class?: string | null;
+    } & Record<string, unknown>);
+}
+export declare class ToolUsageFinishedEvent extends BaseEvent {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly toolArgs: Record<string, unknown> | string;
+    readonly tool_args: Record<string, unknown> | string;
+    readonly toolClass: string | null;
+    readonly tool_class: string | null;
+    readonly startedAt: Date;
+    readonly started_at: Date;
+    readonly finishedAt: Date;
+    readonly finished_at: Date;
+    readonly fromCache: boolean;
+    readonly from_cache: boolean;
+    readonly output: unknown;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolArgs?: Record<string, unknown> | string;
+        tool_args?: Record<string, unknown> | string;
+        toolClass?: string | null;
+        tool_class?: string | null;
+        startedAt?: Date;
+        started_at?: Date;
+        finishedAt?: Date;
+        finished_at?: Date;
+        fromCache?: boolean;
+        from_cache?: boolean;
+        output: unknown;
+    } & Record<string, unknown>);
+}
+export declare class ToolUsageErrorEvent extends BaseEvent {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly toolArgs: Record<string, unknown> | string;
+    readonly tool_args: Record<string, unknown> | string;
+    readonly toolClass: string | null;
+    readonly tool_class: string | null;
+    readonly error: string;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolArgs?: Record<string, unknown> | string;
+        tool_args?: Record<string, unknown> | string;
+        toolClass?: string | null;
+        tool_class?: string | null;
+        error: unknown;
+    } & Record<string, unknown>);
+}
+export declare class ToolValidateInputErrorEvent extends BaseEvent {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly toolArgs: Record<string, unknown> | string;
+    readonly tool_args: Record<string, unknown> | string;
+    readonly toolClass: string | null;
+    readonly tool_class: string | null;
+    readonly error: string;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolArgs?: Record<string, unknown> | string;
+        tool_args?: Record<string, unknown> | string;
+        toolClass?: string | null;
+        tool_class?: string | null;
+        error: unknown;
+    } & Record<string, unknown>);
+}
+export declare class ToolSelectionErrorEvent extends BaseEvent {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly toolArgs: Record<string, unknown> | string;
+    readonly tool_args: Record<string, unknown> | string;
+    readonly toolClass: string | null;
+    readonly tool_class: string | null;
+    readonly error: string;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolArgs?: Record<string, unknown> | string;
+        tool_args?: Record<string, unknown> | string;
+        toolClass?: string | null;
+        tool_class?: string | null;
+        error: unknown;
+    } & Record<string, unknown>);
+}
+export declare class ToolExecutionErrorEvent extends BaseEvent {
+    readonly error: string;
+    readonly tool_name: string;
+    readonly tool_args: Record<string, unknown>;
+    readonly tool_class: unknown;
+    readonly agent: unknown;
+    readonly fingerprintMetadata: Record<string, unknown> | null;
+    readonly fingerprint_metadata: Record<string, unknown> | null;
+    constructor(options: {
+        error: unknown;
+        tool_name: string;
+        tool_args: Record<string, unknown>;
+        tool_class: unknown;
+        agent?: unknown;
+    });
+}
+export declare class LiteAgentExecutionStartedEvent extends BaseEvent {
+    readonly agentInfo: Record<string, unknown>;
+    readonly agent_info: Record<string, unknown>;
+    readonly messages: readonly unknown[];
+    constructor(options?: {
+        agentInfo?: Record<string, unknown>;
+        agent_info?: Record<string, unknown>;
+        messages?: readonly unknown[];
+    });
+}
+export declare class LiteAgentExecutionCompletedEvent extends BaseEvent {
+    readonly agentInfo: Record<string, unknown>;
+    readonly agent_info: Record<string, unknown>;
+    readonly output: LiteAgentOutput;
+    constructor(options: {
+        agentInfo?: Record<string, unknown>;
+        agent_info?: Record<string, unknown>;
+        output: LiteAgentOutput;
+    });
+}
+export declare class LiteAgentExecutionErrorEvent extends BaseEvent {
+    readonly agentInfo: Record<string, unknown>;
+    readonly agent_info: Record<string, unknown>;
+    readonly error: string;
+    constructor(options: {
+        agentInfo?: Record<string, unknown>;
+        agent_info?: Record<string, unknown>;
+        error: unknown;
+    });
+}
+export declare class MemorySaveStartedEvent extends BaseEvent {
+    readonly value: string | null;
+    readonly metadata: Record<string, unknown> | null;
+    readonly agentRole: string | null;
+    constructor(options?: {
+        value?: string | null;
+        metadata?: Record<string, unknown> | null;
+        agentRole?: string | null;
+    });
+}
+export declare class MemorySaveCompletedEvent extends BaseEvent {
+    readonly value: string;
+    readonly metadata: Record<string, unknown> | null;
+    readonly agentRole: string | null;
+    readonly saveTimeMs: number;
+    constructor(options: {
+        value: string;
+        metadata?: Record<string, unknown> | null;
+        agentRole?: string | null;
+        saveTimeMs: number;
+    });
+}
+export declare class MemorySaveFailedEvent extends BaseEvent {
+    readonly value: string | null;
+    readonly metadata: Record<string, unknown> | null;
+    readonly agentRole: string | null;
+    readonly error: string;
+    constructor(options: {
+        value?: string | null;
+        metadata?: Record<string, unknown> | null;
+        agentRole?: string | null;
+        error: unknown;
+    });
+}
+export declare class MemoryQueryStartedEvent extends BaseEvent {
+    readonly query: string;
+    readonly limit: number;
+    readonly scoreThreshold: number | null;
+    constructor(options: {
+        query: string;
+        limit: number;
+        scoreThreshold?: number | null;
+    });
+}
+export declare class MemoryQueryCompletedEvent extends BaseEvent {
+    readonly query: string;
+    readonly results: unknown;
+    readonly limit: number;
+    readonly scoreThreshold: number | null;
+    readonly queryTimeMs: number;
+    constructor(options: {
+        query: string;
+        results: unknown;
+        limit: number;
+        scoreThreshold?: number | null;
+        queryTimeMs: number;
+    });
+}
+export declare class MemoryQueryFailedEvent extends BaseEvent {
+    readonly query: string;
+    readonly limit: number;
+    readonly scoreThreshold: number | null;
+    readonly error: string;
+    constructor(options: {
+        query: string;
+        limit: number;
+        scoreThreshold?: number | null;
+        error: unknown;
+    });
+}
+export declare class MemoryRetrievalStartedEvent extends BaseEvent {
+    readonly task_id: string | null;
+    constructor(options?: {
+        task_id?: string | null;
+    });
+}
+export declare class MemoryRetrievalCompletedEvent extends BaseEvent {
+    readonly task_id: string | null;
+    readonly memory_content: string;
+    readonly retrieval_time_ms: number;
+    constructor(options: {
+        task_id?: string | null;
+        memory_content: string;
+        retrieval_time_ms: number;
+    });
+}
+export declare class MemoryRetrievalFailedEvent extends BaseEvent {
+    readonly task_id: string | null;
+    readonly error: string;
+    constructor(options: {
+        task_id?: string | null;
+        error: unknown;
+    });
+}
+export declare class FlowStartedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly inputs: InputValues;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        inputs?: InputValues;
+    });
+}
+export declare class FlowCreatedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+    });
+}
+export declare class FlowFinishedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly result: unknown;
+    readonly state: unknown;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        result: unknown;
+        state: unknown;
+    });
+}
+export declare class FlowFailedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly error: string;
+    readonly state: unknown;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        error: unknown;
+        state: unknown;
+    });
+}
+export declare class FlowPausedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly flowId: string | null;
+    readonly flow_id: string | null;
+    readonly methodName: string | null;
+    readonly method_name: string | null;
+    readonly pending: unknown;
+    readonly state: unknown;
+    readonly message: string | null;
+    readonly emit: readonly string[] | null;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        flowId?: string | null;
+        flow_id?: string | null;
+        methodName?: string | null;
+        method_name?: string | null;
+        pending?: unknown;
+        state: unknown;
+        message?: string | null;
+        emit?: readonly string[] | null;
+    });
+}
+export declare class FlowPlotEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+    });
+}
+export declare class FlowInputRequestedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly methodName: string | null;
+    readonly method_name: string | null;
+    readonly message: string;
+    readonly metadata: Record<string, unknown> | null;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        methodName?: string | null;
+        method_name?: string | null;
+        message: string;
+        metadata?: Record<string, unknown> | null;
+    });
+}
+export declare class FlowInputReceivedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly methodName: string | null;
+    readonly method_name: string | null;
+    readonly message: string;
+    readonly response: string | null;
+    readonly metadata: Record<string, unknown> | null;
+    readonly responseMetadata: Record<string, unknown> | null;
+    readonly response_metadata: Record<string, unknown> | null;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        methodName?: string | null;
+        method_name?: string | null;
+        message: string;
+        response: string | null;
+        metadata?: Record<string, unknown> | null;
+        responseMetadata?: Record<string, unknown> | null;
+        response_metadata?: Record<string, unknown> | null;
+    });
+}
+export declare class MethodExecutionStartedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly methodName: string;
+    readonly method_name: string;
+    readonly state: unknown;
+    readonly params: Record<string, unknown> | null;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        methodName?: string;
+        method_name?: string;
+        state: unknown;
+        params?: Record<string, unknown> | null;
+    });
+}
+export declare class MethodExecutionFinishedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly methodName: string;
+    readonly method_name: string;
+    readonly result: unknown;
+    readonly state: unknown;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        methodName?: string;
+        method_name?: string;
+        result: unknown;
+        state: unknown;
+    });
+}
+export declare class MethodExecutionFailedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly methodName: string;
+    readonly method_name: string;
+    readonly error: string;
+    readonly state: unknown;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        methodName?: string;
+        method_name?: string;
+        error: unknown;
+        state: unknown;
+    });
+}
+export declare class MethodExecutionPausedEvent extends BaseEvent {
+    readonly flowName: string;
+    readonly flow_name: string;
+    readonly methodName: string;
+    readonly method_name: string;
+    readonly flowId: string | null;
+    readonly flow_id: string | null;
+    readonly pending: unknown;
+    readonly state: unknown;
+    readonly message: string | null;
+    readonly emit: readonly string[] | null;
+    constructor(options: {
+        flowName?: string;
+        flow_name?: string;
+        methodName?: string;
+        method_name?: string;
+        flowId?: string | null;
+        flow_id?: string | null;
+        pending?: unknown;
+        state: unknown;
+        message?: string | null;
+        emit?: readonly string[] | null;
+    });
+}
+export declare abstract class CheckpointBaseEvent extends BaseEvent {
+    readonly location: string;
+    readonly provider: string;
+    readonly trigger: string | null;
+    readonly branch: string | null;
+    readonly parent_id: string | null;
+    constructor(type: EventType, options: {
+        location: string;
+        provider: string;
+        trigger?: string | null;
+        branch?: string | null;
+        parent_id?: string | null;
+    });
+}
+export declare class CheckpointStartedEvent extends CheckpointBaseEvent {
+    constructor(options: {
+        location: string;
+        provider: string;
+        trigger?: string | null;
+        branch?: string | null;
+        parent_id?: string | null;
+    });
+}
+export declare class CheckpointCompletedEvent extends CheckpointBaseEvent {
+    readonly checkpoint_id: string;
+    readonly duration_ms: number;
+    constructor(options: {
+        location: string;
+        provider: string;
+        checkpoint_id: string;
+        duration_ms: number;
+        trigger?: string | null;
+        branch?: string | null;
+        parent_id?: string | null;
+    });
+}
+export declare class CheckpointFailedEvent extends CheckpointBaseEvent {
+    readonly error: string;
+    constructor(options: {
+        location: string;
+        provider: string;
+        error: unknown;
+        trigger?: string | null;
+        branch?: string | null;
+        parent_id?: string | null;
+    });
+}
+export declare class CheckpointPrunedEvent extends CheckpointBaseEvent {
+    readonly removed_count: number;
+    readonly max_checkpoints: number;
+    constructor(options: {
+        location: string;
+        provider: string;
+        removed_count: number;
+        max_checkpoints: number;
+        trigger?: string | null;
+        branch?: string | null;
+        parent_id?: string | null;
+    });
+}
+export declare abstract class CheckpointForkBaseEvent extends BaseEvent {
+    readonly branch: string;
+    readonly parent_branch: string | null;
+    readonly parent_checkpoint_id: string | null;
+    constructor(type: EventType, options: {
+        branch: string;
+        parent_branch?: string | null;
+        parent_checkpoint_id?: string | null;
+    });
+}
+export declare class CheckpointForkStartedEvent extends CheckpointForkBaseEvent {
+    constructor(options: {
+        branch: string;
+        parent_branch?: string | null;
+        parent_checkpoint_id?: string | null;
+    });
+}
+export declare class CheckpointForkCompletedEvent extends CheckpointForkBaseEvent {
+    constructor(options: {
+        branch: string;
+        parent_branch?: string | null;
+        parent_checkpoint_id?: string | null;
+    });
+}
+export declare abstract class CheckpointRestoreBaseEvent extends BaseEvent {
+    readonly location: string;
+    readonly provider: string | null;
+    constructor(type: EventType, options: {
+        location: string;
+        provider?: string | null;
+    });
+}
+export declare class CheckpointRestoreStartedEvent extends CheckpointRestoreBaseEvent {
+    constructor(options: {
+        location: string;
+        provider?: string | null;
+    });
+}
+export declare class CheckpointRestoreCompletedEvent extends CheckpointRestoreBaseEvent {
+    readonly checkpoint_id: string;
+    readonly branch: string | null;
+    readonly parent_id: string | null;
+    readonly duration_ms: number;
+    constructor(options: {
+        location: string;
+        checkpoint_id: string;
+        duration_ms: number;
+        provider?: string | null;
+        branch?: string | null;
+        parent_id?: string | null;
+    });
+}
+export declare class CheckpointRestoreFailedEvent extends CheckpointRestoreBaseEvent {
+    readonly error: string;
+    constructor(options: {
+        location: string;
+        error: unknown;
+        provider?: string | null;
+    });
+}
+export type ObservationCommonEventOptions = {
+    agent_role: string;
+    step_number: number;
+    step_description?: string;
+    from_task?: unknown;
+    from_agent?: unknown;
+};
+export declare abstract class ObservationEvent extends BaseEvent {
+    readonly agent_role: string;
+    readonly step_number: number;
+    readonly step_description: string;
+    readonly from_task: unknown;
+    readonly from_agent: unknown;
+    readonly task_id: string | null;
+    readonly task_name: string | null;
+    readonly agent_id: string | null;
+    constructor(type: EventType, options: ObservationCommonEventOptions);
+}
+export declare class StepObservationStartedEvent extends ObservationEvent {
+    constructor(options: ObservationCommonEventOptions);
+}
+export declare class StepObservationCompletedEvent extends ObservationEvent {
+    readonly step_completed_successfully: boolean;
+    readonly key_information_learned: string;
+    readonly remaining_plan_still_valid: boolean;
+    readonly needs_full_replan: boolean;
+    readonly replan_reason: string | null;
+    readonly goal_already_achieved: boolean;
+    readonly suggested_refinements: readonly string[] | null;
+    constructor(options: ObservationCommonEventOptions & {
+        step_completed_successfully?: boolean;
+        key_information_learned?: string;
+        remaining_plan_still_valid?: boolean;
+        needs_full_replan?: boolean;
+        replan_reason?: string | null;
+        goal_already_achieved?: boolean;
+        suggested_refinements?: readonly string[] | null;
+    });
+}
+export declare class StepObservationFailedEvent extends ObservationEvent {
+    readonly error: string;
+    constructor(options: ObservationCommonEventOptions & {
+        error?: unknown;
+    });
+}
+export declare class PlanRefinementEvent extends ObservationEvent {
+    readonly refined_step_count: number;
+    readonly refinements: readonly string[] | null;
+    constructor(options: ObservationCommonEventOptions & {
+        refined_step_count?: number;
+        refinements?: readonly string[] | null;
+    });
+}
+export declare class PlanReplanTriggeredEvent extends ObservationEvent {
+    readonly replan_reason: string;
+    readonly replan_count: number;
+    readonly completed_steps_preserved: number;
+    constructor(options: ObservationCommonEventOptions & {
+        replan_reason?: string;
+        replan_count?: number;
+        completed_steps_preserved?: number;
+    });
+}
+export declare class GoalAchievedEarlyEvent extends ObservationEvent {
+    readonly steps_remaining: number;
+    readonly steps_completed: number;
+    constructor(options: ObservationCommonEventOptions & {
+        steps_remaining?: number;
+        steps_completed?: number;
+    });
+}
+export declare const SignalType: {
+    readonly SIGTERM: 15;
+    readonly SIGINT: 2;
+    readonly SIGHUP: 1;
+    readonly SIGTSTP: 20;
+    readonly SIGCONT: 18;
+};
+export type SignalType = typeof SignalType[keyof typeof SignalType];
+export declare abstract class SignalEventBase extends BaseEvent {
+    readonly signal_number: SignalType;
+    readonly reason: string | null;
+    constructor(type: EventType, signalNumber: SignalType, reason?: string | null);
+    modelDump(): Record<string, unknown>;
+    model_dump(): Record<string, unknown>;
+}
+export declare class SigTermEvent extends SignalEventBase {
+    constructor(options?: {
+        reason?: string | null;
+    });
+}
+export declare class SigIntEvent extends SignalEventBase {
+    constructor(options?: {
+        reason?: string | null;
+    });
+}
+export declare class SigHupEvent extends SignalEventBase {
+    constructor(options?: {
+        reason?: string | null;
+    });
+}
+export declare class SigTStpEvent extends SignalEventBase {
+    constructor(options?: {
+        reason?: string | null;
+    });
+}
+export declare class SigContEvent extends SignalEventBase {
+    constructor(options?: {
+        reason?: string | null;
+    });
+}
+export type SignalEvent = SigTermEvent | SigIntEvent | SigHupEvent | SigTStpEvent | SigContEvent;
+export declare const SignalEvent: Readonly<{
+    kind: "SignalEvent";
+}>;
+export declare const SIGNAL_EVENT_TYPES: readonly [typeof SigTermEvent, typeof SigIntEvent, typeof SigHupEvent, typeof SigTStpEvent, typeof SigContEvent];
+declare function validateSignalEventPayload(data: unknown): SignalEvent;
+export declare const signal_event_adapter: Readonly<{
+    validatePython: typeof validateSignalEventPayload;
+    validate_python: typeof validateSignalEventPayload;
+}>;
+export declare function on_signal<THandler extends EventHandler<SignalEvent>>(handler: THandler): THandler;
+export declare class AgentLogsStartedEvent extends BaseEvent {
+    readonly agent_role: string;
+    readonly task_description: string | null;
+    readonly verbose: boolean;
+    constructor(options: {
+        agent_role: string;
+        task_description?: string | null;
+        verbose?: boolean;
+    });
+}
+export declare class AgentLogsExecutionEvent extends BaseEvent {
+    readonly agent_role: string;
+    readonly formatted_answer: unknown;
+    readonly verbose: boolean;
+    constructor(options: {
+        agent_role: string;
+        formatted_answer: unknown;
+        verbose?: boolean;
+    });
+}
+export type A2AEventMetadata = Record<string, unknown>;
+export type A2AAgentCardMetadata = Record<string, unknown>;
+export type A2ACommonEventOptions = {
+    fromTask?: unknown;
+    from_task?: unknown;
+    fromAgent?: unknown;
+    from_agent?: unknown;
+    sourceType?: string | null;
+    source_type?: string | null;
+    sourceFingerprint?: string | null;
+    source_fingerprint?: string | null;
+};
+export declare abstract class A2AEventBase extends BaseEvent {
+    readonly fromTask: unknown;
+    readonly from_task: unknown;
+    readonly fromAgent: unknown;
+    readonly from_agent: unknown;
+    readonly taskId: string | null;
+    readonly task_id: string | null;
+    readonly taskName: string | null;
+    readonly task_name: string | null;
+    readonly agentId: string | null;
+    readonly agent_id: string | null;
+    readonly agentRole: string | null;
+    readonly agent_role: string | null;
+    readonly fingerprintMetadata: A2AEventMetadata | null;
+    readonly fingerprint_metadata: A2AEventMetadata | null;
+    static extractTaskAndAgentMetadata<T extends Record<string, unknown>>(data: T): T & Record<string, unknown>;
+    static extract_task_and_agent_metadata(data: Record<string, unknown>): Record<string, unknown>;
+    constructor(type: EventType, options?: A2ACommonEventOptions);
+}
+export declare class A2ADelegationStartedEvent extends A2AEventBase {
+    readonly endpoint: string;
+    readonly task_description: string;
+    readonly agent_id: string;
+    readonly context_id: string | null;
+    readonly is_multiturn: boolean;
+    readonly turn_number: number;
+    readonly a2a_agent_name: string | null;
+    readonly agent_card: A2AAgentCardMetadata | null;
+    readonly protocol_version: string | null;
+    readonly provider: A2AEventMetadata | null;
+    readonly skill_id: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        task_description: string;
+        agent_id?: string;
+        context_id?: string | null;
+        is_multiturn?: boolean;
+        turn_number?: number;
+        a2a_agent_name?: string | null;
+        agent_card?: A2AAgentCardMetadata | null;
+        protocol_version?: string | null;
+        provider?: A2AEventMetadata | null;
+        skill_id?: string | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2ADelegationCompletedEvent extends A2AEventBase {
+    readonly status: string;
+    readonly result: string | null;
+    readonly error: string | null;
+    readonly context_id: string | null;
+    readonly is_multiturn: boolean;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly agent_card: A2AAgentCardMetadata | null;
+    readonly provider: A2AEventMetadata | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        status: string;
+        result?: string | null;
+        error?: string | null;
+        context_id?: string | null;
+        is_multiturn?: boolean;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        agent_card?: A2AAgentCardMetadata | null;
+        provider?: A2AEventMetadata | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AConversationStartedEvent extends A2AEventBase {
+    readonly agent_id: string;
+    readonly endpoint: string;
+    readonly context_id: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly agent_card: A2AAgentCardMetadata | null;
+    readonly protocol_version: string | null;
+    readonly provider: A2AEventMetadata | null;
+    readonly skill_id: string | null;
+    readonly reference_task_ids: readonly string[] | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        agent_id?: string;
+        endpoint: string;
+        context_id?: string | null;
+        a2a_agent_name?: string | null;
+        agent_card?: A2AAgentCardMetadata | null;
+        protocol_version?: string | null;
+        provider?: A2AEventMetadata | null;
+        skill_id?: string | null;
+        reference_task_ids?: readonly string[] | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AMessageSentEvent extends A2AEventBase {
+    readonly message: string;
+    readonly turn_number: number;
+    readonly context_id: string | null;
+    readonly message_id: string | null;
+    readonly is_multiturn: boolean;
+    readonly agent_role: string | null;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly skill_id: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        message: string;
+        turn_number: number;
+        context_id?: string | null;
+        message_id?: string | null;
+        is_multiturn?: boolean;
+        agent_role?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        skill_id?: string | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AResponseReceivedEvent extends A2AEventBase {
+    readonly response: string;
+    readonly turn_number: number;
+    readonly context_id: string | null;
+    readonly message_id: string | null;
+    readonly is_multiturn: boolean;
+    readonly status: string;
+    readonly final: boolean;
+    readonly agent_role: string | null;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        response: string;
+        turn_number: number;
+        status: string;
+        context_id?: string | null;
+        message_id?: string | null;
+        is_multiturn?: boolean;
+        final?: boolean;
+        agent_role?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AConversationCompletedEvent extends A2AEventBase {
+    readonly status: "completed" | "failed";
+    readonly final_result: string | null;
+    readonly error: string | null;
+    readonly context_id: string | null;
+    readonly total_turns: number;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly agent_card: A2AAgentCardMetadata | null;
+    readonly reference_task_ids: readonly string[] | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        status: "completed" | "failed";
+        total_turns: number;
+        final_result?: string | null;
+        error?: string | null;
+        context_id?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        agent_card?: A2AAgentCardMetadata | null;
+        reference_task_ids?: readonly string[] | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2APollingStartedEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string | null;
+    readonly polling_interval: number;
+    readonly endpoint: string;
+    readonly a2a_agent_name: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        context_id?: string | null;
+        polling_interval: number;
+        endpoint: string;
+        a2a_agent_name?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2APollingStatusEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string | null;
+    readonly state: string;
+    readonly elapsed_seconds: number;
+    readonly poll_count: number;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        state: string;
+        elapsed_seconds: number;
+        poll_count: number;
+        context_id?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2APushNotificationRegisteredEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string | null;
+    readonly callback_url: string;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        callback_url: string;
+        context_id?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2APushNotificationReceivedEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string | null;
+    readonly state: string;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        state: string;
+        context_id?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2APushNotificationSentEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string | null;
+    readonly callback_url: string;
+    readonly state: string;
+    readonly success: boolean;
+    readonly error: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        callback_url: string;
+        state: string;
+        context_id?: string | null;
+        success?: boolean;
+        error?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2APushNotificationTimeoutEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string | null;
+    readonly timeout_seconds: number;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        timeout_seconds: number;
+        context_id?: string | null;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AStreamingStartedEvent extends A2AEventBase {
+    readonly task_id: string | null;
+    readonly context_id: string | null;
+    readonly endpoint: string;
+    readonly a2a_agent_name: string | null;
+    readonly turn_number: number;
+    readonly is_multiturn: boolean;
+    readonly agent_role: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        task_id?: string | null;
+        context_id?: string | null;
+        a2a_agent_name?: string | null;
+        turn_number?: number;
+        is_multiturn?: boolean;
+        agent_role?: string | null;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AStreamingChunkEvent extends A2AEventBase {
+    readonly task_id: string | null;
+    readonly context_id: string | null;
+    readonly chunk: string;
+    readonly chunk_index: number;
+    readonly final: boolean;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly turn_number: number;
+    readonly is_multiturn: boolean;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        chunk: string;
+        chunk_index: number;
+        task_id?: string | null;
+        context_id?: string | null;
+        final?: boolean;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        turn_number?: number;
+        is_multiturn?: boolean;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AAgentCardFetchedEvent extends A2AEventBase {
+    readonly endpoint: string;
+    readonly a2a_agent_name: string | null;
+    readonly agent_card: A2AAgentCardMetadata | null;
+    readonly protocol_version: string | null;
+    readonly provider: A2AEventMetadata | null;
+    readonly cached: boolean;
+    readonly fetch_time_ms: number | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        a2a_agent_name?: string | null;
+        agent_card?: A2AAgentCardMetadata | null;
+        protocol_version?: string | null;
+        provider?: A2AEventMetadata | null;
+        cached?: boolean;
+        fetch_time_ms?: number | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AAuthenticationFailedEvent extends A2AEventBase {
+    readonly endpoint: string;
+    readonly auth_type: string | null;
+    readonly error: string;
+    readonly status_code: number | null;
+    readonly a2a_agent_name: string | null;
+    readonly protocol_version: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        error: unknown;
+        auth_type?: string | null;
+        status_code?: number | null;
+        a2a_agent_name?: string | null;
+        protocol_version?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AArtifactReceivedEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly artifact_id: string;
+    readonly artifact_name: string | null;
+    readonly artifact_description: string | null;
+    readonly mime_type: string | null;
+    readonly size_bytes: number | null;
+    readonly append: boolean;
+    readonly last_chunk: boolean;
+    readonly endpoint: string | null;
+    readonly a2a_agent_name: string | null;
+    readonly context_id: string | null;
+    readonly turn_number: number;
+    readonly is_multiturn: boolean;
+    readonly metadata: A2AEventMetadata | null;
+    readonly extensions: readonly string[] | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        artifact_id: string;
+        artifact_name?: string | null;
+        artifact_description?: string | null;
+        mime_type?: string | null;
+        size_bytes?: number | null;
+        append?: boolean;
+        last_chunk?: boolean;
+        endpoint?: string | null;
+        a2a_agent_name?: string | null;
+        context_id?: string | null;
+        turn_number?: number;
+        is_multiturn?: boolean;
+        metadata?: A2AEventMetadata | null;
+        extensions?: readonly string[] | null;
+    });
+}
+export declare class A2AConnectionErrorEvent extends A2AEventBase {
+    readonly endpoint: string;
+    readonly error: string;
+    readonly error_type: string | null;
+    readonly status_code: number | null;
+    readonly a2a_agent_name: string | null;
+    readonly operation: string | null;
+    readonly context_id: string | null;
+    readonly task_id: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        error: unknown;
+        error_type?: string | null;
+        status_code?: number | null;
+        a2a_agent_name?: string | null;
+        operation?: string | null;
+        context_id?: string | null;
+        task_id?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AServerTaskStartedEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        context_id: string;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AServerTaskCompletedEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string;
+    readonly result: string;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        context_id: string;
+        result: string;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AServerTaskCanceledEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        context_id: string;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AServerTaskFailedEvent extends A2AEventBase {
+    readonly task_id: string;
+    readonly context_id: string;
+    readonly error: string;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        task_id?: string;
+        context_id: string;
+        error: unknown;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AParallelDelegationStartedEvent extends A2AEventBase {
+    readonly endpoints: readonly string[];
+    readonly task_description: string;
+    constructor(options: A2ACommonEventOptions & {
+        endpoints: readonly string[];
+        task_description: string;
+    });
+}
+export declare class A2AParallelDelegationCompletedEvent extends A2AEventBase {
+    readonly endpoints: readonly string[];
+    readonly success_count: number;
+    readonly failure_count: number;
+    readonly results: Record<string, string> | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoints: readonly string[];
+        success_count: number;
+        failure_count: number;
+        results?: Record<string, string> | null;
+    });
+}
+export declare class A2ATransportNegotiatedEvent extends A2AEventBase {
+    readonly endpoint: string;
+    readonly a2a_agent_name: string | null;
+    readonly negotiated_transport: string;
+    readonly negotiated_url: string;
+    readonly source: string;
+    readonly client_supported_transports: readonly string[];
+    readonly server_supported_transports: readonly string[];
+    readonly server_preferred_transport: string;
+    readonly client_preferred_transport: string | null;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        negotiated_transport: string;
+        negotiated_url: string;
+        source: string;
+        client_supported_transports: readonly string[];
+        server_supported_transports: readonly string[];
+        server_preferred_transport: string;
+        a2a_agent_name?: string | null;
+        client_preferred_transport?: string | null;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AContentTypeNegotiatedEvent extends A2AEventBase {
+    readonly endpoint: string;
+    readonly a2a_agent_name: string | null;
+    readonly skill_name: string | null;
+    readonly client_input_modes: readonly string[];
+    readonly client_output_modes: readonly string[];
+    readonly server_input_modes: readonly string[];
+    readonly server_output_modes: readonly string[];
+    readonly negotiated_input_modes: readonly string[];
+    readonly negotiated_output_modes: readonly string[];
+    readonly negotiation_success: boolean;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        endpoint: string;
+        client_input_modes: readonly string[];
+        client_output_modes: readonly string[];
+        server_input_modes: readonly string[];
+        server_output_modes: readonly string[];
+        negotiated_input_modes: readonly string[];
+        negotiated_output_modes: readonly string[];
+        a2a_agent_name?: string | null;
+        skill_name?: string | null;
+        negotiation_success?: boolean;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AContextCreatedEvent extends A2AEventBase {
+    readonly context_id: string;
+    readonly created_at: number;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        context_id: string;
+        created_at: number;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AContextExpiredEvent extends A2AEventBase {
+    readonly context_id: string;
+    readonly created_at: number;
+    readonly age_seconds: number;
+    readonly task_count: number;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        context_id: string;
+        created_at: number;
+        age_seconds: number;
+        task_count: number;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AContextIdleEvent extends A2AEventBase {
+    readonly context_id: string;
+    readonly idle_seconds: number;
+    readonly task_count: number;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        context_id: string;
+        idle_seconds: number;
+        task_count: number;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AContextCompletedEvent extends A2AEventBase {
+    readonly context_id: string;
+    readonly total_tasks: number;
+    readonly duration_seconds: number;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        context_id: string;
+        total_tasks: number;
+        duration_seconds: number;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export declare class A2AContextPrunedEvent extends A2AEventBase {
+    readonly context_id: string;
+    readonly task_count: number;
+    readonly age_seconds: number;
+    readonly metadata: A2AEventMetadata | null;
+    constructor(options: A2ACommonEventOptions & {
+        context_id: string;
+        task_count: number;
+        age_seconds: number;
+        metadata?: A2AEventMetadata | null;
+    });
+}
+export type MCPCommonEventOptions = {
+    server_name: string;
+    server_url?: string | null;
+    transport_type?: string | null;
+    agent_id?: string | null;
+    agent_role?: string | null;
+    from_agent?: unknown;
+    from_task?: unknown;
+};
+export declare abstract class MCPEvent extends BaseEvent {
+    readonly server_name: string;
+    readonly server_url: string | null;
+    readonly transport_type: string | null;
+    readonly agent_id: string | null;
+    readonly agent_role: string | null;
+    readonly from_agent: unknown;
+    readonly from_task: unknown;
+    constructor(type: EventType, options: MCPCommonEventOptions);
+}
+export declare class MCPConnectionStartedEvent extends MCPEvent {
+    readonly connect_timeout: number | null;
+    readonly is_reconnect: boolean;
+    constructor(options: MCPCommonEventOptions & {
+        connect_timeout?: number | null;
+        is_reconnect?: boolean;
+    });
+}
+export declare class MCPConnectionCompletedEvent extends MCPEvent {
+    readonly started_at: Date | null;
+    readonly completed_at: Date | null;
+    readonly connection_duration_ms: number | null;
+    readonly is_reconnect: boolean;
+    constructor(options: MCPCommonEventOptions & {
+        started_at?: Date | null;
+        completed_at?: Date | null;
+        connection_duration_ms?: number | null;
+        is_reconnect?: boolean;
+    });
+}
+export declare class MCPConnectionFailedEvent extends MCPEvent {
+    readonly error: string;
+    readonly error_type: string | null;
+    readonly started_at: Date | null;
+    readonly failed_at: Date | null;
+    constructor(options: MCPCommonEventOptions & {
+        error: unknown;
+        error_type?: string | null;
+        started_at?: Date | null;
+        failed_at?: Date | null;
+    });
+}
+export declare class MCPToolExecutionStartedEvent extends MCPEvent {
+    readonly tool_name: string;
+    readonly tool_args: Record<string, unknown> | null;
+    constructor(options: MCPCommonEventOptions & {
+        tool_name: string;
+        tool_args?: Record<string, unknown> | null;
+    });
+}
+export declare class MCPToolExecutionCompletedEvent extends MCPEvent {
+    readonly tool_name: string;
+    readonly tool_args: Record<string, unknown> | null;
+    readonly result: unknown;
+    readonly started_at: Date | null;
+    readonly completed_at: Date | null;
+    readonly execution_duration_ms: number | null;
+    constructor(options: MCPCommonEventOptions & {
+        tool_name: string;
+        tool_args?: Record<string, unknown> | null;
+        result?: unknown;
+        started_at?: Date | null;
+        completed_at?: Date | null;
+        execution_duration_ms?: number | null;
+    });
+}
+export declare class MCPToolExecutionFailedEvent extends MCPEvent {
+    readonly tool_name: string;
+    readonly tool_args: Record<string, unknown> | null;
+    readonly error: string;
+    readonly error_type: string | null;
+    readonly started_at: Date | null;
+    readonly failed_at: Date | null;
+    constructor(options: MCPCommonEventOptions & {
+        tool_name: string;
+        tool_args?: Record<string, unknown> | null;
+        error: unknown;
+        error_type?: string | null;
+        started_at?: Date | null;
+        failed_at?: Date | null;
+    });
+}
+export declare class MCPConfigFetchFailedEvent extends BaseEvent {
+    readonly slug: string;
+    readonly error: string;
+    readonly error_type: string | null;
+    constructor(options: {
+        slug: string;
+        error: unknown;
+        error_type?: string | null;
+    });
+}
+export type SkillCommonEventOptions = {
+    skill_name?: string;
+    skill_path?: string | null;
+    from_agent?: unknown;
+    from_task?: unknown;
+};
+export declare abstract class SkillEvent extends BaseEvent {
+    readonly skill_name: string;
+    readonly skill_path: string | null;
+    readonly from_agent: unknown;
+    readonly from_task: unknown;
+    constructor(type: EventType, options?: SkillCommonEventOptions);
+}
+export declare class SkillDiscoveryStartedEvent extends SkillEvent {
+    readonly search_path: string;
+    constructor(options: SkillCommonEventOptions & {
+        search_path: string;
+    });
+}
+export declare class SkillDiscoveryCompletedEvent extends SkillEvent {
+    readonly search_path: string;
+    readonly skills_found: number;
+    readonly skill_names: readonly string[];
+    constructor(options: SkillCommonEventOptions & {
+        search_path: string;
+        skills_found: number;
+        skill_names: readonly string[];
+    });
+}
+export declare class SkillLoadedEvent extends SkillEvent {
+    readonly disclosure_level: number;
+    constructor(options?: SkillCommonEventOptions & {
+        disclosure_level?: number;
+    });
+}
+export declare class SkillActivatedEvent extends SkillEvent {
+    readonly disclosure_level: number;
+    constructor(options?: SkillCommonEventOptions & {
+        disclosure_level?: number;
+    });
+}
+export declare class SkillLoadFailedEvent extends SkillEvent {
+    readonly error: string;
+    constructor(options: SkillCommonEventOptions & {
+        error: unknown;
+    });
+}
+export declare class SkillDownloadStartedEvent extends SkillEvent {
+    readonly registry_ref: string;
+    readonly version: string | null;
+    constructor(options: SkillCommonEventOptions & {
+        registry_ref: string;
+        version?: string | null;
+    });
+}
+export declare class SkillDownloadCompletedEvent extends SkillEvent {
+    readonly registry_ref: string;
+    readonly version: string | null;
+    readonly cache_path: string | null;
+    constructor(options: SkillCommonEventOptions & {
+        registry_ref: string;
+        version?: string | null;
+        cache_path?: string | null;
+    });
+}
+export declare const LLMCallType: {
+    readonly TOOL_CALL: "tool_call";
+    readonly LLM_CALL: "llm_call";
+};
+export type LLMCallType = typeof LLMCallType[keyof typeof LLMCallType];
+export type LLMEventMessage = string | readonly Record<string, unknown>[];
+export type LLMFunctionCall = {
+    arguments: string;
+    name?: string | null;
+};
+export declare class ToolCall {
+    readonly id: string | null;
+    readonly function: LLMFunctionCall;
+    readonly type: string | null;
+    readonly index: number;
+    constructor(options: LLMToolCall);
+}
+export type LLMToolCall = {
+    id?: string | null;
+    function: LLMFunctionCall;
+    type?: string | null;
+    index: number;
+};
+export type LLMCommonEventOptions = {
+    from_task?: unknown;
+    from_agent?: unknown;
+    model?: string | null;
+    call_id: string;
+};
+export declare abstract class LLMEventBase extends BaseEvent {
+    readonly from_task: unknown;
+    readonly from_agent: unknown;
+    readonly model: string | null;
+    readonly call_id: string;
+    readonly task_id: string | null;
+    readonly task_name: string | null;
+    readonly agent_id: string | null;
+    readonly agent_role: string | null;
+    constructor(type: EventType, options: LLMCommonEventOptions);
+}
+export declare class LLMCallStartedEvent extends LLMEventBase {
+    readonly messages: LLMEventMessage | null;
+    readonly tools: readonly Record<string, unknown>[] | null;
+    readonly callbacks: readonly unknown[] | null;
+    readonly available_functions: Record<string, unknown> | null;
+    constructor(options: LLMCommonEventOptions & {
+        messages?: LLMEventMessage | null;
+        tools?: readonly Record<string, unknown>[] | null;
+        callbacks?: readonly unknown[] | null;
+        available_functions?: Record<string, unknown> | null;
+    });
+}
+export declare class LLMCallCompletedEvent extends LLMEventBase {
+    readonly messages: LLMEventMessage | null;
+    readonly response: unknown;
+    readonly call_type: LLMCallType;
+    readonly usage: Record<string, unknown> | null;
+    constructor(options: LLMCommonEventOptions & {
+        response: unknown;
+        call_type: LLMCallType;
+        messages?: LLMEventMessage | null;
+        usage?: Record<string, unknown> | null;
+    });
+}
+export declare class LLMCallFailedEvent extends LLMEventBase {
+    readonly error: string;
+    constructor(options: LLMCommonEventOptions & {
+        error: unknown;
+    });
+}
+export declare class LLMStreamChunkEvent extends LLMEventBase {
+    readonly chunk: string;
+    readonly tool_call: LLMToolCall | null;
+    readonly call_type: LLMCallType | null;
+    readonly response_id: string | null;
+    constructor(options: LLMCommonEventOptions & {
+        chunk: string;
+        tool_call?: LLMToolCall | null;
+        call_type?: LLMCallType | null;
+        response_id?: string | null;
+    });
+}
+export declare class LLMThinkingChunkEvent extends LLMEventBase {
+    readonly chunk: string;
+    readonly response_id: string | null;
+    constructor(options: LLMCommonEventOptions & {
+        chunk: string;
+        response_id?: string | null;
+    });
+}
+export type LLMGuardrailCommonEventOptions = {
+    task_id?: string | null;
+    task_name?: string | null;
+    from_task?: unknown;
+    from_agent?: unknown;
+    agent_role?: string | null;
+    agent_id?: string | null;
+    guardrail_type?: string | null;
+    guardrail_name?: string | null;
+};
+export declare abstract class LLMGuardrailBaseEvent extends BaseEvent {
+    readonly task_id: string | null;
+    readonly task_name: string | null;
+    readonly from_task: unknown;
+    readonly from_agent: unknown;
+    readonly agent_role: string | null;
+    readonly agent_id: string | null;
+    guardrail_type: string | null;
+    guardrail_name: string | null;
+    constructor(type: EventType, options?: LLMGuardrailCommonEventOptions);
+}
+type LLMGuardrailCallable = (...args: never[]) => unknown;
+export declare class LLMGuardrailStartedEvent extends LLMGuardrailBaseEvent {
+    guardrail: string | LLMGuardrailCallable;
+    readonly retry_count: number;
+    constructor(options: LLMGuardrailCommonEventOptions & {
+        guardrail: string | LLMGuardrailCallable;
+        retry_count: number;
+    });
+}
+export declare class LLMGuardrailCompletedEvent extends LLMGuardrailBaseEvent {
+    readonly success: boolean;
+    readonly result: unknown;
+    readonly error: string | null;
+    readonly retry_count: number;
+    constructor(options: LLMGuardrailCommonEventOptions & {
+        success: boolean;
+        result: unknown;
+        error?: unknown;
+        retry_count: number;
+    });
+}
+export type KnowledgeCommonEventOptions = {
+    task_id?: string | null;
+    task_name?: string | null;
+    from_task?: unknown;
+    from_agent?: unknown;
+    agent_role?: string | null;
+    agent_id?: string | null;
+};
+export declare abstract class KnowledgeEventBase extends BaseEvent {
+    readonly task_id: string | null;
+    readonly task_name: string | null;
+    readonly from_task: unknown;
+    readonly from_agent: unknown;
+    readonly agent_role: string | null;
+    readonly agent_id: string | null;
+    constructor(type: EventType, options?: KnowledgeCommonEventOptions);
+}
+export declare class KnowledgeRetrievalStartedEvent extends KnowledgeEventBase {
+    constructor(options?: KnowledgeCommonEventOptions);
+}
+export declare class KnowledgeRetrievalCompletedEvent extends KnowledgeEventBase {
+    readonly query: string;
+    readonly retrieved_knowledge: string;
+    constructor(options: KnowledgeCommonEventOptions & {
+        query: string;
+        retrieved_knowledge: string;
+    });
+}
+export declare class KnowledgeQueryStartedEvent extends KnowledgeEventBase {
+    readonly task_prompt: string;
+    constructor(options: KnowledgeCommonEventOptions & {
+        task_prompt: string;
+    });
+}
+export declare class KnowledgeQueryFailedEvent extends KnowledgeEventBase {
+    readonly error: string;
+    constructor(options: KnowledgeCommonEventOptions & {
+        error: unknown;
+    });
+}
+export declare class KnowledgeQueryCompletedEvent extends KnowledgeEventBase {
+    readonly query: string;
+    constructor(options: KnowledgeCommonEventOptions & {
+        query: string;
+    });
+}
+export declare class KnowledgeSearchQueryFailedEvent extends KnowledgeEventBase {
+    readonly query: string;
+    readonly error: string;
+    constructor(options: KnowledgeCommonEventOptions & {
+        query: string;
+        error: unknown;
+    });
+}
+export declare class CCEnvEvent extends BaseEvent {
+    constructor();
+}
+export declare class CodexEnvEvent extends BaseEvent {
+    constructor();
+}
+export declare class CursorEnvEvent extends BaseEvent {
+    constructor();
+}
+export declare class DefaultEnvEvent extends BaseEvent {
+    constructor();
+}
+export type EnvContextEvent = CCEnvEvent | CodexEnvEvent | CursorEnvEvent | DefaultEnvEvent;
+export declare const EnvContextEvent: Readonly<{
+    kind: "EnvContextEvent";
+}>;
+export declare const ENV_CONTEXT_EVENT_TYPES: readonly [typeof CCEnvEvent, typeof CodexEnvEvent, typeof CursorEnvEvent, typeof DefaultEnvEvent];
+declare function validateEnvContextEventPayload(data: unknown): EnvContextEvent;
+export declare const env_context_event_adapter: Readonly<{
+    validatePython: typeof validateEnvContextEventPayload;
+    validate_python: typeof validateEnvContextEventPayload;
+}>;
+export type CrewAIEvent = CCEnvEvent | CodexEnvEvent | CursorEnvEvent | DefaultEnvEvent | CrewKickoffStartedEvent | CrewKickoffCompletedEvent | CrewKickoffFailedEvent | CrewTrainStartedEvent | CrewTrainCompletedEvent | CrewTrainFailedEvent | CrewTestStartedEvent | CrewTestCompletedEvent | CrewTestFailedEvent | TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | TaskEvaluationEvent | CrewTestResultEvent | AgentExecutionStartedEvent | AgentExecutionCompletedEvent | AgentExecutionErrorEvent | AgentEvaluationStartedEvent | AgentEvaluationCompletedEvent | AgentEvaluationFailedEvent | AgentReasoningStartedEvent | AgentReasoningCompletedEvent | AgentReasoningFailedEvent | A2ADelegationStartedEvent | A2ADelegationCompletedEvent | A2AConversationStartedEvent | A2AMessageSentEvent | A2AResponseReceivedEvent | A2AConversationCompletedEvent | A2APollingStartedEvent | A2APollingStatusEvent | A2APushNotificationRegisteredEvent | A2APushNotificationReceivedEvent | A2APushNotificationSentEvent | A2APushNotificationTimeoutEvent | A2AStreamingStartedEvent | A2AStreamingChunkEvent | A2AAgentCardFetchedEvent | A2AAuthenticationFailedEvent | A2AArtifactReceivedEvent | A2AConnectionErrorEvent | A2AServerTaskStartedEvent | A2AServerTaskCompletedEvent | A2AServerTaskCanceledEvent | A2AServerTaskFailedEvent | A2AParallelDelegationStartedEvent | A2AParallelDelegationCompletedEvent | A2ATransportNegotiatedEvent | A2AContentTypeNegotiatedEvent | A2AContextCreatedEvent | A2AContextExpiredEvent | A2AContextIdleEvent | A2AContextCompletedEvent | A2AContextPrunedEvent | MCPConnectionStartedEvent | MCPConnectionCompletedEvent | MCPConnectionFailedEvent | MCPToolExecutionStartedEvent | MCPToolExecutionCompletedEvent | MCPToolExecutionFailedEvent | MCPConfigFetchFailedEvent | SkillDiscoveryStartedEvent | SkillDiscoveryCompletedEvent | SkillLoadedEvent | SkillActivatedEvent | SkillLoadFailedEvent | SkillDownloadStartedEvent | SkillDownloadCompletedEvent | LLMCallStartedEvent | LLMCallCompletedEvent | LLMCallFailedEvent | LLMStreamChunkEvent | LLMThinkingChunkEvent | LLMGuardrailStartedEvent | LLMGuardrailCompletedEvent | KnowledgeRetrievalStartedEvent | KnowledgeRetrievalCompletedEvent | KnowledgeQueryStartedEvent | KnowledgeQueryFailedEvent | KnowledgeQueryCompletedEvent | KnowledgeSearchQueryFailedEvent | HumanFeedbackRequestedEvent | HumanFeedbackReceivedEvent | ToolUsageStartedEvent | ToolUsageFinishedEvent | ToolUsageErrorEvent | ToolValidateInputErrorEvent | ToolSelectionErrorEvent | ToolExecutionErrorEvent | LiteAgentExecutionStartedEvent | LiteAgentExecutionCompletedEvent | LiteAgentExecutionErrorEvent | MemorySaveStartedEvent | MemorySaveCompletedEvent | MemorySaveFailedEvent | MemoryQueryStartedEvent | MemoryQueryCompletedEvent | MemoryQueryFailedEvent | MemoryRetrievalStartedEvent | MemoryRetrievalCompletedEvent | MemoryRetrievalFailedEvent | FlowStartedEvent | FlowCreatedEvent | FlowFinishedEvent | FlowFailedEvent | FlowPausedEvent | FlowPlotEvent | FlowInputRequestedEvent | FlowInputReceivedEvent | MethodExecutionStartedEvent | MethodExecutionFinishedEvent | MethodExecutionFailedEvent | MethodExecutionPausedEvent | CheckpointStartedEvent | CheckpointCompletedEvent | CheckpointFailedEvent | CheckpointPrunedEvent | CheckpointForkStartedEvent | CheckpointForkCompletedEvent | CheckpointRestoreStartedEvent | CheckpointRestoreCompletedEvent | CheckpointRestoreFailedEvent | StepObservationStartedEvent | StepObservationCompletedEvent | StepObservationFailedEvent | PlanRefinementEvent | PlanReplanTriggeredEvent | GoalAchievedEarlyEvent | SignalEvent | AgentLogsStartedEvent | AgentLogsExecutionEvent;
+export type EventMap = {
+    crew_kickoff_started: CrewKickoffStartedEvent;
+    crew_kickoff_completed: CrewKickoffCompletedEvent;
+    crew_kickoff_failed: CrewKickoffFailedEvent;
+    crew_train_started: CrewTrainStartedEvent;
+    crew_train_completed: CrewTrainCompletedEvent;
+    crew_train_failed: CrewTrainFailedEvent;
+    crew_test_started: CrewTestStartedEvent;
+    crew_test_completed: CrewTestCompletedEvent;
+    crew_test_failed: CrewTestFailedEvent;
+    task_started: TaskStartedEvent;
+    task_completed: TaskCompletedEvent;
+    task_failed: TaskFailedEvent;
+    task_evaluation: TaskEvaluationEvent;
+    crew_test_result: CrewTestResultEvent;
+    agent_execution_started: AgentExecutionStartedEvent;
+    agent_execution_completed: AgentExecutionCompletedEvent;
+    agent_execution_error: AgentExecutionErrorEvent;
+    agent_evaluation_started: AgentEvaluationStartedEvent;
+    agent_evaluation_completed: AgentEvaluationCompletedEvent;
+    agent_evaluation_failed: AgentEvaluationFailedEvent;
+    agent_reasoning_started: AgentReasoningStartedEvent;
+    agent_reasoning_completed: AgentReasoningCompletedEvent;
+    agent_reasoning_failed: AgentReasoningFailedEvent;
+    a2a_delegation_started: A2ADelegationStartedEvent;
+    a2a_delegation_completed: A2ADelegationCompletedEvent;
+    a2a_conversation_started: A2AConversationStartedEvent;
+    a2a_message_sent: A2AMessageSentEvent;
+    a2a_response_received: A2AResponseReceivedEvent;
+    a2a_conversation_completed: A2AConversationCompletedEvent;
+    a2a_polling_started: A2APollingStartedEvent;
+    a2a_polling_status: A2APollingStatusEvent;
+    a2a_push_notification_registered: A2APushNotificationRegisteredEvent;
+    a2a_push_notification_received: A2APushNotificationReceivedEvent;
+    a2a_push_notification_sent: A2APushNotificationSentEvent;
+    a2a_push_notification_timeout: A2APushNotificationTimeoutEvent;
+    a2a_streaming_started: A2AStreamingStartedEvent;
+    a2a_streaming_chunk: A2AStreamingChunkEvent;
+    a2a_agent_card_fetched: A2AAgentCardFetchedEvent;
+    a2a_authentication_failed: A2AAuthenticationFailedEvent;
+    a2a_artifact_received: A2AArtifactReceivedEvent;
+    a2a_connection_error: A2AConnectionErrorEvent;
+    a2a_server_task_started: A2AServerTaskStartedEvent;
+    a2a_server_task_completed: A2AServerTaskCompletedEvent;
+    a2a_server_task_canceled: A2AServerTaskCanceledEvent;
+    a2a_server_task_failed: A2AServerTaskFailedEvent;
+    a2a_parallel_delegation_started: A2AParallelDelegationStartedEvent;
+    a2a_parallel_delegation_completed: A2AParallelDelegationCompletedEvent;
+    a2a_transport_negotiated: A2ATransportNegotiatedEvent;
+    a2a_content_type_negotiated: A2AContentTypeNegotiatedEvent;
+    a2a_context_created: A2AContextCreatedEvent;
+    a2a_context_expired: A2AContextExpiredEvent;
+    a2a_context_idle: A2AContextIdleEvent;
+    a2a_context_completed: A2AContextCompletedEvent;
+    a2a_context_pruned: A2AContextPrunedEvent;
+    mcp_connection_started: MCPConnectionStartedEvent;
+    mcp_connection_completed: MCPConnectionCompletedEvent;
+    mcp_connection_failed: MCPConnectionFailedEvent;
+    mcp_tool_execution_started: MCPToolExecutionStartedEvent;
+    mcp_tool_execution_completed: MCPToolExecutionCompletedEvent;
+    mcp_tool_execution_failed: MCPToolExecutionFailedEvent;
+    mcp_config_fetch_failed: MCPConfigFetchFailedEvent;
+    skill_discovery_started: SkillDiscoveryStartedEvent;
+    skill_discovery_completed: SkillDiscoveryCompletedEvent;
+    skill_loaded: SkillLoadedEvent;
+    skill_activated: SkillActivatedEvent;
+    skill_load_failed: SkillLoadFailedEvent;
+    skill_download_started: SkillDownloadStartedEvent;
+    skill_download_completed: SkillDownloadCompletedEvent;
+    llm_call_started: LLMCallStartedEvent;
+    llm_call_completed: LLMCallCompletedEvent;
+    llm_call_failed: LLMCallFailedEvent;
+    llm_stream_chunk: LLMStreamChunkEvent;
+    llm_thinking_chunk: LLMThinkingChunkEvent;
+    llm_guardrail_started: LLMGuardrailStartedEvent;
+    llm_guardrail_completed: LLMGuardrailCompletedEvent;
+    knowledge_search_query_started: KnowledgeRetrievalStartedEvent;
+    knowledge_search_query_completed: KnowledgeRetrievalCompletedEvent;
+    knowledge_query_started: KnowledgeQueryStartedEvent;
+    knowledge_query_failed: KnowledgeQueryFailedEvent;
+    knowledge_query_completed: KnowledgeQueryCompletedEvent;
+    knowledge_search_query_failed: KnowledgeSearchQueryFailedEvent;
+    human_feedback_requested: HumanFeedbackRequestedEvent;
+    human_feedback_received: HumanFeedbackReceivedEvent;
+    tool_usage_started: ToolUsageStartedEvent;
+    tool_usage_finished: ToolUsageFinishedEvent;
+    tool_usage_error: ToolUsageErrorEvent;
+    tool_validate_input_error: ToolValidateInputErrorEvent;
+    tool_selection_error: ToolSelectionErrorEvent;
+    tool_execution_error: ToolExecutionErrorEvent;
+    lite_agent_execution_started: LiteAgentExecutionStartedEvent;
+    lite_agent_execution_completed: LiteAgentExecutionCompletedEvent;
+    lite_agent_execution_error: LiteAgentExecutionErrorEvent;
+    memory_save_started: MemorySaveStartedEvent;
+    memory_save_completed: MemorySaveCompletedEvent;
+    memory_save_failed: MemorySaveFailedEvent;
+    memory_query_started: MemoryQueryStartedEvent;
+    memory_query_completed: MemoryQueryCompletedEvent;
+    memory_query_failed: MemoryQueryFailedEvent;
+    memory_retrieval_started: MemoryRetrievalStartedEvent;
+    memory_retrieval_completed: MemoryRetrievalCompletedEvent;
+    memory_retrieval_failed: MemoryRetrievalFailedEvent;
+    flow_started: FlowStartedEvent;
+    flow_created: FlowCreatedEvent;
+    flow_finished: FlowFinishedEvent;
+    flow_failed: FlowFailedEvent;
+    flow_paused: FlowPausedEvent;
+    flow_plot: FlowPlotEvent;
+    flow_input_requested: FlowInputRequestedEvent;
+    flow_input_received: FlowInputReceivedEvent;
+    method_execution_started: MethodExecutionStartedEvent;
+    method_execution_finished: MethodExecutionFinishedEvent;
+    method_execution_failed: MethodExecutionFailedEvent;
+    method_execution_paused: MethodExecutionPausedEvent;
+    checkpoint_started: CheckpointStartedEvent;
+    checkpoint_completed: CheckpointCompletedEvent;
+    checkpoint_failed: CheckpointFailedEvent;
+    checkpoint_pruned: CheckpointPrunedEvent;
+    checkpoint_fork_started: CheckpointForkStartedEvent;
+    checkpoint_fork_completed: CheckpointForkCompletedEvent;
+    checkpoint_restore_started: CheckpointRestoreStartedEvent;
+    checkpoint_restore_completed: CheckpointRestoreCompletedEvent;
+    checkpoint_restore_failed: CheckpointRestoreFailedEvent;
+    step_observation_started: StepObservationStartedEvent;
+    step_observation_completed: StepObservationCompletedEvent;
+    step_observation_failed: StepObservationFailedEvent;
+    plan_refinement: PlanRefinementEvent;
+    plan_replan_triggered: PlanReplanTriggeredEvent;
+    goal_achieved_early: GoalAchievedEarlyEvent;
+    SIGTERM: SigTermEvent;
+    SIGINT: SigIntEvent;
+    SIGHUP: SigHupEvent;
+    SIGTSTP: SigTStpEvent;
+    SIGCONT: SigContEvent;
+    agent_logs_started: AgentLogsStartedEvent;
+    agent_logs_execution: AgentLogsExecutionEvent;
+    cc_env: CCEnvEvent;
+    codex_env: CodexEnvEvent;
+    cursor_env: CursorEnvEvent;
+    default_env: DefaultEnvEvent;
+};
+export type EventHandler<TEvent extends CrewAIEvent = CrewAIEvent> = (source: unknown, event: TEvent, runtimeState?: RuntimeState | null) => void | Promise<void>;
+export declare const EventHandler: Readonly<{
+    kind: "EventHandler";
+}>;
+export type ConsoleStreamingLive = {
+    start: () => void;
+    stop: () => void;
+    readonly active?: boolean;
+};
+export type SyncHandler = (source: unknown, event: BaseEvent, context?: unknown) => void;
+export type AsyncHandler = (source: unknown, event: BaseEvent, context?: unknown) => Promise<void>;
+export type SyncHandlerSet = ReadonlySet<SyncHandler>;
+export type AsyncHandlerSet = ReadonlySet<AsyncHandler>;
+export type Handler = (source: unknown, event: BaseEvent, context?: unknown) => unknown;
+export type ExecutionPlan = Array<Set<Handler>>;
+export type EventT_co = BaseEvent;
+export declare const SyncHandler: Readonly<{
+    kind: "SyncHandler";
+}>;
+export declare const AsyncHandler: Readonly<{
+    kind: "AsyncHandler";
+}>;
+export declare const SyncHandlerSet: Readonly<{
+    kind: "SyncHandlerSet";
+}>;
+export declare const AsyncHandlerSet: Readonly<{
+    kind: "AsyncHandlerSet";
+}>;
+export declare const Handler: Readonly<{
+    kind: "Handler";
+}>;
+export declare const ExecutionPlan: Readonly<{
+    kind: "ExecutionPlan";
+}>;
+export declare const EventT_co: Readonly<{
+    kind: "EventT_co";
+}>;
+export declare const EventTypes: Readonly<{
+    kind: "EventTypes";
+}>;
+export declare function _get_or_create_counter(): IterableIterator<number>;
+export declare function get_next_emission_sequence(): number;
+export declare function is_replaying(): boolean;
+export declare class Depends<THandler extends EventHandler = EventHandler> {
+    readonly handler: THandler;
+    constructor(handler: THandler);
+    __repr__(): string;
+    __eq__(other: unknown): boolean;
+    __hash__(): number;
+    toString(): string;
+}
+export declare class CircularDependencyError extends Error {
+    readonly handlers: readonly EventHandler[];
+    constructor(handlers?: readonly EventHandler[]);
+}
+export declare function is_async_handler(handler: unknown): handler is AsyncHandler;
+export declare function is_call_handler_safe(handler: SyncHandler, source: unknown, event: BaseEvent, state?: unknown): Error | null;
+export declare class HandlerGraph {
+    readonly handlers: Map<Handler, readonly Depends[]>;
+    readonly levels: ExecutionPlan;
+    constructor(handlers: Map<Handler, readonly Depends[]> | Record<string, readonly Depends[]>);
+    private resolve;
+    getExecutionPlan(): ExecutionPlan;
+    get_execution_plan(): ExecutionPlan;
+}
+export declare function build_execution_plan(handlers: readonly Handler[], dependencies?: Map<Handler, readonly Depends[]> | Record<string, readonly Depends[]>): ExecutionPlan;
+export declare class TraceBatch {
+    readonly version: string;
+    readonly batchId: string;
+    readonly batch_id: string;
+    readonly userContext: Record<string, string>;
+    readonly user_context: Record<string, string>;
+    readonly executionMetadata: Record<string, unknown>;
+    readonly execution_metadata: Record<string, unknown>;
+    events: BaseEvent[];
+    constructor(options?: {
+        version?: string;
+        batchId?: string;
+        batch_id?: string;
+        userContext?: Record<string, string>;
+        user_context?: Record<string, string>;
+        executionMetadata?: Record<string, unknown>;
+        execution_metadata?: Record<string, unknown>;
+        events?: BaseEvent[];
+    });
+    toDict(): Record<string, unknown>;
+    to_dict(): Record<string, unknown>;
+}
+export declare class TraceEvent extends BaseEvent {
+    readonly raw: Record<string, unknown>;
+    constructor(options?: BaseEventOptions | Record<string, unknown>);
+    toDict(): Record<string, unknown>;
+    to_dict(): Record<string, unknown>;
+}
+type TraceBackendApi = {
+    sendTraceEvents?: (traceBatchId: string, payload: TraceEventsPayload) => unknown;
+    send_trace_events?: (traceBatchId: string, payload: TraceEventsPayload) => unknown;
+    sendEphemeralTraceEvents?: (traceBatchId: string, payload: TraceEventsPayload) => unknown;
+    send_ephemeral_trace_events?: (traceBatchId: string, payload: TraceEventsPayload) => unknown;
+    finalizeTraceBatch?: (traceBatchId: string, payload: TraceFinalizePayload) => unknown;
+    finalize_trace_batch?: (traceBatchId: string, payload: TraceFinalizePayload) => unknown;
+    finalizeEphemeralTraceBatch?: (traceBatchId: string, payload: TraceFinalizePayload) => unknown;
+    finalize_ephemeral_trace_batch?: (traceBatchId: string, payload: TraceFinalizePayload) => unknown;
+};
+export declare class TraceBatchManager {
+    readonly plusApi: TraceBackendApi;
+    readonly plus_api: TraceBackendApi;
+    isCurrentBatchEphemeral: boolean;
+    is_current_batch_ephemeral: boolean;
+    traceBatchId: string | null;
+    trace_batch_id: string | null;
+    currentBatch: TraceBatch | null;
+    current_batch: TraceBatch | null;
+    eventBuffer: BaseEvent[];
+    event_buffer: BaseEvent[];
+    executionStartTimes: Map<string, number>;
+    execution_start_times: Map<string, number>;
+    batchOwnerType: string | null;
+    batch_owner_type: string | null;
+    batchOwnerId: string | null;
+    batch_owner_id: string | null;
+    backendInitialized: boolean;
+    backend_initialized: boolean;
+    batchFinalized: boolean;
+    batch_finalized: boolean;
+    _batch_finalized: boolean;
+    deferSessionFinalization: boolean;
+    defer_session_finalization: boolean;
+    ephemeralTraceUrl: string | null;
+    ephemeral_trace_url: string | null;
+    private pendingEventsCount;
+    private backendFinalizePromise;
+    constructor(options?: {
+        plusApi?: TraceBackendApi;
+        plus_api?: TraceBackendApi;
+    });
+    initializeBatch(userContext: Record<string, string> | {
+        userContext?: Record<string, string>;
+        user_context?: Record<string, string>;
+        executionMetadata?: Record<string, unknown>;
+        execution_metadata?: Record<string, unknown>;
+        useEphemeral?: boolean;
+        use_ephemeral?: boolean;
+    }, executionMetadata?: Record<string, unknown>, useEphemeral?: boolean): TraceBatch;
+    initialize_batch(userContext: Parameters<TraceBatchManager["initializeBatch"]>[0], executionMetadata?: Record<string, unknown>, useEphemeral?: boolean): TraceBatch;
+    beginEventProcessing(): void;
+    begin_event_processing(): void;
+    endEventProcessing(): void;
+    end_event_processing(): void;
+    waitForPendingEvents(_timeout?: number): boolean;
+    wait_for_pending_events(timeout?: number): boolean;
+    addEvent(traceEvent: BaseEvent): void;
+    add_event(traceEvent: BaseEvent): void;
+    finalizeBatch(): TraceBatch | null;
+    finalize_batch(): TraceBatch | null;
+    finalizeBackendBatch(): Promise<boolean>;
+    _finalize_backend_batch(): Promise<boolean>;
+    private finalizeBackendBatchOnce;
+    private readTraceResponseJson;
+    hasEvents(): boolean;
+    has_events(): boolean;
+    getEventCount(): number;
+    get_event_count(): number;
+    isBatchInitialized(): boolean;
+    is_batch_initialized(): boolean;
+    shouldFinalizeOnShutdown(): boolean;
+    should_finalize_on_shutdown(): boolean;
+    waitForBatchInitialization(_timeout?: number): boolean;
+    wait_for_batch_initialization(timeout?: number): boolean;
+    recordStartTime(key: string): void;
+    record_start_time(key: string): void;
+    calculateDuration(key: string): number;
+    private setBatchFinalized;
+    calculate_duration(key: string): number;
+    getTraceId(): string | null;
+    get_trace_id(): string | null;
+}
+export declare abstract class BaseEventListener {
+    verbose: boolean;
+    constructor(eventBus?: EventBus);
+    abstract setupListeners(eventBus: EventBus): void;
+    setup_listeners(eventBus: EventBus): void;
+}
+export declare class EventBus {
+    _shutting_down: boolean;
+    private readonly handlers;
+    private readonly classHandlers;
+    private readonly handlerDependencies;
+    private readonly classHandlerDependencies;
+    private readonly pendingHandlers;
+    private currentRuntimeState;
+    private registeredEntityIds;
+    on<TEvent extends CrewAIEvent>(eventType: EventClass<TEvent>): (registeredHandler: EventHandler<TEvent>) => EventHandler<TEvent>;
+    on<TEvent extends CrewAIEvent>(eventType: EventClass<TEvent>, handler: EventHandler<TEvent>, dependsOn?: Depends | readonly Depends[] | null): () => void;
+    on<TEventType extends EventType>(eventType: TEventType): (registeredHandler: EventHandler<EventMap[TEventType]>) => EventHandler<EventMap[TEventType]>;
+    on<TEventType extends EventType>(eventType: TEventType, handler: EventHandler<EventMap[TEventType]>, dependsOn?: Depends | readonly Depends[] | null): () => void;
+    off(eventType: EventRegistrationKey, handler: EventHandler): void;
+    once<TEvent extends CrewAIEvent>(eventType: EventClass<TEvent>, handler: EventHandler<TEvent>): () => void;
+    emit(source: unknown, event: CrewAIEvent): void;
+    replay(source: unknown, event: CrewAIEvent): void;
+    aemit(source: unknown, event: CrewAIEvent): Promise<void>;
+    registerHandler<TEventType extends EventType>(eventType: TEventType, handler: EventHandler<EventMap[TEventType]>): void;
+    register_handler<TEventType extends EventType>(eventType: TEventType, handler: EventHandler<EventMap[TEventType]>): void;
+    flush(timeout?: number | null): Promise<boolean>;
+    scopedHandlers<T>(callback: () => MaybePromise<T>): MaybePromise<T>;
+    scoped_handlers<T>(callback: () => MaybePromise<T>): MaybePromise<T>;
+    private dispatchPrepared;
+    private dispatchPreparedAndWait;
+    private emitWithDependencies;
+    private runDependencyPlan;
+    private runRemainingDependencyPlan;
+    private runDependencyPlanAndWait;
+    private callHandler;
+    private trackPendingHandler;
+    clear(): void;
+    setRuntimeState(state: RuntimeState): void;
+    set_runtime_state(state: RuntimeState): void;
+    get runtimeState(): RuntimeState | null;
+    get runtime_state(): RuntimeState | null;
+    registerEntity(entity: unknown): void;
+    register_entity(entity: unknown): void;
+    private recordEvent;
+    private prepareEvent;
+    private registerSource;
+    validateDependencies(): void;
+    validate_dependencies(): void;
+    shutdown(wait?: boolean): MaybePromise<void>;
+    private restoreHandlers;
+    private handlerStores;
+    private addHandler;
+    private handlerSet;
+    private dependencyMap;
+    private deleteHandlerSet;
+    private deleteDependencyMap;
+    private resolveHandlers;
+}
+export declare const crewaiEventBus: EventBus;
+export declare const crewai_event_bus: EventBus;
+export declare const CrewAIEventsBus: typeof EventBus;
+export declare class EventListener extends BaseEventListener {
+    private static instance;
+    _telemetry: Telemetry;
+    formatter: ConsoleFormatter;
+    executionSpans: Map<unknown, unknown>;
+    execution_spans: Map<unknown, unknown>;
+    nextChunk: number;
+    next_chunk: number;
+    textStream: string;
+    text_stream: string;
+    knowledgeRetrievalInProgress: boolean;
+    knowledge_retrieval_in_progress: boolean;
+    knowledgeQueryInProgress: boolean;
+    knowledge_query_in_progress: boolean;
+    static getInstance(): EventListener;
+    setupListeners(eventBus: EventBus): void;
+    setup_listeners(eventBus: EventBus): void;
+}
+export declare class ConsoleFormatter {
+    readonly verbose: boolean;
+    static readonly toolUsageCounts: Map<string, number>;
+    static crewCompletionPrinted: boolean;
+    current_a2a_turn_count: number;
+    private pendingA2AMessage;
+    private pendingA2AAgentRole;
+    private pendingA2ATurnNumber;
+    private currentA2AAgentName;
+    private isStreaming;
+    private justStreamedFinalAnswer;
+    private lastStreamCallType;
+    _streaming_live: ConsoleStreamingLive | null;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    create_panel(content: unknown, title: string, style?: string): Record<string, unknown>;
+    createPanel(content: unknown, title: string, style?: string): Record<string, unknown>;
+    _show_version_update_message_if_needed(): void;
+    _show_tracing_disabled_message_if_needed(): void;
+    _simplify_tools_field<TFields extends Record<string, unknown>>(fields: TFields): TFields;
+    create_status_content(title: string, name: string, status_style?: string, tool_args?: Record<string, unknown> | string, fields?: Record<string, unknown>): string;
+    createStatusContent(title: string, name: string, statusStyle?: string, toolArgs?: Record<string, unknown> | string, fields?: Record<string, unknown>): string;
+    print(...args: unknown[]): void;
+    pause_live_updates(): void;
+    pauseLiveUpdates(): void;
+    resume_live_updates(): void;
+    resumeLiveUpdates(): void;
+    print_panel(content: unknown, title: string, style?: string, is_flow?: boolean): void;
+    printPanel(content: unknown, title: string, style?: string, isFlow?: boolean): void;
+    handle_crew_status(crew_name: string, source_id: string, status?: string, final_string_output?: string): void;
+    handleCrewStatus(crewName: string, sourceId: string, status?: string, finalStringOutput?: string): void;
+    handle_crew_started(crew_name: string, source_id: string): void;
+    handleCrewStarted(crewName: string, sourceId: string): void;
+    handle_task_started(task_id: string, task_name?: string | null): void;
+    handleTaskStarted(taskId: string, taskName?: string | null): void;
+    handle_task_status(task_id: string, agent_role: string, status?: string, task_name?: string | null): void;
+    handleTaskStatus(taskId: string, agentRole: string, status?: string, taskName?: string | null): void;
+    handle_flow_created(flow_name: string, flow_id: string): void;
+    handle_flow_started(flow_name: string, flow_id: string): void;
+    handle_flow_status(flow_name: string, flow_id: string, status?: string): void;
+    handle_method_status(method_name: string, status?: string): void;
+    handle_llm_tool_usage_started(tool_name: string, tool_args: Record<string, unknown> | string): void;
+    handle_llm_tool_usage_finished(tool_name: string): void;
+    handle_llm_tool_usage_error(tool_name: string, error: string): void;
+    handle_tool_usage_started(tool_name: string, tool_args?: Record<string, unknown> | string, run_attempts?: number | null): void;
+    handle_tool_usage_finished(tool_name: string, output: string, run_attempts?: number | null): void;
+    handle_tool_usage_error(tool_name: string, error: string, run_attempts?: number | null): void;
+    handle_llm_call_failed(error: string): void;
+    handle_llm_stream_chunk(accumulated_text: string, call_type?: unknown): void;
+    handle_llm_stream_completed(): void;
+    create_streaming_live(): ConsoleStreamingLive;
+    handle_crew_test_started(crew_name: string, source_id: string, n_iterations: number): void;
+    handle_crew_test_completed(crew_name: string): void;
+    handle_crew_train_started(crew_name: string, timestamp: string): void;
+    handle_crew_train_completed(crew_name: string, timestamp: string): void;
+    handle_crew_train_failed(crew_name: string): void;
+    handle_crew_test_failed(crew_name: string): void;
+    create_lite_agent_branch(lite_agent_role: string): void;
+    update_lite_agent_status(lite_agent_role: string, status?: string, fields?: Record<string, unknown>): void;
+    handle_lite_agent_execution(lite_agent_role: string, status?: string, error?: unknown, fields?: Record<string, unknown>): void;
+    handle_knowledge_retrieval_started(): void;
+    handle_knowledge_retrieval_completed(retrieved_knowledge: unknown, search_query: string): void;
+    handle_knowledge_query_started(task_prompt: string): void;
+    handle_knowledge_query_failed(error: string): void;
+    handle_knowledge_query_completed(): void;
+    handle_knowledge_search_query_failed(error: string): void;
+    handle_reasoning_started(attempt: number): void;
+    handle_reasoning_completed(plan: string, ready: boolean): void;
+    handle_reasoning_failed(error: string): void;
+    handle_observation_started(agent_role: string, step_number: number, step_description: string): void;
+    handle_observation_completed(agent_role: string, step_number: number, step_completed: boolean, plan_valid: boolean, key_info: string, needs_replan: boolean, goal_achieved: boolean): void;
+    handle_observation_failed(step_number: number, error: string): void;
+    handle_plan_refinement(step_number: number, refined_count: number, refinements: readonly string[] | null): void;
+    handle_plan_replan(reason: string, replan_count: number, preserved_count: number): void;
+    handle_goal_achieved_early(steps_completed: number, steps_remaining: number): void;
+    handle_agent_logs_started(agent_role: string, task_description?: string | null, verbose?: boolean): void;
+    handle_agent_logs_execution(agent_role: string, formatted_answer: unknown, verbose?: boolean): void;
+    handle_memory_retrieval_started(): void;
+    handle_memory_retrieval_completed(memory_content: string, retrieval_time_ms: number): void;
+    handle_memory_query_failed(error: string, source_type: string): void;
+    handle_memory_save_started(): void;
+    handle_memory_save_completed(save_time_ms: number, source_type: string): void;
+    handle_memory_save_failed(error: string, source_type: string): void;
+    handle_guardrail_started(guardrail_name: string, retry_count: number): void;
+    handle_guardrail_completed(success: boolean, error: string | null, retry_count: number): void;
+    handle_a2a_delegation_started(endpoint: string, task_description: string, agent_id: string, is_multiturn?: boolean, turn_number?: number): void;
+    handle_a2a_delegation_completed(status: string, result?: string | null, error?: string | null, is_multiturn?: boolean): void;
+    handle_a2a_conversation_started(agent_id: string, endpoint: string): void;
+    handle_a2a_message_sent(message: string, turn_number: number, agent_role?: string | null): void;
+    handle_a2a_response_received(response: string, turn_number: number, status: string, agent_role?: string | null): void;
+    handle_a2a_conversation_completed(status: string, final_result: string | null, error: string | null, total_turns: number): void;
+    handle_mcp_connection_started(server_name: string, server_url?: string | null, transport_type?: string | null, is_reconnect?: boolean, connect_timeout?: number | null): void;
+    handle_mcp_connection_completed(server_name: string, server_url?: string | null, transport_type?: string | null, connection_duration_ms?: number | null, is_reconnect?: boolean): void;
+    handle_mcp_connection_failed(server_name: string, server_url?: string | null, transport_type?: string | null, error?: string, error_type?: string | null): void;
+    handle_mcp_config_fetch_failed(slug: string, error?: string, error_type?: string | null): void;
+    handle_mcp_tool_execution_started(server_name: string, tool_name: string, tool_args?: Record<string, unknown> | null): void;
+    handle_mcp_tool_execution_failed(server_name: string, tool_name: string, tool_args?: Record<string, unknown> | null, error?: string, error_type?: string | null): void;
+    handle_a2a_polling_started(task_id: string, polling_interval: number, endpoint: string): void;
+    handle_a2a_polling_status(task_id: string, state: string, elapsed_seconds: number, poll_count: number): void;
+    private truncate;
+    private formatConsoleValue;
+}
+export declare const event_listener: EventListener;
+export declare class TraceCollectionListener extends BaseEventListener {
+    readonly batchManager: TraceBatchManager;
+    readonly batch_manager: TraceBatchManager;
+    constructor(eventBus?: EventBus, batchManager?: TraceBatchManager);
+    setupListeners(_eventBus: EventBus): void;
+    setup_listeners(eventBus: EventBus): void;
+    static _isInsideActiveFlowContext(): boolean;
+    static _is_inside_active_flow_context(): boolean;
+    _nestedInFlowExecution(): boolean;
+    _nested_in_flow_execution(): boolean;
+    shouldFinalizeBatchForOwner(): boolean;
+    _should_finalize_batch_for_owner(): boolean;
+    _handleActionEvent(_eventType: string, _source: unknown, event: BaseEvent): void;
+    _handle_action_event(eventType: string, source: unknown, event: BaseEvent): void;
+}
+export declare class FirstTimeTraceHandler {
+    readonly enabled: boolean;
+    isFirstTime: boolean;
+    is_first_time: boolean;
+    collectedEvents: boolean;
+    collected_events: boolean;
+    traceBatchId: string | null;
+    trace_batch_id: string | null;
+    ephemeralUrl: string | null;
+    ephemeral_url: string | null;
+    batchManager: TraceBatchManager | null;
+    batch_manager: TraceBatchManager | null;
+    constructor(enabled?: boolean);
+    initializeForFirstTimeUser(): boolean;
+    initialize_for_first_time_user(): boolean;
+    setBatchManager(batchManager: TraceBatchManager): void;
+    set_batch_manager(batch_manager: TraceBatchManager): void;
+    markEventsCollected(): void;
+    mark_events_collected(): void;
+    handleExecutionCompletion(): void;
+    handle_execution_completion(): void;
+    private captureLocalTraceSummary;
+    _resetBatchState(): void;
+    _reset_batch_state(): void;
+}
+export declare function resetEmissionSequence(): void;
+export {};