import { beforeEach, describe, expect, it, vi } from "vitest";import { createApiCore } from "./core";import { clearStoredBackendUrl, getStoredBackendUrl } from "../backend-url"; vi.mock("../backend-url", () => ({  getStoredBackendUrl: vi.fn(),  clearStoredBackendUrl: vi.fn(),})); vi.mock("../api-key", () => ({  getApiKey: vi.fn(() => ""),})); const getStoredBackendUrlMock = vi.mocked(getStoredBackendUrl);const clearStoredBackendUrlMock = vi.mocked(clearStoredBackendUrl); const encode = (text: string) => new TextEncoder().encode(text); const sseResponse = (chunks: string[], headers?: Record<string, string>) =>  new Response(    new ReadableStream<Uint8Array>({      start(controller) {        for (const chunk of chunks) {          controller.enqueue(encode(chunk));        }        controller.close();      },    }),    {      status: 200,      headers: {        "Content-Type": "text/event-stream",        ...(headers ?? {}),      },    },  ); describe("createApiCore", () => {  beforeEach(() => {    vi.restoreAllMocks();    getStoredBackendUrlMock.mockReturnValue("http://localhost:8080");  });   it("clears stale backend override when proxy marks it invalid", async () => {    const fetchMock = vi.fn().mockResolvedValue(      new Response(JSON.stringify({ ok: true }), {        status: 200,        headers: {          "Content-Type": "application/json",          "X-Backend-Override-Invalid": "1",        },      }),    );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    await core.request("/status", { retries: 0 });     expect(clearStoredBackendUrlMock).toHaveBeenCalledTimes(1);  });   it("retries once without a stale backend override when the proxy rejects it", async () => {    getStoredBackendUrlMock.mockReturnValue("http://localhost:8080");    const fetchMock = vi      .fn()      .mockResolvedValueOnce(        new Response(JSON.stringify({ error: "blocked" }), {          status: 403,          headers: {            "Content-Type": "application/json",            "X-Backend-Override-Invalid": "1",          },        }),      )      .mockResolvedValueOnce(        new Response(JSON.stringify({ ok: true }), {          status: 200,          headers: {            "Content-Type": "application/json",          },        }),      );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    const result = await core.request<{ ok: boolean }>("/recipes", { retries: 0 });     expect(result.ok).toBe(true);    expect(clearStoredBackendUrlMock).toHaveBeenCalledTimes(1);    expect(fetchMock).toHaveBeenCalledTimes(2);    expect(fetchMock.mock.calls[0]?.[1]?.headers).toMatchObject({      "X-Backend-Url": "http://localhost:8080",    });    expect(fetchMock.mock.calls[1]?.[1]?.headers).not.toHaveProperty("X-Backend-Url");  });   it("does not clear backend override when no invalid marker is present", async () => {    const fetchMock = vi.fn().mockResolvedValue(      new Response(JSON.stringify({ ok: true }), {        status: 200,        headers: {          "Content-Type": "application/json",        },      }),    );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    await core.request("/status", { retries: 0 });     expect(clearStoredBackendUrlMock).not.toHaveBeenCalled();  });   it("parses canonical SSE events from event lines", async () => {    const fetchMock = vi      .fn()      .mockResolvedValue(        sseResponse(          [            "event: run_start\n",            'data: {"run_id":"r1","session_id":"s1"}\n\n',            "event: run_end\n",            'data: {"run_id":"r1","session_id":"s1","status":"completed","error":null}\n\n',          ],          { "X-Run-Id": "r1" },        ),      );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    const { runId, stream } = await core.postSseJson("/chats/s1/turn", { content: "hello" });     const events: Array<{ event: string; data: Record<string, unknown> }> = [];    for await (const entry of stream) {      events.push(entry);    }     expect(runId).toBe("r1");    expect(events.map((entry) => entry.event)).toEqual(["run_start", "run_end"]);    expect(events[1]?.data["status"]).toBe("completed");  });   it("unwraps legacy SSE payloads wrapped as data.event/data", async () => {    const fetchMock = vi      .fn()      .mockResolvedValue(        sseResponse([          'data: {"event":"run_start","data":{"run_id":"legacy-1","session_id":"s1"}}\n\n',          'data: {"event":"run_end","data":{"run_id":"legacy-1","session_id":"s1","status":"completed","error":null}}\n\n',        ]),      );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    const { stream } = await core.postSseJson("/chats/s1/turn", { content: "hello" });     const events: Array<{ event: string; data: Record<string, unknown> }> = [];    for await (const entry of stream) {      events.push(entry);    }     expect(events.map((entry) => entry.event)).toEqual(["run_start", "run_end"]);    expect(events[1]?.data["run_id"]).toBe("legacy-1");    expect(events[1]?.data["status"]).toBe("completed");  });   it("unwraps legacy SSE payloads wrapped as data.type/payload", async () => {    const fetchMock = vi      .fn()      .mockResolvedValue(        sseResponse([          'data: {"type":"run_start","payload":{"run_id":"legacy-2","session_id":"s2"}}\n\n',          'data: {"type":"run_end","payload":{"run_id":"legacy-2","session_id":"s2","status":"completed","error":null}}\n\n',        ]),      );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    const { stream } = await core.postSseJson("/chats/s2/turn", { content: "hello" });     const events: Array<{ event: string; data: Record<string, unknown> }> = [];    for await (const entry of stream) {      events.push(entry);    }     expect(events.map((entry) => entry.event)).toEqual(["run_start", "run_end"]);    expect(events[1]?.data["run_id"]).toBe("legacy-2");    expect(events[1]?.data["status"]).toBe("completed");  });   it("ends SSE stream gracefully when the body reader throws a transport close (no Bun hint surfaced)", async () => {    let pulls = 0;    const fetchMock = vi.fn().mockResolvedValue(      new Response(        new ReadableStream<Uint8Array>({          pull(controller) {            pulls += 1;            if (pulls === 1) {              controller.enqueue(encode('event: run_start\ndata: {"run_id":"t1"}\n\n'));              return;            }            return Promise.reject(              new Error(                "The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",              ),            );          },        }),        {          status: 200,          headers: { "Content-Type": "text/event-stream", "X-Run-Id": "t1" },        },      ),    );    vi.stubGlobal("fetch", fetchMock);     const core = createApiCore({ baseUrl: "/api/proxy", useProxy: true });    const { stream } = await core.postSseJson("/chats/s1/turn", { content: "hello" });     const events: Array<{ event: string; data: Record<string, unknown> }> = [];    for await (const entry of stream) {      events.push(entry);    }     expect(events.map((e) => e.event)).toEqual(["run_start"]);  });});