import { reactivateCompletedSubagentSession } from "../session-subagent-reactivation.js";

import {

canonicalizeSpawnedByForAgent,

loadGatewaySessionRow,

loadSessionEntry,

migrateAndPruneGatewaySessionStoreKey,

resolveGatewaySessionStoreTarget,

waitForTerminalGatewayDedupe,

} from "./agent-wait-dedupe.js";

import { normalizeRpcAttachmentsToChatAttachments } from "./attachment-normalize.js";

import { emitSessionsChanged } from "./session-change-event.js";

import type {

GatewayRequestContext,

GatewayRequestHandlerOptions,

return Boolean(params.trustedGroupId && requestGroupId === params.trustedGroupId);

}

function emitSessionsChanged(

context: Pick<

GatewayRequestHandlerOptions["context"],

"broadcastToConnIds" | "getSessionEventSubscriberConnIds"

>,

payload: { sessionKey?: string; agentId?: string; reason: string },

) {

const connIds = context.getSessionEventSubscriberConnIds();

if (connIds.size === 0) {

return;

}

const sessionRow = payload.sessionKey

? loadGatewaySessionRow(

payload.sessionKey,

payload.sessionKey === "global" && payload.agentId

? { agentId: payload.agentId }

: undefined,

)

: null;

// Unscoped global updates must not leak one agent's goal into another agent's UI row.

const omitUnscopedGlobalGoal = payload.sessionKey === "global" && !payload.agentId;

context.broadcastToConnIds(

"sessions.changed",

{

...payload,

ts: Date.now(),

...(sessionRow

? {

updatedAt: sessionRow.updatedAt ?? undefined,

sessionId: sessionRow.sessionId,

kind: sessionRow.kind,

channel: sessionRow.channel,

subject: sessionRow.subject,

groupChannel: sessionRow.groupChannel,

space: sessionRow.space,

chatType: sessionRow.chatType,

origin: sessionRow.origin,

spawnedBy: sessionRow.spawnedBy,

spawnedWorkspaceDir: sessionRow.spawnedWorkspaceDir,

spawnedCwd: sessionRow.spawnedCwd,

forkedFromParent: sessionRow.forkedFromParent,

spawnDepth: sessionRow.spawnDepth,

subagentRole: sessionRow.subagentRole,

subagentControlScope: sessionRow.subagentControlScope,

label: sessionRow.label,

displayName: sessionRow.displayName,

deliveryContext: sessionRow.deliveryContext,

parentSessionKey: sessionRow.parentSessionKey,

childSessions: sessionRow.childSessions,

thinkingLevel: sessionRow.thinkingLevel,

fastMode: sessionRow.fastMode,

verboseLevel: sessionRow.verboseLevel,

traceLevel: sessionRow.traceLevel,

reasoningLevel: sessionRow.reasoningLevel,

elevatedLevel: sessionRow.elevatedLevel,

sendPolicy: sessionRow.sendPolicy,

systemSent: sessionRow.systemSent,

abortedLastRun: sessionRow.abortedLastRun,

inputTokens: sessionRow.inputTokens,

outputTokens: sessionRow.outputTokens,

lastChannel: sessionRow.lastChannel,

lastTo: sessionRow.lastTo,

lastAccountId: sessionRow.lastAccountId,

lastThreadId: sessionRow.lastThreadId,

totalTokens: sessionRow.totalTokens,

totalTokensFresh: sessionRow.totalTokensFresh,

...(omitUnscopedGlobalGoal ? {} : { goal: sessionRow.goal ?? null }),

contextTokens: sessionRow.contextTokens,

estimatedCostUsd: sessionRow.estimatedCostUsd,

responseUsage: sessionRow.responseUsage,

modelProvider: sessionRow.modelProvider,

model: sessionRow.model,

status: sessionRow.status,

startedAt: sessionRow.startedAt,

endedAt: sessionRow.endedAt,

runtimeMs: sessionRow.runtimeMs,

compactionCheckpointCount: sessionRow.compactionCheckpointCount,

latestCompactionCheckpoint: sessionRow.latestCompactionCheckpoint,

}

: {}),

},

connIds,

{ dropIfSlow: true },

);

}

type GatewayAgentTaskTerminalStatus = Extract<

TaskStatus,

"succeeded" | "failed" | "timed_out" | "cancelled"