@stablebaseline/sdk 0.4.4 → 0.4.5

package/src/types.generated.ts

@@ -684,7 +684,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/tools/exportDeck": {
+    "/tools/designDeck": {
         parameters: {
             query?: never;
             header?: never;
@@ -694,17 +694,17 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * exportDeck
-         * @description Export an already-generated slide DECK (from the branded HTML-deck pipeline) to an editable PowerPoint (PPTX), PDF, PNG images, or raw HTML. Give it the deckId of a deck whose status is 'ready'; it downloads the deck's stored HTML and renders it in a headless browser via the export worker. 'pptx' = native, fully-editable PowerPoint (real shapes and text, not screenshots); 'pdf' = vector, one page per slide; 'png' = one image per slide (returned as a base64 array); 'html' = the self-contained deck HTML. Returns the file as base64 in `data` (pptx/pdf/html) or per-slide base64 in `slides` (png). The deck must be finished; a deck that is still generating, failed, or archived returns a clear message.
+         * designDeck
+         * @description Create or refine a slide deck on a whiteboard by conversing with the AI design agent. Send a brief for a NEW deck, a change to an EXISTING one, or an answer to the agent's question. The agent builds a polished, on-brand deck and places it on the board; if the brief is ambiguous it asks ONE clarifying question (answer with the same sessionId). Returns immediately; poll getDeckReply for the result. Use for building or editing slide decks / presentations. The deck lives in a whiteboard, so it needs an existing whiteboard documentId: if you do not have one, create it first with createWhiteboard and pass its documentId here. FIRST vs FOLLOW-UP: the first call (from nothing) builds; a follow-up call (an answer, a change, or a new instruction) passes the sessionId (or the deckId) plus the new message. kind:'deck' (default) is the premium on-brand HTML deck; kind:'express' builds the native, deterministic branded-executive deck directly on the whiteboard (faster, lower fidelity, one-shot, not conversational). COST + APPROVAL: a build costs 50 credits and an edit 10; a clarifying question is FREE. Call FIRST without confirm to get the exact cost plus the workspace balance, show it to the user, and only call again with confirm:true once they agree. The fee is auto-refunded if a turn produces no change or fails. Returns sessionId (the conversation), deckId (the deck), status, turnType, started, awaitingUser, needsConfirmation, insufficientCredits, and assistantMessage. Export the finished deck with exportFromWhiteboard.
          */
-        post: operations["exportDeck"];
+        post: operations["designDeck"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/tools/generateIllustration": {
+    "/tools/getDeckReply": {
         parameters: {
             query?: never;
             header?: never;
@@ -714,17 +714,17 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * generateIllustration
-         * @description Generate a standalone, on-brand ILLUSTRATION (raw pixels) from a plain-language prompt, the one thing native shapes and diagrams cannot make. Returns a durable image URL you can insert into a whiteboard or document. Colour-conditioned to the organisation's brand (or a specific brandKitId) and rendered in a clean flat-vector editorial style with NO text, letters, or numbers baked in. Costs a small flat credit charge (refunded automatically if generation fails on our side); an identical prompt reuses a cached image at no charge.
+         * getDeckReply
+         * @description Get the design agent's reply after calling designDeck: the status (thinking/building/ready) and EITHER the finished deck (slide count + preview) OR a clarifying question to answer (call designDeck with the sessionId + your answer). Poll until ready or a question appears. Give it the whiteboard documentId and the deckId (both returned by designDeck). It returns the build status ('generating' while working, 'ready' when the deck is finished, 'failed' if it failed) plus, once ready, the slide count and a thumbnail image URL. IMPORTANT for the conversation: if the agent asked a CLARIFYING QUESTION instead of doing the work, this returns awaitingUser:true with pendingQuestion (and assistantMessage) — relay that question to the user, then call designDeck again with the same sessionId and the user's answer as message to continue. It also returns the full conversation (history + status + pending question). A turn usually takes about 1 to 3 minutes, so poll every 15 to 30 seconds until it is 'ready' or awaitingUser is true. When ready, the deck has already been placed on the whiteboard; you can also export it with exportFromWhiteboard. If a turn failed or produced no change, the user was not charged.
          */
-        post: operations["generateIllustration"];
+        post: operations["getDeckReply"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/tools/designDeck": {
+    "/tools/designInWhiteboard": {
         parameters: {
             query?: never;
             header?: never;
@@ -734,17 +734,57 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * designDeck
-         * @description Design a complete, branded HTML slide deck from a plain-language goal using the premium agentic deck builder. COST-GATED (50 credits): the first call (confirm unset) returns the cost quote plus the workspace balance so you can ask the user; only a call with confirm:true charges the flat fee and builds the deck. The deck is themed to the organisation's brand (or a brandKitId), composed slide by slide, rendered and self-corrected, then saved as a finished deck you can export with exportDeck (pptx/pdf/png/html). The fee is auto-refunded if the build fails or produces nothing. If the user would rather not spend the credits, build slides another way. Requires a projectId for a new deck, or a deckId to rebuild an existing one.
+         * designInWhiteboard
+         * @description DEPRECATED — use designDeck instead. This tool no longer designs anything; it returns a short message pointing you at designDeck (to build or edit a slide deck on a whiteboard) or at createWhiteboard + addWhiteboardElements (for manual whiteboard content). It has NO side effects and runs no design. It is kept only so existing callers get a clear message; it will be upgraded in a future update.
          */
-        post: operations["designDeck"];
+        post: operations["designInWhiteboard"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/tools/editInWhiteboard": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * editInWhiteboard
+         * @description DEPRECATED — use designDeck instead. An edit is just another turn in the design conversation, and designDeck handles build AND edit. This tool no longer edits anything; it returns a short message pointing you at designDeck. It has NO side effects and runs no design. It is kept only so existing callers get a clear message; it will be upgraded in a future update.
+         */
+        post: operations["editInWhiteboard"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/tools/exportFromWhiteboard": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * exportFromWhiteboard
+         * @description Export a design that lives in a whiteboard to an editable PowerPoint (PPTX), PDF, PNG images, or raw HTML. Give it the whiteboard documentId and the designId (the deck). kind:'deck' (default) renders the finished deck via the export worker: 'pptx' = native, fully-editable PowerPoint (real shapes and text, not screenshots); 'pdf' = vector, one page per slide; 'png' = one image per slide (returned as a base64 array); 'html' = the self-contained deck HTML. Returns the file as base64 in data (pptx/pdf/html) or per-slide base64 in slides (png). The design must be finished; one that is still generating, failed, or archived returns a clear message.
+         */
+        post: operations["exportFromWhiteboard"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/tools/editDeck": {
+    "/tools/getDesignStatusInWhiteboard": {
         parameters: {
             query?: never;
             header?: never;
@@ -754,17 +794,17 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * editDeck
-         * @description Make a targeted change to an existing, finished deck using the agentic deck builder. COST-GATED (10 credits): the first call (confirm unset) returns the cost quote plus balance; only confirm:true charges the fee and applies the edit. Loads the deck's current HTML, makes ONLY the requested change (leaving other slides intact), renders to verify it, and re-saves. The fee is auto-refunded if the edit makes no change or fails.
+         * getDesignStatusInWhiteboard
+         * @description DEPRECATED — use getDeckReply instead. This tool no longer reads any status; it returns a short message pointing you at getDeckReply (poll it after calling designDeck to get the agent's reply — the deck, or a clarifying question). It has NO side effects. It is kept only so existing callers get a clear message; it will be upgraded in a future update.
          */
-        post: operations["editDeck"];
+        post: operations["getDesignStatusInWhiteboard"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/tools/insertDeckIntoWhiteboard": {
+    "/tools/generateInWhiteboard": {
         parameters: {
             query?: never;
             header?: never;
@@ -774,10 +814,10 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * insertDeckIntoWhiteboard
-         * @description Render a FINISHED slide DECK's pages into framed images on a WHITEBOARD: one Excalidraw frame per slide, laid out as a horizontal row of pages so the whole deck appears on the board to pan across, annotate around, and edit beside. Give it the deckId of a deck whose status is 'ready'; it renders each slide to a PNG (via the export worker) and drops each image inside its own 1280x720 frame named 'Slide N'. Pass an existing whiteboard documentId to place the slides on it, or a projectId to create a new board (defaults to the deck's own project; the new board is named '<deck title> (deck)'). Returns the documentId, the number of slide frames placed, and the board title. The deck must be finished; a deck that is still generating, failed, or archived returns a clear message.
+         * generateInWhiteboard
+         * @description Generate an on-brand ASSET inside a whiteboard and place it on the board. kind:'illustration' (default) makes a standalone, on-brand illustration (raw pixels, the one thing native shapes and diagrams cannot make) from a plain-language prompt, colour-conditioned to the organisation's brand (or a specific brandKitId), in a clean flat-vector editorial style with NO text, letters, or numbers baked in. It is stored and dropped onto the whiteboard as an image element. Costs a small flat credit charge (refunded automatically if generation fails on our side); an identical prompt reuses a cached image at no charge. Returns the durable image URL and confirms it was placed.
          */
-        post: operations["insertDeckIntoWhiteboard"];
+        post: operations["generateInWhiteboard"];
         delete?: never;
         options?: never;
         head?: never;
@@ -7035,7 +7075,7 @@ export interface operations {
             };
         };
     };
-    exportDeck: {
+    designDeck: {
         parameters: {
             query?: never;
             header?: never;
@@ -7045,15 +7085,38 @@ export interface operations {
         requestBody?: {
             content: {
                 "application/json": {
-                    /** @description The id of an existing, finished ('ready') deck to export. */
-                    deckId: string;
+                    /** @description The whiteboard to design into. REQUIRED: the deck lives in this whiteboard. Create one first with createWhiteboard if you do not already have its id. */
+                    documentId: string;
+                    /** @description This turn's message in plain language: the design brief on the first turn, an edit instruction later, or the user's ANSWER to a clarifying question the agent asked. On a follow-up turn, pass this together with the sessionId (or deckId) from the earlier call. */
+                    message: string;
+                    /** @description The design conversation to continue, as returned by an earlier designDeck call. Pass it together with message to answer a question, make an edit, or send a follow-up. Omit on the very first call to start a new conversation. */
+                    sessionId?: string;
+                    /** @description Optional. An existing deck to continue designing (usually you pass sessionId instead; when both are given the session's deck wins). */
+                    deckId?: string;
                     /**
-                     * @description Output format. 'pptx' (default) = editable PowerPoint; 'pdf' = vector PDF; 'png' = one base64 image per slide; 'html' = the deck's self-contained HTML.
+                     * @description Which engine. 'deck' (default) = the premium on-brand HTML deck (conversational, build + edit); 'illustration' and 'design' are conversational variants. 'express' = the native, deterministic branded-executive deck (faster, lower fidelity, one-shot, not conversational).
                      * @enum {string}
                      */
-                    format?: "pptx" | "pdf" | "png" | "html";
-                    /** @description Optional brand kit id (reserved for future per-export theming; the deck is already branded, so this is usually unnecessary). */
+                    kind?: "deck" | "illustration" | "design" | "express";
+                    /** @description Optional title. If omitted, a clear one is derived from the brief. */
+                    title?: string;
+                    /** @description Optional brand kit id (from listBrandKits) to theme the deck. If omitted, the organisation's effective brand is used. */
                     brandKitId?: string;
+                    /** @description Optional target number of slides for a build turn (the composer adjusts to fit the story). Typical 6 to 12. */
+                    slideCount?: number;
+                    /** @description Optional reference images for THIS turn (up to 8; images only). The agent lifts palette, layout, and tone from them (it does not pixel-copy). Non-image attachments are ignored. */
+                    attachments?: {
+                        /** @description A public https URL to the image. */
+                        url?: string;
+                        /** @description The image as base64 (no data: prefix). Provide mediaType alongside it. */
+                        data?: string;
+                        /** @description The image MIME type, e.g. 'image/png' or 'image/jpeg'. */
+                        mediaType?: string;
+                        /** @description Optional human-readable name for the image. */
+                        name?: string;
+                    }[];
+                    /** @description Set true ONLY after the user has approved the cost (50 for a build, 10 for an edit). Leave unset/false on the first call of a turn to receive the cost quote plus balance. A clarifying question turn is never charged. */
+                    confirm?: boolean;
                 };
             };
         };
@@ -7125,7 +7188,7 @@ export interface operations {
             };
         };
     };
-    generateIllustration: {
+    getDeckReply: {
         parameters: {
             query?: never;
             header?: never;
@@ -7135,18 +7198,95 @@ export interface operations {
         requestBody?: {
             content: {
                 "application/json": {
-                    /** @description Plain-language description of the illustration to generate (e.g. 'a friendly robot assistant helping a small team'). */
-                    prompt: string;
-                    /** @description Optional output width in px (rounded to a multiple of 64, 512 to 2048). Default 1024. */
-                    width?: number;
-                    /** @description Optional output height in px (rounded to a multiple of 64, 512 to 2048). Default 1024. */
-                    height?: number;
-                    /** @description Optional extra style hint appended to the prompt (e.g. 'isometric', 'soft gradients, pastel'). */
-                    style?: string;
-                    /** @description Optional brand kit id to colour-condition the illustration. Defaults to the organisation's effective brand. */
-                    brandKitId?: string;
-                    /** @description Optional document this illustration is for (used only for usage logging and provenance). */
+                    /** @description The whiteboard that hosts the deck. */
+                    documentId: string;
+                    /** @description The deck to poll, as returned by designDeck. */
+                    deckId: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            /** @description Validation error. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Missing or invalid credentials. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authenticated but lacking the required permission or feature flag. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Body did not match the tool's input schema. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Server error. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    designInWhiteboard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Ignored. Deprecated tool — use designDeck. */
                     documentId?: string;
+                    /** @description Ignored. Deprecated tool — use designDeck. */
+                    message?: string;
                 };
             };
         };
@@ -7218,7 +7358,7 @@ export interface operations {
             };
         };
     };
-    designDeck: {
+    editInWhiteboard: {
         parameters: {
             query?: never;
             header?: never;
@@ -7228,20 +7368,12 @@ export interface operations {
         requestBody?: {
             content: {
                 "application/json": {
-                    /** @description The deck to build, in plain language (topic, audience, and what it should cover). */
-                    goal: string;
-                    /** @description The project to create the deck in. Required when no deckId is given (a deck must live in a project). */
-                    projectId: string;
-                    /** @description Optional deck title. If omitted, a clear title is derived from the goal. */
-                    title?: string;
-                    /** @description Optional. An existing deck to rebuild. If omitted, a new deck is created in projectId. */
-                    deckId?: string;
-                    /** @description Optional brand kit id (from listBrandKits) to theme the deck. If omitted, the organisation's effective brand is used. Create one from a logo or a .pptx/.docx via createBrandKit. */
-                    brandKitId?: string;
-                    /** @description Optional target number of slides (the composer adjusts to fit the story). Typical 6 to 12. */
-                    slideCount?: number;
-                    /** @description Set true ONLY after the user has approved the 50-credit cost. Leave unset/false on the first call to receive the cost quote plus balance. */
-                    confirm?: boolean;
+                    /** @description Ignored. Deprecated tool — use designDeck. */
+                    documentId?: string;
+                    /** @description Ignored. Deprecated tool — use designDeck. */
+                    designId?: string;
+                    /** @description Ignored. Deprecated tool — use designDeck. */
+                    instruction?: string;
                 };
             };
         };
@@ -7313,7 +7445,7 @@ export interface operations {
             };
         };
     };
-    editDeck: {
+    exportFromWhiteboard: {
         parameters: {
             query?: never;
             header?: never;
@@ -7323,14 +7455,22 @@ export interface operations {
         requestBody?: {
             content: {
                 "application/json": {
-                    /** @description The id of the finished deck to edit. */
-                    deckId: string;
-                    /** @description The change to make, in plain language (e.g. 'change the title slide subhead to ...', 'make slide 3 a bar chart of these numbers ...'). */
-                    instruction: string;
-                    /** @description Optional 1-based slide number to focus the edit on. Omit to let the builder find the right slide(s) from the instruction. */
-                    slideIndex?: number;
-                    /** @description Set true ONLY after the user has approved the 10-credit cost. Leave unset/false on the first call to receive the cost quote plus balance. */
-                    confirm?: boolean;
+                    /** @description The whiteboard that hosts the design. */
+                    documentId: string;
+                    /** @description The design to export (the deck id), as returned by designInWhiteboard. */
+                    designId: string;
+                    /**
+                     * @description Which engine. 'deck' (default).
+                     * @enum {string}
+                     */
+                    kind?: "deck";
+                    /**
+                     * @description Output format. 'pptx' (default) = editable PowerPoint; 'pdf' = vector PDF; 'png' = one base64 image per slide; 'html' = the design's self-contained HTML.
+                     * @enum {string}
+                     */
+                    format?: "pptx" | "pdf" | "png" | "html";
+                    /** @description Optional brand kit id (reserved for future per-export theming; the design is already branded, so this is usually unnecessary). */
+                    brandKitId?: string;
                 };
             };
         };
@@ -7402,7 +7542,7 @@ export interface operations {
             };
         };
     };
-    insertDeckIntoWhiteboard: {
+    getDesignStatusInWhiteboard: {
         parameters: {
             query?: never;
             header?: never;
@@ -7412,12 +7552,112 @@ export interface operations {
         requestBody?: {
             content: {
                 "application/json": {
-                    /** @description The id of an existing, finished ('ready') deck whose slides to place on a whiteboard. */
-                    deckId: string;
-                    /** @description Optional existing whiteboard to place the slides on. When omitted, a new whiteboard is created in projectId. */
+                    /** @description Ignored. Deprecated tool — use getDeckReply. */
                     documentId?: string;
-                    /** @description Optional project to create the new whiteboard in when documentId is omitted. Defaults to the deck's own project. */
-                    projectId?: string;
+                    /** @description Ignored. Deprecated tool — use getDeckReply. */
+                    designId?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            /** @description Validation error. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Missing or invalid credentials. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Authenticated but lacking the required permission or feature flag. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Body did not match the tool's input schema. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Server error. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    generateInWhiteboard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description The whiteboard to generate the asset into (the asset is placed on this board). */
+                    documentId: string;
+                    /** @description Plain-language description of the asset to generate (e.g. 'a friendly robot assistant helping a small team'). */
+                    prompt: string;
+                    /**
+                     * @description What to make. 'illustration' (default).
+                     * @enum {string}
+                     */
+                    kind?: "illustration";
+                    /** @description Optional output width in px (rounded to a multiple of 64, 512 to 2048). Default 1024. */
+                    width?: number;
+                    /** @description Optional output height in px (rounded to a multiple of 64, 512 to 2048). Default 1024. */
+                    height?: number;
+                    /** @description Optional extra style hint appended to the prompt (e.g. 'isometric', 'soft gradients, pastel'). */
+                    style?: string;
+                    /** @description Optional brand kit id to colour-condition the asset. Defaults to the organisation's effective brand. */
+                    brandKitId?: string;
+                    /** @description Optional x position on the board. Omit to auto-place. */
+                    x?: number;
+                    /** @description Optional y position on the board. Omit to auto-place. */
+                    y?: number;
                 };
             };
         };
@@ -7931,6 +8171,10 @@ export interface operations {
                         columns?: (string | Record<string, never>)[];
                         /** @description For type:'table' — data rows; each row is an array of cell values (string|number) aligned to columns, e.g. [['T-1','Sam','Done'],['T-2','Lee','WIP']]. */
                         rows?: (string | number)[][];
+                        /** @description Arbitrary Excalidraw customData stored on the element (e.g. a slide frame's { deckId } so a board frame resolves back to its source deck). Merged with any builder-set customData. */
+                        customData?: {
+                            [key: string]: unknown;
+                        };
                     } & {
                         [key: string]: unknown;
                     })[];