@apollo/client-ai-apps 0.4.0 → 0.5.1

package/src/tsconfig/openai/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "customConditions": ["openai"],
+    "types": ["@apollo/client-ai-apps/openai/globals"],
+    "moduleSuffixes": [".openai", ""]
+  }
+}

package/src/types/application-manifest.ts

@@ -1,10 +1,16 @@
 export type ApplicationManifest = {
   format: "apollo-ai-app-manifest";
   version: "1";
+  appVersion: string;
   name: string;
   description: string;
   hash: string;
-  resource: string;
+  resource:
+    | string
+    | {
+        mcp?: string;
+        openai?: string;
+      };
   operations: ManifestOperation[];
   csp: ManifestCsp;
   widgetSettings?: ManifestWidgetSettings;

package/src/utilities/__tests__/cacheAsync.test.ts

@@ -0,0 +1,64 @@
+import { test, expect, vi } from "vitest";
+import { cacheAsync } from "../cacheAsync.js";
+
+test("returns the same promise on subsequent calls", async () => {
+  const fn = vi.fn(() => Promise.resolve("result"));
+  const cached = cacheAsync(fn);
+
+  const p1 = cached();
+  const p2 = cached();
+
+  expect(p1).toBe(p2);
+  expect(fn).toHaveBeenCalledTimes(1);
+  await expect(p1).resolves.toBe("result");
+});
+
+test("reset allows the function to be called again", async () => {
+  let count = 0;
+  const fn = vi.fn(() => Promise.resolve(++count));
+  const cached = cacheAsync(fn);
+
+  await expect(cached()).resolves.toBe(1);
+
+  cached.reset();
+
+  await expect(cached()).resolves.toBe(2);
+  expect(fn).toHaveBeenCalledTimes(2);
+});
+
+test("passes arguments to the wrapped function", async () => {
+  const fn = vi.fn((a: number, b: string) => Promise.resolve(`${a}-${b}`));
+  const cached = cacheAsync(fn);
+
+  await expect(cached(1, "hello")).resolves.toBe("1-hello");
+  expect(fn).toHaveBeenCalledWith(1, "hello");
+});
+
+test("does not cache after reset even if prior promise is still pending", async () => {
+  let resolve!: () => void;
+  let count = 0;
+
+  const fn = vi.fn(
+    () =>
+      new Promise<number>((res) => {
+        resolve = () => res(++count);
+      })
+  );
+
+  const cached = cacheAsync(fn);
+
+  const p1 = cached();
+  const resolveFirst = resolve;
+
+  cached.reset();
+  const p2 = cached();
+
+  expect(p1).not.toBe(p2);
+  expect(fn).toHaveBeenCalledTimes(2);
+
+  resolveFirst();
+  await expect(p1).resolves.toBe(1);
+
+  resolve();
+  await expect(p2).resolves.toBe(2);
+});

package/src/utilities/cacheAsync.ts

@@ -0,0 +1,25 @@
+// NOTE: This is a simplified cache function that does not handles variances in
+// arguments. For a more robust implementation, we would want to consider
+// caching based on input so it works more similarly to a memoization cache. For
+// that we can use `@sry/trie`. That is overkill for our use now, but if this
+// needs to be more robust later, let's implement the cache with that package.
+export function cacheAsync<TArgs extends any[], TReturn>(
+  fn: (...args: TArgs) => Promise<TReturn>
+) {
+  let promise: Promise<TReturn> | undefined;
+
+  return Object.assign(
+    (...args: TArgs): Promise<TReturn> => {
+      if (promise) {
+        return promise;
+      }
+
+      return (promise = fn(...args));
+    },
+    {
+      reset: () => {
+        promise = undefined;
+      },
+    }
+  );
+}

package/src/utilities/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * Used to mark this package's client in order to validate the right client is
+ * provided.
+ */
+export const aiClientSymbol = Symbol.for("apollo.aiClient");

package/src/utilities/emptyModule.ts

@@ -0,0 +1 @@
+export {};

package/src/utilities/getVariablesForOperationFromToolInput.ts

@@ -0,0 +1,27 @@
+import type { OperationVariables } from "@apollo/client";
+import type { ManifestOperation } from "../types/application-manifest.js";
+
+// We need to get the variables used as part of the tool call that resulted in
+// rendering this app so that we can properly write to the cache, however we
+// want to only include keys that are defined as part of the operation in case
+// additional input was provided to the tool.
+
+/** @internal */
+export function getVariablesForOperationFromToolInput(
+  operation: ManifestOperation,
+  toolInput: Record<string, unknown> | undefined
+): OperationVariables {
+  if (!operation.variables || !toolInput) {
+    return {};
+  }
+
+  const variableNames = new Set(Object.keys(operation.variables));
+
+  return Object.keys(toolInput).reduce((obj, key) => {
+    if (variableNames.has(key)) {
+      obj[key] = toolInput[key];
+    }
+
+    return obj;
+  }, {} as OperationVariables);
+}

package/src/utilities/index.ts

@@ -0,0 +1,5 @@
+export { aiClientSymbol } from "./constants.js";
+export { getVariablesForOperationFromToolInput } from "./getVariablesForOperationFromToolInput.js";
+export { cacheAsync } from "./cacheAsync.js";
+export { invariant } from "./invariant.js";
+export { promiseWithResolvers } from "./promiseWithResolvers.js";

package/src/utilities/invariant.ts

@@ -0,0 +1,5 @@
+export function invariant(condition: any, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}

package/src/utilities/promiseWithResolvers.ts

@@ -0,0 +1,18 @@
+// Polyfill for the `Promise.withResolvers` API:
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+//
+// Once `Promise.withResolvers` hits widely available, we should remove this
+// polyfill in favor of that API.
+
+/** @internal */
+export function promiseWithResolvers<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: any) => void;
+
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+}