});

expect(emitWarning).toHaveBeenCalledOnce();

const [message, options] = emitWarning.mock.calls[0] as [

const [message, options] = emitWarning.mock.calls.at(0) as [

string,

{ code: string; type: string },

];

},

);

const [, requestAuth] = (resolveOperatorScopes.mock.calls[0] as unknown as

const [, requestAuth] = (resolveOperatorScopes.mock.calls.at(0) as unknown as

| [IncomingMessage, { authMethod?: string; trustDeclaredOperatorScopes: boolean }]

| undefined) ?? [undefined, undefined];

expect(requestAuth?.authMethod).toBe("token");

expect(response.status).toBe(200);

expect(payload.result?.isError).toBe(false);

expect(execute).toHaveBeenCalledTimes(1);

const [callId, params, signal] = execute.mock.calls[0] ?? [];

const [callId, params, signal] = execute.mock.calls.at(0) ?? [];

expect(callId).toMatch(/^mcp-/);

expect(params).toEqual({ body: "hello" });

expect(signal).toBeInstanceOf(AbortSignal);

respond: ReturnType<typeof vi.fn>,

expected: { code?: string; messageIncludes?: string },

) {

const call = respond.mock.calls[0];

const call = respond.mock.calls.at(0);

if (!call) {

throw new Error("expected response call");

}

function expectRespondedErrorMessage(opts: GatewayRequestHandlerOptions, message: string): void {

const respond = opts.respond as ReturnType<typeof vi.fn>;

expect(respond).toHaveBeenCalledTimes(1);

const call = respond.mock.calls[0] as unknown as [boolean, unknown, { message?: string }];

const call = respond.mock.calls.at(0) as unknown as [boolean, unknown, { message?: string }];

expect(call[0]).toBe(false);

expect(call[1]).toBeUndefined();

expect(call[2]?.message).toBe(message);

respond,

context: mockContext(),

} as never);

return respond.mock.calls[0];

const call = respond.mock.calls.at(0);

if (call === undefined) {

throw new Error("expected environments handler to respond");

}

return call;

}

beforeEach(() => {

} as never,

});

const call = respond.mock.calls[0] as

const call = respond.mock.calls.at(0) as

| [boolean, unknown, { code?: number; message?: string }]

| undefined;

expect(call?.[0]).toBe(false);

context: {} as never,

});

const call = respond.mock.calls[0] as

const call = respond.mock.calls.at(0) as

| [boolean, unknown, { code?: string; message?: string }]

| undefined;

expect(call?.[0]).toBe(false);

respond: ReturnType<typeof vi.fn>,

expected: { code: string; message?: string },

): void {

const call = respond.mock.calls[0];

const call = respond.mock.calls.at(0);

expect(call?.[0]).toBe(false);

expect(call?.[1]).toBeUndefined();

const error = requireRecord(call?.[2]);

idempotencyKey: "idem-send-options",

});

const options = mocks.deliverOutboundPayloads.mock.calls[0]?.[0];

const options = mocks.deliverOutboundPayloads.mock.calls.at(0)?.[0];

expect(options?.forceDocument).toBe(true);

expect(options?.silent).toBe(true);

expect(options?.formatting).toEqual({ parseMode: "HTML" });