@rebasepro/plugin-ai 0.12.0 → 0.12.1-canary.g009ed95

package/README.md

@@ -8,17 +8,52 @@ AI-powered data autofill and text autocomplete plugin for Rebase.
 pnpm add @rebasepro/plugin-ai
 ```
 
-**Peer dependencies:** `react >= 19.0.0`, `react-dom >= 19.0.0`, `react-router >= 6.28.0`, `react-router-dom >= 6.28.0`
+**Peer dependencies:** `react >= 19.2.7`, `react-dom >= 19.2.7`, `react-router ^8`
 
 ## What This Package Does
 
 This plugin adds AI-powered capabilities to the Rebase admin panel:
 
-- **Form autofill** — An "Enhance" action button injected into snapshot forms that uses AI to suggest and fill field values based on collection schema and existing data.
-- **Editor autocomplete** — A streaming text autocomplete controller for rich text editors, powered by an AI backend.
+- **Form autofill** — An "Autofill" action in the entity form footer that proposes values from the collection schema, whatever is already in the record, and an optional instruction.
+- **Editor autocomplete** — A streaming inline continuation for the rich text editor.
 
 It registers as a standard `RebasePlugin`, injecting UI slots and providers automatically.
 
+### Autofill proposes; it does not edit
+
+Clicking **Autofill** opens a review. Fields stream into that list as the model
+writes them, so a long run shows progress — but the record is not touched. Each row
+shows the proposed value, and the current value struck through when the proposal
+would replace one. Untick anything you don't want, then **Apply** writes the rest in
+a single step. **Discard** leaves the record exactly as it was.
+
+This is a deliberate change from the FireCMS-era behaviour, where generated text was
+streamed directly into the live form fields. That approach mutated the record before
+anyone had agreed to it, showed half-written sentences that read as bugs, and relied
+on heuristics to guess whether each token should append to or replace what you had
+already typed — with no way back but retyping.
+
+## How it reaches a model
+
+The plugin talks to a small hosted service that Rebase runs and pays for (Gemini 3.6 Flash, behind Rebase’s own credits). There is
+**nothing to configure and no API key to obtain** — install the plugin, mount it, done.
+
+Two consequences worth knowing:
+
+- **Requests are anonymous.** No auth token of any kind leaves your app. The service
+  cannot verify a self-hosted backend's JWT (you sign it with your own secret), so
+  asking for one would only hand a live credential to a third party that has no use
+  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
+  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.
+
 ## Key Exports
 
 | Export | Type | Description |
@@ -31,38 +66,39 @@ It registers as a standard `RebasePlugin`, injecting UI slots and providers auto
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `apiKey` | `string` | Built-in default key | API key for the data enhancement service |
-| `getConfigForPath` | `(props: { path, collection, user }) => boolean` | — | Return `false` to disable enhancement for specific paths |
-| `host` | `string` | — | Custom API host (development only) |
+| `getConfigForPath` | `(props: { path, collection, user }) => boolean` | — | Return `false` to disable autofill for specific paths |
+| `endpoint` | `string` | Rebase's hosted service | Base URL of the AI service. Point it at your own deployment to keep generation inside your infrastructure |
 
 ## Quick Start
 
 ```tsx
 import { useDataEnhancementPlugin } from "@rebasepro/plugin-ai";
 
-// In your app setup:
 const dataEnhancementPlugin = useDataEnhancementPlugin({
-    getConfigForPath: ({ path, collection }) => {
-        // Disable for certain collections
-        return collection.name !== "system_logs";
-    }
+    getConfigForPath: ({ collection }) => collection.name !== "system_logs"
 });
 
 // Pass to your Rebase app:
-<RebaseFirebaseApp
-    plugins={[dataEnhancementPlugin]}
-    // ...other props
-/>
+// <Rebase plugins={[dataEnhancementPlugin]} ... />
 ```
 
+### Self-hosting the service
+
+```tsx
+const dataEnhancementPlugin = useDataEnhancementPlugin({
+    endpoint: "https://ai.internal.example.com"
+});
+```
+
+Your endpoint needs to answer `GET /status`, `POST /autofill` (SSE), `POST /autocomplete`
+(SSE) and `POST /prompts`.
+
 ### Editor AI Autocomplete
 
 ```tsx
 import { useEditorAIController } from "@rebasepro/plugin-ai";
 
