@watermarkinsights/ai-toolbox 0.0.1

package/README.md

@@ -0,0 +1,5 @@
+# @watermarkinsights/ai-toolbox
+
+React component SDK for embedding Watermark AI Toolbox features into your application. Provides pre-built components for authentication and chat interfaces that connect to the AI Toolbox platform.
+
+For installation and usage instructions, see the [documentation](https://ds-ai-api-dev.watermarkinsights.com/toolbox/sdk/docs/).

package/dist/ai-toolbox.d.ts

@@ -0,0 +1,112 @@
+import { JSX } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { RunAgentResult } from '@copilotkit/react-core/v2';
+import * as z from 'zod/mini';
+
+declare type FileAttachment = File | FileAttachmentUrl;
+
+declare type FileAttachmentUrl = {
+    url: string;
+    name: string;
+    mimeType: string;
+};
+
+declare type SendMessageOptions = {
+    files?: FileAttachment[];
+};
+
+declare const TOOLBOX_CHAT_SCHEMA: z.ZodMiniObject<{
+    product: z.ZodMiniString<string>;
+    sessionUrl: z.ZodMiniUnion<readonly [z.ZodMiniURL, z.ZodMiniCustom<() => Promise<{
+        sessionId: string;
+        institutionId: string;
+    }>, () => Promise<{
+        sessionId: string;
+        institutionId: string;
+    }>>]>;
+    fallback: z.ZodMiniOptional<z.ZodMiniCustom<ReactNode, ReactNode>>;
+    featureId: z.ZodMiniString<string>;
+    toolboxBaseUrl: z.ZodMiniOptional<z.ZodMiniURL>;
+    children: z.ZodMiniCustom<ReactNode, ReactNode>;
+}, z.core.$strip>;
+
+export declare const ToolboxChat: (props: ToolboxChatProps) => JSX.Element;
+
+declare type ToolboxChatProps = z.infer<typeof TOOLBOX_CHAT_SCHEMA>;
+
+export declare const useAgent: () => {
+    sendMessage: (message: string, options?: SendMessageOptions) => Promise<RunAgentResult>;
+    isRunning: boolean;
+    messages: ({
+        role: "developer";
+        content: string;
+        id: string;
+        name?: string | undefined;
+        encryptedValue?: string | undefined;
+    } | {
+        role: "system";
+        content: string;
+        id: string;
+        name?: string | undefined;
+        encryptedValue?: string | undefined;
+    } | {
+        role: "assistant";
+        id: string;
+        content?: string | undefined;
+        name?: string | undefined;
+        encryptedValue?: string | undefined;
+        toolCalls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+            encryptedValue?: string | undefined;
+        }[] | undefined;
+    } | {
+        role: "user";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "binary";
+            mimeType: string;
+            id?: string | undefined;
+            url?: string | undefined;
+            data?: string | undefined;
+            filename?: string | undefined;
+        })[];
+        id: string;
+        name?: string | undefined;
+        encryptedValue?: string | undefined;
+    } | {
+        role: "tool";
+        toolCallId: string;
+        content: string;
+        id: string;
+        encryptedValue?: string | undefined;
+        error?: string | undefined;
+    } | {
+        role: "activity";
+        content: Record<string, any>;
+        id: string;
+        activityType: string;
+    } | {
+        role: "reasoning";
+        content: string;
+        id: string;
+        encryptedValue?: string | undefined;
+    })[];
+};
+
+export declare function useLatestToolCall<T = unknown>(toolName: string): T | undefined;
+
+export declare function useToolCall<T = unknown>(toolName: string): T[];
+
+export declare const useToolResponse: (toolName: string) => {
+    isWaiting: boolean;
+    respond: (response: unknown) => void;
+};
+
+export { }

package/dist/ai-toolbox.js

