import type { ReadonlyJSONValue } from "assistant-stream/utils";
import type { ModelContext } from "../../model-context/types.js";
import type { Unsubscribe } from "../../types/unsubscribe.js";
import type { AppendMessage, ThreadMessage } from "../../types/message.js";
import type { RunConfig } from "../../types/message.js";
import type { SpeechSynthesisAdapter } from "../../adapters/speech.js";
import type { RealtimeVoiceAdapter } from "../../adapters/voice.js";
import type { ChatModelRunOptions, ChatModelRunResult } from "../utils/chat-model-adapter.js";
import type { ExportedMessageRepository } from "../utils/message-repository.js";
import type { ThreadMessageLike } from "../utils/thread-message-like.js";
import type { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "./composer-runtime-core.js";
export type RuntimeCapabilities = {
    readonly switchToBranch: boolean;
    readonly switchBranchDuringRun: boolean;
    readonly edit: boolean;
    readonly reload: boolean;
    readonly cancel: boolean;
    readonly unstable_copy: boolean;
    readonly speech: boolean;
    readonly dictation: boolean;
    readonly voice: boolean;
    readonly attachments: boolean;
    readonly feedback: boolean;
    readonly queue: boolean;
};
export type AddToolResultOptions = {
    messageId: string;
    toolName: string;
    toolCallId: string;
    result: ReadonlyJSONValue;
    isError: boolean;
    artifact?: ReadonlyJSONValue | undefined;
};
export type ResumeToolCallOptions = {
    toolCallId: string;
    payload: unknown;
};
export type SubmitFeedbackOptions = {
    messageId: string;
    type: "negative" | "positive";
};
export type ThreadSuggestion = {
    prompt: string;
};
export type SpeechState = {
    readonly messageId: string;
    readonly status: SpeechSynthesisAdapter.Status;
};
export type VoiceSessionState = {
    readonly status: RealtimeVoiceAdapter.Status;
    readonly isMuted: boolean;
    readonly mode: RealtimeVoiceAdapter.Mode;
};
export type SubmittedFeedback = {
    readonly type: "negative" | "positive";
};
export type ThreadRuntimeEventPayload = {
    /**
     * @deprecated State-derivable. Observe `state.isRunning` flipping to `true`
     * via `subscribe` + `getState` instead. Note: this event fires at the
     * transition point and may run before the next subscriber notification.
     * Kept for backward compatibility.
     */
    runStart: Record<string, never>;
    /**
     * @deprecated State-derivable. Observe `state.isRunning` flipping to `false`
     * via `subscribe` + `getState` instead. Note: this event fires at the
     * transition point and may run before the next subscriber notification.
     * Kept for backward compatibility.
     */
    runEnd: Record<string, never>;
    /**
     * @deprecated State-derivable. This event fires at the initialization
     * transition immediately BEFORE the first message is added, so reading state
     * inside the handler still sees an empty thread; observe `state.messages`
     * becoming non-empty via a regular `subscribe` callback instead. Kept for
     * backward compatibility.
     */
    initialize: Record<string, never>;
    /**
     * Truly transient. The model context lives in a provider, not in thread
     * state, so this event has no state-derivable equivalent.
     */
    modelContextUpdate: Record<string, never>;
};
export type ThreadRuntimeEventType = keyof ThreadRuntimeEventPayload;
export type ThreadRuntimeEventCallback<E extends ThreadRuntimeEventType> = (payload: ThreadRuntimeEventPayload[E]) => void;
export type StartRunConfig = {
    parentId: string | null;
    sourceId: string | null;
    runConfig: RunConfig;
};
export type ResumeRunConfig = StartRunConfig & {
    stream?: (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
};
export type ThreadRuntimeCore = Readonly<{
    getMessageById: (messageId: string) => {
        parentId: string | null;
        message: ThreadMessage;
        index: number;
    } | undefined;
    getBranches: (messageId: string) => readonly string[];
    switchToBranch: (branchId: string) => void;
    append: (message: AppendMessage) => void;
    startRun: (config: StartRunConfig) => void;
    resumeRun: (config: ResumeRunConfig) => void;
    cancelRun: () => void;
    addToolResult: (options: AddToolResultOptions) => void;
    resumeToolCall: (options: ResumeToolCallOptions) => void;
    speak: (messageId: string) => void;
    stopSpeaking: () => void;
    connectVoice: () => void;
    disconnectVoice: () => void;
    muteVoice: () => void;
    unmuteVoice: () => void;
    submitFeedback: (feedback: SubmitFeedbackOptions) => void;
    getModelContext: () => ModelContext;
    composer: ThreadComposerRuntimeCore;
    getEditComposer: (messageId: string) => EditComposerRuntimeCore | undefined;
    beginEdit: (messageId: string) => void;
    speech: SpeechState | undefined;
    voice: VoiceSessionState | undefined;
    capabilities: Readonly<RuntimeCapabilities>;
    isDisabled: boolean;
    isLoading: boolean;
    /**
     * Optional explicit thread-level running flag. When provided, takes
     * precedence over the last-message-status heuristic. When omitted, falls
     * back to the legacy behavior. External-store runtimes surface this via
     * `ExternalStoreAdapter.isRunning`.
     */
    isRunning?: boolean | undefined;
    messages: readonly ThreadMessage[];
    state: ReadonlyJSONValue;
    suggestions: readonly ThreadSuggestion[];
    extras: unknown;
    subscribe: (callback: () => void) => Unsubscribe;
    getVoiceVolume: () => number;
    subscribeVoiceVolume: (callback: () => void) => Unsubscribe;
    import(repository: ExportedMessageRepository): void;
    export(): ExportedMessageRepository;
    exportExternalState(): any;
    importExternalState(state: any): void;
    reset(initialMessages?: readonly ThreadMessageLike[]): void;
    /**
     * @deprecated This API is still under active development and might change without notice.
     * For state-derivable transitions, prefer `subscribe` + `getState`. This channel is the
     * escape hatch for transient occurrences not represented in state.
     */
    unstable_on<E extends ThreadRuntimeEventType>(event: E, callback: ThreadRuntimeEventCallback<E>): Unsubscribe;
    /**
     * @deprecated Use importExternalState instead. This method will be removed in 0.12.0.
     */
    unstable_loadExternalState: (state: any) => void;
}>;
//# sourceMappingURL=thread-runtime-core.d.ts.map