const agentCommandFromIngressMock = vi.fn();

let registeredListener: ((evt: unknown) => void) | undefined;

const embeddedEventTimestamp = Date.parse("2026-05-09T07:26:00.000Z");

vi.mock("../agents/agent-command.js", () => ({

agentCommandFromIngress: (...args: unknown[]) => agentCommandFromIngressMock(...args),

const originalRuntimeError = defaultRuntime.error;

beforeEach(() => {

vi.useFakeTimers();

vi.setSystemTime(embeddedEventTimestamp);

agentCommandFromIngressMock.mockReset();

registeredListener = undefined;

setEmbeddedMode(false);

});

afterEach(() => {

vi.useRealTimers();

setEmbeddedMode(false);

defaultRuntime.log = originalRuntimeLog;

defaultRuntime.error = originalRuntimeError;

message: {

role: "assistant",

content: [{ type: "text", text: "hello" }],

timestamp: expect.any(Number),

timestamp: embeddedEventTimestamp,

},

},

},

message: {

role: "assistant",

content: [{ type: "text", text: "hello" }],

timestamp: expect.any(Number),

timestamp: embeddedEventTimestamp,

},

},

},

.filter((entry) => entry.event === "chat")

.map(

(entry) =>

entry.payload as { state?: string; message?: { content?: Array<{ text?: string }> } },

entry.payload as {

runId?: string;

sessionKey?: string;

state?: string;

stopReason?: string;

message?: { content?: Array<{ text?: string }> };

},

);

const nonEmptyDeltas = chatPayloads.filter(

(payload) => payload.state === "delta" && payload.message?.content?.[0]?.text,

);

expect(nonEmptyDeltas).toHaveLength(0);

expect(chatPayloads.at(-1)).toEqual(

expect.objectContaining({

state: "final",

message: {

role: "assistant",

content: [{ type: "text", text: "No" }],

timestamp: expect.any(Number),

},

}),

);

expect(chatPayloads.at(-1)).toStrictEqual({

runId: "run-local-no",

sessionKey: "agent:main:main",

state: "final",

stopReason: "stop",

message: {

role: "assistant",

content: [{ type: "text", text: "No" }],

timestamp: embeddedEventTimestamp,

},

});

});

it("emits side-result events for local /btw runs", async () => {

message: {

role: "assistant",

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

timestamp: expect.any(Number),

timestamp: embeddedEventTimestamp,

},

},

},

message: {

role: "assistant",

content: [{ type: "text", text: "done" }],

timestamp: expect.any(Number),

timestamp: embeddedEventTimestamp,

},

},

},

await flushMicrotasks();

expect(agentCommandFromIngressMock).toHaveBeenCalledTimes(1);

expect(agentCommandFromIngressMock.mock.calls[0]?.[0]).toEqual(

expect.objectContaining({

timeout: "300",

}),

);

const ingressOptions = agentCommandFromIngressMock.mock.calls[0]?.[0] as

| { timeout?: unknown }

| undefined;

expect(ingressOptions?.timeout).toBe("300");

} finally {

backend.stop();

}