});

expect(fetchImpl).toHaveBeenCalledTimes(1);

const [calledUrl, calledInit] = fetchImpl.mock.calls[0];

const [calledUrl, calledInit] = fetchImpl.mock.calls.at(0) ?? [];

expect(calledUrl).toBe("https://api.githubcopilot.com/models");

expect((calledInit as RequestInit).method).toBe("GET");

expect(((calledInit as RequestInit).headers as Record<string, string>).Authorization).toBe(

fetchImpl: fetchImpl as unknown as typeof fetch,

});

expect(fetchImpl.mock.calls[0][0]).toBe("https://api.githubcopilot.com/models");

expect(fetchImpl.mock.calls.at(0)?.[0]).toBe("https://api.githubcopilot.com/models");

});

it("dedupes by id when API returns duplicates", async () => {

],

{ from: "user" },

);

const gatewayCall = callGatewayFromCli.mock.calls[0] as unknown as

const gatewayCall = callGatewayFromCli.mock.calls.at(0) as unknown as

| [

string,

{ json?: boolean; timeout?: unknown },

expectFields(checks[0], { id: "oauth-config", ok: true });

expectFields(checks[1], { id: "oauth-token", ok: true });

expect(ensureRuntime).not.toHaveBeenCalled();

const body = fetchMock.mock.calls[0]?.[1]?.body as URLSearchParams;

const body = fetchMock.mock.calls.at(0)?.[1]?.body as URLSearchParams;

expect(body.get("grant_type")).toBe("refresh_token");

} finally {

stdout.restore();

{ timeoutMs: 10_000 },

);

expect(runtime.log).toHaveBeenCalledTimes(1);

expect(String(runtime.log.mock.calls[0][0])).toContain(

expect(String(runtime.log.mock.calls.at(0)?.[0])).toContain(

"imessage: watch.subscribe startup failed (attempt 1/3): Error: imsg rpc timeout (watch.subscribe); retrying",

);

expect(

expect((monitorError as Error).message).toContain("imsg rpc timeout (watch.subscribe)");

expect(createIMessageRpcClientMock).toHaveBeenCalledTimes(3);

expect(runtime.error).toHaveBeenCalledTimes(1);

expect(String(runtime.error.mock.calls[0][0])).toContain(

expect(String(runtime.error.mock.calls.at(0)?.[0])).toContain(

"imessage: monitor failed: Error: imsg rpc timeout (watch.subscribe)",

);

});

expect(MessagingApiBlobClientMock).toHaveBeenCalledWith({ channelAccessToken: "line-token" });

expect(setRichMenuImageMock).toHaveBeenCalledOnce();

const [richMenuId, blob] = setRichMenuImageMock.mock.calls[0] ?? [];

const [richMenuId, blob] = setRichMenuImageMock.mock.calls.at(0) ?? [];

expect(richMenuId).toBe("rich-menu-1");

expect(blob).toBeInstanceOf(Blob);

expect((blob as Blob).type).toBe("image/png");

});

expect(setRichMenuImageMock).toHaveBeenCalledOnce();

const blob = setRichMenuImageMock.mock.calls[0]?.[1] as Blob;

const blob = setRichMenuImageMock.mock.calls.at(0)?.[1] as Blob;

expect(blob.type).toBe("image/jpeg");

await expect(blob.arrayBuffer()).resolves.toEqual(

imageBytes.buffer.slice(imageBytes.byteOffset, imageBytes.byteOffset + imageBytes.byteLength),

async function executeEmbeddedRun(input: Record<string, unknown>) {

const tool = createLlmTaskTool(fakeApi());

await tool.execute("id", input);

return (runEmbeddedPiAgent as any).mock.calls[0]?.[0];

return (runEmbeddedPiAgent as any).mock.calls.at(0)?.[0];

}

describe("llm-task tool (json-only)", () => {

await tool.execute("id", { prompt: "x", model: "gemini-flash" });

const call = (runEmbeddedPiAgent as any).mock.calls[0]?.[0];

const call = (runEmbeddedPiAgent as any).mock.calls.at(0)?.[0];

expect(call.provider).toBe("google");

expect(call.model).toBe("gemini-3-flash-preview");

});

await stream.stop();

expect(sendMessageMock).toHaveBeenCalledTimes(1);

expect(sendMessageMock.mock.calls[0]?.[1]).toHaveProperty("org.matrix.msc4357.live");

expect(sendMessageMock.mock.calls.at(0)?.[1]).toHaveProperty("org.matrix.msc4357.live");

});

