@rebasepro/plugin-ai 0.13.0 → 0.13.1-canary.g06dbe5b

package/README.md

@@ -46,13 +46,17 @@ Two consequences worth knowing:
   for it. Cost is bounded by rate limits and a daily ceiling instead.
 - **Your collection schema and the record's current values are sent** with each
   autofill request, because the service has no other way to know the shape of what
-  it is filling. If that is not acceptable for your data, set `endpoint` and run the
+  it is filling. Values of properties marked `admin: { readOnly: true }` or
+  `admin: { disabled: true }` are the exception — they are neither filled nor sent.
+  If the rest is not acceptable for your data, set `endpoint` and run the
   service yourself — the reference implementation is `saas/backend/functions/ai.ts`
   in the Rebase repository, and the wire format is documented in `src/api.ts`.
 
 The plugin renders nothing until the service's `GET /status` reports itself
 available, so an unreachable host or an exhausted daily quota means no Autofill
-button — never a button that fails when clicked.
+button — never a button that fails when clicked. That check is one request per
+session, not one per record opened; return `false` from `getConfigForPath` to
+keep a collection from being asked about at all.
 
 ## Key Exports
 

package/dist/api.d.ts

@@ -21,6 +21,25 @@ export declare function fetchAiStatus(props: {
     endpoint?: string;
     signal?: AbortSignal;
 }): Promise<AiStatus>;
+/**
+ * {@link fetchAiStatus}, asked once per endpoint per session.
+ *
+ * The provider is form-scoped, so the uncached call meant one request to the
+ * host every time any record was opened — a beacon on an install that may never
+ * click Autofill, and enough traffic from one NAT'd office to spend the host's
+ * per-IP rate limit on nothing, which reads back as `available: false` and makes
+ * the button flicker in and out for everyone behind it.
+ *
+ * Availability changes on the order of a deploy or a daily quota reset, not of a
+ * form open, so a session-long answer is the right resolution. Failures resolve
+ * to `available: false` and are cached like any other answer — retrying per form
+ * open is the behaviour this replaces.
+ */
+export declare function fetchAiStatusCached(props: {
+    endpoint?: string;
+}): Promise<AiStatus>;
+/** Forget every cached probe, so the next caller asks again. */
+export declare function clearAiStatusCache(): void;
 /**
  * Fill a record, streaming each field as the service writes it.
  *

package/dist/components/DataEnhancementControllerProvider.d.ts

@@ -1,11 +1,18 @@
 import React, { PropsWithChildren } from "react";
 import { DataEnhancementController } from "../types/data_enhancement_controller";
-import { CollectionConfig } from "@rebasepro/types";
+import { CollectionConfig, User } from "@rebasepro/types";
 import { PluginFormActionProps } from "@rebasepro/admin-types";
 type DataEnhancementControllerProviderProps = {
+    /**
+     * Kept in step with `DataEnhancementPluginProps.getConfigForPath`, which is
+     * the signature the host app actually writes against: the plugin hands this
+     * component through as `ComponentType<any>`, so nothing but agreement here
+     * makes the two match.
+     */
     getConfigForPath?: (props: {
         path: string;
         collection: CollectionConfig;
+        user: User | null;
     }) => boolean;
     endpoint?: string;
 };

package/dist/index.es.js

@@ -1,10 +1,10 @@
 import React, { useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { AIIcon, useAuthController } from "@rebasepro/app";
 import { getFieldId } from "@rebasepro/admin";
 import { isPropertyBuilder, stripCollectionPath } from "@rebasepro/common";
 import { getValueInPath } from "@rebasepro/utils";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Button, Checkbox, CircularProgress, Dialog, DialogActions, DialogContent, DialogTitle, IconButton, Menu, MenuItem, SendIcon, Separator, TextareaAutosize, Typography, XIcon, cls, fieldBackgroundMixin, focusedDisabled, iconSize } from "@rebasepro/ui";
