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

package/src/components/DataEnhancementControllerProvider.tsx

@@ -7,11 +7,12 @@ import {
     InputProperty,
     ProposedField
 } from "../types/data_enhancement_controller";
-import { CollectionConfig } from "@rebasepro/types";
+import { CollectionConfig, User } from "@rebasepro/types";
 import { PluginFormActionProps } from "@rebasepro/admin-types";
-import { autofillStream, fetchAiStatus, fetchPromptSuggestions } from "../api";
+import { useAuthController } from "@rebasepro/app";
+import { autofillStream, fetchAiStatusCached, fetchPromptSuggestions } from "../api";
 import { getSimplifiedProperties } from "../utils/properties";
-import { flatMapEntityValues } from "../utils/values";
+import { flatMapEntityValues, omitDisabledValues } from "../utils/values";
 import { useEditorAIController } from "../editor/useEditorAIController";
 import { getValueInPath } from "@rebasepro/utils";
 
@@ -19,9 +20,16 @@ const DataEnhancementControllerContext = React.createContext<DataEnhancementCont
 
 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
+        collection: CollectionConfig,
+        user: User | null
     }) => boolean;
 
     endpoint?: string;
@@ -84,15 +92,26 @@ export function DataEnhancementControllerProvider({
     const propertiesRef = useRef(properties);
     propertiesRef.current = properties;
 
-    /** The host app's own opt-out. */
+    /**
+     * The host app's own opt-out.
+     *
+     * `user` is part of the documented signature and was never passed, so
+     * `getConfigForPath: ({ user }) => user?.roles?.includes("editor")` was
+     * `Boolean(undefined)` for everyone — an access rule that silently decided
+     * nothing, in whichever direction the host had written it.
+     */
+    const authController = useAuthController();
+    const user: User | null = authController?.user ?? null;
+
     useEffect(() => {
         if (!getConfigForPath) {
             setAllowedHere(true);
             return;
         }
         setAllowedHere(Boolean(getConfigForPath({ path,
-collection })));
-    }, [getConfigForPath, path, collection]);
+collection,
+user })));
+    }, [getConfigForPath, path, collection, user]);
 
     /**
      * The service's own availability.
@@ -101,15 +120,23 @@ collection })));
      * 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;
@@ -131,7 +158,10 @@ fields };
     const generate = useCallback(async (params: GenerateParams<Record<string, unknown>>): Promise<void> => {
 
         const currentProperties = propertiesRef.current;
-        const flatValues = flatMapEntityValues(params.values ?? {}) as Record<string, unknown>;
+        const flatValues = omitDisabledValues(
+            flatMapEntityValues(params.values ?? {}),
+            currentProperties
+        );
 
         setReview({
             status: "generating",
@@ -150,6 +180,12 @@ fields };
                     // Flattened to dotted paths so the keys line up with the
                     // property map: the service is told about `seo.title`, so it
                     // has to be told the value of `seo.title` too, not of `seo`.
+                    // Exactly the same rule in both directions — an array or a
+                    // date is one value under one key here because it is one
+                    // property under one key there. Where they disagreed, the
+                    // service read a filled field as empty and offered to
+                    // rewrite it. Values of properties nobody may edit do not
+                    // travel at all.
                     values: flatValues,
                     properties: currentProperties,
                     propertyKey: params.propertyKey,

package/src/components/FormEnhanceAction.tsx

@@ -1,7 +1,6 @@
 import React, { useCallback, useEffect, useRef } from "react";
 
 import {
-    Button,
     CircularProgress,
     cls,
     fieldBackgroundMixin,
@@ -117,14 +116,18 @@ export function FormEnhanceAction({
                 // Never full width: this used to stretch to fill the form's
                 // `w-80 2xl:w-96` side rail in full screen. That rail is gone, and
                 // in the footer a stretched button reads as the primary action.
-                trigger={<Button variant={"filled"}
-                    color={"neutral"}
+                // Icon only. The label is carried by `aria-label`/`title` — a
+                // `Tooltip` here would swallow the menu: both it and
+                // `DropdownMenu.Trigger` render `asChild`, and `Tooltip` drops
+                // the props Radix clones onto it, so the menu never opens.
+                trigger={<IconButton variant={"filled"}
                     size={"small"}
+                    aria-label={"Autofill"}
+                    title={"Autofill"}
                     disabled={loading}>
                     {!loading && <AIIcon size={"small"}/>}
                     {loading && <CircularProgress size={"small"}/>}
-                    Autofill
-                </Button>}>
+                </IconButton>}>
 
                 <MenuItem className={"py-4"}
                     onClick={() => {

package/src/tests/api.test.ts

@@ -6,7 +6,9 @@ import {
     DEFAULT_AI_ENDPOINT,
     autocompleteStream,
     autofillStream,
+    clearAiStatusCache,
     fetchAiStatus,
+    fetchAiStatusCached,
     fetchPromptSuggestions
 } from "../api";
 import { AutofillRequest } from "../types/data_enhancement_controller";
@@ -144,7 +146,8 @@ stock: 42 });
     });
 
     it("joins a multi-line data field", async () => {
-        const body = 'event: suggestion\ndata: {"key":"body",\ndata: "value":"two lines"}\n\n';
+        const body = 'event: suggestion\ndata: {"key":"body",\ndata: "value":"two lines"}\n\n'
+            + "event: done\ndata: {}\n\n";
         const { values } = await runAutofill([body]);
         expect(values).toEqual([["body", "two lines"]]);
     });
@@ -185,6 +188,58 @@ onValue: () => undefined })
         ).rejects.toThrow(/quota for today/);
     });
 
+    it("fails a stream that ends without a `done` record", async () => {
+        // A rolled pod, a proxy timeout, a dropped connection. The body simply
+        // stops. Returning `{ suggestions: {} }` for that is indistinguishable
+        // from the service saying there was nothing to fill — and the operator
+        // is then told, in a confident sentence, that their empty fields are
+        // fields the model would not improve on.
+        const truncated = [
+            "event: suggestion",
+            'data: {"key":"title","value":"Blue widget"}',
+            "",
+            "event: suggestion_delta",
+            'data: {"key":"summary","text":"half a sen'
+        ].join("\n");
+        (global as any).fetch = jest.fn().mockResolvedValue(streamingResponse([truncated]));
+
+        const values: [string, unknown][] = [];
+        await expect(autofillStream({
+            request: REQUEST,
+            onDelta: () => undefined,
+            onValue: (k, v) => values.push([k, v])
+        })).rejects.toThrow(/ended before it finished/);
+
+        // Whatever did arrive was still delivered — the caller keeps the fields
+        // that completed and reports the run as failed.
+        expect(values).toEqual([["title", "Blue widget"]]);
+    });
+
+    it("fails a stream whose every record was unreadable", async () => {
+        // Zero good fields plus n discarded records is not "nothing to fill".
+        const garbage = "event: suggestion\ndata: {not json\n\nevent: suggestion\ndata: {also not\n\n";
+        (global as any).fetch = jest.fn().mockResolvedValue(streamingResponse([garbage]));
+        await expect(
+            autofillStream({ request: REQUEST,
+onDelta: () => undefined,
+onValue: () => undefined })
+        ).rejects.toThrow(/could not be read|ended before it finished/);
+    });
+
+    it("accepts the empty run the service sends when there is nothing to fill", async () => {
+        // That case is a `done` with no suggestions, not an empty body, so it
+        // must stay distinguishable from a truncation.
+        (global as any).fetch = jest.fn().mockResolvedValue(
+            streamingResponse(['event: done\ndata: {"suggestions":{},"usage":{}}\n\n'])
+        );
+        await expect(
+            autofillStream({ request: REQUEST,
+onDelta: () => undefined,
+onValue: () => undefined })
+        ).resolves.toEqual({ suggestions: {},
+usage: {} });
+    });
+
     it("sends no credentials of any kind", async () => {
         // The FireCMS-era client sent the tenant's JWT as `Authorization: Basic`
         // plus a hardcoded `fcms-…` key. No external service could verify the
@@ -200,7 +255,10 @@ onValue: () => undefined });
     });
 
     it("posts to the hosted endpoint by default and to an override when given", async () => {
-        const fetchMock = jest.fn().mockResolvedValue(streamingResponse([BODY]));
+        // A fresh response per call: one `streamingResponse` is a single reader,
+        // and handing the same exhausted one to the second call makes it read an
+        // empty body — which is now, correctly, a truncated stream.
+        const fetchMock = jest.fn().mockImplementation(async () => streamingResponse([BODY]));
         (global as any).fetch = fetchMock;
 
         await autofillStream({ request: REQUEST,
@@ -263,6 +321,47 @@ features: ["autofill"] })
     });
 });
 
+describe("fetchAiStatusCached", () => {
+
+    beforeEach(() => clearAiStatusCache());
+    afterEach(() => clearAiStatusCache());
+
+    it("asks the host once per endpoint, however many callers there are", async () => {
+        // The provider is form-scoped, so an uncached probe is one request to
+        // the host every time any record is opened — a beacon from an install
+        // that may never use the feature, and enough traffic from one office
+        // behind one address to spend the host's per-IP limit on nothing.
+        const fetchMock = jest.fn().mockResolvedValue(jsonResponse({ available: true }));
+        (global as any).fetch = fetchMock;
+
+        const answers = await Promise.all([
+            fetchAiStatusCached({}),
+            fetchAiStatusCached({}),
+            fetchAiStatusCached({})
+        ]);
+        await fetchAiStatusCached({});
+
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(answers.every(a => a.available)).toBe(true);
+    });
+
+    it("keeps one answer per endpoint", async () => {
+        const fetchMock = jest.fn().mockResolvedValue(jsonResponse({ available: true }));
+        (global as any).fetch = fetchMock;
+        await fetchAiStatusCached({});
+        await fetchAiStatusCached({ endpoint: "https://ai.example.com" });
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+    });
+
+    it("answers unavailable, once, when the host cannot be reached", async () => {
+        const fetchMock = jest.fn().mockRejectedValue(new Error("offline"));
+        (global as any).fetch = fetchMock;
+        await expect(fetchAiStatusCached({})).resolves.toEqual({ available: false });
+        await expect(fetchAiStatusCached({})).resolves.toEqual({ available: false });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+});
+
 describe("fetchPromptSuggestions", () => {
     it("maps the service's prompts", async () => {
         (global as any).fetch = jest.fn().mockResolvedValue(jsonResponse({ prompts: ["A blue widget", "A red one"] }));

package/src/tests/request_agreement.test.ts

@@ -0,0 +1,240 @@
+import { Properties } from "@rebasepro/types";
+import { getValueInPath } from "@rebasepro/utils";
+
+import { getSimplifiedProperties } from "../utils/properties";
+import { flatMapEntityValues, omitDisabledValues } from "../utils/values";
+import { InputProperty } from "../types/data_enhancement_controller";
+
+/**
+ * The two halves of an autofill request have to be keyed the same way.
+ *
+ * "Autofill only fills blanks" is not enforced anywhere in this package. It is
+ * enforced on the service, by omitting already-filled fields from the JSON
+ * schema the model answers into — and the service decides a field is filled by
+ * looking up `values[key]` for each `key` of `properties`. So the guard is only
+ * as true as the agreement between the two maps this file checks.
+ *
+ * That is why these tests build *both* maps from one record and then replay the
+ * service's own decision over them, rather than testing either map alone. Every
+ * assertion here passed against a client that flattened `tags: ["a","b"]` into
+ * `tags.0`/`tags.1` and dropped `Date` values entirely — as long as it was the
+ * flattener, or the property map, that was looked at in isolation.
+ *
+ * `getFieldId` is mocked deterministically; the real one resolves against the
+ * admin field registry, which is not what is under test.
+ */
+jest.mock("@rebasepro/admin", () => ({
+    getFieldId: (property: { type?: string }) => {
+        if (!property?.type) return undefined;
+        if (property.type === "string") return "text_field";
+        if (property.type === "number") return "number_field";
+        if (property.type === "boolean") return "switch";
+        if (property.type === "date") return "date_time";
+        return undefined;
+    }
+}));
+
+// ---------------------------------------------------------------------------
+// The service's side of the contract, reproduced.
+//
+// Copied from `saas/backend/functions/ai.ts` (`alreadyFilled`, `scalarSchema`,
+// `propertySchema`, `planFill`). It lives in another repository and cannot be
+// imported, so it is mirrored — and mirrored *including* the JSON round trip,
+// because the difference between a `Date` object and the ISO string a `Date`
+// serialises to is exactly the difference between "this field is empty" and
+// "this field is filled" over there.
+// ---------------------------------------------------------------------------
+
+function alreadyFilled(value: unknown): boolean {
+    if (value === null || value === undefined) return false;
+    if (typeof value === "string") return value.trim().length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    if (typeof value === "object") return Object.keys(value as object).length > 0;
+    return true;
+}
+
+function scalarSchema(property: InputProperty): object | undefined {
+    if (property.enum && property.enum.length > 0) return { type: "string",
+enum: property.enum };
+    switch (property.type) {
+        case "string":
+            return { type: "string" };
+        case "number":
+            return { type: "number" };
+        case "boolean":
+            return { type: "boolean" };
+        case "date":
+            return { type: "string",
+format: "date-time" };
+        default:
+            return undefined;
+    }
+}
+
+function propertySchema(property: InputProperty): object | undefined {
+    if (property.disabled) return undefined;
+    if (property.type === "array") {
+        const items = property.of ? scalarSchema(property.of) : undefined;
+        return items ? { type: "array",
+items } : undefined;
+    }
+    return scalarSchema(property);
+}
+
+/** The keys the service would offer the model, given one request body. */
+function plannedFillKeys(request: { properties: Record<string, InputProperty>, values: Record<string, unknown> }): string[] {
+    // As the service receives it: JSON, not the client's live objects.
+    const values = JSON.parse(JSON.stringify(request.values)) as Record<string, unknown>;
+    return Object.entries(request.properties)
+        .filter(([key, property]) => {
+            if (!property || typeof property !== "object") return false;
+            if (alreadyFilled(values[key])) return false;
+            return Boolean(propertySchema(property));
+        })
+        .map(([key]) => key);
+}
+
+/** What the client puts on the wire, built the way the provider builds it. */
+function requestFor(properties: Properties, record: Record<string, unknown>) {
+    const simplified = getSimplifiedProperties(properties, record);
+    return {
+        properties: simplified,
+        values: omitDisabledValues(flatMapEntityValues(record), simplified)
+    };
+}
+
+const POST_PROPERTIES: Properties = {
+    title: { name: "Title",
+type: "string" },
+    summary: { name: "Summary",
+type: "string" },
+    tags: {
+        name: "Tags",
+        type: "array",
+        of: { name: "Tag",
+type: "string" }
+    },
+    published_at: { name: "Published at",
+type: "date" },
+    seo: {
+        name: "SEO",
+        type: "map",
+        properties: {
+            title: { name: "SEO title",
+type: "string" },
+            description: { name: "SEO description",
+type: "string" }
+        }
+    },
+    internal_notes: {
+        name: "Internal notes",
+        type: "string",
+        admin: { readOnly: true }
+    }
+} as Properties;
+
+/** A published post: five tags, a publication date, one genuinely empty field. */
+const PUBLISHED_POST = {
+    title: "Hello",
+    tags: ["news", "launch"],
+    published_at: new Date("2026-01-01T00:00:00.000Z"),
+    seo: { title: "Hello — SEO" },
+    internal_notes: "written by a backend hook"
+};
+
+describe("the request the client sends", () => {
+
+    it("keys an array and a date exactly as the property map names them", () => {
+        const { properties, values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
+
+        expect(Object.keys(properties)).toEqual(expect.arrayContaining(["tags", "published_at"]));
+        expect(values.tags).toEqual(["news", "launch"]);
+        expect(values.published_at).toEqual(new Date("2026-01-01T00:00:00.000Z"));
+        // The whole key set, because the old shapes — `tags.0`, `tags.1`, and no
+        // `published_at` at all — are absences a per-key assertion would miss.
+        expect(Object.keys(values).sort()).toEqual(["published_at", "seo.title", "tags", "title"]);
+    });
+
+    it("still descends into a map, which is the one container with its own fields", () => {
+        const { properties, values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
+        expect(Object.keys(properties)).toContain("seo.title");
+        expect(values["seo.title"]).toBe("Hello — SEO");
+    });
+
+    it("offers the model only the fields that are actually empty", () => {
+        // The whole invariant, end to end. `tags` and `published_at` used to be
+        // in this list, so a populated tag list and a set publication date
+        // arrived in the review pre-ticked for replacement.
+        expect(plannedFillKeys(requestFor(POST_PROPERTIES, PUBLISHED_POST)))
+            .toEqual(["summary", "seo.description"]);
+    });
+
+    it("offers every field of an empty record", () => {
+        // The other direction: the agreement must not be bought by hiding
+        // fillable fields. `internal_notes` is absent because it is read-only,
+        // and `seo` because a map is a container, not a field.
+        expect(plannedFillKeys(requestFor(POST_PROPERTIES, {})))
+            .toEqual(["title", "summary", "tags", "published_at", "seo.title", "seo.description"]);
+    });
+
+    it("carries a value for every fillable property the record has filled", () => {
+        // The drift check, stated as a rule rather than a list: whatever a
+        // future property type does to either map, a value the operator can see
+        // in the form must reach the service under the key the service will
+        // look it up by.
+        const { properties, values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
+        const onTheWire = JSON.parse(JSON.stringify(values)) as Record<string, unknown>;
+
+        for (const [key, property] of Object.entries(properties)) {
+            if (!propertySchema(property)) continue; // not a field the service fills
+            if (!alreadyFilled(getValueInPath(PUBLISHED_POST, key))) continue;
+            expect({ key,
+filled: alreadyFilled(onTheWire[key]) }).toEqual({ key,
+filled: true });
+        }
+    });
+
+    it("does not transmit the value of a read-only property", () => {
+        // `disabled` already means "the service may not fill this". It has to
+        // mean "and it is not context either": the prompt includes every value
+        // it is given, so a field owned by a backend hook was being pasted into
+        // it verbatim.
+        const { values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
+        expect(values).not.toHaveProperty("internal_notes");
+        expect(JSON.stringify(values)).not.toContain("backend hook");
+    });
+
+    it("takes the children of a disabled map with it", () => {
+        const properties = {
+            audit: {
+                name: "Audit",
+                type: "map",
+                admin: { disabled: true },
+                properties: {
+                    author: { name: "Author",
+type: "string" }
+                }
+            }
+        } as Properties;
+        const { values } = requestFor(properties, { audit: { author: "root" } });
+        expect(values).toEqual({});
+    });
+});
+
+describe("omitDisabledValues", () => {
+
+    it("leaves a record alone when nothing is disabled", () => {
+        const values = { a: 1,
+b: 2 };
+        expect(omitDisabledValues(values, { a: { type: "number",
+fieldConfigId: "number_field" } })).toBe(values);
+    });
+
+    it("survives a property map carrying a non-object at a path", () => {
+        // `getSimplifiedProperty` writes a raw type string at
+        // `${path}.${i}.${typeField}` for `oneOf` arrays, and `"disabled" in
+        // aString` throws.
+        const properties = { "blocks.0.type": "images" } as unknown as Record<string, InputProperty>;
+        expect(() => omitDisabledValues({ "blocks.0.type": "images" }, properties)).not.toThrow();
+    });
+});