@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/core/page/render.d.ts

@@ -1,22 +1,27 @@
 import type { CompiledSlotSchema, RuntimeFieldDef } from '../slot/types.js';
+import { type ActionParameters, type PageToolName } from './define.js';
 import type { ChannelAction, PageAction, PageChannel, SlotRef, SlotState } from './define.js';
+import { type Spoken } from '../conversation/index.js';
 /**
- * `table#n` for each row a conversation has seen: the same row keeps its name on every page of the
- * conversation; names only grow and are never reused, so a late output naming a deleted row's name
- * cannot reach another row. Serialisable (`toJSON` / `fromJSON`) so a session can keep it.
+ * `table:` and the last 12 hex digits of the row's uuid (33): what the row is called in logs, the
+ * timeline and the database too, so the same in every conversation and every process; nothing to keep.
+ * A name comes from the id alone, never from which row came first: two rows of a table alike in those
+ * digits (one page of n rows: about n² / 2⁴⁹) are both named by their whole id from then on, and the
+ * short name they share resolves to neither. So a name from an earlier conversation, or another
+ * process, means the row it meant or no row (the AI is told), never another row. A name resolves only
+ * to a row named here, and the AI's names are checked against the page's own (`one-of`, `enum`) first.
  */
 export declare class RowNames {
-    private readonly byId;
-    private readonly byName;
-    private readonly counters;
+    /** The rows named here: id → table. */
+    private readonly tables;
+    /** A short name → the ids of its table ending in its digits. */
+    private readonly byShort;
     name(table: string, id: string): string;
     resolve(name: string): {
         table: string;
         id: string;
     } | undefined;
     nameOf(id: string): string | undefined;
-    toJSON(): Array<[string, string, string]>;
-    static fromJSON(entries: Array<[string, string, string]>): RowNames;
 }
 export type ReadSlot = {
     value: unknown;
@@ -67,8 +72,10 @@ export type PageNode = BlockNode
 export type RenderedCell = {
     slotId: string;
     ref: SlotRef;
-    /** The row's page name, `table#n`. */
+    /** The row's page name, `table:<uuid tail>`. */
     row: string;
+    /** A ref's value, by its row's name (33). */
+    valueRow?: string;
     label: string;
     description?: string;
     /** The schema's; the page's `$extraction` for its `table.field` replaces it (`RenderedPage.extractions`). */
@@ -155,42 +162,53 @@ export type RenderedAction = {
         parentId: string | null;
         set: Record<string, unknown>;
         fields: string[];
-        required: string[];
+        required: string[]; /** The run key, when the page named one. */
+        key?: string;
     } | {
         kind: 'deleteRow';
         table: string;
         rowId: string;
-        reason?: string;
+        reason?: string; /** The run key, when the page named one. */
+        key?: string;
     } | {
         kind: 'custom';
         name: string;
-        prefill: Record<string, unknown>;
+        prefill: Record<string, unknown>; /** The run key, when the page named one. */
+        key?: string;
     } | {
         kind: 'channel';
         spec: ChannelAction;
     }
-    /** A text or an email sent now (25 §8); `to` the contact (null: the conversation's). */
+    /**
+     * Book the case's next step (40 §2.2) on one of `channels`; `prefill`: what the page fixed (the
+     * channel, the contact's id), not asked of the AI.
+     */
      | {
-        kind: 'message';
-        channel: 'sms' | 'email';
+        kind: 'followUp';
         key: string;
-        to: string | null;
-        body?: string;
-        subject?: string;
-        say?: string;
+        channels: Array<'call' | 'sms' | 'email'>;
+        prefill: {
+            channel?: 'call' | 'sms' | 'email';
+            contactId?: string;
+        };
     }
-    /** Book what the customer asked for, as an agreed follow-up (25 §5), on one of `channels`. */
+    /** Cancel the case's next step (40 §2.2), with why. */
      | {
-        kind: 'followUp';
+        kind: 'cancelFollowUp';
         key: string;
-        channels: Array<'call' | 'sms' | 'email'>;
+    }
+    /** A platform tool (76 §2.18): the platform runs it, the AI reads the result next turn. */
+     | {
+        kind: 'tool';
+        tool: PageToolName;
     }
     /** A company function (20 §6.2): run on the Worker by the platform, waited for, with the page's prefilled arguments. */
      | {
         kind: 'function';
-        name: string;
-        say?: string;
-        prefill?: Record<string, unknown>;
+        name: string; /** Per language (66): the engine says the call's. */
+        say?: Spoken;
+        prefill?: Record<string, unknown>; /** The run key, when the page named one. */
+        key?: string;
     };
 };
 /**
@@ -224,6 +242,8 @@ export type RenderedPage = {
     }>;
     /** The page's `$extraction` (26 §15.3): how to fill a field on this page, by `table.field`; replaces the schema's. */
     extractions?: Record<string, string>;
+    /** The voice the page asks for (`page({ voice })`, 76). */
+    voice?: unknown;
     warnings: string[];
 };
 export declare class PageDocumentError extends Error {
@@ -236,8 +256,30 @@ export type RenderDocumentInput = {
     names: RowNames;
     /** The conversation's channel: a button the channel cannot do (a transfer by text) is an error (20 §5.2). */
     channel?: PageChannel;
+    /** The sequence's functions' parameters, from their `args` types (38 §2.4): a function button's. */
+    functions?: Readonly<Record<string, {
+        parameters?: ActionParameters;
+    }>>;
+    /** The page's actions' parameters, from their `args` types (38 §2.9): a page action button's. */
+    actions?: Readonly<Record<string, {
+        parameters?: ActionParameters;
+    }>>;
 };
 export declare function renderDocument(input: RenderDocumentInput): RenderedPage;
+/**
+ * The buttons' ids (46 §2.1), in page order: what each does (its run key's words: a function's name,
+ * `add:injury`, `remove`, `transfer`, …); where several on the page do the same, the rows that tell them
+ * apart, by page name (`voidInjury@injury:3f9a2c1d7e04`); where that still leaves two alike, `#2`, `#3`
+ * after the first. Unique on the page, and the same from one render to the next while the button does
+ * the same thing to the same rows.
+ */
+export declare function buttonIds(buttons: readonly RenderedAction[], rows: RenderedPage['rows']): string[];
+/**
+ * The button the AI means by `id` on this page (46 §2.1), or null. Its own id first; else an id it read
+ * on an earlier page, where alike buttons needed their rows (`bookSlot@slot_option:d12f648904ec`) and now
+ * one is left (`bookSlot`): the one button doing that to those rows. Never a guess among several.
+ */
+export declare function pressedButton(page: RenderedPage, id: string): string | null;
 /**
  * The run key of a button on the page (17b §7): the action's own key, whoever runs it — the model
  * pressing it, or the page function returning it — not its place on the page, which moves with rows.