-import { AIIcon } from "@rebasepro/app";
 /**
 * ## No credentials cross this boundary
 *
@@ -98,6 +98,30 @@ async function fetchAiStatus(props) {
 		features: Array.isArray(body?.features) ? body.features : void 0
 	};
 }
+/** One in-flight or settled probe per endpoint, for the life of the page. */
+var statusProbes = /* @__PURE__ */ new Map();
+/**
+* {@link fetchAiStatus}, asked once per endpoint per session.
+*
+* The provider is form-scoped, so the uncached call meant one request to the
+* host every time any record was opened — a beacon on an install that may never
+* click Autofill, and enough traffic from one NAT'd office to spend the host's
+* per-IP rate limit on nothing, which reads back as `available: false` and makes
+* the button flicker in and out for everyone behind it.
+*
+* Availability changes on the order of a deploy or a daily quota reset, not of a
+* form open, so a session-long answer is the right resolution. Failures resolve
+* to `available: false` and are cached like any other answer — retrying per form
+* open is the behaviour this replaces.
+*/
+function fetchAiStatusCached(props) {
+	const key = endpointOf(props.endpoint, "/status");
+	const existing = statusProbes.get(key);
+	if (existing) return existing;
+	const probe = fetchAiStatus({ endpoint: props.endpoint }).catch(() => ({ available: false }));
+	statusProbes.set(key, probe);
+	return probe;
+}
 /**
 * Fill a record, streaming each field as the service writes it.
 *
@@ -116,21 +140,33 @@ async function autofillStream(props) {
 	});
 	if (!response.ok) throw await errorFrom(response, "The AI service could not complete this request.");
 	let result = { suggestions: {} };
+	let done = false;
+	let delivered = 0;
+	let discarded = 0;
 	for await (const { event, data } of readServerSentEvents(response)) {
 		let payload;
 		try {
 			payload = JSON.parse(data);
 		} catch {
+			discarded++;
 			continue;
 		}
-		if (event === "suggestion_delta") props.onDelta(payload.key, payload.text);
-		else if (event === "suggestion") props.onValue(payload.key, payload.value);
-		else if (event === "done") result = {
-			suggestions: payload.suggestions ?? {},
-			usage: payload.usage
-		};
-		else if (event === "error") throw new Error(payload.message ?? "The AI service reported an error.");
+		if (event === "suggestion_delta") {
+			delivered++;
+			props.onDelta(payload.key, payload.text);
+		} else if (event === "suggestion") {
+			delivered++;
+			props.onValue(payload.key, payload.value);
+		} else if (event === "done") {
+			done = true;
+			result = {
+				suggestions: payload.suggestions ?? {},
+				usage: payload.usage
+			};
+		} else if (event === "error") throw new Error(payload.message ?? "The AI service reported an error.");
 	}
+	if (!done) throw new Error("The connection to the AI service ended before it finished.");
+	if (discarded > 0 && delivered === 0) throw new Error("The AI service's response could not be read.");
 	return result;
 }
 /** Inline continuation for the rich-text editor. Streams plain text. */
@@ -314,17 +350,63 @@ function getSimpleEnumValues(enumValues) {
 }
 //#endregion
 //#region src/utils/values.ts
+/**
+* Flatten a record onto the dotted paths the property map uses.
+*
+* The two halves of an autofill request have to be keyed the same way: the
+* service decides a field is empty by looking up `values[key]` for every `key`
+* in `properties`, so a value filed under a key the property map has never
+* heard of is a value the service cannot see.
+*
+* Only plain objects are containers. This used to recurse into anything
+* `typeof value === "object"`, which is both an array and a `Date` — so
+* `tags: ["a", "b"]` was sent as `tags.0`/`tags.1` while the property map still
+* called it `tags`, and a `Date` disappeared entirely (`Object.entries(date)` is
+* `[]`). Both then read as empty on the far side and came back in the review
+* pre-ticked to replace a value the record already had. `getSimplifiedProperties`
+* names an array by its own path and never descends into one, so neither does
+* this.
+*/
 function flatMapEntityValues(values, path = "") {
 	if (!values) return {};
 	return Object.entries(values).flatMap(([key, value]) => {
 		const currentPath = path ? `${path}.${key}` : key;
-		if (typeof value === "object") return flatMapEntityValues(value, currentPath);
+		if (isPlainObject(value)) return flatMapEntityValues(value, currentPath);
 		else return { [currentPath]: value };
 	}).reduce((acc, curr) => ({
 		...acc,
 		...curr
 	}), {});
 }
