turnResult.dispatched &&

shouldSendNoVisibleReplyFallback({

...turnResult.dispatchResult,

failedCounts: dispatcher.getFailedCounts(),

failedCounts: dispatcher.getFailedCounts?.() ?? { tool: 0, block: 0, final: 0 },

})

) {

await ensureNoVisibleReplyFallback("broadcast-dispatch-complete-no-visible-reply");

if (

shouldSendNoVisibleReplyFallback({

...dispatchResult,

failedCounts: dispatcher.getFailedCounts(),

failedCounts: dispatcher.getFailedCounts?.() ?? { tool: 0, block: 0, final: 0 },

})

) {

await ensureNoVisibleReplyFallback("dispatch-complete-no-visible-reply");

import type { ReplyPayload } from "../types.js";

import { waitForReplyDispatcherIdle } from "./reply-dispatcher.js";

import type { ReplyDispatchKind, ReplyDispatcher } from "./reply-dispatcher.types.js";

import { readDispatcherFailedCounts } from "./reply-dispatcher.types.js";

import { resolveRoutedDeliveryThreadId } from "./routed-delivery-thread.js";

const routeReplyRuntimeLoader = createLazyImportLoader(() => import("./route-reply.runtime.js"));

state.settledDirectVisibleText = true;

hasPendingDirectBlockReplyDelivery = false;

await params.dispatcher.waitForIdle();

const failedCounts = params.dispatcher.getFailedCounts();

const failedCounts = readDispatcherFailedCounts(params.dispatcher);

const failedVisibleCount = failedCounts.block + failedCounts.final;

if (failedVisibleCount > 0) {

state.failedVisibleTextDelivery = true;

import { describe, expect, it } from "vitest";

import { getDispatcherFinalOutcomeCounts } from "./dispatch-from-config.js";

import type { ReplyDispatcher } from "./reply-dispatcher.types.js";

describe("getDispatcherFinalOutcomeCounts (#89116)", () => {

it("returns failed: 0 when the dispatcher does not implement getFailedCounts", () => {

// Some ReplyDispatcher variants omit the optional count methods entirely; the

// previous code called dispatcher.getFailedCounts() unguarded and threw

// "TypeError: dispatcher.getFailedCounts is not a function".

const dispatcher = {

getCancelledCounts: () => ({ tool: 0, block: 0, final: 2 }),

// getFailedCounts intentionally absent

} as unknown as ReplyDispatcher;

expect(() => getDispatcherFinalOutcomeCounts(dispatcher)).not.toThrow();

expect(getDispatcherFinalOutcomeCounts(dispatcher)).toEqual({ cancelled: 2, failed: 0 });

});

it("returns cancelled: 0 when getCancelledCounts is absent (existing behavior preserved)", () => {

const dispatcher = {

getFailedCounts: () => ({ tool: 0, block: 1, final: 3 }),

} as unknown as ReplyDispatcher;

expect(getDispatcherFinalOutcomeCounts(dispatcher)).toEqual({ cancelled: 0, failed: 3 });

});

it("uses the real final counts when both methods are present", () => {

const dispatcher = {

getCancelledCounts: () => ({ tool: 0, block: 0, final: 1 }),

getFailedCounts: () => ({ tool: 0, block: 0, final: 5 }),

} as unknown as ReplyDispatcher;

expect(getDispatcherFinalOutcomeCounts(dispatcher)).toEqual({ cancelled: 1, failed: 5 });

});

});

import { claimInboundDedupe, commitInboundDedupe, releaseInboundDedupe } from "./inbound-dedupe.js";

import { resolveOriginMessageProvider } from "./origin-routing.js";

import { waitForReplyDispatcherIdle } from "./reply-dispatcher.js";

import type { ReplyDispatchKind, ReplyDispatcher } from "./reply-dispatcher.types.js";

import type {

DispatcherOutcomeCountsView,

ReplyDispatchKind,

ReplyDispatcher,

} from "./reply-dispatcher.types.js";

import { readDispatcherFailedCounts } from "./reply-dispatcher.types.js";

import { replyRunRegistry, type ReplyOperation } from "./reply-run-registry.js";

import { isReplyProfilerEnabled } from "./reply-timing-tracker.js";

import { admitReplyTurn, resolveReplyTurnKind } from "./reply-turn-admission.js";

}

}

function getDispatcherFinalOutcomeCounts(dispatcher: ReplyDispatcher): {

export function getDispatcherFinalOutcomeCounts(dispatcher: DispatcherOutcomeCountsView): {

cancelled: number;

failed: number;

} {

return {

cancelled: dispatcher.getCancelledCounts?.().final ?? 0,

failed: dispatcher.getFailedCounts().final,

failed: readDispatcherFailedCounts(dispatcher).final,

};

}

sendFinalReply: sendIfActive(params.dispatcher.sendFinalReply),

waitForIdle: () => params.dispatcher.waitForIdle(),

getQueuedCounts: () => params.dispatcher.getQueuedCounts(),

getFailedCounts: () => params.dispatcher.getFailedCounts(),

getFailedCounts: () => readDispatcherFailedCounts(params.dispatcher),

markComplete: () => {

if (!params.isAborted()) {

params.dispatcher.markComplete();

getFailedCounts: () => Record<ReplyDispatchKind, number>;

markComplete: () => void;

};

/**

* Internal view for defensive outcome-count accounting. Some non-conforming

* runtime dispatcher variants (for example plugin-provided dispatchers) may omit

* these readers even though the public ReplyDispatcher contract requires

* getFailedCounts. Read the counters through this view so the guards stay

* type-correct without weakening the SDK-visible ReplyDispatcher type.

*/

export type DispatcherOutcomeCountsView = {

getCancelledCounts?: () => Record<ReplyDispatchKind, number>;

getFailedCounts?: () => Record<ReplyDispatchKind, number>;

};

export function readDispatcherFailedCounts(

dispatcher: DispatcherOutcomeCountsView,

): Record<ReplyDispatchKind, number> {

return dispatcher.getFailedCounts?.() ?? { tool: 0, block: 0, final: 0 };

}