import { chatAbortMarkerTimestampMs, type ChatRunTiming } from "../server-chat-state.js";

import { getMaxChatHistoryMessagesBytes, MAX_PAYLOAD_BYTES } from "../server-constants.js";

import { resolveSessionHistoryTailReadOptions } from "../session-history-state.js";

import { persistGatewaySessionLifecycleEvent } from "../session-lifecycle-state.js";

import { readSessionTranscriptIndex } from "../session-transcript-index.fs.js";

import {

capArrayByJsonBytes,

const deliveredReplies: Array<{ payload: ReplyPayload; kind: "block" | "final" }> = [];

let appendedWebchatAgentMedia = false;

let agentRunStarted = false;

let pendingDispatchLifecycleError:

| {

endedAt: number;

error: string;

sessionId: string;

startedAt: number;

}

| undefined;

const userTurnRecorder: UserTurnTranscriptRecorder = createUserTurnTranscriptRecorder({

input: baseUserTurnInput,

resolveInput: () => userTurnInputPromise,

);

})

.catch(async (err: unknown) => {

const errorMessage = String(err);

const emitAfterError =

userTurnRecorder.hasPersisted() || userTurnRecorder.isBlocked()

? Promise.resolve()

`webchat user transcript update failed after error: ${formatForLog(transcriptErr)}`,

);

});

const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));

if (

!agentRunStarted &&

!activeRunAbort.controller.signal.aborted &&

!context.chatAbortedRuns.has(clientRunId)

) {

pendingDispatchLifecycleError = {

endedAt: Date.now(),

error: errorMessage,

sessionId: activeRunAbort.entry?.sessionId ?? backingSessionId ?? clientRunId,

startedAt: activeRunAbort.entry?.startedAtMs ?? now,

};

}

const error = errorShape(ErrorCodes.UNAVAILABLE, errorMessage);

setGatewayDedupeEntry({

dedupe: context.dedupe,

key: `chat:${clientRunId}`,

payload: {

runId: clientRunId,

status: "error" as const,

summary: String(err),

summary: errorMessage,

},

error,

},

runId: clientRunId,

sessionKey,

agentId,

errorMessage: String(err),

errorMessage,

});

})

.finally(() => {

activeRunAbort.cleanup();

clearAgentRunContext(clientRunId, lifecycleGeneration);

clearActiveChatSendDedupeRun(context.dedupe, activeChatSendDedupeKey, clientRunId);

context.removeChatRun(clientRunId, clientRunId, sessionKey);

if (!pendingDispatchLifecycleError) {

return;

}

const persistDispatchLifecycleError = async () => {

const dispatchError = pendingDispatchLifecycleError;

if (!dispatchError) {

return;

}

const hasActiveRun = hasTrackedActiveSessionRun({

context,

requestedKey: rawSessionKey,

canonicalKey: sessionKey,

...(sessionKey === "global" && agentId ? { agentId } : {}),

defaultAgentId: resolveDefaultAgentId(cfg),

});

if (hasActiveRun) {

return;

}

try {

await persistGatewaySessionLifecycleEvent({

sessionKey,

...(sessionKey === "global" && agentId ? { agentId } : {}),

event: {

runId: clientRunId,

sessionId: dispatchError.sessionId,

lifecycleGeneration,

ts: dispatchError.endedAt,

data: {

phase: "error",

startedAt: dispatchError.startedAt,

endedAt: dispatchError.endedAt,

error: dispatchError.error,

},

},

});

emitSessionsChanged(context, {

sessionKey,

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

reason: "chat.dispatch-error",

});

} catch (persistErr: unknown) {

context.logGateway.warn(

`webchat session lifecycle persist failed after error: ${formatForLog(persistErr)}`,

);

}

};

void persistDispatchLifecycleError();

});

} catch (err) {

activeRunAbort.cleanup({ force: true });