+/**
+* A container, as opposed to a leaf value.
+*
+* Arrays, dates, files and every other class instance are values in their own
+* right — a map property is the only thing whose children are separate fields.
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Drop the values of properties the panel will not let anyone edit.
+*
+* A `readOnly` or `disabled` property is already excluded from what the service
+* may fill, but the values map was built from the whole record, and the prompt
+* includes every value it is given as context. So a field marked read-only
+* because a backend hook owns it — an internal note, a customer id — was still
+* being transmitted and pasted into the prompt. The collection config lives
+* here, so this is the honest place to decide it: disabled means neither
+* fillable nor context.
+*
+* Prefixes match too: a disabled map takes its children with it.
+*/
+function omitDisabledValues(values, properties) {
+	const disabled = Object.entries(properties ?? {}).filter(([, property]) => property && typeof property === "object" && property.disabled).map(([key]) => key);
+	if (disabled.length === 0) return values;
+	return Object.fromEntries(Object.entries(values).filter(([key]) => !disabled.some((prefix) => key === prefix || key.startsWith(`${prefix}.`))));
+}
 //#endregion
 //#region src/editor/useEditorAIController.tsx
 /**
@@ -385,7 +467,7 @@ function DataEnhancementControllerProvider({ getConfigForPath, children, endpoin
 	*/
 	const propertiesRef = useRef(properties);
 	propertiesRef.current = properties;
-	/** The host app's own opt-out. */
+	const user = useAuthController()?.user ?? null;
 	useEffect(() => {
 		if (!getConfigForPath) {
 			setAllowedHere(true);
@@ -393,12 +475,14 @@ function DataEnhancementControllerProvider({ getConfigForPath, children, endpoin
 		}
 		setAllowedHere(Boolean(getConfigForPath({
 			path,
-			collection
+			collection,
+			user
 		})));
 	}, [
 		getConfigForPath,
 		path,
-		collection
+		collection,
+		user
 	]);
 	/**
 	* The service's own availability.
@@ -407,15 +491,22 @@ function DataEnhancementControllerProvider({ getConfigForPath, children, endpoin
 	* unconfigured provider key or an exhausted daily quota all land here, and
 	* all of them mean the same thing to the operator: no Autofill button,
 	* rather than a button that fails when clicked.
+	*
+	* Asked through the session cache: this provider is form-scoped, so an
+	* uncached probe is one request to the host per record opened, by an install
+	* that may never use the feature. The probe is shared rather than aborted on
+	* unmount — cancelling it would cancel it for whatever else is waiting on the
+	* same answer — so unmounting only stops this component from reading it.
 	*/
 	useEffect(() => {
 		if (!allowedHere) return;
-		const abort = new AbortController();
-		fetchAiStatus({
-			endpoint,
-			signal: abort.signal
-		}).then((status) => setServiceAvailable(status.available)).catch(() => setServiceAvailable(false));
-		return () => abort.abort();
+		let cancelled = false;
+		fetchAiStatusCached({ endpoint }).then((status) => {
+			if (!cancelled) setServiceAvailable(status.available);
+		});
+		return () => {
+			cancelled = true;
+		};
 	}, [allowedHere, endpoint]);
 	const enabled = allowedHere && serviceAvailable;
 	/** Add or update one row in the review, preserving arrival order. */
@@ -433,7 +524,7 @@ function DataEnhancementControllerProvider({ getConfigForPath, children, endpoin
 	}, []);
 	const generate = useCallback(async (params) => {
 		const currentProperties = propertiesRef.current;
-		const flatValues = flatMapEntityValues(params.values ?? {});
+		const flatValues = omitDisabledValues(flatMapEntityValues(params.values ?? {}), currentProperties);
 		setReview({
 			status: "generating",
 			fields: [],
@@ -807,16 +898,13 @@ function FormEnhanceAction({ path, status, collection, formContext }) {
 		align: "end",
 		sideOffset: 8,
 		className: "max-w-[100vw]",
-		trigger: /* @__PURE__ */ jsxs(Button, {
+		trigger: /* @__PURE__ */ jsxs(IconButton, {
 			variant: "filled",
-			color: "neutral",
 			size: "small",
+			"aria-label": "Autofill",
+			title: "Autofill",
 			disabled: loading,
-			children: [
-				!loading && /* @__PURE__ */ jsx(AIIcon, { size: "small" }),
-				loading && /* @__PURE__ */ jsx(CircularProgress, { size: "small" }),
-				"Autofill"
-			]
+			children: [!loading && /* @__PURE__ */ jsx(AIIcon, { size: "small" }), loading && /* @__PURE__ */ jsx(CircularProgress, { size: "small" })]
 		}),
 		children: [
 			/* @__PURE__ */ jsxs(MenuItem, {