function mockCalls(mock: unknown, label: string): Array<Array<unknown>> {

const mockState = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock;

expect(mockState, `${label}.mock`).toBeDefined();

expect(Array.isArray(mockState?.calls), `${label}.mock.calls`).toBe(true);

return mockState?.calls ?? [];

if (!mockState) {

throw new Error(`Expected ${label}.mock`);

}

const calls = mockState.calls;

if (!Array.isArray(calls)) {

throw new Error(`Expected ${label}.mock.calls`);

}

return calls;

}

function findMockCall(mock: unknown, label: string, predicate: (call: Array<unknown>) => boolean) {

const call = mockCalls(mock, label).find(predicate);

expect(call, label).toBeDefined();

return call as Array<unknown>;

if (!call) {

throw new Error(`Expected ${label}`);

}

return call;

}

function responsePayload(respond: unknown): Record<string, unknown> {

model: ProviderRuntimeModel | undefined,

fields: Partial<ProviderRuntimeModel>,

) {

expect(model).toBeDefined();

if (!model) {

throw new Error("expected provider model");

}

});

const mediaProvider = mediaProviders.find((provider) => provider.id === "opencode-go");

expect(mediaProvider).toBeDefined();

expect(mediaProvider?.capabilities).toEqual(["image"]);

expect(mediaProvider?.defaultModels).toEqual({ image: "kimi-k2.6" });

expect(typeof mediaProvider?.describeImage).toBe("function");

expect(typeof mediaProvider?.describeImages).toBe("function");

if (!mediaProvider) {

throw new Error("Expected opencode-go media provider");

}

expect(mediaProvider.capabilities).toEqual(["image"]);

expect(mediaProvider.defaultModels).toEqual({ image: "kimi-k2.6" });

expect(typeof mediaProvider.describeImage).toBe("function");

expect(typeof mediaProvider.describeImages).toBe("function");

});

it("owns passthrough-gemini replay policy for Gemini-backed models", async () => {

});

expect(rows).toHaveLength(1);

const row = rows[0];

expect(row).toBeDefined();

if (!row) {

throw new Error("expected OpenRouter catalog row");

}

function requireSlackSendCall(index: number) {

const call = sendSlackMessage.mock.calls[index] as unknown[] | undefined;

expect(call).toBeDefined();

if (!call) {

throw new Error(`missing Slack send call ${index + 1}`);

}

function gatewayRequest(method: string): { method?: string; params?: Record<string, unknown> } {

const request = gatewayRequests().find((candidate) => candidate.method === method);

expect(request).toBeDefined();

return request as { method?: string; params?: Record<string, unknown> };

if (!request) {

throw new Error(`Expected gateway request for ${method}`);

}

return request;

}

function expectGatewayMethodNotCalled(method: string): void {

function requireMockArg(mock: typeof runCliAgentMock, callIndex: number, label: string) {

const arg = mock.mock.calls[callIndex]?.[0];

expect(arg).toBeDefined();

if (arg === undefined) {

throw new Error(`Expected mock argument for ${label}`);

}

return requireRecord(arg, label);

}

function expectRetryAfterHeader(setHeader: ReturnType<typeof vi.fn>): void {

const retryAfterCall = setHeader.mock.calls.find(([name]) => name === "Retry-After");

expect(retryAfterCall).toBeDefined();

const retryAfterValue = retryAfterCall?.[1];

if (!retryAfterCall) {

throw new Error("Expected Retry-After header call");

}

const retryAfterValue = retryAfterCall[1];

expect(typeof retryAfterValue).toBe("string");

expect(Number.parseInt(String(retryAfterValue), 10)).toBeGreaterThan(0);

}

function mockCall(source: MockCallSource, index: number, label: string) {

const call = source.mock.calls[index];

expect(call, label).toBeDefined();

if (!call) {

throw new Error(`Expected ${label}`);

}

return call;

}

function responseCall(source: MockCallSource, index = 0) {

const call = mockCall(source, index, `response call ${index}`);

return {

ok: call?.[0],

result: call?.[1],

error: call?.[2],

ok: call[0],

result: call[1],

error: call[2],

};

}

? (result as Record<string, unknown>).status === "accepted"

: false;

});

expect(call, "accepted response call").toBeDefined();

return requireRecord(call?.[1], "accepted response result");

if (!call) {

throw new Error("Expected accepted response call");

}

return requireRecord(call[1], "accepted response result");

}

function acceptedApprovalId(source: MockCallSource) {

function firstMockArg(mock: { mock: { calls: unknown[][] } }, label: string): unknown {

const arg = mock.mock.calls[0]?.[0];

expect(arg, label).toBeDefined();

if (arg === undefined) {

throw new Error(`Expected ${label}`);

}

return arg;

}