import { FailoverError } from "../failover-error.js";

import { runAgentHarnessBeforeMessageWriteHook } from "../harness/hook-helpers.js";

import { resolveAvailableAgentHarnessPolicy } from "../harness/selection.js";

import { AGENT_LANE_SUBAGENT } from "../lanes.js";

import { resolveCliRuntimeExecutionProvider } from "../model-runtime-aliases.js";

import { isCliProvider } from "../model-selection.js";

import { resolveOpenAIRuntimeProvider } from "../openai-routing.js";

runId: params.runId,

lifecycleGeneration: params.lifecycleGeneration,

lane: params.opts.lane,

// Subagents have no live stream consumer (result is read back from the

// persisted transcript), so skip per-chunk live visible-text parsing.

suppressLiveStreamOutput: params.opts.lane === AGENT_LANE_SUBAGENT,

abortSignal: params.opts.abortSignal,

extraSystemPrompt: params.opts.extraSystemPrompt,

bootstrapContextMode: params.opts.bootstrapContextMode,

modelRun?: boolean;

promptMode?: string;

promptCacheKey?: string;

suppressLiveStreamOutput?: boolean;

} {

const call = mockedRunEmbeddedAttempt.mock.calls[0] as

| [

modelRun?: boolean;

promptMode?: string;

promptCacheKey?: string;

suppressLiveStreamOutput?: boolean;

},

]

| undefined;

expect(firstAttemptParams().promptCacheKey).toBe("cron-cache-key");

});

it("forwards suppressed live stream output into the embedded attempt", async () => {

mockedRunEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: null }));

await runEmbeddedAgent({

...overflowBaseRunParams,

suppressLiveStreamOutput: true,

});

expect(firstAttemptParams().suppressLiveStreamOutput).toBe(true);

});

});

ownerNumbers: params.ownerNumbers,

enforceFinalTag: params.enforceFinalTag,

silentExpected: params.silentExpected,

suppressLiveStreamOutput: params.suppressLiveStreamOutput,

bootstrapContextMode: params.bootstrapContextMode,

bootstrapContextRunKind: params.bootstrapContextRunKind,

jobId: params.jobId,

},

enforceFinalTag: params.enforceFinalTag,

silentExpected: params.silentExpected,

suppressLiveStreamOutput: params.suppressLiveStreamOutput,

config: params.config,

sessionKey: sandboxSessionKey,

currentChannelId: params.currentChannelId,

ownerNumbers?: string[];

enforceFinalTag?: boolean;

silentExpected?: boolean;

/** Skip per-chunk live visible-text parsing when no live stream consumer exists (e.g. subagents). */

suppressLiveStreamOutput?: boolean;

/**

* Treat a clean empty assistant stop as an intentional silent reply.

* Only set when the caller's prompt policy already allows an exact NO_REPLY

if (isPhasePendingOpenAiResponsesTextItem) {

return;

}

// Subagents have no live consumer; their final result is delivered from

// message_end. Keep accumulating deltaBuffer, but skip per-chunk visible-text

// parsing so long parallel subagent streams do not monopolize the event loop.

const skipLiveStream = ctx.params.suppressLiveStreamOutput === true;

const shouldUsePhaseAwareBlockReply = Boolean(deliveryPhase);

if (chunk) {

ctx.state.deltaBuffer += chunk;

if (!shouldUsePhaseAwareBlockReply) {

if (!skipLiveStream && !shouldUsePhaseAwareBlockReply) {

appendBlockReplyChunk(ctx, chunk);

}

}

if (skipLiveStream) {

return;

}

if (!suppressMessageToolOnlySourceReplyOutput && ctx.state.streamReasoning) {

// Handle partial <think> tags: stream whatever reasoning is visible so far.

ctx.emitReasoningStream(extractThinkingFromTaggedStream(ctx.state.deltaBuffer));

},

);

it("suppressLiveStreamOutput skips per-chunk preview but still delivers final text", () => {

const onAgentEvent = vi.fn();

const { emit } = createSubscribedHarness({

runId: "run",

onAgentEvent,

suppressLiveStreamOutput: true,

});

emit({ type: "message_start", message: { role: "assistant" } });

emitAssistantTextDelta(emit, "Hello ");

emitAssistantTextDelta(emit, "world");

// No live preview events while suppressed (the per-chunk parsing path is skipped).

expect(extractAgentEventPayloads(onAgentEvent.mock.calls)).toHaveLength(0);

const assistantMessage = {

role: "assistant",

content: [{ type: "text", text: "Hello world" }],

} as AssistantMessage;

emit({ type: "message_end", message: assistantMessage });

expectSingleAgentEventText(onAgentEvent.mock.calls, "Hello world");

});

it("blocks local MEDIA urls from case-variant tool names in verbose output", async () => {

const onToolResult = vi.fn();

const { emit } = createSubscribedHarness({

onBeforeLifecycleTerminal?: () => void | Promise<void>;

enforceFinalTag?: boolean;

silentExpected?: boolean;

/**

* Skip per-chunk live visible-text parsing in handleMessageUpdate. Set for runs

* with no live stream consumer — notably subagents, whose result is read back

* from the final message_end path. Suppressing intermediate passes does not

* change final output.

*/

suppressLiveStreamOutput?: boolean;

config?: OpenClawConfig;

sessionKey?: string;

/** Current transport channel resolved for this run. */