@@ -0,0 +1,276 @@
+import { CopilotKit as e, useCopilotContext as t } from "@copilotkit/react-core";
+import { createContext as n, useCallback as r, useContext as i, useEffect as a, useMemo as o, useReducer as s, useRef as c, useState as l } from "react";
+import * as u from "zod/mini";
+import { z as d } from "zod/mini";
+import { jsx as f, jsxs as p } from "react/jsx-runtime";
+import { useAgent as m, useCopilotKit as h } from "@copilotkit/react-core/v2";
+import { parse as g } from "partial-json";
+//#region src/utilities/constants.ts
+var _ = "https://ai-toolbox-qa.watermarkinsights.com", v = n(void 0), y = () => {
+	let e = i(v);
+	if (!e) throw Error("useAuth must be used in an <Auth/> component");
+	return e;
+}, b = async ({ sessionId: e, institutionId: t, product: n, toolboxBaseUrl: r }) => {
+	let i = `${r}/api/session/cookie`, a = await fetch(i, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		credentials: "include",
+		body: JSON.stringify({
+			sessionId: e,
+			product: n,
+			institutionId: t
+		})
+	});
+	if (!a.ok) {
+		let e = await a.json().catch(() => ({ message: "Unknown error" }));
+		throw a.status === 400 ? Error(`Invalid session ID: ${e.message}`) : a.status === 404 ? Error(`Session not found: ${e.message}`) : Error(`Failed to set session cookie: ${e.message}`);
+	}
+	return a.json();
+}, x = async (e) => {
+	let t = await fetch(e, {
+		method: "POST",
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		},
+		credentials: "include"
+	});
+	if (!t.ok) throw Error(`Failed to get toolbox session.  Endpoint ${e} returned status ${t.status}.`);
+	let n;
+	try {
+		n = await t.json();
+	} catch (t) {
+		throw Error(`Could not parse JSON for toolbox session. Requested from ${e}`, { cause: t });
+	}
+	if (!n.sessionId || typeof n.sessionId != "string") throw Error(`Invalid sessionId received from ${e}. Received ${n.sessionId}`);
+	if (!n.institutionId || typeof n.institutionId != "string") throw Error(`Invalid institution received from ${e}. Received ${n.institutionId}`);
+	let { sessionId: r, institutionId: i } = n;
+	return {
+		sessionId: r,
+		institutionId: i
+	};
+}, S = async (e) => {
+	if (typeof e == "function") {
+		let t = await e();
+		if (!t.sessionId || typeof t.sessionId != "string") throw Error(`Invalid sessionId returned from sessionUrl function. Received ${t.sessionId}`);
+		if (!t.institutionId || typeof t.institutionId != "string") throw Error(`Invalid institution returned from sessionUrl function. Received ${t.institutionId}`);
+		return {
+			sessionId: t.sessionId,
+			institutionId: t.institutionId
+		};
+	}
+	try {
+		new URL(e);
+	} catch (t) {
+		throw Error(`sessionUrl is not a valid url: ${e}`, { cause: t });
+	}
+	return x(e);
+}, C = d.object({
+	product: d.string(),
+	sessionUrl: d.union([d.url(), d.custom((e) => typeof e == "function")]),
+	children: d.custom(),
+	fallback: d.optional(d.custom()),
+	toolboxBaseUrl: d.optional(d.url())
+}), w = {}, T = (e) => {
+	let { product: t, sessionUrl: n, fallback: r, children: s, toolboxBaseUrl: u = _ } = d.parse(C, e), [p, m] = l(null), h = i(v), g = c(n);
+	a(() => {
+		g.current = n;
+	}, [n]);
+	let y = o(() => p ?? h, [h, p]);
+	return a(() => {
+		if (y) return;
+		let e = !1, n = g.current, r = u, i = `${t}-${typeof n == "string" ? n : "function"}-${r}`;
+		return w[i] || (w[i] = S(n).then(({ sessionId: e, institutionId: n }) => (b({
+			sessionId: e,
+			institutionId: n,
+			product: t,
+			toolboxBaseUrl: r
+		}), {
+			sessionId: e,
+			institutionId: n
+		}))), w[i].then((t) => {
+			e || m(t);
+		}), () => {
+			e = !0;
+		};
+	}, [
+		t,
+		y,
+		u
+	]), h ? s : y ? /* @__PURE__ */ f(v.Provider, {
+		value: y,
+		children: s
+	}) : r ?? null;
+}, E = "on_interrupt";
+function D(e, t) {
+	switch (t.type) {
+		case "SET_INTERRUPT": return e.interruptedTool === null || e.interruptedTool.name === t.payload.name ? { interruptedTool: t.payload } : (console.error(`ToolboxInterruptProvider: Received interrupt for tool "${t.payload.name}" but tool "${e.interruptedTool.name}" is already interrupted. Ignoring.`), e);
+		case "CLEAR_INTERRUPT": return { interruptedTool: null };
+		default: return e;
+	}
+}
+var O = n({
+	interruptedTool: null,
+	dispatch: () => {}
+});
+function k({ children: e }) {
+	let [t, n] = s(D, { interruptedTool: null }), { agent: r } = m();
+	return a(() => {
+		let { unsubscribe: e } = r.subscribe({
+			onCustomEvent: ({ event: e }) => {
+				let t = e.value;
+				e.name === E && n({
+					type: "SET_INTERRUPT",
+					payload: {
+						name: t.tool,
+						value: t.toolArgs
+					}
+				});
+			},
+			onRunStartedEvent: () => {
+				n({ type: "CLEAR_INTERRUPT" });
+			},
+			onRunFailed: () => {
+				n({ type: "CLEAR_INTERRUPT" });
+			}
+		});
+		return () => {
+			e();
+		};
+	}, [r]), /* @__PURE__ */ f(O.Provider, {
+		value: {
+			interruptedTool: t.interruptedTool,
+			dispatch: n
+		},
+		children: e
+	});
+}
+var A = (e) => {
+	let { interruptedTool: n, dispatch: a } = i(O), { copilotkit: s } = h(), { copilotApiConfig: c } = t(), { agent: l } = m(), u = n?.name === e, d = r((e) => {
+		a({ type: "CLEAR_INTERRUPT" }), s.runAgent({
+			agent: l,
+			forwardedProps: { command: { resume: JSON.stringify({
+				response: e,
+				properties: c.properties ?? {}
+			}) } }
+		});
+	}, [
+		l,
+		c.properties,
+		s,
+		a
+	]);
+	return o(() => ({
+		isWaiting: u,
+		respond: d
+	}), [u, d]);
+}, j = u.object({
+	featureId: u.string({ error: "invalid feature id" }),
+	toolboxBaseUrl: u.optional(u.url()),
+	children: u.custom(),
+	...u.pick(C, {
+		product: !0,
+		sessionUrl: !0,
+		fallback: !0
+	}).shape
+}), M = (e) => {
+	let { product: t, sessionUrl: n, fallback: r, featureId: i, children: a, toolboxBaseUrl: o = _ } = u.parse(j, e);
+	return /* @__PURE__ */ f(T, {
+		product: t,
+		sessionUrl: n,
+		fallback: r,
+		toolboxBaseUrl: o,
+		children: /* @__PURE__ */ f(N, {
+			featureId: i,
+			runtimeUrl: `${o}/api/feature/chat`,
+			children: a
+		})
+	});
+}, N = ({ featureId: t, runtimeUrl: n, children: r }) => {
+	let { institutionId: i, sessionId: a } = y();
+	return /* @__PURE__ */ p(e, {
+		agent: "default",
+		showDevConsole: !1,
+		runtimeUrl: n,
+		properties: {
+			featureId: t,
+			username: "toolbox-user",
+			sessionId: a,
+			institutionId: i
+		},
+		children: [/* @__PURE__ */ f("style", { children: "cpk-web-inspector {\n      display: none !important;\n    }" }), /* @__PURE__ */ f(k, { children: r })]
+	});
+};
+//#endregion
+//#region src/hooks/use-tool-call.ts
+function P(e) {
+	let { agent: t } = m();
+	return o(() => {
+		let n = t.messages ?? [], r = [];
+		for (let t = 0; t < n.length; t++) {
+			let i = n[t];
+			if (i.role !== "assistant" || !i.toolCalls) continue;
+			let a = t === n.length - 1;
+			for (let t of i.toolCalls) {
+				if (t.function?.name !== e) continue;
+				let n = t.function.arguments;
+				if (n) try {
+					let e = a ? g(n) : JSON.parse(n);
+					r.push(e);
+				} catch {}
+			}
+		}
+		return r;
+	}, [t.messages, e]);
+}
+//#endregion
+//#region src/hooks/use-latest-tool-call.ts
+function F(e) {
+	let t = P(e);
+	return t[t.length - 1];
+}
+//#endregion
+//#region src/hooks/use-agent.ts
+var I = () => {
+	let { agent: e } = m(), { copilotkit: t } = h(), n = r(async (n, r) => {
+		let i = r?.files ?? [], a;
+		if (i.length === 0) a = n;
+		else {
+			let e = [];
+			for (let t of i) if (t instanceof File) {
+				let n = await t.arrayBuffer(), r = new Uint8Array(n).reduce((e, t) => e + String.fromCharCode(t), ""), i = btoa(r);
+				e.push({
+					type: "binary",
+					mimeType: t.type,
+					data: i,
+					filename: t.name
+				});
+			} else e.push({
+				type: "binary",
+				mimeType: t.mimeType,
+				url: t.url,
+				filename: t.name
+			});
+			a = [{
+				type: "text",
+				text: n
+			}, ...e];
+		}
+		return e.addMessage({
+			id: crypto.randomUUID(),
+			role: "user",
+			content: a
+		}), t.runAgent({ agent: e });
+	}, [e, t]);
+	return o(() => ({
+		sendMessage: n,
+		isRunning: e.isRunning,
+		messages: e.messages ?? []
+	}), [
+		e.isRunning,
+		e.messages,
+		n
+	]);
+};
+//#endregion
+export { M as ToolboxChat, I as useAgent, F as useLatestToolCall, P as useToolCall, A as useToolResponse };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@watermarkinsights/ai-toolbox",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/ai-toolbox.js",
+      "types": "./dist/ai-toolbox.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "bunx --bun vite build --watch ",
+    "build": "bunx --bun vite build",
+    "typecheck": "bunx --bun tsc --noEmit --incremental -p tsconfig.app.json",
+    "lint": "bunx --bun eslint --cache .",
+    "lint:fix": "bunx --bun eslint --cache --fix .",
+    "preview": "vite preview",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build"
+  },
+  "dependencies": {
+    "@copilotkit/react-core": "^1.53.0",
+    "partial-json": "^0.1.7",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "^5.0.1",
+    "@eslint/js": "catalog:",
+    "@storybook/addon-a11y": "^10.2.15",
+    "@storybook/addon-docs": "^10.2.15",
+    "@storybook/addon-onboarding": "^10.2.15",
+    "@storybook/addon-vitest": "^10.2.15",
+    "@storybook/react-vite": "^10.2.15",
+    "@types/node": "^24.10.1",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "@vitejs/plugin-react": "catalog:",
+    "@vitejs/plugin-react-swc": "^4.2.2",
+    "@vitest/browser-playwright": "^4.0.18",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "catalog:",
+    "eslint-plugin-react-hooks": "catalog:",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "eslint-plugin-storybook": "^10.2.15",
+    "globals": "catalog:",
+    "playwright": "^1.58.2",
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "storybook": "^10.2.15",
+    "typescript": "catalog:",
+    "typescript-eslint": "catalog:",
+    "vite": "^8.0.2",
+    "vite-bundle-analyzer": "^1.3.6",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-externalize-deps": "^0.10.0",
+    "vitest": "^4.0.18"
+  }
+}