import { afterEach, describe, expect, it } from "vitest";

import { type WebSocket, WebSocketServer } from "ws";

import { rawDataToString } from "../infra/ws.js";

import "../test-support/browser-security.mock.js";

import {

type AriaSnapshotNode,

captureScreenshot,

import { describe, expect, it, vi } from "vitest";

import type { BrowserRouteContext, ProfileContext } from "../server-context.js";

import "../../test-support/browser-security.mock.js";

import {

readBody,

resolveSafeRouteTabUrl,

import { afterEach, describe, expect, it, vi } from "vitest";

import "../../../test-support.js";

import "../server-context.chrome-test-harness.js";

import "../../test-support/browser-security.mock.js";

import * as chromeModule from "../chrome.js";

import { createBrowserRouteContext } from "../server-context.js";

import { makeBrowserServerState } from "../server-context.test-harness.js";

import { afterEach, describe, expect, it, vi } from "vitest";

import { withBrowserFetchPreconnect } from "../../test-fetch.js";

import "../test-support/browser-security.mock.js";

vi.hoisted(() => {

vi.resetModules();

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import { getFreePort } from "./test-port.js";

import { getBrowserTestFetch } from "./test-support/fetch.js";

import "../test-support/browser-security.mock.js";

let testPort = 0;

let prevGatewayPort: string | undefined;

import { vi } from "vitest";

const lookupFn = vi.hoisted(() => async (_hostname: string, options?: { all?: boolean }) => {

const result = { address: "93.184.216.34", family: 4 };

return options?.all === true ? [result] : result;

});

vi.mock("../infra/net/ssrf.js", async () => {

const actual =

await vi.importActual<typeof import("../infra/net/ssrf.js")>("../infra/net/ssrf.js");

return {

...actual,

resolvePinnedHostnameWithPolicy: (hostname: string, params: object = {}) =>

actual.resolvePinnedHostnameWithPolicy(hostname, { ...params, lookupFn: lookupFn as never }),

};

});

vi.mock("../sdk-security-runtime.js", async () => {

const actual = await vi.importActual<typeof import("../sdk-security-runtime.js")>(

"../sdk-security-runtime.js",

);

const lookupFn = async (_hostname: string, options?: { all?: boolean }) => {

const result = { address: "93.184.216.34", family: 4 };

return options?.all === true ? [result] : result;

};

return {

...actual,

resolvePinnedHostnameWithPolicy: (hostname: string, params: object = {}) =>

mode: "progress",

progress: {

label: "Clawing...",

maxLines: 3,

maxLines: 4,

},

},

},

});

await runProcessDiscordMessage(ctx);

expect(draftStream.update).toHaveBeenNthCalledWith(1, "Clawing...\n🧩 First\n🧩 Second");

expect(draftStream.update).toHaveBeenNthCalledWith(2, "🧩 First\n🧩 Second\n🧩 Third");

expect(draftStream.update).toHaveBeenCalledWith("Clawing...\n🧩 First\n🧩 Second\n🧩 Third");

});

it("skips empty apply_patch starts and renders the patch summary", async () => {

import { describe, expect, it, vi } from "vitest";

import { mockPinnedHostnameResolution } from "openclaw/plugin-sdk/test-env";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {

elevenLabsMediaUnderstandingProvider,

transcribeElevenLabsAudio,

} from "./media-understanding-provider.js";

describe("elevenLabsMediaUnderstandingProvider", () => {

let ssrfMock: { mockRestore: () => void } | undefined;

beforeEach(() => {

ssrfMock = mockPinnedHostnameResolution();

});

afterEach(() => {

ssrfMock?.mockRestore();

ssrfMock = undefined;

});

it("has expected provider metadata", () => {

expect(elevenLabsMediaUnderstandingProvider.id).toBe("elevenlabs");

expect(elevenLabsMediaUnderstandingProvider.capabilities).toEqual(["audio"]);

import * as providerAuthRuntime from "openclaw/plugin-sdk/provider-auth-runtime";

import * as providerHttp from "openclaw/plugin-sdk/provider-http";

import { afterEach, describe, expect, it, vi } from "vitest";

import { mockPinnedHostnameResolution } from "openclaw/plugin-sdk/test-env";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import { buildGoogleImageGenerationProvider } from "./image-generation-provider.js";

import { __testing as geminiWebSearchTesting } from "./src/gemini-web-search-provider.js";

let ssrfMock: { mockRestore: () => void } | undefined;

function mockGoogleApiKeyAuth() {

vi.spyOn(providerAuthRuntime, "resolveApiKeyForProvider").mockResolvedValue({

apiKey: "google-test-key",

}

describe("Google image-generation provider", () => {

beforeEach(() => {

ssrfMock = mockPinnedHostnameResolution();

});

afterEach(() => {

ssrfMock?.mockRestore();

ssrfMock = undefined;

vi.restoreAllMocks();

vi.unstubAllGlobals();

});

import { writeFile } from "node:fs/promises";

import path from "node:path";

import { afterAll, afterEach, describe, expect, it, vi } from "vitest";

import { mockPinnedHostnameResolution } from "openclaw/plugin-sdk/test-env";

import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from "vitest";

const { createGoogleGenAIMock, downloadMock, generateVideosMock, getVideosOperationMock } =

vi.hoisted(() => {

return recordField(firstObjectArg(createGoogleGenAIMock).httpOptions, "httpOptions");

}

let ssrfMock: { mockRestore: () => void } | undefined;

describe("google video generation provider", () => {

beforeEach(() => {

ssrfMock = mockPinnedHostnameResolution();

});

afterEach(() => {

ssrfMock?.mockRestore();

ssrfMock = undefined;

vi.restoreAllMocks();

vi.unstubAllGlobals();

downloadMock.mockReset();