assistant-cloud 0.1.40 → 0.1.42

package/src/tests/AssistantCloudAuthStrategy.test.ts

@@ -11,6 +11,7 @@ const refreshToken = {
   token: "r1",
   expires_at: "2099-01-01",
 };
+const refreshTokenKey = `aui:refresh_token:${baseUrl}`;
 
 let originalLocalStorageDescriptor: PropertyDescriptor | undefined;
 
@@ -79,9 +80,7 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     await expect(strategy.getAuthHeaders()).resolves.toEqual({
       Authorization: `Bearer ${accessToken}`,
     });
-    expect(values.get("aui:refresh_token")).toBe(
-      JSON.stringify(nextRefreshToken),
-    );
+    expect(values.get(refreshTokenKey)).toBe(JSON.stringify(nextRefreshToken));
     expect(fetchMock).toHaveBeenCalledWith(
       `${baseUrl}/v1/auth/tokens/anonymous`,
       { method: "POST" },
@@ -107,6 +106,183 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     expect(fetchMock).toHaveBeenCalledTimes(1);
   });
 
+  it("scopes anonymous refresh tokens by backend", async () => {
+    const secondBaseUrl = "https://other.example.com";
+    const values = new Map<string, string>();
+    installLocalStorage({
+      getItem: (key) => values.get(key) ?? null,
+      setItem: (key, value) => {
+        values.set(key, value);
+      },
+      removeItem: (key) => {
+        values.delete(key);
+      },
+    } as Storage);
+    const secondRefreshToken = {
+      token: "r2",
+      expires_at: "2099-01-01",
+    };
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: accessToken,
+          refresh_token: refreshToken,
+        }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: accessToken,
+          refresh_token: secondRefreshToken,
+        }),
+      });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new AssistantCloudAnonymousAuthStrategy(baseUrl).getAuthHeaders();
+    await new AssistantCloudAnonymousAuthStrategy(
+      secondBaseUrl,
+    ).getAuthHeaders();
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      `${baseUrl}/v1/auth/tokens/anonymous`,
+      { method: "POST" },
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      `${secondBaseUrl}/v1/auth/tokens/anonymous`,
+      { method: "POST" },
+    );
+    expect(values.get(refreshTokenKey)).toBe(JSON.stringify(refreshToken));
+    expect(values.get(`aui:refresh_token:${secondBaseUrl}`)).toBe(
+      JSON.stringify(secondRefreshToken),
+    );
+  });
+
+  it("migrates the legacy refresh token to the first backend", async () => {
+    const secondBaseUrl = "https://other.example.com";
+    const secondRefreshToken = {
+      token: "r2",
+      expires_at: "2099-01-01",
+    };
+    const values = new Map([
+      ["aui:refresh_token", JSON.stringify(refreshToken)],
+    ]);
+    installLocalStorage({
+      getItem: (key) => values.get(key) ?? null,
+      setItem: (key, value) => {
+        values.set(key, value);
+      },
+      removeItem: (key) => {
+        values.delete(key);
+      },
+    } as Storage);
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({ access_token: accessToken }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: accessToken,
+          refresh_token: secondRefreshToken,
+        }),
+      });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new AssistantCloudAnonymousAuthStrategy(baseUrl).getAuthHeaders();
+    await new AssistantCloudAnonymousAuthStrategy(
+      secondBaseUrl,
+    ).getAuthHeaders();
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      `${baseUrl}/v1/auth/tokens/refresh`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: refreshToken.token }),
+      },
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      `${secondBaseUrl}/v1/auth/tokens/anonymous`,
+      { method: "POST" },
+    );
+    expect(values.get(refreshTokenKey)).toBe(JSON.stringify(refreshToken));
+    expect(values.get(`aui:refresh_token:${secondBaseUrl}`)).toBe(
+      JSON.stringify(secondRefreshToken),
+    );
+    expect(values.has("aui:refresh_token")).toBe(false);
+  });
+
+  it("retires the legacy refresh token when a scoped token exists", async () => {
+    const secondBaseUrl = "https://other.example.com";
+    const scopedRefreshToken = {
+      token: "scoped-r1",
+      expires_at: "2099-01-01",
+    };
+    const secondRefreshToken = {
+      token: "r2",
+      expires_at: "2099-01-01",
+    };
+    const values = new Map([
+      ["aui:refresh_token", JSON.stringify(refreshToken)],
+      [refreshTokenKey, JSON.stringify(scopedRefreshToken)],
+    ]);
+    installLocalStorage({
+      getItem: (key) => values.get(key) ?? null,
+      setItem: (key, value) => {
+        values.set(key, value);
+      },
+      removeItem: (key) => {
+        values.delete(key);
+      },
+    } as Storage);
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({ access_token: accessToken }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: accessToken,
+          refresh_token: secondRefreshToken,
+        }),
+      });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new AssistantCloudAnonymousAuthStrategy(baseUrl).getAuthHeaders();
+    await new AssistantCloudAnonymousAuthStrategy(
+      secondBaseUrl,
+    ).getAuthHeaders();
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      `${baseUrl}/v1/auth/tokens/refresh`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: scopedRefreshToken.token }),
+      },
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      `${secondBaseUrl}/v1/auth/tokens/anonymous`,
+      { method: "POST" },
+    );
+    expect(values.has("aui:refresh_token")).toBe(false);
+    expect(values.get(`aui:refresh_token:${secondBaseUrl}`)).toBe(
+      JSON.stringify(secondRefreshToken),
+    );
+  });
+
   it("returns an anonymous access token without localStorage", async () => {
     delete (globalThis as { localStorage?: Storage }).localStorage;
     mockAnonymousTokenFetch();
@@ -160,7 +336,7 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     ).resolves.toEqual({ Authorization: `Bearer ${accessToken}` });
     expect(getItem).toHaveBeenCalledTimes(2);
     expect(setItem).toHaveBeenCalledTimes(2);
-    expect(removeItem).toHaveBeenCalledTimes(1);
+    expect(removeItem).toHaveBeenCalledTimes(2);
   });
 
   it("treats corrupted refresh token JSON as absent", async () => {
@@ -181,7 +357,8 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     await expect(strategy.getAuthHeaders()).resolves.toEqual({
       Authorization: `Bearer ${accessToken}`,
     });
-    expect(values.get("aui:refresh_token")).toBe(JSON.stringify(refreshToken));
+    expect(values.get(refreshTokenKey)).toBe(JSON.stringify(refreshToken));
+    expect(values.has("aui:refresh_token")).toBe(false);
   });
 
   it("rejects malformed anonymous token responses without persisting them", async () => {
@@ -298,6 +475,102 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     expect(setItem).not.toHaveBeenCalled();
   });
 
