@apollo/client-ai-apps 0.4.0 → 0.5.1

package/src/react/hooks/__tests__/useCallTool.test.ts

@@ -1,46 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { useCallTool } from "../useCallTool.js";
-
-test("Should execute tool when returned function is called", async () => {
-  vi.stubGlobal("openai", {
-    callTool: vi.fn(async (name: string, args: Record<string, unknown>) => {
-      return {
-        structuredContent: {
-          data: {
-            product: {
-              id: "1",
-              title: "Pen",
-              rating: 5,
-              price: 1.0,
-              description: "Awesome pen",
-              images: [],
-              __typename: "Product",
-            },
-          },
-        },
-      };
-    }),
-  });
-
-  const callTool = useCallTool();
-  const result = await callTool("my-tool", { id: 1 });
-
-  expect(window.openai.callTool).toBeCalledWith("my-tool", { id: 1 });
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "structuredContent": {
-        "data": {
-          "product": {
-            "__typename": "Product",
-            "description": "Awesome pen",
-            "id": "1",
-            "images": [],
-            "price": 1,
-            "rating": 5,
-            "title": "Pen",
-          },
-        },
-      },
-    }
-  `);
-});

package/src/react/hooks/__tests__/useOpenExternal.test.tsx

@@ -1,24 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { renderHookToSnapshotStream } from "@testing-library/react-render-stream";
-import { useOpenExternal } from "../useOpenExternal.js";
-import { stubOpenAiGlobals } from "../../../testing/internal/index.js";
-
-test("calls the global openExternal function", async () => {
-  const openExternalMock = vi.fn();
-
-  stubOpenAiGlobals({ openExternal: openExternalMock });
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useOpenExternal()
-  );
-
-  const openExternal = await takeSnapshot();
-  openExternal({ href: "https://example.com" });
-
-  expect(openExternalMock).toHaveBeenCalledTimes(1);
-  expect(openExternalMock).toHaveBeenCalledWith({
-    href: "https://example.com",
-  });
-
-  await expect(takeSnapshot).not.toRerender();
-});

package/src/react/hooks/__tests__/useRequestDisplayMode.test.ts

@@ -1,17 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { useRequestDisplayMode } from "../useRequestDisplayMode.js";
-import type { DisplayMode } from "../../../types/openai.js";
-
-test("Should set display mode when returned function is called", async () => {
-  vi.stubGlobal("openai", {
-    requestDisplayMode: vi.fn(async (args: { mode: DisplayMode }) => {
-      return args;
-    }),
-  });
-
-  const requestDisplayMode = useRequestDisplayMode();
-  const result = await requestDisplayMode({ mode: "inline" });
-
-  expect(window.openai.requestDisplayMode).toBeCalledWith({ mode: "inline" });
-  expect(result).toEqual({ mode: "inline" });
-});

package/src/react/hooks/__tests__/useSendFollowUpMessage.test.ts

@@ -1,15 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { useSendFollowUpMessage } from "../useSendFollowUpMessage.js";
-
-test("Should set display mode when returned function is called", async () => {
-  vi.stubGlobal("openai", {
-    sendFollowUpMessage: vi.fn(async (args: { prompt: string }) => {}),
-  });
-
-  const sendFollowUpMessage = useSendFollowUpMessage();
-  await sendFollowUpMessage("Do a cool thing!");
-
-  expect(window.openai.sendFollowUpMessage).toBeCalledWith({
-    prompt: "Do a cool thing!",
-  });
-});

package/src/react/hooks/__tests__/useToolEffect.test.tsx

@@ -1,67 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { useToolEffect } from "../useToolEffect.js";
-import { renderHook } from "@testing-library/react";
-import { ToolUseProvider } from "../../context/ToolUseContext.js";
-
-test("Should trigger effect when tool name matches toolResponseMetadata", async () => {
-  vi.stubGlobal("openai", {
-    toolResponseMetadata: { toolName: "my-app--my-tool" },
-  });
-  const navigate = vi.fn();
-  const wrapper = ({ children }: { children: any }) => (
-    <ToolUseProvider appName="my-app">{children}</ToolUseProvider>
-  );
-
-  renderHook(() => useToolEffect("my-tool", () => navigate(), [navigate]), {
-    wrapper,
-  });
-
-  expect(navigate).toBeCalled();
-});
-
-test("Should trigger effect when one of multiple tool name matches toolResponseMetadata", async () => {
-  vi.stubGlobal("openai", {
-    toolResponseMetadata: { toolName: "my-app--my-tool" },
-  });
-  const navigate = vi.fn();
-  const wrapper = ({ children }: { children: any }) => (
-    <ToolUseProvider appName="my-app">{children}</ToolUseProvider>
-  );
-
-  renderHook(
-    () =>
-      useToolEffect(["my-tool", "my-similar-tool"], () => navigate(), [
-        navigate,
-      ]),
-    { wrapper }
-  );
-
-  expect(navigate).toBeCalled();
-});
-
-test("Should not trigger effect when tool name does not match toolResponseMetadata", async () => {
-  vi.stubGlobal("openai", {
-    toolResponseMetadata: { toolName: "my-app--my-other-tool" },
-  });
-  const navigate = vi.fn();
-  const wrapper = ({ children }: { children: any }) => (
-    <ToolUseProvider appName="my-app">{children}</ToolUseProvider>
-  );
-
-  renderHook(() => useToolEffect("my-tool", () => navigate(), [navigate]), {
-    wrapper,
-  });
-
-  expect(navigate).not.toBeCalled();
-});
-
-test("Should throw an error when used outside of a ToolUseProvider", async () => {
-  vi.stubGlobal("openai", {
-    toolResponseMetadata: { toolName: "my-app--my-other-tool" },
-  });
-  const navigate = vi.fn();
-
-  expect(() =>
-    renderHook(() => useToolEffect("my-tool", () => navigate(), [navigate]))
-  ).toThrowError("useToolEffect must be used within ToolUseProvider");
-});

package/src/react/hooks/__tests__/useToolInput.test.ts

@@ -1,13 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { useToolInput } from "../useToolInput.js";
-import { renderHook } from "@testing-library/react";
-
-test("Should return tool input when called", async () => {
-  vi.stubGlobal("openai", {
-    toolInput: { name: "John" },
-  });
-
-  const { result } = renderHook(() => useToolInput());
-
-  expect(result.current).toEqual({ name: "John" });
-});

package/src/react/hooks/__tests__/useToolName.test.ts

@@ -1,13 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { useToolName } from "../useToolName.js";
-import { renderHook } from "@testing-library/react";
-
-test("Should return tool input when called", async () => {
-  vi.stubGlobal("openai", {
-    toolResponseMetadata: { toolName: "get-products" },
-  });
-
-  const { result } = renderHook(() => useToolName());
-
-  expect(result.current).toBe("get-products");
-});

package/src/react/hooks/__tests__/useToolOutput.test.tsx

@@ -1,49 +0,0 @@
-import { afterEach, expect, test, vi } from "vitest";
-import {
-  dispatchStateChange,
-  stubOpenAiGlobals,
-} from "../../../testing/internal/index.js";
-import { renderHookToSnapshotStream } from "@testing-library/react-render-stream";
-import { useToolOutput } from "../useToolOutput.js";
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-test("returns the tool output set in window", async () => {
-  stubOpenAiGlobals({ toolOutput: { test: true } });
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useToolOutput()
-  );
-
-  await expect(takeSnapshot()).resolves.toEqual({ test: true });
-  await expect(takeSnapshot).not.toRerender();
-});
-
-test("returns null when not set", async () => {
-  stubOpenAiGlobals();
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useToolOutput()
-  );
-
-  await expect(takeSnapshot()).resolves.toBeNull();
-  await expect(takeSnapshot).not.toRerender();
-});
-
-test("reacts to changes in globals", async () => {
-  stubOpenAiGlobals({ toolOutput: { initial: true } });
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useToolOutput()
-  );
-
-  await expect(takeSnapshot()).resolves.toEqual({ initial: true });
-
-  window.openai.toolOutput = { updated: true };
-  dispatchStateChange();
-
-  await expect(takeSnapshot()).resolves.toEqual({ updated: true });
-  await expect(takeSnapshot).not.toRerender();
-});

package/src/react/hooks/__tests__/useToolResponseMetadata.test.tsx

@@ -1,49 +0,0 @@
-import { afterEach, expect, test, vi } from "vitest";
-import {
-  dispatchStateChange,
-  stubOpenAiGlobals,
-} from "../../../testing/internal/index.js";
-import { renderHookToSnapshotStream } from "@testing-library/react-render-stream";
-import { useToolResponseMetadata } from "../useToolResponseMetadata.js";
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-test("returns the tool output set in window", async () => {
-  stubOpenAiGlobals({ toolResponseMetadata: { test: true } });
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useToolResponseMetadata()
-  );
-
-  await expect(takeSnapshot()).resolves.toEqual({ test: true });
-  await expect(takeSnapshot).not.toRerender();
-});
-
-test("returns null when not set", async () => {
-  stubOpenAiGlobals();
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useToolResponseMetadata()
-  );
-
-  await expect(takeSnapshot()).resolves.toBeNull();
-  await expect(takeSnapshot).not.toRerender();
-});
-
-test("reacts to changes in globals", async () => {
-  stubOpenAiGlobals({ toolResponseMetadata: { initial: true } });
-
-  const { takeSnapshot } = await renderHookToSnapshotStream(() =>
-    useToolResponseMetadata()
-  );
-
-  await expect(takeSnapshot()).resolves.toEqual({ initial: true });
-
-  window.openai.toolResponseMetadata = { updated: true };
-  dispatchStateChange();
-
-  await expect(takeSnapshot()).resolves.toEqual({ updated: true });
-  await expect(takeSnapshot).not.toRerender();
-});

package/src/react/hooks/useCallTool.ts

@@ -1,13 +0,0 @@
-type UseCallToolResult = <K>(
-  toolId: string,
-  variables?: Record<string, unknown> | undefined
-) => Promise<K>;
-
-export const useCallTool = (): UseCallToolResult => {
-  const callTool = async (
-    toolId: string,
-    variables: Record<string, unknown> | undefined = {}
-  ) => await window.openai?.callTool(toolId, variables);
-
-  return callTool;
-};

package/src/react/hooks/useOpenExternal.ts

@@ -1,11 +0,0 @@
-import { useCallback } from "react";
-import type { API } from "../../types/openai.js";
-
-type OpenExternalFn = API<any>["openExternal"];
-
-export function useOpenExternal() {
-  return useCallback<OpenExternalFn>(
-    (...args) => window.openai.openExternal(...args),
-    []
-  );
-}

package/src/react/hooks/useRequestDisplayMode.ts

@@ -1,7 +0,0 @@
-import type { DisplayMode } from "../../types/openai.js";
-
-export const useRequestDisplayMode = () => {
-  return async (args: { mode: DisplayMode }) => {
-    return await window.openai?.requestDisplayMode(args);
-  };
-};

package/src/react/hooks/useSendFollowUpMessage.ts

@@ -1,7 +0,0 @@
-export const useSendFollowUpMessage = () => {
-  return async (prompt: string) => {
-    await window.openai?.sendFollowUpMessage({
-      prompt,
-    });
-  };
-};

package/src/react/hooks/useToolEffect.tsx

@@ -1,37 +0,0 @@
-import React, { useEffect } from "react";
-import { useToolName } from "./useToolName.js";
-import { useToolInput } from "./useToolInput.js";
-import { useToolUseState } from "../context/ToolUseContext.js";
-
-export const useToolEffect = (
-  toolName: string | string[],
-  effect: (toolInput: any) => void,
-  deps: React.DependencyList = []
-) => {
-  const ctx = useToolUseState();
-  const fullToolName = useToolName();
-  const toolInput = useToolInput();
-  if (!ctx)
-    throw new Error("useToolEffect must be used within ToolUseProvider");
-
-  const toolNames = Array.isArray(toolName) ? toolName : [toolName];
-
-  useEffect(() => {
-    const matches = toolNames.some(
-      (name) => fullToolName === `${ctx.appName}--${name}`
-    );
-
-    if (!ctx.hasNavigated && matches) {
-      effect(toolInput);
-      ctx.setHasNavigated(true);
-    }
-  }, [
-    ctx.hasNavigated,
-    ctx.setHasNavigated,
-    ctx.appName,
-    toolNames,
-    fullToolName,
-    toolInput,
-    ...deps,
-  ]);
-};

package/src/react/hooks/useToolInput.ts

@@ -1,7 +0,0 @@
-import { useOpenAiGlobal } from "./useOpenAiGlobal.js";
-
-export const useToolInput = (): any => {
-  const toolInput = useOpenAiGlobal("toolInput");
-
-  return toolInput;
-};

package/src/react/hooks/useToolName.ts

@@ -1,7 +0,0 @@
-import { useOpenAiGlobal } from "./useOpenAiGlobal.js";
-
-export const useToolName = (): string | undefined => {
-  const toolResponseMetadata = useOpenAiGlobal("toolResponseMetadata");
-
-  return toolResponseMetadata?.toolName as string;
-};

package/src/react/hooks/useToolOutput.ts

@@ -1,5 +0,0 @@
-import { useOpenAiGlobal } from "./useOpenAiGlobal.js";
-
-export function useToolOutput() {
-  return useOpenAiGlobal("toolOutput") ?? null;
-}

package/src/react/hooks/useToolResponseMetadata.ts

@@ -1,5 +0,0 @@
-import { useOpenAiGlobal } from "./useOpenAiGlobal.js";
-
-export function useToolResponseMetadata() {
-  return useOpenAiGlobal("toolResponseMetadata") ?? null;
-}

package/src/vite/__tests__/absolute_asset_imports_plugin.test.ts

@@ -1,102 +0,0 @@
-import { expect, test } from "vitest";
-import { AbsoluteAssetImportsPlugin } from "../absolute_asset_imports_plugin.js";
-
-test("Should replace root relative scripts with full url when origin is provided", () => {
-  const ctx = {
-    server: {
-      config: {
-        server: {
-          origin: "http://localhost:3000/",
-        },
-      },
-    },
-  };
-  const html = `<html><head><script type="module" src="/@vite/client"></script></head><body><script module src="/assets/main.ts?t=12345"></script></body></html>`;
-  const plugin = AbsoluteAssetImportsPlugin();
-
-  let result = plugin.transformIndexHtml(html, ctx);
-
-  expect(result).toMatchInlineSnapshot(
-    `"<html><head><script type="module" src="http://localhost:3000/@vite/client"></script></head><body><script module src="http://localhost:3000/assets/main.ts?t=12345"></script></body></html>"`
-  );
-});
-
-test("Should replace root relative scripts with full url when origin is not provided", () => {
-  const ctx = {
-    server: {
-      resolvedUrls: {
-        local: ["http://localhost:3000/"],
-      },
-    },
-  };
-  const html = `<html><head>    <script type="module">import { injectIntoGlobalHook } from "/@react-refresh";
-injectIntoGlobalHook(window);
-window.$RefreshReg$ = () => {};
-window.$RefreshSig$ = () => (type) => type;</script></head></html>`;
-  const plugin = AbsoluteAssetImportsPlugin();
-
-  let result = plugin.transformIndexHtml(html, ctx);
-
-  expect(result).toMatchInlineSnapshot(`
-    "<html><head>    <script type="module">import { injectIntoGlobalHook } from "http://localhost:3000/@react-refresh";
-    injectIntoGlobalHook(window);
-    window.$RefreshReg$ = () => {};
-    window.$RefreshSig$ = () => (type) => type;</script></head></html>"
-  `);
-});
-
-test("Should replace root relative imports with full url when origin is provided", () => {
-  const ctx = {
-    server: {
-      config: {
-        server: {
-          origin: "http://localhost:3000/",
-        },
-      },
-    },
-  };
-  const html = `<html><head>    <script type="module">import { injectIntoGlobalHook } from "/@react-refresh";
-injectIntoGlobalHook(window);
-window.$RefreshReg$ = () => {};
-window.$RefreshSig$ = () => (type) => type;</script></head></html>`;
-  const plugin = AbsoluteAssetImportsPlugin();
-
-  let result = plugin.transformIndexHtml(html, ctx);
-
-  expect(result).toMatchInlineSnapshot(`
-    "<html><head>    <script type="module">import { injectIntoGlobalHook } from "http://localhost:3000/@react-refresh";
-    injectIntoGlobalHook(window);
-    window.$RefreshReg$ = () => {};
-    window.$RefreshSig$ = () => (type) => type;</script></head></html>"
-  `);
-});
-
-test("Should replace root relative imports with full url when origin is not provided", () => {
-  const ctx = {
-    server: {
-      resolvedUrls: {
-        local: ["http://localhost:3000/"],
-      },
-    },
-  };
-  const html = `<html><body><script module src="/assets/main.ts?t=12345"></script></body></html>`;
-  const plugin = AbsoluteAssetImportsPlugin();
-
-  let result = plugin.transformIndexHtml(html, ctx);
-
-  expect(result).toMatchInlineSnapshot(
-    `"<html><body><script module src="http://localhost:3000/assets/main.ts?t=12345"></script></body></html>"`
-  );
-});
-
-test("Should not modify html when not running a local server", () => {
-  const ctx = {};
-  const html = `<html><head><script type="module" src="/@vite/client"></script></head><body><script module src="/assets/main.ts?t=12345"></script></body></html>`;
-  const plugin = AbsoluteAssetImportsPlugin();
-
-  let result = plugin.transformIndexHtml(html, ctx);
-
-  expect(result).toMatchInlineSnapshot(
-    `"<html><head><script type="module" src="/@vite/client"></script></head><body><script module src="/assets/main.ts?t=12345"></script></body></html>"`
-  );
-});