assistant-cloud 0.1.36 → 0.1.38

package/src/AssistantCloudRuns.ts

@@ -48,7 +48,11 @@ export type AssistantCloudRunReport = {
 };
 
 export class AssistantCloudRuns {
-  constructor(private cloud: AssistantCloudAPI) {}
+  private cloud: AssistantCloudAPI;
+
+  constructor(cloud: AssistantCloudAPI) {
+    this.cloud = cloud;
+  }
 
   public __internal_getAssistantOptions(assistantId: string) {
     return {

package/src/AssistantCloudThreadMessages.ts

@@ -59,7 +59,11 @@ export const decodeCloudMessage = (
 };
 
 export class AssistantCloudThreadMessages {
-  constructor(private cloud: AssistantCloudAPI) {}
+  private cloud: AssistantCloudAPI;
+
+  constructor(cloud: AssistantCloudAPI) {
+    this.cloud = cloud;
+  }
 
   public async list(
     threadId: string,

package/src/AssistantCloudThreads.ts

@@ -78,7 +78,10 @@ export const decodeCloudThread = (
 export class AssistantCloudThreads {
   public readonly messages: AssistantCloudThreadMessages;
 
-  constructor(private cloud: AssistantCloudAPI) {
+  private cloud: AssistantCloudAPI;
+
+  constructor(cloud: AssistantCloudAPI) {
+    this.cloud = cloud;
     this.messages = new AssistantCloudThreadMessages(cloud);
   }
 

package/src/tests/AssistantCloudAPI.test.ts

@@ -1,12 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AssistantCloudAPI, CloudAPIError } from "../AssistantCloudAPI";
-
-const createJwt = () => {
-  const payload = Buffer.from(JSON.stringify({ exp: 4_102_444_800 })).toString(
-    "base64url",
-  );
-  return `header.${payload}.signature`;
-};
+import { CloudResponseError } from "../cloudResponse";
 
 describe("AssistantCloudAPI", () => {
   beforeEach(() => {
@@ -101,65 +95,6 @@ describe("AssistantCloudAPI", () => {
     expect(url.toString()).toBe("https://custom.example.com/v1/threads");
   });
 
-  it("strips a trailing slash from a JWT baseUrl", async () => {
-    const fetchMock = vi.fn().mockResolvedValue({
-      ok: true,
-      headers: new Headers(),
-    });
-    vi.stubGlobal("fetch", fetchMock);
-
-    const api = new AssistantCloudAPI({
-      baseUrl: "https://custom.example.com/",
-      authToken: async () => createJwt(),
-    });
-
-    await api.makeRawRequest("/threads");
-
-    const [url] = fetchMock.mock.calls[0]!;
-    expect(url.toString()).toBe("https://custom.example.com/v1/threads");
-  });
-
-  it("strips a trailing slash from anonymous auth URLs", async () => {
-    const storage = {
-      getItem: vi.fn().mockReturnValue(null),
-      setItem: vi.fn(),
-      removeItem: vi.fn(),
-    };
-    vi.stubGlobal("localStorage", storage);
-
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce({
-        ok: true,
-        json: vi.fn().mockResolvedValue({
-          access_token: createJwt(),
-          refresh_token: {
-            token: "refresh-token",
-            expires_at: "2100-01-01T00:00:00.000Z",
-          },
-        }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-      });
-    vi.stubGlobal("fetch", fetchMock);
-
-    const api = new AssistantCloudAPI({
-      baseUrl: "https://custom.example.com/",
-      anonymous: true,
-    });
-
-    await api.makeRawRequest("/threads");
-
-    expect(fetchMock.mock.calls[0]![0]).toBe(
-      "https://custom.example.com/v1/auth/tokens/anonymous",
-    );
-    expect(fetchMock.mock.calls[1]![0].toString()).toBe(
-      "https://custom.example.com/v1/threads",
-    );
-  });
-
   it("rejects before fetch when auth token callback returns null", async () => {
     const fetchMock = vi.fn();
     vi.stubGlobal("fetch", fetchMock);
@@ -184,6 +119,30 @@ describe("AssistantCloudAPI", () => {
     await expect(api.initializeAuth()).resolves.toBe(false);
   });
 
+  it("rejects initializeAuth with context for malformed anonymous responses", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: 123,
+          refresh_token: null,
+        }),
+      }),
+    );
+
+    const api = new AssistantCloudAPI({
+      baseUrl: "https://test.example.com",
+      anonymous: true,
+    });
+
+    await expect(api.initializeAuth()).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "anonymous auth token response.access_token": expected a string',
+      ),
+    );
+  });
+
   it("throws APIError with parsed message for JSON error responses", async () => {
     const fetchMock = vi.fn().mockResolvedValue({
       ok: false,
@@ -289,22 +248,4 @@ describe("AssistantCloudAPI", () => {
     await expect(api.makeRequest("/threads/t-1")).resolves.toBeUndefined();
     expect(text).not.toHaveBeenCalled();
   });
-
-  it("makeRequest returns undefined from a whitespace-only success body", async () => {
-    const fetchMock = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: new Headers(),
-      text: vi.fn().mockResolvedValue("  "),
-    });
-    vi.stubGlobal("fetch", fetchMock);
-
-    const api = new AssistantCloudAPI({
-      apiKey: "test-key",
-      userId: "u-1",
-      workspaceId: "w-1",
-    });
-
-    await expect(api.makeRequest("/threads/t-1")).resolves.toBeUndefined();
-  });
 });

package/src/tests/AssistantCloudAuthStrategy.test.ts

@@ -3,10 +3,14 @@ import {
   AssistantCloudAnonymousAuthStrategy,
   AssistantCloudJWTAuthStrategy,
 } from "../AssistantCloudAuthStrategy";
+import { CloudResponseError } from "../cloudResponse";
 
 const baseUrl = "https://test.example.com";
 const accessToken = `${Buffer.from(JSON.stringify({ alg: "none" })).toString("base64url")}.${Buffer.from(JSON.stringify({ exp: 4102444800 })).toString("base64url")}.sig`;
-const refreshToken = { token: "r1", expires_at: "2099-01-01" };
+const refreshToken = {
+  token: "r1",
+  expires_at: "2099-01-01",
+};
 
 let originalLocalStorageDescriptor: PropertyDescriptor | undefined;
 
@@ -17,12 +21,12 @@ const installLocalStorage = (storage: Storage): void => {
   });
 };
 
-const mockAnonymousTokenFetch = () => {
+const mockAnonymousTokenFetch = (nextRefreshToken = refreshToken) => {
   const fetchMock = vi.fn().mockResolvedValue({
     ok: true,
     json: vi.fn().mockResolvedValue({
       access_token: accessToken,
-      refresh_token: refreshToken,
+      refresh_token: nextRefreshToken,
     }),
   });
   vi.stubGlobal("fetch", fetchMock);
@@ -50,7 +54,14 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     }
   });
 
-  it("persists the refresh token and returns the anonymous access token", async () => {
+  it.each([
+    "2099-01-01",
+    "2099-01-01T00:00:00Z",
+    "2099-01-01T00:00:00+0000",
+    "2099-01-01T00:00:00",
+    "2099-01-01 00:00:00+00",
+  ])("persists refresh tokens with expiry %s", async (expiresAt) => {
+    const nextRefreshToken = { ...refreshToken, expires_at: expiresAt };
     const values = new Map<string, string>();
     installLocalStorage({
       getItem: (key) => values.get(key) ?? null,
@@ -61,14 +72,16 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
         values.delete(key);
       },
     } as Storage);
-    const fetchMock = mockAnonymousTokenFetch();
+    const fetchMock = mockAnonymousTokenFetch(nextRefreshToken);
 
     const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
 
     await expect(strategy.getAuthHeaders()).resolves.toEqual({
       Authorization: `Bearer ${accessToken}`,
     });
-    expect(values.get("aui:refresh_token")).toBe(JSON.stringify(refreshToken));
+    expect(values.get("aui:refresh_token")).toBe(
+      JSON.stringify(nextRefreshToken),
+    );
     expect(fetchMock).toHaveBeenCalledWith(
       `${baseUrl}/v1/auth/tokens/anonymous`,
       { method: "POST" },
@@ -170,6 +183,139 @@ describe("AssistantCloudAnonymousAuthStrategy", () => {
     });
     expect(values.get("aui:refresh_token")).toBe(JSON.stringify(refreshToken));
   });
+
+  it("rejects malformed anonymous token responses without persisting them", async () => {
+    const setItem = vi.fn();
+    installLocalStorage({
+      getItem: () => null,
+      setItem,
+      removeItem: vi.fn(),
+    } as unknown as Storage);
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: accessToken,
+          refresh_token: "not-a-refresh-token",
+        }),
+      }),
+    );
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "anonymous auth token response.refresh_token": expected an object',
+      ),
+    );
+    expect(setItem).not.toHaveBeenCalled();
+  });
+
+  it("rejects empty refresh token expiry without persisting it", async () => {
+    const setItem = vi.fn();
+    installLocalStorage({
+      getItem: () => null,
+      setItem,
+      removeItem: vi.fn(),
+    } as unknown as Storage);
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: accessToken,
+          refresh_token: {
+            token: "r2",
+            expires_at: "",
+          },
+        }),
+      }),
+    );
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "anonymous auth token response.refresh_token.expires_at": expected a non-empty string',
+      ),
+    );
+    expect(setItem).not.toHaveBeenCalled();
+  });
+
+  it("contextualizes malformed refresh token responses", async () => {
+    installLocalStorage({
+      getItem: () => JSON.stringify(refreshToken),
+      setItem: vi.fn(),
+      removeItem: vi.fn(),
+    } as unknown as Storage);
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: vi.fn().mockResolvedValue({ access_token: 123 }),
+      }),
+    );
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "refresh auth token response.access_token": expected a string',
+      ),
+    );
+  });
+
+  it("accepts valid refresh responses without a rotated refresh token", async () => {
+    const setItem = vi.fn();
+    installLocalStorage({
+      getItem: () => JSON.stringify(refreshToken),
+      setItem,
+      removeItem: vi.fn(),
+    } as unknown as Storage);
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue({
+        access_token: accessToken,
+        refresh_token: null,
+      }),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).resolves.toEqual({
+      Authorization: `Bearer ${accessToken}`,
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${baseUrl}/v1/auth/tokens/refresh`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: refreshToken.token }),
+      },
+    );
+    expect(setItem).not.toHaveBeenCalled();
+  });
+
+  it("contextualizes invalid JSON token responses", async () => {
+    delete (globalThis as { localStorage?: Storage }).localStorage;
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: vi.fn().mockRejectedValue(new SyntaxError("Unexpected token")),
+      }),
+    );
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).rejects.toThrow(
+      new CloudResponseError(
+        'Invalid Assistant Cloud response for "anonymous auth token response": expected valid JSON',
+      ),
+    );
+  });
 });
 
 describe("AssistantCloudJWTAuthStrategy", () => {