import { normalizeAgentId } from "../routing/session-key.js";

import type { SessionLifecycleEvent } from "../sessions/session-lifecycle-events.js";

import type { SessionTranscriptUpdate } from "../sessions/transcript-events.js";

import type { ChatAbortControllerEntry } from "./chat-abort.js";

import { projectChatDisplayMessage } from "./chat-display-projection.js";

import type { GatewayBroadcastToConnIdsFn } from "./server-broadcast-types.js";

import type {

SessionEventSubscriberRegistry,

SessionMessageSubscriberRegistry,

} from "./server-chat.js";

import { hasTrackedActiveSessionRun } from "./server-methods/session-active-runs.js";

import { resolveSessionKeyForTranscriptFile } from "./session-transcript-key.js";

import {

attachOpenClawTranscriptMeta,

label?: string;

displayName?: string;

parentSessionKey?: string;

hasActiveRun?: boolean;

}): Record<string, unknown> {

const { sessionRow } = params;

if (!sessionRow) {

if (session && omitUnscopedGlobalGoal) {

delete session.goal;

}

if (session && params.hasActiveRun !== undefined) {

session.hasActiveRun = params.hasActiveRun;

}

return {

...(session ? { session } : {}),

updatedAt: sessionRow.updatedAt ?? undefined,

modelProvider: sessionRow.modelProvider,

model: sessionRow.model,

status: sessionRow.status,

...(params.hasActiveRun === undefined ? {} : { hasActiveRun: params.hasActiveRun }),

subagentRunState: sessionRow.subagentRunState,

hasActiveSubagentRun: sessionRow.hasActiveSubagentRun,

startedAt: sessionRow.startedAt,

broadcastToConnIds: GatewayBroadcastToConnIdsFn;

sessionEventSubscribers: SessionEventSubscribers;

sessionMessageSubscribers: SessionMessageSubscribers;

chatAbortControllers: Map<string, ChatAbortControllerEntry>;

}) {

let broadcastQueue = Promise.resolve();

return (update: SessionTranscriptUpdate): void => {

broadcastToConnIds: GatewayBroadcastToConnIdsFn;

sessionEventSubscribers: SessionEventSubscribers;

sessionMessageSubscribers: SessionMessageSubscribers;

chatAbortControllers: Map<string, ChatAbortControllerEntry>;

},

update: SessionTranscriptUpdate,

): Promise<void> {

)

: undefined;

}

const sessionRow = loadGatewaySessionRow(sessionKey, {

agentId: visibleAgentId,

transcriptUsageMaxBytes: 64 * 1024,

});

const hasActiveRun = sessionRow

? hasTrackedActiveSessionRun({

context: params,

requestedKey: sessionKey,

canonicalKey: sessionRow.key,

...(sessionRow.key === "global" && visibleAgentId ? { agentId: visibleAgentId } : {}),

defaultAgentId: normalizeAgentId(resolveDefaultAgentId(getRuntimeConfig())),

})

: false;

const sessionSnapshot = buildGatewaySessionSnapshot({

sessionRow: loadGatewaySessionRow(sessionKey, {

agentId: visibleAgentId,

transcriptUsageMaxBytes: 64 * 1024,

}),

sessionRow,

agentId: visibleAgentId,

includeSession: true,

hasActiveRun,

});

const rawMessage = attachOpenClawTranscriptMeta(update.message, {

...(typeof update.messageId === "string" ? { id: update.messageId } : {}),