params.model,

);

expect(agent.streamFn).toEqual(expect.any(Function));

if (!agent.streamFn) {

throw new Error("expected extra params to wrap streamFn");

}

}

// Mock the logger to avoid noise in tests

});

const dispatcherOptions = hoisted.createReplyDispatcherMock.mock.calls[0]?.[0];

expect(dispatcherOptions?.beforeDeliver).toEqual(expect.any(Function));

if (!dispatcherOptions?.beforeDeliver) {

throw new Error("expected beforeDeliver hook");

}

const payload = await dispatcherOptions.beforeDeliver(

{ text: "original reply" },

});

expect(completeMock).toHaveBeenCalledTimes(2);

const [, , retryOptions] = completeMock.mock.calls[1] ?? [];

expect(retryOptions?.onPayload).toEqual(expect.any(Function));

const retryPayload = await retryOptions?.onPayload?.(

if (!retryOptions?.onPayload) {

throw new Error("expected retry payload mapper");

}

const retryPayload = await retryOptions.onPayload(

{

reasoning: { effort: "high", summary: "auto" },

reasoning_effort: "high",

throw new Error("expected onDiagnosticEvent export");

}

const unsubscribe = (value as (listener: () => void) => () => void)(() => undefined);

expect(unsubscribe).toEqual(expect.any(Function));

unsubscribe();

},

},

])("$name", ({ exportName, exportValue, expectIdentity, assertForwarded }) => {

inflightCallbackDedupe?: Set<string>;

};

expect(hydrated.interactiveHandlers).toBeInstanceOf(Map);

expect(hydrated.callbackDedupe?.clear).toEqual(expect.any(Function));

if (!hydrated.callbackDedupe) {

throw new Error("expected hydrated callback dedupe");

}

expect(() => hydrated.callbackDedupe?.clear()).not.toThrow();

expect(hydrated.inflightCallbackDedupe).toBeInstanceOf(Set);

const handler = vi.fn(async () => ({ handled: true }));