it("finalizeLive clears the live marker at most once", async () => {

await stream.finalizeLive();

expect(sendMessageMock).toHaveBeenCalledTimes(2);

expect(sendMessageMock.mock.calls[1]?.[1]).not.toHaveProperty("org.matrix.msc4357.live");

expect(sendMessageMock.mock.calls.at(1)?.[1]).not.toHaveProperty("org.matrix.msc4357.live");

});

it("marks live finalize failures for normal final delivery fallback", async () => {

}

function readFirstMockArg(fn: unknown): unknown {

return (fn as { mock: { calls: unknown[][] } }).mock.calls[0]?.[0];

return (fn as { mock: { calls: unknown[][] } }).mock.calls.at(0)?.[0];

}

describe("createMatrixRoomMessageHandler thread root media", () => {

expect(formatAgentEnvelope).toHaveBeenCalledTimes(1);

const envelope = requireRecord(

formatAgentEnvelope.mock.calls[0]?.[0],

formatAgentEnvelope.mock.calls.at(0)?.[0],

"format agent envelope params",

);

expect(String(envelope.body)).toContain("replying");

await client.start();

const startOpts = matrixJsClient.startClient.mock.calls[0]?.[0] as

const startOpts = matrixJsClient.startClient.mock.calls.at(0)?.[0] as

| { filter?: { getDefinition?: () => unknown } }

| undefined;

expect(startOpts?.filter?.getDefinition?.()).toEqual({

await client.start();

expect(databasesSpy).toHaveBeenCalled();

const intervalCall = setIntervalSpy.mock.calls[0] as unknown[];

const intervalCall = setIntervalSpy.mock.calls.at(0) as unknown[];

expect(intervalCall[0]).toBeTypeOf("function");

expect(intervalCall[1]).toBe(60_000);

client.stop();

expect(mockState.enqueueSystemEvent).not.toHaveBeenCalled();

expect(mockState.dispatchReplyFromConfig).toHaveBeenCalledTimes(1);

const ctx = mockState.dispatchReplyFromConfig.mock.calls[0]?.[0].ctx;

const ctx = mockState.dispatchReplyFromConfig.mock.calls.at(0)?.[0].ctx;

expect(ctx?.BodyForAgent).toBe("hello from mattermost");

expect(ctx?.ConversationLabel).toBe("Town Square id:chan-1");

expect(ctx?.MessageSid).toBe("post-1");

await monitor;

expect(runtimeCore.channel.session.recordInboundSession).toHaveBeenCalledTimes(1);

const [recordCall] = runtimeCore.channel.session.recordInboundSession.mock.calls[0] ?? [];

const [recordCall] = runtimeCore.channel.session.recordInboundSession.mock.calls.at(0) ?? [];

expect(recordCall?.storePath).toBe("/tmp/openclaw-test-sessions.json");

expect(recordCall?.sessionKey).toBe("mattermost:default:channel:chan-1");

const updateLastRoute = recordCall?.updateLastRoute;

expect(decision.dropReason).toBeNull();

expect(decision.shouldRequireMention).toBe(false);

expect(resolver).toHaveBeenCalledTimes(1);

const [resolverCall] = resolver.mock.calls[0] ?? [];

const [resolverCall] = resolver.mock.calls.at(0) ?? [];

expect(resolverCall).toStrictEqual({

cfg,

channel: "mattermost",

});

expect(updateMattermostPostSpy).toHaveBeenCalledTimes(1);

const [updateClient, updatePostId, updateParams] = updateMattermostPostSpy.mock.calls[0] ?? [];

const [updateClient, updatePostId, updateParams] =

updateMattermostPostSpy.mock.calls.at(0) ?? [];

expect(updateClient).toBe(client);

expect(updatePostId).toBe("preview-post-1");

expect(updateParams).toStrictEqual({ message: "Final answer" });