+  it.each([429, 500, 503])(
+    "preserves the anonymous identity after transient status %i",
+    async (status) => {
+      const values = new Map([[refreshTokenKey, JSON.stringify(refreshToken)]]);
+      installLocalStorage({
+        getItem: (key) => values.get(key) ?? null,
+        setItem: (key, value) => {
+          values.set(key, value);
+        },
+        removeItem: (key) => {
+          values.delete(key);
+        },
+      } as Storage);
+      const fetchMock = vi.fn().mockResolvedValue({ ok: false, status });
+      vi.stubGlobal("fetch", fetchMock);
+
+      const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+      await expect(strategy.getAuthHeaders()).rejects.toThrow(
+        `Assistant Cloud token refresh failed with status ${status}`,
+      );
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(values.get(refreshTokenKey)).toBe(JSON.stringify(refreshToken));
+    },
+  );
+
+  it.each([401, 403])(
+    "replaces an anonymous identity after refresh is rejected with %i",
+    async (status) => {
+      const replacementRefreshToken = {
+        token: "r2",
+        expires_at: "2099-02-01",
+      };
+      const values = new Map([[refreshTokenKey, JSON.stringify(refreshToken)]]);
+      installLocalStorage({
+        getItem: (key) => values.get(key) ?? null,
+        setItem: (key, value) => {
+          values.set(key, value);
+        },
+        removeItem: (key) => {
+          values.delete(key);
+        },
+      } as Storage);
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValueOnce({ ok: false, status })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: vi.fn().mockResolvedValue({
+            access_token: accessToken,
+            refresh_token: replacementRefreshToken,
+          }),
+        });
+      vi.stubGlobal("fetch", fetchMock);
+
+      const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+      await expect(strategy.getAuthHeaders()).resolves.toEqual({
+        Authorization: `Bearer ${accessToken}`,
+      });
+      expect(fetchMock).toHaveBeenNthCalledWith(
+        2,
+        `${baseUrl}/v1/auth/tokens/anonymous`,
+        { method: "POST" },
+      );
+      expect(values.get(refreshTokenKey)).toBe(
+        JSON.stringify(replacementRefreshToken),
+      );
+    },
+  );
+
+  it("preserves a rejected refresh token until its replacement succeeds", async () => {
+    const values = new Map([[refreshTokenKey, JSON.stringify(refreshToken)]]);
+    installLocalStorage({
+      getItem: (key) => values.get(key) ?? null,
+      setItem: (key, value) => {
+        values.set(key, value);
+      },
+      removeItem: (key) => {
+        values.delete(key);
+      },
+    } as Storage);
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValueOnce({ ok: false, status: 403 })
+        .mockResolvedValueOnce({ ok: false, status: 503 }),
+    );
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).resolves.toBe(false);
+    expect(values.get(refreshTokenKey)).toBe(JSON.stringify(refreshToken));
+  });
+
   it("contextualizes invalid JSON token responses", async () => {
     delete (globalThis as { localStorage?: Storage }).localStorage;
     vi.stubGlobal(

package/src/tests/AssistantCloudRuns.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { AssistantCloudAPI } from "../AssistantCloudAPI";
+import { AssistantCloud } from "../AssistantCloud";
+import { AssistantCloudRuns } from "../AssistantCloudRuns";
+import { CloudResponseError } from "../cloudResponse";
+
+const createCloud = () =>
+  new AssistantCloud({
+    apiKey: "test-key",
+    userId: "user-id",
+    workspaceId: "workspace-id",
+  });
+
+const streamBody = {
+  thread_id: "thread-id",
+  assistant_id: "system/thread_title" as const,
+  messages: [],
+};
+
+describe("AssistantCloudRuns", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("decodes text/plain run streams", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(
+        new Response("Generated title", {
+          headers: { "Content-Type": "text/plain; charset=utf-8" },
+        }),
+      ),
+    );
+    const stream = await createCloud().runs.stream(streamBody);
+    let text = "";
+
+    await stream.pipeTo(
+      new WritableStream({
+        write(chunk) {
+          if (chunk.type === "text-delta") text += chunk.textDelta;
+        },
+      }),
+    );
+
+    expect(text).toBe("Generated title");
+  });
+
+  it("rejects successful run responses without a body", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(new Response(null, { status: 204 })),
+    );
+
+    await expect(createCloud().runs.stream(streamBody)).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "run stream": expected a response body',
+      ),
+    );
+  });
+
+  it("rejects and cancels run responses with the wrong content type", async () => {
+    const cancel = vi.fn();
+    const body = new ReadableStream({ cancel });
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(
+        new Response(body, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        }),
+      ),
+    );
+
+    await expect(createCloud().runs.stream(streamBody)).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "run stream": expected a "text/plain" content type, received "text/html; charset=utf-8"',
+      ),
+    );
+    expect(cancel).toHaveBeenCalledOnce();
+  });
+
+  it("rejects and cancels run responses without a content type", async () => {
+    const cancel = vi.fn();
+    const body = new ReadableStream({ cancel });
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response(body)));
+
+    await expect(createCloud().runs.stream(streamBody)).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "run stream": expected a "text/plain" content type, received no Content-Type header',
+      ),
+    );
+    expect(cancel).toHaveBeenCalledOnce();
+  });
+});
+
+const createCloudRuns = () => {
+  const makeRequest = vi.fn();
+  const api = { makeRequest } as unknown as AssistantCloudAPI;
+  return { runs: new AssistantCloudRuns(api), makeRequest };
+};
+
+describe("AssistantCloudRuns responses", () => {
+  it("validates reported run IDs", async () => {
+    const { runs, makeRequest } = createCloudRuns();
+    const body = { thread_id: "thread-1", status: "completed" } as const;
+    makeRequest.mockResolvedValueOnce({ run_id: "run-1" });
+
+    await expect(runs.report(body)).resolves.toEqual({ run_id: "run-1" });
+
+    makeRequest.mockResolvedValueOnce({});
+
+    await expect(runs.report(body)).rejects.toThrow(
+      'Invalid Assistant Cloud response for "run_id": expected a string',
+    );
+  });
+});