-const aiController = useEditorAIController({
-    getAuthToken: () => firebaseUser.getIdToken()
-});
+const aiController = useEditorAIController();
 
 // Use in a rich text editor:
 await aiController.autocomplete(
@@ -74,6 +110,14 @@ await aiController.autocomplete(
 );
 ```
 
+## Migrating from the FireCMS-era plugin
+
+The `apiKey` and `host` props are gone. `apiKey` shipped a hardcoded key in the
+published package and pointed at a service that no longer exists; `host` is now
+`endpoint` and is a supported production option rather than a development-only
+escape hatch. `useEditorAIController` no longer takes `getAuthToken` — it needs no
+token.
+
 ## Related Packages
 
 - `@rebasepro/admin` — The admin panel this plugin extends

package/dist/api.d.ts

@@ -1,34 +1,60 @@
-import { EnhancedDataResult, InputProperty, SamplePromptsResult } from "./types/data_enhancement_controller";
-import { EntityValues } from "@rebasepro/types";
-export declare function enhanceDataAPIStream<M extends Record<string, unknown>>(props: {
-    apiKey: string;
-    entityId?: string | number;
-    entityName: string;
-    entityDescription?: string;
-    propertyKey?: string;
-    propertyInstructions?: string;
-    values: EntityValues<M>;
-    path: string;
-    properties: Record<string, InputProperty>;
-    instructions?: string;
-    firebaseToken: string;
-    onUpdate: (suggestions: Record<string, string | number>) => void;
-    onUpdateDelta: (propertyKey: string, partialValue: string) => void;
-    onError: (error: Error) => void;
-    onEnd: (result: EnhancedDataResult) => void;
-    host?: string;
-}): Promise<void>;
-export declare function fetchEntityPromptSuggestion<M extends object>(props: {
-    input?: string;
-    entityName: string;
-    firebaseToken: string;
-    apiKey: string;
-    host?: string;
-}): Promise<SamplePromptsResult>;
+import { AutofillRequest, AutofillResult, AiStatus, SamplePromptsResult } from "./types/data_enhancement_controller";
+/**
+ * The hosted service Rebase runs for this plugin.
+ *
+ * The previous value here was `https://api.rebase.pro`, a FireCMS-era host that
+ * resolves but serves nothing — every path 404s — so Autofill had never worked
+ * in a Rebase install. This one is served by the control plane
+ * (`saas/backend/functions/ai.ts`). Point `endpoint` somewhere else to run your
+ * own; the wire format below is the whole contract.
+ */
+export declare const DEFAULT_AI_ENDPOINT = "https://app.rebase.pro/api/functions/ai";
+/**
+ * Ask the service whether it can serve a request at all.
+ *
+ * The plugin gates every affordance on this. A missing provider key, an
+ * exhausted daily quota or an unreachable host all resolve to `available:
+ * false`, and the Autofill button is simply not rendered — rather than
+ * rendered, clicked, and failed.
+ */
+export declare function fetchAiStatus(props: {
+    endpoint?: string;
+    signal?: AbortSignal;
+}): Promise<AiStatus>;
+/**
+ * Fill a record, streaming each field as the service writes it.
+ *
+ * `onDelta` fires with more text for a field still being written; `onValue`
+ * fires once a field is complete and carries its final, correctly typed value.
+ * A caller that implements only `onValue` still ends up with the right record —
+ * the deltas exist so a long text field fills in visibly instead of appearing
+ * all at once.
+ */
+export declare function autofillStream(props: {
+    request: AutofillRequest;
+    endpoint?: string;
+    signal?: AbortSignal;
+    onDelta: (key: string, text: string) => void;
+    onValue: (key: string, value: unknown) => void;
+}): Promise<AutofillResult>;
+/** Inline continuation for the rich-text editor. Streams plain text. */
 export declare function autocompleteStream(props: {
-    firebaseToken: string;
     textBefore?: string;
-    textAfter: string;
-    host?: string;
-    onUpdate: (delta: string) => void;
+    textAfter?: string;
+    endpoint?: string;
+    signal?: AbortSignal;
+    onDelta: (text: string) => void;
 }): Promise<string>;
+/**
+ * Sample prompts for the Autofill menu.
+ *
+ * Failure is deliberately not thrown: the menu has built-in prompts to fall
+ * back on, and an empty suggestion list is a far better outcome than an error
+ * toast for something nobody asked for.
+ */
+export declare function fetchPromptSuggestions(props: {
+    entityName: string;
+    input?: string;
+    endpoint?: string;
+    signal?: AbortSignal;
+}): Promise<SamplePromptsResult>;

package/dist/components/AutofillReviewDialog.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+/**
+ * The review step.
+ *
+ * Autofill used to write generated text into the live form as it streamed —
+ * fields mutating under the cursor, half-written sentences that looked like
+ * bugs, and a pile of heuristics deciding whether each token should append to
+ * or replace what the operator had already typed. Getting the old value back
+ * meant retyping it.
+ *
+ * So the generated values land here instead. Streaming still happens, and is
+ * still worth having — rows appear and fill in as the model works, so a long
+ * run shows progress — but it happens in a surface that owns nothing. The
+ * record changes on **Apply**, once, for the rows still ticked.
+ */
+export declare function AutofillReviewDialog(): React.JSX.Element | null;

package/dist/components/DataEnhancementControllerProvider.d.ts

@@ -3,13 +3,12 @@ import { DataEnhancementController } from "../types/data_enhancement_controller"
 import { CollectionConfig } from "@rebasepro/types";
 import { PluginFormActionProps } from "@rebasepro/admin-types";
 type DataEnhancementControllerProviderProps = {
-    apiKey: string;
     getConfigForPath?: (props: {
         path: string;
         collection: CollectionConfig;
     }) => boolean;
-    host?: string;
+    endpoint?: string;
 };
 export declare const useDataEnhancementController: () => DataEnhancementController;
-export declare function DataEnhancementControllerProvider({ apiKey, getConfigForPath, children, host, path, collection, formContext }: PropsWithChildren<DataEnhancementControllerProviderProps & PluginFormActionProps>): React.JSX.Element;
+export declare function DataEnhancementControllerProvider({ getConfigForPath, children, endpoint, path, collection, formContext }: PropsWithChildren<DataEnhancementControllerProviderProps & PluginFormActionProps>): React.JSX.Element;
 export {};

package/dist/components/FormEnhanceAction.d.ts

@@ -1,3 +1,3 @@
 import React from "react";
 import { PluginFormActionProps } from "@rebasepro/admin-types";
-export declare function FormEnhanceAction({ entityId, path, status, collection, formContext, openEntityMode }: PluginFormActionProps): React.JSX.Element | null;
+export declare function FormEnhanceAction({ path, status, collection, formContext }: PluginFormActionProps): React.JSX.Element | null;

package/dist/editor/useEditorAIController.d.ts

@@ -1,4 +1,13 @@
 import { EditorAIController } from "@rebasepro/admin";
-export declare function useEditorAIController({ getAuthToken }: {
-    getAuthToken?: () => Promise<string>;
+/**
+ * Inline continuation for the rich-text editor's slash command.
+ *
+ * No token is threaded through any more. The previous version demanded a
+ * Firebase ID token and threw `"Firebase token is required"` when it could not
+ * get one — in a Rebase app there is no such thing, and the token it actually
+ * sent was a Rebase JWT the receiving service had no way to verify. The hosted
+ * service authenticates nobody; see `src/api.ts`.
+ */
+export declare function useEditorAIController({ endpoint }?: {
+    endpoint?: string;
 }): EditorAIController;