const GPT_CHAT_BREVITY_SOFT_MAX_CHARS = 900;

const GPT_CHAT_BREVITY_SOFT_MAX_SENTENCES = 6;

function shouldBridgeCliAssistantTextToReasoning(provider: string): boolean {

return normalizeLowercaseStringOrEmpty(provider) === "claude-cli";

}

function readApprovalScopeValue(value: unknown): "turn" | "session" | undefined {

return value === "turn" || value === "session" ? value : undefined;

}

});

return (async () => {

let lifecycleTerminalEmitted = false;

let lastBridgedAssistantText: string | undefined;

let assistantBridgeUnsubscribed = false;

let assistantBridgeDelivery: Promise<void> = Promise.resolve();

const deliverBridgedAssistantText = async (text: string): Promise<void> => {

const createAssistantTextBridge = (deliver: (text: string) => Promise<void>) => {

let lastText: string | undefined;

let unsubscribed = false;

let delivery = Promise.resolve();

const rawUnsubscribe = onAgentEvent((evt) => {

if (evt.runId !== runId || evt.stream !== "assistant") {

return;

}

if (params.followupRun.run.silentExpected) {

return;

}

const text = typeof evt.data.text === "string" ? evt.data.text : undefined;

if (text === undefined || text === lastText) {

return;

}

lastText = text;

delivery = delivery.then(() => deliver(text)).catch(() => undefined);

});

return {

unsubscribe() {

if (unsubscribed) {

return;

}

unsubscribed = true;

rawUnsubscribe();

},

async drain(): Promise<void> {

await delivery;

},

};

};

const noopBridge = {

unsubscribe: () => undefined,

drain: async (): Promise<void> => undefined,

};

const assistantBridge = createAssistantTextBridge(async (text) => {

const textForTyping = await handlePartialForTyping({ text } as ReplyPayload);

if (textForTyping === undefined || !params.opts?.onPartialReply) {

return;

}

await params.opts.onPartialReply({ text: textForTyping });

};

const queueBridgedAssistantText = (text: string) => {

assistantBridgeDelivery = assistantBridgeDelivery

.then(() => deliverBridgedAssistantText(text))

.catch(() => undefined);

};

const drainAssistantBridgeDelivery = async (): Promise<void> => {

await assistantBridgeDelivery;

};

const rawUnsubscribeAssistantBridge = onAgentEvent((evt) => {

if (evt.runId !== runId || evt.stream !== "assistant") {

return;

}

if (params.followupRun.run.silentExpected) {

return;

}

const text = typeof evt.data.text === "string" ? evt.data.text : undefined;

if (text === undefined || text === lastBridgedAssistantText) {

return;

}

lastBridgedAssistantText = text;

queueBridgedAssistantText(text);

});

const unsubscribeAssistantBridge = () => {

if (assistantBridgeUnsubscribed) {

return;

}

assistantBridgeUnsubscribed = true;

rawUnsubscribeAssistantBridge();

};

let lastBridgedReasoningText: string | undefined;

let reasoningBridgeUnsubscribed = false;

let reasoningBridgeDelivery: Promise<void> = Promise.resolve();

const deliverBridgedReasoningText = async (text: string): Promise<void> => {

if (typeof params.opts?.onReasoningStream !== "function") {

return;

}

await params.opts.onReasoningStream({ text });

};

const queueBridgedReasoningText = (text: string) => {

reasoningBridgeDelivery = reasoningBridgeDelivery

.then(() => deliverBridgedReasoningText(text))

.catch(() => undefined);

};

const drainReasoningBridgeDelivery = async (): Promise<void> => {

await reasoningBridgeDelivery;

};

// CLI-runtime-only bridge: claude-opus-4-7 over `claude --output-format

// stream-json` suppresses readable `thinking_delta` events on the wire,

// so the reasoning preview lane stays silent during streaming. Bridge

// `stream: "assistant"` agent-events to `onReasoningStream` so the

// reasoning lane reflects the model's live text output. The reply lane

// is unaffected: `onPartialReply` is still settled by the assistant-text

// bridge above (PR #76914). API/native runtimes get reasoning content

// from real thinking_delta events and must NOT double-receive

// text_delta as reasoning — this bridge is gated on `isCliProvider`.

const rawUnsubscribeReasoningBridge = onAgentEvent((evt) => {

if (evt.runId !== runId || evt.stream !== "assistant") {

return;

}

if (params.followupRun.run.silentExpected) {

return;

}

const text = typeof evt.data.text === "string" ? evt.data.text : undefined;

if (text === undefined || text === lastBridgedReasoningText) {

return;

}

lastBridgedReasoningText = text;

queueBridgedReasoningText(text);

});

const unsubscribeReasoningBridge = () => {

if (reasoningBridgeUnsubscribed) {

return;

}

reasoningBridgeUnsubscribed = true;

rawUnsubscribeReasoningBridge();

};

const reasoningBridge = shouldBridgeCliAssistantTextToReasoning(cliExecutionProvider)

? createAssistantTextBridge(async (text) => {

await params.opts?.onReasoningStream?.({ text });

})

: noopBridge;

try {

const result = await runCliAgent({

sessionId: params.followupRun.run.sessionId,

result.meta?.systemPromptReport,

);

unsubscribeAssistantBridge();

unsubscribeReasoningBridge();

await drainAssistantBridgeDelivery();

await drainReasoningBridgeDelivery();

assistantBridge.unsubscribe();

reasoningBridge.unsubscribe();

await assistantBridge.drain();

await reasoningBridge.drain();

// CLI backends don't emit streaming assistant events, so we need to

// emit one with the final text so server-chat can populate its buffer

return result;

} catch (err) {

unsubscribeAssistantBridge();

unsubscribeReasoningBridge();

await drainAssistantBridgeDelivery();

await drainReasoningBridgeDelivery();

assistantBridge.unsubscribe();

reasoningBridge.unsubscribe();

await assistantBridge.drain();

await reasoningBridge.drain();

if (rollbackFallbackCandidateSelection) {

try {

await rollbackFallbackCandidateSelection();

lifecycleTerminalEmitted = true;

throw err;

} finally {

unsubscribeAssistantBridge();

unsubscribeReasoningBridge();

assistantBridge.unsubscribe();

reasoningBridge.unsubscribe();

// Defensive backstop: never let a CLI run complete without a terminal

// lifecycle event, otherwise downstream consumers can hang.

if (!lifecycleTerminalEmitted) {