import {

abortActiveReplyRuns,

abortReplyRunBySessionId,

getActiveReplyRunCount,

isReplyRunActiveForSessionId,

isReplyRunStreamingForSessionId,

listActiveReplyRunSessionIds,

queueReplyRunMessage,

resolveActiveReplyRunSessionId,

waitForReplyRunEndBySessionId,

logMessageQueued,

logSessionStateChange,

} from "../../logging/diagnostic.js";

import { resolveGlobalSingleton } from "../../shared/global-singleton.js";

import { normalizeOptionalString } from "../../shared/string-coerce.js";

import {

ACTIVE_EMBEDDED_RUNS,

ACTIVE_EMBEDDED_RUN_SESSION_IDS_BY_KEY,

ACTIVE_EMBEDDED_RUN_SNAPSHOTS,

EMBEDDED_RUN_MODEL_SWITCH_REQUESTS,

EMBEDDED_RUN_WAITERS,

getActiveEmbeddedRunCount,

type ActiveEmbeddedRunSnapshot,

type EmbeddedPiQueueHandle,

type EmbeddedRunModelSwitchRequest,

type EmbeddedRunWaiter,

} from "./run-state.js";

export type EmbeddedPiQueueHandle = {

kind?: "embedded";

queueMessage: (text: string) => Promise<void>;

isStreaming: () => boolean;

isCompacting: () => boolean;

cancel?: (reason?: "user_abort" | "restart" | "superseded") => void;

abort: () => void;

};

export type ActiveEmbeddedRunSnapshot = {

transcriptLeafId: string | null;

messages?: unknown[];

inFlightPrompt?: string;

};

type EmbeddedRunWaiter = {

resolve: (ended: boolean) => void;

timer: NodeJS.Timeout;

};

export type EmbeddedRunModelSwitchRequest = {

provider: string;

model: string;

authProfileId?: string;

authProfileIdSource?: "auto" | "user";

};

/**

* Use global singleton state so busy/streaming checks stay consistent even

* when the bundler emits multiple copies of this module into separate chunks.

*/

const EMBEDDED_RUN_STATE_KEY = Symbol.for("openclaw.embeddedRunState");

const embeddedRunState = resolveGlobalSingleton(EMBEDDED_RUN_STATE_KEY, () => ({

activeRuns: new Map<string, EmbeddedPiQueueHandle>(),

snapshots: new Map<string, ActiveEmbeddedRunSnapshot>(),

sessionIdsByKey: new Map<string, string>(),

waiters: new Map<string, Set<EmbeddedRunWaiter>>(),

modelSwitchRequests: new Map<string, EmbeddedRunModelSwitchRequest>(),

}));

const ACTIVE_EMBEDDED_RUNS =

embeddedRunState.activeRuns ??

(embeddedRunState.activeRuns = new Map<string, EmbeddedPiQueueHandle>());

const ACTIVE_EMBEDDED_RUN_SNAPSHOTS =

embeddedRunState.snapshots ??

(embeddedRunState.snapshots = new Map<string, ActiveEmbeddedRunSnapshot>());

const ACTIVE_EMBEDDED_RUN_SESSION_IDS_BY_KEY =

embeddedRunState.sessionIdsByKey ??

(embeddedRunState.sessionIdsByKey = new Map<string, string>());

const EMBEDDED_RUN_WAITERS =

embeddedRunState.waiters ??

(embeddedRunState.waiters = new Map<string, Set<EmbeddedRunWaiter>>());

const EMBEDDED_RUN_MODEL_SWITCH_REQUESTS =

embeddedRunState.modelSwitchRequests ??

(embeddedRunState.modelSwitchRequests = new Map<string, EmbeddedRunModelSwitchRequest>());

export {

getActiveEmbeddedRunCount,

type ActiveEmbeddedRunSnapshot,

type EmbeddedPiQueueHandle,

type EmbeddedRunModelSwitchRequest,

} from "./run-state.js";

function setActiveRunSessionKey(sessionKey: string | undefined, sessionId: string): void {

const normalizedSessionKey = sessionKey?.trim();

);

}

export function getActiveEmbeddedRunCount(): number {

let activeCount = ACTIVE_EMBEDDED_RUNS.size;

for (const sessionId of listActiveReplyRunSessionIds()) {

if (!ACTIVE_EMBEDDED_RUNS.has(sessionId)) {

activeCount += 1;

}

}

return Math.max(activeCount, getActiveReplyRunCount());

}

export function getActiveEmbeddedRunSnapshot(

sessionId: string,

): ActiveEmbeddedRunSnapshot | undefined {