@assistant-ui/core 0.3.14 → 0.3.16

package/src/model-context/frame/provider.test.ts

@@ -9,6 +9,45 @@ describe("AssistantFrameProvider", () => {
   let messageHandler: ((event: MessageEvent) => void) | undefined;
   let parentWindow: Window;
 
+  const dispatchToolCall = (
+    origin: string,
+    source: Window = parentWindow,
+    id = "tool-call-1",
+  ) => {
+    messageHandler?.(
+      new MessageEvent("message", {
+        data: {
+          channel: FRAME_MESSAGE_CHANNEL,
+          message: {
+            type: "tool-call",
+            id,
+            toolName: "sensitiveTool",
+            args: {},
+          },
+        },
+        origin,
+        source,
+      }),
+    );
+  };
+
+  const dispatchToolCancel = (
+    origin: string,
+    source: Window = parentWindow,
+    id = "tool-call-1",
+  ) => {
+    messageHandler?.(
+      new MessageEvent("message", {
+        data: {
+          channel: FRAME_MESSAGE_CHANNEL,
+          message: { type: "tool-cancel", id },
+        },
+        origin,
+        source,
+      }),
+    );
+  };
+
   beforeEach(() => {
     parentWindow = {
       postMessage: vi.fn(),
@@ -47,37 +86,580 @@ describe("AssistantFrameProvider", () => {
       "https://parent.example",
     );
 
-    const toolCall = {
-      channel: FRAME_MESSAGE_CHANNEL,
-      message: {
-        type: "tool-call",
-        id: "tool-call-1",
-        toolName: "sensitiveTool",
-        args: {},
-      },
-    };
     const otherWindow = {
       postMessage: vi.fn(),
     } as unknown as Window;
 
-    messageHandler?.(
-      new MessageEvent("message", {
-        data: toolCall,
-        origin: "https://parent.example",
-        source: otherWindow,
+    dispatchToolCall("https://parent.example", otherWindow);
+
+    expect(execute).not.toHaveBeenCalled();
+
+    dispatchToolCall("https://parent.example");
+
+    await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
+  });
+
+  it("defaults to the current origin", async () => {
+    const execute = vi.fn(async () => "result");
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({
+        tools: { sensitiveTool: { execute } },
       }),
+    });
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      window.location.origin,
     );
 
+    dispatchToolCall("https://untrusted.example");
     expect(execute).not.toHaveBeenCalled();
 
-    messageHandler?.(
-      new MessageEvent("message", {
-        data: toolCall,
-        origin: "https://parent.example",
-        source: parentWindow,
+    dispatchToolCall(window.location.origin);
+    await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
+  });
+
+  it("reports a failure even when the thrown error has an empty message", async () => {
+    const execute = vi.fn(async () => {
+      throw new Error();
+    });
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({
+        tools: {
+          sensitiveTool: { execute },
+        },
+      }),
+    });
+
+    dispatchToolCall(window.location.origin);
+
+    await vi.waitFor(() => {
+      const frame = (
+        parentWindow.postMessage as ReturnType<typeof vi.fn>
+      ).mock.calls
+        .map(([data]) => data)
+        .find((data) => data?.message?.type === "tool-result");
+      expect(frame).toBeDefined();
+      expect(frame.message).toHaveProperty("error");
+      expect(frame.message).not.toHaveProperty("result");
+    });
+  });
+
+  it("aborts in-flight tool calls when the parent cancels them", async () => {
+    let toolSignal: AbortSignal | undefined;
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        toolSignal = context.abortSignal;
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({
+        tools: { sensitiveTool: { execute } },
+      }),
+    });
+
+    dispatchToolCall(window.location.origin);
+    await vi.waitFor(() => expect(toolSignal).toBeDefined());
+
+    dispatchToolCancel(window.location.origin);
+
+    expect(toolSignal?.aborted).toBe(true);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(parentWindow.postMessage).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.objectContaining({ type: "tool-result" }),
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("cancels only the matching in-flight tool call", async () => {
+    const signals = new Map<string, AbortSignal>();
+    const execute = vi.fn(
+      async (
+        _args: unknown,
+        context: { toolCallId: string; abortSignal: AbortSignal },
+      ) => {
+        signals.set(context.toolCallId, context.abortSignal);
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({ tools: { sensitiveTool: { execute } } }),
+    });
+
+    dispatchToolCall(window.location.origin, parentWindow, "tool-a");
+    dispatchToolCall(window.location.origin, parentWindow, "tool-b");
+    await vi.waitFor(() => expect(signals.size).toBe(2));
+
+    dispatchToolCancel(window.location.origin, parentWindow, "tool-a");
+
+    expect(signals.get("tool-a")?.aborted).toBe(true);
+    expect(signals.get("tool-b")?.aborted).toBe(false);
+  });
+
+  it("aborts an earlier call when a duplicate ID arrives", async () => {
+    const signals: AbortSignal[] = [];
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        signals.push(context.abortSignal);
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({ tools: { sensitiveTool: { execute } } }),
+    });
+
+    dispatchToolCall(window.location.origin, parentWindow, "duplicate");
+    await vi.waitFor(() => expect(signals).toHaveLength(1));
+    dispatchToolCall(window.location.origin, parentWindow, "duplicate");
+    await vi.waitFor(() => expect(signals).toHaveLength(2));
+
+    expect(signals[0]?.aborted).toBe(true);
+    expect(signals[1]?.aborted).toBe(false);
+  });
+
+  it("aborts in-flight tool calls when the provider is disposed", async () => {
+    let toolSignal: AbortSignal | undefined;
+    const execute = vi.fn(
+      async (_args: unknown, context: { abortSignal: AbortSignal }) => {
+        toolSignal = context.abortSignal;
+        await new Promise<never>((_resolve, reject) => {
+          context.abortSignal.addEventListener(
+            "abort",
+            () => reject(context.abortSignal.reason),
+            { once: true },
+          );
+        });
+      },
+    );
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({ tools: { sensitiveTool: { execute } } }),
+    });
+
+    dispatchToolCall(window.location.origin);
+    await vi.waitFor(() => expect(toolSignal).toBeDefined());
+
+    AssistantFrameProvider.dispose();
+
+    expect(toolSignal?.aborted).toBe(true);
+    expect(parentWindow.postMessage).toHaveBeenCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: {
+          type: "tool-result",
+          id: "tool-call-1",
+          error: "AssistantFrameProvider has been disposed",
+        },
+      },
+      { targetOrigin: window.location.origin },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const toolResults = vi
+      .mocked(parentWindow.postMessage)
+      .mock.calls.filter(
+        ([data]) =>
+          (data as { message?: { type?: string } }).message?.type ===
+          "tool-result",
+      );
+    expect(toolResults).toHaveLength(1);
+  });
+
+  it("upgrades a wildcard origin policy when a strict provider registers", async () => {
+    AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "*",
+    );
+
+    const execute = vi.fn(async () => "result");
+    AssistantFrameProvider.addModelContextProvider(
+      {
+        getModelContext: () => ({
+          tools: {
+            sensitiveTool: { execute },
+          },
+        }),
+      },
+      "https://parent.example",
+    );
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      "https://parent.example",
+    );
+
+    dispatchToolCall("https://untrusted.example");
+
+    expect(execute).not.toHaveBeenCalled();
+
+    dispatchToolCall("https://parent.example");
+
+    await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
+  });
+
+  it("does not downgrade a strict origin policy for a wildcard provider", async () => {
+    const execute = vi.fn(async () => "result");
+    AssistantFrameProvider.addModelContextProvider(
+      {
+        getModelContext: () => ({
+          tools: {
+            sensitiveTool: { execute },
+          },
+        }),
+      },
+      "https://parent.example",
+    );
+    AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "*",
+    );
+
+    dispatchToolCall("https://untrusted.example");
+
+    expect(execute).not.toHaveBeenCalled();
+
+    dispatchToolCall("https://parent.example");
+
+    await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
+  });
+
+  it("rejects conflicting strict origin policies", () => {
+    AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "https://first.example",
+    );
+
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        { getModelContext: () => ({}) },
+        "https://second.example",
+      ),
+    ).toThrow(
+      'AssistantFrameProvider cannot register conflicting target origins: "https://first.example" and "https://second.example"',
+    );
+  });
+
+  it("rolls back a provider when registration fails", () => {
+    const execute = vi.fn(async () => "result");
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        {
+          getModelContext: () => ({
+            tools: { sensitiveTool: { execute } },
+          }),
+          subscribe: () => {
+            throw new Error("subscribe failed");
+          },
+        },
+        "https://first.example",
+      ),
+    ).toThrow("subscribe failed");
+
+    dispatchToolCall("https://first.example");
+    expect(execute).not.toHaveBeenCalled();
+
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        { getModelContext: () => ({}) },
+        "https://second.example",
+      ),
+    ).not.toThrow();
+  });
+
+  it("keeps an existing registration when the same provider fails to register again", async () => {
+    const execute = vi.fn(async () => "result");
+    const firstUnsubscribe = vi.fn();
+    let subscriptionCount = 0;
+    const provider = {
+      getModelContext: () => ({
+        tools: { sensitiveTool: { execute } },
       }),
+      subscribe: () => {
+        subscriptionCount += 1;
+        if (subscriptionCount === 1) return firstUnsubscribe;
+        throw new Error("second subscribe failed");
+      },
+    };
+    const releaseFirst = AssistantFrameProvider.addModelContextProvider(
+      provider,
+      "https://parent.example",
     );
 
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        provider,
+        "https://parent.example",
+      ),
+    ).toThrow("second subscribe failed");
+    expect(firstUnsubscribe).not.toHaveBeenCalled();
+
+    dispatchToolCall("https://parent.example");
+
+    await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
+    releaseFirst();
+    expect(firstUnsubscribe).toHaveBeenCalledOnce();
+  });
+
+  it("merges a provider registered more than once only once", () => {
+    const provider = {
+      getModelContext: () => ({ system: "shared system" }),
+    };
+
+    AssistantFrameProvider.addModelContextProvider(provider);
+    AssistantFrameProvider.addModelContextProvider(provider);
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      {
+        channel: FRAME_MESSAGE_CHANNEL,
+        message: {
+          type: "model-context-update",
+          context: {
+            system: "shared system",
+            tools: {},
+          },
+        },
+      },
+      window.location.origin,
+    );
+  });
+
+  it("releases a subscription when the initial broadcast fails", () => {
+    const unsubscribe = vi.fn();
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        {
+          getModelContext: () => {
+            throw new Error("context failed");
+          },
+          subscribe: () => unsubscribe,
+        },
+        "https://first.example",
+      ),
+    ).toThrow("context failed");
+
+    expect(unsubscribe).toHaveBeenCalledOnce();
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        { getModelContext: () => ({}) },
+        "https://second.example",
+      ),
+    ).not.toThrow();
+  });
+
+  it("reports rollback cleanup failures without replacing the original error", () => {
+    const contextError = new Error("context failed");
+    const unsubscribeError = new Error("unsubscribe failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
+
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider({
+        getModelContext: () => {
+          throw contextError;
+        },
+        subscribe: () => () => {
+          throw unsubscribeError;
+        },
+      }),
+    ).toThrow(contextError);
+
+    expect(consoleError).toHaveBeenCalledWith(unsubscribeError);
+  });
+
+  it("cleans up provider state when its unsubscribe throws", () => {
+    const unsubscribe = vi.fn(() => {
+      throw new Error("unsubscribe failed");
+    });
+    const release = AssistantFrameProvider.addModelContextProvider(
+      {
+        getModelContext: () => ({}),
+        subscribe: () => unsubscribe,
+      },
+      "https://first.example",
+    );
+
+    expect(release).toThrow("unsubscribe failed");
+    expect(unsubscribe).toHaveBeenCalledOnce();
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        { getModelContext: () => ({}) },
+        "https://second.example",
+      ),
+    ).not.toThrow();
+  });
+
+  it("finishes disposal when a provider unsubscribe throws", () => {
+    const error = new Error("unsubscribe failed");
+    const firstUnsubscribe = vi.fn(() => {
+      throw error;
+    });
+    const secondUnsubscribe = vi.fn();
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({}),
+      subscribe: () => firstUnsubscribe,
+    });
+    AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({}),
+      subscribe: () => secondUnsubscribe,
+    });
+
+    expect(() => AssistantFrameProvider.dispose()).toThrow(error);
+    expect(firstUnsubscribe).toHaveBeenCalledOnce();
+    expect(secondUnsubscribe).toHaveBeenCalledOnce();
+
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        { getModelContext: () => ({}) },
+        "https://new.example",
+      ),
+    ).not.toThrow();
+    expect(window.addEventListener).toHaveBeenCalledTimes(2);
+  });
+
+  it("returns to the same-origin policy after every provider unsubscribes", () => {
+    const unsubscribe = AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "https://first.example",
+    );
+
+    unsubscribe();
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      window.location.origin,
+    );
+
+    expect(() =>
+      AssistantFrameProvider.addModelContextProvider(
+        { getModelContext: () => ({}) },
+        "https://second.example",
+      ),
+    ).not.toThrow();
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      "https://second.example",
+    );
+  });
+
+  it("treats a second unsubscribe as a no-op", () => {
+    const unsubscribe = AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "https://first.example",
+    );
+
+    unsubscribe();
+    unsubscribe();
+
+    const unsubscribeSecond = AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "https://second.example",
+    );
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      "https://second.example",
+    );
+
+    unsubscribeSecond();
+    unsubscribeSecond();
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      window.location.origin,
+    );
+  });
+
+  it("recomputes the origin policy from providers that remain", () => {
+    AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "*",
+    );
+    const unsubscribeStrict = AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "https://parent.example",
+    );
+
+    unsubscribeStrict();
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      "*",
+    );
+  });
+
+  it("returns to the same-origin policy after a wildcard provider unsubscribes", () => {
+    const unsubscribe = AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "*",
+    );
+
+    unsubscribe();
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      window.location.origin,
+    );
+  });
+
+  it("allows opting back into a wildcard policy after every provider unsubscribes", () => {
+    const unsubscribe = AssistantFrameProvider.addModelContextProvider({
+      getModelContext: () => ({}),
+    });
+    unsubscribe();
+
+    AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "*",
+    );
+
+    expect(parentWindow.postMessage).toHaveBeenLastCalledWith(
+      expect.anything(),
+      "*",
+    );
+  });
+
+  it("keeps a shared strict origin after one provider unsubscribes", async () => {
+    const unsubscribeFirst = AssistantFrameProvider.addModelContextProvider(
+      { getModelContext: () => ({}) },
+      "https://parent.example",
+    );
+    const execute = vi.fn(async () => "result");
+    AssistantFrameProvider.addModelContextProvider(
+      {
+        getModelContext: () => ({
+          tools: {
+            sensitiveTool: { execute },
+          },
+        }),
+      },
+      "https://parent.example",
+    );
+
+    unsubscribeFirst();
+
+    dispatchToolCall("https://untrusted.example");
+    expect(execute).not.toHaveBeenCalled();
+
+    dispatchToolCall("https://parent.example");
     await vi.waitFor(() => expect(execute).toHaveBeenCalledOnce());
   });
 });