import type { PubSub } from '../events/pubsub.js';
import type { RequestContext } from '../request-context/index.js';
import type { MastraModelOutput } from '../stream/base/output.js';
import type { Agent } from './agent.js';
import type { AgentExecutionOptions } from './agent.types.js';
import type { MessageListInput } from './message-list/index.js';
import type { AgentMessageInput, AgentStateSignalInput, CreatedAgentSignal } from './signals.js';
import type { AgentSignal, AgentSubscribeToThreadOptions, AgentThreadSubscription, QueueAgentMessageOptions, QueueAgentMessageResult, SendAgentMessageOptions, SendAgentMessageResult, SendAgentSignalOptions, SendAgentSignalResult, SendAgentStateSignalOptions, SendAgentStateSignalResult } from './types.js';
export declare let defaultAgentThreadPubSub: PubSub;
export type AgentThreadState = 'active' | 'idle';
export declare class AgentThreadStreamRuntime {
    #private;
    getThreadState(options: {
        resourceId?: string;
        threadId: string;
    }, pubsub?: PubSub): AgentThreadState;
    prepareRunOptions<OUTPUT>(options: AgentExecutionOptions<OUTPUT>, pubsub?: PubSub): AgentExecutionOptions<OUTPUT>;
    abortRun(runId: string, pubsub?: PubSub): boolean;
    getActiveThreadRunId(options: AgentSubscribeToThreadOptions, pubsub?: PubSub): string | undefined;
    abortThread(options: AgentSubscribeToThreadOptions, pubsub?: PubSub): boolean;
    /** @internal */
    resetForTests(): void;
    registerRun<OUTPUT>(agent: Agent<any, any, any, any>, output: MastraModelOutput<OUTPUT>, streamOptions: AgentExecutionOptions<OUTPUT>, pubsub?: PubSub): void;
    continueWithMessages<OUTPUT = unknown>(agent: Agent<any, any, any, any>, messages: MessageListInput, target: {
        resourceId: string;
        threadId: string;
        streamOptions?: AgentExecutionOptions<OUTPUT>;
        runId?: string;
    }, pubsub?: PubSub): {
        accepted: true;
        runId: string;
    };
    drainPendingSignals(runId: string, pubsub?: PubSub): CreatedAgentSignal[];
    waitForCrossAgentThreadRun(agent: Agent<any, any, any, any>, options: {
        memory?: AgentExecutionOptions<any>['memory'];
        requestContext?: RequestContext;
    }, pubsub?: PubSub): Promise<void>;
    subscribeToThread<OUTPUT = unknown>(agent: Agent<any, any, any, any>, options: AgentSubscribeToThreadOptions, pubsub?: PubSub): Promise<AgentThreadSubscription<OUTPUT>>;
    sendMessage<OUTPUT = unknown>(agent: Agent<any, any, any, any>, message: AgentMessageInput, target: SendAgentMessageOptions<OUTPUT>, pubsub?: PubSub): SendAgentMessageResult;
    queueMessage<OUTPUT = unknown>(agent: Agent<any, any, any, any>, message: AgentMessageInput, target: QueueAgentMessageOptions<OUTPUT>, pubsub?: PubSub): QueueAgentMessageResult;
    sendStateSignal<OUTPUT = unknown>(agent: Agent<any, any, any, any>, stateInput: AgentStateSignalInput, target: SendAgentStateSignalOptions<OUTPUT>, pubsub?: PubSub): Promise<SendAgentStateSignalResult>;
    /**
     * Routes a signal to an agent thread.
     *
     * Signals can land in three places:
     * - an active same-agent run, where they are queued for the execution loop to drain;
     * - a reserved thread run that has not registered its stream record yet;
     * - a new idle-started run, when the caller opts into `ifIdle`.
     *
     * Cross-agent active runs are intentionally not interrupted here. They either finish first
     * through `waitForCrossAgentThreadRun()` on the stream path, or this method falls through to
     * the idle-start path when the caller provided a resource/thread target and `ifIdle` options.
     */
    sendSignal<OUTPUT = unknown>(agent: Agent<any, any, any, any>, signalInput: AgentSignal, target: SendAgentSignalOptions<OUTPUT>, pubsub?: PubSub): SendAgentSignalResult;
}
export declare const agentThreadStreamRuntime: AgentThreadStreamRuntime;
//# sourceMappingURL=thread-stream-runtime.d.ts.map