@salsita-ai/sdk 0.50.0-develop.a4dde5f252 → 0.50.0-develop.a8cf9ffd01

package/dist/configurator/ui/assistant/reference-link/index.d.ts

@@ -0,0 +1,3 @@
+export { AssistantReferenceLink, type ThemeableAssistantReferenceLinkProps } from './AssistantReferenceLink.js';
+export { isAssistantLinkHref, parseAssistantLinkTarget } from './assistant-link-target.js';
+export { assistantReferenceStyles } from './reference-styles.js';

package/dist/configurator/ui/assistant/reference-link/index.js

@@ -0,0 +1 @@
+export{AssistantReferenceLink}from"./AssistantReferenceLink.js";export{isAssistantLinkHref,parseAssistantLinkTarget}from"./assistant-link-target.js";export{assistantReferenceStyles}from"./reference-styles.js";

package/dist/configurator/ui/assistant/reference-link/reference-styles.d.ts

@@ -0,0 +1,12 @@
+import { type CSSObject, type Theme } from '@mui/material';
+/**
+ * How a link in a reply reads: a glossary reference, text that flows with the sentence and wraps
+ * with it, in the reference color with a dashed underline. Entity links and the references to
+ * recipes and options share it, so every link of a reply looks alike.
+ *
+ * - `data-reference="plain"`: something that exists but does nothing on a click, in the text color;
+ * - `data-reference="muted"`: something that is gone or cannot be read right now.
+ */
+export declare const assistantReferenceStyles: ({ theme: { palette, shape } }: {
+    readonly theme: Theme;
+}) => CSSObject;

package/dist/configurator/ui/assistant/reference-link/reference-styles.js

@@ -0,0 +1 @@
+import{alpha as e}from"@mui/material";import{hoverStyles as r}from"#package/ui-sdk";export const assistantReferenceStyles=({theme:{palette:o,shape:i}})=>({background:"none",border:"none",borderRadius:i.borderRadius/2,boxDecorationBreak:"clone",color:o.primary.main,cursor:"pointer",font:"inherit",margin:0,padding:0,textDecorationLine:"underline",textDecorationStyle:"dashed",textDecorationThickness:1,textUnderlineOffset:"0.2em",WebkitBoxDecorationBreak:"clone",'&:focus-visible, &[data-hovered="true"], &[aria-expanded="true"]':{background:e(o.primary.main,o.action.hoverOpacity)},...r({"&:hover":{background:e(o.primary.main,o.action.hoverOpacity)}}),"&:focus-visible":{outline:`2px solid ${o.primary.main}`,outlineOffset:1},'&[data-reference="plain"]':{color:"inherit",cursor:"auto"},'&[data-reference="muted"]':{color:o.text.disabled}});

package/dist/configurator/ui/assistant/reference-link/use-assistant-reference-details.d.ts

@@ -0,0 +1,8 @@
+import type { AssistantReferenceTarget } from './assistant-link-target.js';
+import { type AssistantReferenceDetails } from './assistant-reference-details.js';
+/**
+ * The details of what a reference points at, read from the committed state and followed while the
+ * caller is mounted; `null` when it does not resolve there. Only the open popover of a reference
+ * calls it, so a reply full of references reads nothing until one is opened.
+ */
+export declare const useAssistantReferenceDetails: (target: AssistantReferenceTarget) => AssistantReferenceDetails | null;

package/dist/configurator/ui/assistant/reference-link/use-assistant-reference-details.js

@@ -0,0 +1 @@
+import{useDomain as e,useResolveLocalizable as t,useStoreSelector as r}from"#package/react-sdk";import{useConfigurator as s}from"../../../application-runtime/index.js";import{readAssistantReferenceDetails as i}from"./assistant-reference-details.js";export const useAssistantReferenceDetails=a=>{let{assistantSystem:n}=s(),{componentReader:o}=e(),l=t();return r(({state:e})=>{let t=n.getSessionManifest();return t?i(a,e,{manifest:t,componentReader:o,resolveLocalizable:e=>l(e)}):null},[n,o,l,a])};

package/dist/configurator/ui/assistant/resource-image/AssistantImage.d.ts

@@ -0,0 +1,56 @@
+import type { ButtonBaseProps, ComponentsOverrides } from '@mui/material';
+import { type ElementType, type ImgHTMLAttributes, type ReactNode } from 'react';
+declare const MuiComponentName: 'PhxAssistantImage';
+declare module '@mui/material/styles' {
+    interface ComponentNameToClassKey {
+        [MuiComponentName]: 'root' | 'button';
+    }
+    interface ComponentsPropsList {
+        [MuiComponentName]: ThemeableAssistantImageProps;
+    }
+    interface Components {
+        [MuiComponentName]?: {
+            defaultProps?: ComponentsPropsList[typeof MuiComponentName];
+            styleOverrides?: ComponentsOverrides<Theme>[typeof MuiComponentName];
+        };
+    }
+}
+/** The slots of an image in a reply. Read from the theme only. */
+export interface ThemeableAssistantImageProps {
+    /**
+     * The components used for each slot.
+     *
+     * - `root` — The picture (`img`).
+     * - `button` — The button around the picture that opens it larger; none inside a link (`ButtonBase`).
+     */
+    readonly slots?: Partial<Record<'root' | 'button', ElementType>>;
+    /**
+     * Props applied to each slot component.
+     *
+     * - `root` — Props for the picture.
+     * - `button` — Props for the button.
+     */
+    readonly slotProps?: Partial<{
+        readonly root: ImgHTMLAttributes<HTMLImageElement>;
+        readonly button: ButtonBaseProps;
+    }>;
+}
+/**
+ * Marks the pictures among `children` as the content of a link, which they then leave to the link: they
+ * open nothing themselves, so a click follows the link or selects the entity, and no button nests in it.
+ */
+export declare const AssistantImageLinkScope: ({ children }: {
+    readonly children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export interface AssistantImageProps {
+    readonly src: string | undefined;
+    readonly alt: string | undefined;
+}
+/**
+ * An image in a reply, loaded from the project's resources; a click opens it larger beside the panel,
+ * where the user can annotate it, unless it is inside a link (see {@link AssistantImageLinkScope}),
+ * whose click it leaves to the link. One the panel refuses to request or that fails to load shows its
+ * alt text instead, so the sentence around it still reads.
+ */
+export declare const AssistantImage: import("react").MemoExoticComponent<({ src, alt }: AssistantImageProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/configurator/ui/assistant/resource-image/AssistantImage.js

@@ -0,0 +1 @@
+import{jsx as e,Fragment as r}from"react/jsx-runtime";import{ButtonBase as i,styled as o,useThemeProps as t}from"@mui/material";import{createContext as a,memo as n,useCallback as s,useContext as l,useState as m}from"react";import{useLocalizable as d}from"#package/react-sdk";import{useConfigurator as u}from"../../../application-runtime/index.js";import{useResourceImageUrl as c}from"./use-resource-image-url.js";let p="PhxAssistantImage",g={id:"sdk.assistant.image.open.label",message:"Open the image"},b=o("img",{name:p,slot:"root"})(({theme:{shape:e,spacing:r}})=>({blockSize:"auto",borderRadius:e.borderRadius,display:"block",maxInlineSize:"100%","& + &":{marginBlockStart:r(1)}})),k=o(i,{name:p,slot:"button"})(({theme:{palette:e,shape:r,spacing:i}})=>({borderRadius:r.borderRadius,cursor:"zoom-in",display:"block",maxInlineSize:"100%","& + &":{marginBlockStart:i(1)},"&:focus-visible":{outline:`2px solid ${e.primary.main}`,outlineOffset:2}})),f={},x=a(!1);export const AssistantImageLinkScope=({children:r})=>e(x.Provider,{value:!0,children:r});export const AssistantImage=n(({src:i,alt:o})=>{let{assistantSystem:a}=u(),n=c()(i),[h,v]=m(),I=l(x),S=d(g),{slots:z={},slotProps:j={}}=t({props:f,name:p}),y=""===o?void 0:o,R=s(()=>{null!=n&&a.viewImage({kind:"url",url:n,title:y})},[a,y,n]),A=s(()=>{v(n)},[n]);if(null==n||n===h)return e(r,{children:o});let B=z.root??b,O=z.button??k,P=e(B,{loading:"lazy",...j.root,src:n,alt:o??"",onError:A});return I?P:e(O,{...j.button,"aria-label":void 0===y?S:void 0,onClick:R,children:P})});

package/dist/configurator/ui/assistant/resource-image/index.d.ts

@@ -0,0 +1,3 @@
+export { AssistantImage, AssistantImageLinkScope, type ThemeableAssistantImageProps } from './AssistantImage.js';
+export { isResourcePath } from './resource-path.js';
+export { useResourceImageUrl } from './use-resource-image-url.js';

package/dist/configurator/ui/assistant/resource-image/index.js

@@ -0,0 +1 @@
+export{AssistantImage,AssistantImageLinkScope}from"./AssistantImage.js";export{isResourcePath}from"./resource-path.js";export{useResourceImageUrl}from"./use-resource-image-url.js";

package/dist/configurator/ui/assistant/resource-image/resource-path.d.ts

@@ -0,0 +1,2 @@
+/** True when the image source the model wrote may be requested: a path into the project's resources. */
+export declare const isResourcePath: (src: string | undefined) => src is string;

package/dist/configurator/ui/assistant/resource-image/resource-path.js

@@ -0,0 +1 @@
+import{ASSISTANT_RESOURCE_PATH_PATTERN as e}from"#package/domain";let t=RegExp(e,"u");export const isResourcePath=e=>null!=e&&t.test(e);

package/dist/configurator/ui/assistant/resource-image/use-resource-image-url.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolves an image source the model wrote the way the configurator resolves thumbnails, or returns
+ * `undefined` when it is not a path into the project's resources and must not be requested.
+ */
+export declare const useResourceImageUrl: () => (src: string | undefined) => string | undefined;

package/dist/configurator/ui/assistant/resource-image/use-resource-image-url.js

@@ -0,0 +1 @@
+import{useCallback as r}from"react";import{useResourceUrl as e}from"#package/react-sdk";import{isResourcePath as o}from"./resource-path.js";export const useResourceImageUrl=()=>{let{getResourceUrl:t}=e();return r(r=>o(r)?t(r):void 0,[t])};

package/dist/configurator/ui/assistant/screenshots/ScreenshotThumbnails.d.ts

@@ -0,0 +1,43 @@
+import type { ComponentsOverrides } from '@mui/material';
+import type { ElementType, HTMLAttributes } from 'react';
+import type { AssistantToolScreenshot } from './tool-screenshots.js';
+declare const MuiComponentName: 'PhxAssistantScreenshots';
+declare module '@mui/material/styles' {
+    interface ComponentNameToClassKey {
+        [MuiComponentName]: 'root';
+    }
+    interface ComponentsPropsList {
+        [MuiComponentName]: ThemeableAssistantScreenshotsProps;
+    }
+    interface Components {
+        [MuiComponentName]?: {
+            defaultProps?: ComponentsPropsList[typeof MuiComponentName];
+            styleOverrides?: ComponentsOverrides<Theme>[typeof MuiComponentName];
+        };
+    }
+}
+/** The slots of the pictures of a tool call's screenshots, in their popover. Read from the theme only. */
+export interface ThemeableAssistantScreenshotsProps {
+    /**
+     * The components used for each slot.
+     *
+     * - `root` — The grid of pictures (`span`); it gets the number of its columns in `ownerState`.
+     */
+    readonly slots?: Partial<Record<'root', ElementType>>;
+    /**
+     * Props applied to each slot component.
+     *
+     * - `root` — Props for the grid.
+     */
+    readonly slotProps?: Partial<{
+        readonly root: HTMLAttributes<HTMLSpanElement>;
+    }>;
+}
+interface ScreenshotThumbnailsProps {
+    readonly screenshots: readonly AssistantToolScreenshot[];
+    /** Called once a picture has loaded, which changes the size of the popover. */
+    readonly onImageLoad: () => void;
+}
+/** The pictures of a tool call's screenshots. */
+export declare const ScreenshotThumbnails: ({ screenshots, onImageLoad }: ScreenshotThumbnailsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/configurator/ui/assistant/screenshots/ScreenshotThumbnails.js

@@ -0,0 +1 @@
+import{jsx as e}from"react/jsx-runtime";import{styled as o,useThemeProps as r}from"@mui/material";import{useScreenshotSrc as a}from"./use-screenshot-src.js";let t="PhxAssistantScreenshots",i=o("span",{name:t,slot:"root",shouldForwardProp:e=>"ownerState"!==e})(({ownerState:{columns:e},theme:{palette:o,shape:r,shadows:a,spacing:t}})=>({background:o.background.paper,borderRadius:r.borderRadius,boxShadow:a[4],display:"grid",gap:t(1.5),gridTemplateColumns:`repeat(${e}, minmax(0, 200px))`,maxInlineSize:"80vw",padding:t(1.5)})),s=o("img")(({theme:{palette:e,shape:o}})=>({blockSize:"auto",borderRadius:o.borderRadius/2,boxShadow:`inset 0 0 0 1px ${e.divider}`,display:"block",inlineSize:"100%"})),n=o("span")(({theme:{palette:e,shape:o}})=>({aspectRatio:"4 / 3",background:e.action.hover,borderRadius:o.borderRadius/2,display:"block"})),d={},m=({picture:o,onImageLoad:r})=>{let t=a(o);return void 0===t?e(n,{}):e(s,{src:t,alt:"",onLoad:r})};export const ScreenshotThumbnails=({screenshots:o,onImageLoad:a})=>{let{slots:s={},slotProps:n={}}=r({props:d,name:t});return e(s.root??i,{...n.root,ownerState:{columns:Math.min(o.length,2)},children:o.map(({label:o,picture:r})=>e(m,{picture:r,onImageLoad:a},o))})};

package/dist/configurator/ui/assistant/screenshots/index.d.ts

@@ -0,0 +1,3 @@
+export { ScreenshotThumbnails, type ThemeableAssistantScreenshotsProps } from './ScreenshotThumbnails.js';
+export { type AssistantToolScreenshot, readToolScreenshots } from './tool-screenshots.js';
+export { useScreenshotSrc } from './use-screenshot-src.js';

package/dist/configurator/ui/assistant/screenshots/index.js

@@ -0,0 +1 @@
+export{ScreenshotThumbnails}from"./ScreenshotThumbnails.js";export{readToolScreenshots}from"./tool-screenshots.js";export{useScreenshotSrc}from"./use-screenshot-src.js";

package/dist/configurator/ui/assistant/screenshots/tool-screenshots.d.ts

@@ -0,0 +1,16 @@
+/** Where the panel gets a screenshot's picture from: the server, by the id the browser uploaded it under. */
+export interface AssistantScreenshotPicture {
+    readonly kind: 'stored';
+    readonly imageId: string;
+}
+/** A screenshot a `query` or `apply` call took, as the panel shows it. */
+export interface AssistantToolScreenshot {
+    /** The label the call's `image` field returned, such as `Cabinet-2/doorLayout#2`. */
+    readonly label: string;
+    readonly picture: AssistantScreenshotPicture;
+}
+/**
+ * The screenshots of a tool result: the image parts that follow the result's JSON, each after the
+ * text part with its label. A result without them, such as plain JSON or an error, has none.
+ */
+export declare const readToolScreenshots: (result: unknown) => readonly AssistantToolScreenshot[];

package/dist/configurator/ui/assistant/screenshots/tool-screenshots.js

@@ -0,0 +1 @@
+import{z as t}from"zod";import{readAssistantImageReference as e}from"@salsita-ai/contracts/assistant";let a=t.object({type:t.literal("text"),content:t.string()}),r=t.object({type:t.literal("image"),source:t.object({type:t.literal("url"),value:t.string()})}),s=/^[^/]+\/[^#]+(?:#\d+)?$/;export const readToolScreenshots=t=>Array.isArray(t)?t.slice(1).flatMap((t,l,o)=>{let n=r.safeParse(t),c=a.safeParse(o[l-1]),i=n.success?(({source:t})=>{let a=e(t.value);return null===a?null:{kind:"stored",imageId:a}})(n.data):null;return i&&c.success&&s.test(c.data.content)?[{label:c.data.content,picture:i}]:[]}):[];

package/dist/configurator/ui/assistant/screenshots/use-screenshot-src.d.ts

@@ -0,0 +1,8 @@
+import type { AssistantScreenshotPicture } from './tool-screenshots.js';
+/**
+ * The `src` of a screenshot's or an attached image's picture: the object URL the assistant system
+ * reads the uploaded image into, once it has been read; `undefined` until then and when the read
+ * fails. The screenshots of a call are read only while their popover is open; the images a user
+ * attached are read as soon as their bubble shows.
+ */
+export declare const useScreenshotSrc: (picture: AssistantScreenshotPicture) => string | undefined;

package/dist/configurator/ui/assistant/screenshots/use-screenshot-src.js

@@ -0,0 +1 @@
+import{useEffect as r,useState as e}from"react";import{useConfigurator as t}from"../../../application-runtime/index.js";export const useScreenshotSrc=o=>{let{assistantSystem:i}=t(),{imageId:n}=o,[c,m]=e();return r(()=>{let r=!0;return i.loadScreenshotUrl(n).then(e=>{r&&m({imageId:n,src:e})},()=>void 0),()=>{r=!1}},[i,n]),c?.imageId===n?c.src:void 0};

package/dist/configurator/ui/assistant/streamed-markdown.d.ts

@@ -1,6 +1,19 @@
+/** Where a code block starts and ends in the text, as Markdown parsed it. */
+export interface FencePosition {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * True when a code block of a finished reply was cut off: it runs to the end of the reply without
+ * the line that closes its fence, whatever backticks the reply has elsewhere. A block that the end
+ * of its list item or blockquote closed before the reply went on is not cut off.
+ */
+export declare const isCutOffFence: (text: string, { start, end }: FencePosition) => boolean;
+/** True when the text has a code fence the model has not closed yet. */
+export declare const hasOpenFence: (text: string) => boolean;
 /**
  * Makes the Markdown of a reply that is still streaming renderable as it stands, so half-written
- * markup does not flash as raw characters: an open code fence is closed, an inline code span, a link
- * or a table header the model has not finished is held back, and open bold text is closed.
+ * markup does not flash as raw characters: an open code fence is closed, an inline code span, a link,
+ * an alert marker or a table header the model has not finished is held back, and open bold text is closed.
  */
 export declare const completeStreamedMarkdown: (text: string) => string;

package/dist/configurator/ui/assistant/streamed-markdown.js

@@ -1,2 +1,2 @@
-let e=(e,t)=>e.split(t).length-1,t=/^\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;export const completeStreamedMarkdown=l=>{if(e(l,"```")%2==1)return`${l}
-\`\`\``;let n=l.lastIndexOf("```"),s=-1===n?"":l.slice(0,n+3),r=l.slice(s.length),i=(e=>{let l=e.split("\n"),n=l.length;for(;n>0&&l[n-1]?.trimStart().startsWith("|");)n-=1;let s=l.slice(n),r=s[1],i=null!=r&&s.length>2&&t.test(r);return 0===s.length||i?e:l.slice(0,n).join("\n")})((e(r,"`")%2==1?r.slice(0,r.lastIndexOf("`")):r).replace(/!?\[([^\]\n]*)\]\([^)\n]*$/,"$1").replace(/!?\[[^\]\n]*$/,"")),c=e(i,"**")%2==1?`${i}**`:i;return`${s}${c}`};
+let e=(e,t)=>e.split(t).length-1,t=/^\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/,l=/(^|\n) {0,3}>[ \t]*\[![a-z]*$/i,n=/(^|\n) {0,3}>[ \t]*\[![a-z]+\][ \t]*$/i,s=/^[ \t>]*(`{3,}|~{3,})/,r=/^[ \t>]*(`{3,}|~{3,})[ \t]*$/;export const isCutOffFence=(e,{start:t,end:l})=>{let n,i,c;return l>=e.trimEnd().length&&(n=e.slice(t,l).split("\n"),i=s.exec(n[0]??"")?.[1],c=n.length>1?r.exec(n.at(-1)??"")?.[1]:void 0,null==i||null==c||c[0]!==i[0]||!(c.length>=i.length))};export const hasOpenFence=t=>e(t,"```")%2==1;export const completeStreamedMarkdown=s=>{var r;let i;if(hasOpenFence(s))return`${s}
+\`\`\``;let c=s.lastIndexOf("```"),a=-1===c?"":s.slice(0,c+3),{head:h,marker:$}=(r=s.slice(a.length),null==(i=n.exec(r))?{head:r.replace(l,"$1"),marker:""}:{head:r.slice(0,i.index),marker:r.slice(i.index)}),p=(e=>{let l=e.split("\n"),n=l.length;for(;n>0&&l[n-1]?.trimStart().startsWith("|");)n-=1;let s=l.slice(n),r=s[1],i=null!=r&&s.length>2&&t.test(r);return 0===s.length||i?e:l.slice(0,n).join("\n")})((e(h,"`")%2==1?h.slice(0,h.lastIndexOf("`")):h).replace(/!?\[([^\]\n]*)\](?:\([^)\n]*)?$/,"$1").replace(/!?\[[^\]\n]*$/,"")),d=e(p,"**")%2==1?`${p}**`:p;return`${a}${d}${$}`};

package/dist/configurator/ui/assistant/thread-items.d.ts

@@ -1,4 +1,5 @@
 import type { UIMessage } from '@tanstack/ai-client';
+import { type AssistantMessageAnnotation } from '@salsita-ai/contracts/assistant';
 import type { AssistantEarlierThreadSnapshot } from '../../application-runtime/index.js';
 import { type AssistantToolChip } from './tool-chip.js';
 /** A tool call of the thread, with what its chip shows and what a click on the chip logs. */
@@ -8,6 +9,12 @@ export interface AssistantToolItem {
     readonly input: unknown;
     readonly result: unknown;
 }
+/**
+ * What the forms in a stretch of assistant text are: shown only in the last message of the thread,
+ * and usable only once its reply has ended. A form in any earlier message has been answered or
+ * passed over, so it is not shown at all.
+ */
+export type AssistantFormsVisibility = 'hidden' | 'disabled' | 'enabled';
 /**
  * One block of the thread, in reading order: a user bubble, a stretch of assistant Markdown, a row
  * of chips for the tool calls that follow each other without text in between, or the line that
@@ -17,11 +24,18 @@ export type AssistantThreadItem = {
     readonly kind: 'user';
     readonly id: string;
     readonly text: string;
+    /** The images the user attached, by the ids the message references them by; annotations are not among them. */
+    readonly imageIds: readonly string[];
+    /** The annotations the user attached, in their order among the message's images. */
+    readonly annotations: readonly AssistantMessageAnnotation[];
+    /** How the user spoke the message, when they did; nothing for a typed one. */
+    readonly voice: AssistantUserVoice | null;
 } | {
     readonly kind: 'text';
     readonly id: string;
     readonly markdown: string;
     readonly isStreaming: boolean;
+    readonly forms: AssistantFormsVisibility;
 } | {
     readonly kind: 'tools';
     readonly id: string;
@@ -30,6 +44,12 @@ export type AssistantThreadItem = {
     readonly kind: 'separator';
     readonly id: string;
 };
+/**
+ * How a user message was spoken:
+ * - `transcribing`: its recording was sent, and the server's transcript has not arrived yet
+ * - `spoken`: its text is the transcript the server made of the recording
+ */
+export type AssistantUserVoice = 'transcribing' | 'spoken';
 export interface AssistantThreadView {
     readonly items: readonly AssistantThreadItem[];
     /** True while a reply runs and neither streaming text nor a row of tool chips shows that it does. */
@@ -39,7 +59,7 @@ export interface AssistantThreadView {
  * Lays the messages of the chat out as the blocks the thread renders. Reasoning is left out; tool
  * results are not shown on their own but decide the state of the chip of their call.
  */
-export declare const buildThreadView: (messages: ReadonlyArray<UIMessage>, isReplying: boolean) => AssistantThreadView;
+export declare const buildThreadView: (messages: ReadonlyArray<UIMessage>, isReplying: boolean, isResuming: boolean) => AssistantThreadView;
 /**
  * Lays the closed threads of the conversation out above the thread that continues them, oldest
  * first, each ended by a separator: the assistant read on from a summary of it, not from the

package/dist/configurator/ui/assistant/thread-items.js

@@ -1 +1 @@
-import{describeToolCall as t}from"./tool-chip.js";let e=t=>{try{return JSON.parse(t)}catch{return t}},r=t=>t.map(t=>"text"===t.type?t.content:"").join("").trim();export const buildThreadView=(o,i)=>{let l=(t=>{let r=new Map;for(let o of t)for(let t of o.parts)"tool-result"===t.type&&r.set(t.toolCallId,{result:"string"==typeof t.content?e(t.content):t.content,error:"error"===t.state?t.error??"The tool call failed.":void 0});return r})(o),n=[],a=o.at(-1),s=t=>{let e=n.at(-1);e?.kind==="tools"?n[n.length-1]={...e,tools:[...e.tools,t]}:n.push({kind:"tools",id:t.id,tools:[t]})};for(let e of o){if("user"===e.role){let t=r(e.parts);t&&n.push({kind:"user",id:e.id,text:t});continue}let o=i&&e===a;e.parts.forEach((r,i)=>{let a=`${e.id}:${i}`;if("text"===r.type){if(r.content.trim()){let t=o&&i===e.parts.length-1;n.push({kind:"text",id:a,markdown:r.content,isStreaming:t})}return}if("tool-call"!==r.type)return;let d=l.get(r.id),p=r.input,u=r.output??d?.result;s({id:r.id,input:p,result:u,chip:t({name:r.name,input:p,result:u,error:d?.error,isReplyRunning:o})})})}let d=n.at(-1),p=a?.role==="assistant"&&(d?.kind==="text"&&d.isStreaming||d?.kind==="tools");return{items:n,isThinking:i&&!p}};export const buildEarlierThreadItems=t=>t.flatMap(({threadId:t,messages:e})=>[...buildThreadView(e,!1).items.map(e=>({...e,id:`${t}:${e.id}`})),{kind:"separator",id:`${t}:separator`}]);
+import{match as t}from"ts-pattern";import{AssistantMessageMetadata as e,banTool as r,readAssistantImageReference as a}from"@salsita-ai/contracts/assistant";import{describeToolCall as i}from"./tool-chip.js";let o=t=>{try{return JSON.parse(t)}catch{return t}},s=t=>t.map(t=>"text"===t.type?t.content:"").join("").trim(),n=t=>t.flatMap(t=>"image"===t.type&&"url"===t.source.type?a(t.source.value)??[]:[]),l=(t,r)=>{let a=e.safeParse(t.metadata),i=a.success?a.data.annotations??[]:[];return r.flatMap(t=>i.filter(e=>e.imageId===t))},d=t=>t.parts.some(t=>"audio"===t.type)?"transcribing":e.safeParse(t.metadata).data?.spoken?"spoken":null;export const buildThreadView=(e,a,p)=>{let u=(t=>{let e=new Map;for(let r of t)for(let t of r.parts)"tool-result"===t.type&&e.set(t.toolCallId,{result:"string"==typeof t.content?o(t.content):t.content,error:"error"===t.state?t.error??"The tool call failed.":void 0});return e})(e),m=[],f=e.at(-1),c=t=>{let e=m.at(-1);e?.kind==="tools"?m[m.length-1]={...e,tools:[...e.tools,t]}:m.push({kind:"tools",id:t.id,tools:[t]})};for(let o of e){if("user"===o.role){let t=s(o.parts),e=n(o.parts),r=l(o,e),a=e.filter(t=>!r.some(e=>e.imageId===t)),i=d(o);(t||e.length>0||i)&&m.push({kind:"user",id:o.id,text:t,imageIds:a,annotations:r,voice:i});continue}let e=a&&o===f,h=t({isLast:o===f,isBusy:e||p}).with({isLast:!1},()=>"hidden").with({isBusy:!0},()=>"disabled").otherwise(()=>"enabled");o.parts.forEach((t,a)=>{let s=`${o.id}:${a}`;if("text"===t.type){if(t.content.trim()){let r=e&&a===o.parts.length-1;m.push({kind:"text",id:s,markdown:t.content,isStreaming:r,forms:h})}return}if("tool-call"!==t.type||t.name===r.name)return;let n=u.get(t.id),l=t.input,d=t.output??n?.result;c({id:t.id,input:l,result:d,chip:i({name:t.name,input:l,result:d,error:n?.error,isReplyRunning:e})})})}let h=m.at(-1),k=f?.role==="assistant"&&(h?.kind==="text"&&h.isStreaming||h?.kind==="tools");return{items:m,isThinking:a&&!k}};export const buildEarlierThreadItems=t=>t.flatMap(({threadId:t,messages:e})=>[...buildThreadView(e,!1,!1).items.map(e=>"text"===e.kind?{...e,id:`${t}:${e.id}`,forms:"hidden"}:{...e,id:`${t}:${e.id}`}),{kind:"separator",id:`${t}:separator`}]);

package/dist/configurator/ui/assistant/tool-chip.d.ts

@@ -1,11 +1,14 @@
 import { type AssistantToolErrorCode } from '@salsita-ai/contracts/assistant';
 /**
- * How a tool call of the assistant looks in the thread: still running, finished, a change that was
- * not kept (`failed`), or a read that answered with errors (`flawed`), which matters less because
- * the assistant usually just asks again.
+ * How a tool call of the assistant looks in the thread: still running, finished, or gone wrong
+ * (`failed`): a change that was not kept, or a read that answered with errors. Both look the same,
+ * since the reply says what came of them.
+ */
+export type AssistantToolChipState = 'running' | 'done' | 'failed';
+/**
+ * What a tool chip is called: the title or the operation names the model gave, a fixed text, or the
+ * tool's name.
  */
-export type AssistantToolChipState = 'running' | 'done' | 'failed' | 'flawed';
-/** What a tool chip is called: the operation names the model gave, a fixed text, or the tool's name. */
 export type AssistantToolChipLabel = {
     readonly kind: 'text';
     readonly text: string;
@@ -22,6 +25,12 @@ export interface AssistantToolChip {
      * panel knows. Nothing for a call that went wrong for any other reason.
      */
     readonly errorCode: AssistantToolErrorCode | undefined;
+    /**
+     * The messages of the violations a failed call failed on, written for the user, in result order.
+     * Empty for a call that did not fail, that failed for any other reason, or whose violations have
+     * no message.
+     */
+    readonly violations: readonly string[];
 }
 /** A tool call of a message as the chip reads it. */
 export interface AssistantToolCall {
@@ -36,9 +45,10 @@ export interface AssistantToolCall {
     readonly isReplyRunning: boolean;
 }
 /**
- * Describes one tool call for its chip: the label in the order operation names, fixed text for the
- * `apply` and `query` tools, tool name; and whether the call runs, finished, or went wrong. Why it
- * went wrong is part of it only as the code of an error the server recorded: the text of a tool
- * result is worded for the model, not for the user.
+ * Describes one tool call for its chip: the label in the order title, operation names, fixed text
+ * for the `apply` and `query` tools, tool name; and whether the call runs, finished, or went wrong.
+ * Why it went wrong is part of it only as the code of an error the server recorded, or as the
+ * messages of the violations it failed on, which are written for the user: the rest of a tool result
+ * is worded for the model.
  */
 export declare const describeToolCall: (call: AssistantToolCall) => AssistantToolChip;

package/dist/configurator/ui/assistant/tool-chip.js

@@ -1 +1 @@
-import{Kind as e,parse as t}from"graphql";import{z as n}from"zod";import{ASSISTANT_TOOL_ERROR_CODES as r,AssistantToolError as a,applyTool as i,queryTool as o}from"@salsita-ai/contracts/assistant";let l=n.object({operations:n.array(n.object({query:n.string(),operationName:n.string().nullish()}))}),s=n.object({results:n.array(n.object({errors:n.array(n.unknown()).optional()})),committed:n.boolean()});export const describeToolCall=n=>{let d=(({name:n,input:r})=>{let a,s=(a=l.safeParse(r)).success?a.data.operations.flatMap(({query:n,operationName:r})=>r??(n=>{try{let r=t(n).definitions.find(t=>t.kind===e.OPERATION_DEFINITION);return r?.kind===e.OPERATION_DEFINITION?r.name?.value:void 0}catch{return}})(n)??[]):[];return s.length>0?{kind:"text",text:s.join(", ")}:n===i.name?{kind:"updateDesign"}:n===o.name?{kind:"readDesign"}:{kind:"text",text:n}})(n);if(null==n.result&&null==n.error)return{label:d,state:n.isReplyRunning?"running":"done",errorCode:void 0};let u=(e=>{let t=a.safeParse(e);if(t.success)return r.find(e=>e===t.data.code)})(n.result);return{label:d,state:(({name:e,result:t,error:n},r)=>{if(null!=n||null!=r)return e===o.name?"flawed":"failed";if(e!==i.name&&e!==o.name)return"done";let a=s.safeParse(t);if(!a.success)return e===o.name?"flawed":"failed";let{results:l,committed:d}=a.data;return e===i.name?d?"done":"failed":l.some(({errors:e})=>(e?.length??0)>0)||0===l.length?"flawed":"done"})(n,u),errorCode:u}};
+import{Kind as e,parse as t}from"graphql";import{z as r}from"zod";import{ASSISTANT_TOOL_ERROR_CODES as n,AssistantToolError as s,applyTool as a,queryTool as i}from"@salsita-ai/contracts/assistant";import{SCREENSHOT_NOT_TAKEN as o}from"../../application-runtime/index.js";let l=r.object({title:r.string().nullish().catch(void 0),operations:r.array(r.object({query:r.string(),operationName:r.string().nullish()}))}),u=r.object({results:r.array(r.object({errors:r.array(r.unknown()).optional()})),committed:r.boolean()}),d=r.tuple([r.object({type:r.literal("text"),content:r.string()})]).rest(r.unknown()),c=e=>{let t=d.safeParse(e);if(!t.success)return e;try{return JSON.parse(t.data[0].content)}catch{return e}},f=r.object({extensions:r.object({code:r.string()})}),m=r.object({message:r.string(),extensions:r.object({code:r.literal("VIOLATION"),type:r.string()})});export const describeToolCall=r=>{var d;let p,g=(({name:r,input:n})=>{let s,o,u=(s=l.safeParse(n)).success&&s.data.title?.trim()||void 0;if(null!=u)return{kind:"text",text:u};let d=(o=l.safeParse(n)).success?o.data.operations.flatMap(({query:r,operationName:n})=>n??(r=>{try{let n=t(r).definitions.find(t=>t.kind===e.OPERATION_DEFINITION);return n?.kind===e.OPERATION_DEFINITION?n.name?.value:void 0}catch{return}})(r)??[]):[];return d.length>0?{kind:"text",text:d.join(", ")}:r===a.name?{kind:"updateDesign"}:r===i.name?{kind:"readDesign"}:{kind:"text",text:r}})(r);if(null==r.result&&null==r.error)return{label:g,state:r.isReplyRunning?"running":"done",errorCode:void 0,violations:[]};let x=(e=>{let t=s.safeParse(e);if(t.success)return n.find(e=>e===t.data.code)})(r.result),b=(({name:e,result:t,error:r},n)=>{if(null!=r||null!=n)return"failed";if(e!==a.name&&e!==i.name)return"done";let s=u.safeParse(c(t));if(!s.success)return"failed";let{results:l,committed:d}=s.data;return e===a.name?d?"done":"failed":l.some(({errors:e})=>e?.some(e=>{let t;return!(t=f.safeParse(e)).success||t.data.extensions.code!==o}))||0===l.length?"failed":"done"})(r,x);return{label:g,state:b,errorCode:x,violations:"failed"===b?(d=r.result,(p=u.safeParse(c(d))).success?p.data.results.flatMap(({errors:e})=>(e??[]).flatMap(e=>{let t=m.safeParse(e);return t.success&&t.data.message!==t.data.extensions.type?[t.data.message]:[]})):[]):[]}};

package/dist/configurator/ui/assistant/use-assistant-composer.d.ts

@@ -0,0 +1,88 @@
+import { type AssistantRecording } from './voice/index.js';
+/** An image or an annotation attached to the message being written, as a composer shows it. */
+export interface AssistantComposerAttachment {
+    readonly id: string;
+    /** Object URL of the prepared image for the thumbnail, valid while the attachment is attached. */
+    readonly previewUrl: string;
+    /** True for an annotation, of the view or of an image; false for an image the user added. */
+    readonly isAnnotation: boolean;
+    /** How many comment pins an annotation has; 0 for an image. */
+    readonly pinCount: number;
+}
+/**
+ * Why the last images the user added are not all attached:
+ * - `unreadable`: one could not be read as an image
+ * - `limit`: the message already carries as many images as it can
+ */
+export type AssistantComposerNotice = 'unreadable' | 'limit';
+/**
+ * The message being written to the assistant, with its attachments and what can be done with it.
+ * - `draft` and `setDraft`: the text of the message.
+ * - `attachments`: the images and annotations attached to it, in their order.
+ * - `addFiles(files)`: prepares the files as images and attaches them, as many as `maxAttachments` allows.
+ * - `annotate()`: opens the annotation editor over the configurator; the annotation is attached once the user is
+ *   done with it. Like a file too many, an annotation too many is not made, and `notice` says why.
+ * - `annotateAttachment(id)`: opens the annotation editor on an attached image; the annotation takes its place once
+ *   the user is done with it, so it needs no free slot. An annotation is not annotated again.
+ * - `removeAttachment(id)`: takes an attachment off the message.
+ * - `isPreparing`: whether files added are still being prepared; the message cannot be sent meanwhile.
+ * - `notice`: why the files added last are not all attached, until the attachments change again.
+ * - `maxAttachments`: the most images and annotations one message can carry together.
+ * - `isBusy`: whether a send waits for the thread to be resumed or the images to upload; the message should not
+ *   change meanwhile.
+ * - `isReplying`: whether the assistant is replying; `stop()` ends the reply.
+ * - `isLocked`: whether the assistant banned the user on this configuration, so it takes no message there; nothing
+ *   should be written or attached then, and `canSend` is false.
+ * - `canSend` and `send()`: whether the message can be sent, and sending it. The message is cleared once the chat
+ *   takes it, and comes back, after what was written meanwhile, when the chat gives it back.
+ * - `inputFocusHandlers`: `onFocus` and `onBlur` for the message input, so a phone layout makes room for it.
+ * - `canRecord`: whether the user may speak the message: the session has voice messages on, the browser can record,
+ *   and the assistant takes messages here. A composer shows a mic in place of Send while the text is empty then.
+ * - `recording`: the voice message being recorded, its status, how long it runs and how loud the microphone is.
+ * - `startRecording()`: starts recording, asking for the microphone; a microphone blocked for the page shows as the
+ *   `refused` status, and starting again asks again.
+ * - `sendRecording()`: stops the recording and sends it as the message, with the images and annotations attached. A
+ *   recording the server refuses comes back as `recorded`, to be sent again or dropped; one in which nothing was
+ *   heard is dropped. A recording that reaches two minutes is sent on its own.
+ * - `cancelRecording()`: drops the recording, and the composer is as it was.
+ */
+export interface UseAssistantComposerResult {
+    readonly draft: string;
+    readonly setDraft: (draft: string) => void;
+    readonly attachments: readonly AssistantComposerAttachment[];
+    readonly addFiles: (files: ReadonlyArray<File>) => Promise<void>;
+    readonly annotate: () => Promise<void>;
+    readonly annotateAttachment: (id: string) => Promise<void>;
+    readonly removeAttachment: (id: string) => void;
+    readonly isPreparing: boolean;
+    readonly notice: AssistantComposerNotice | undefined;
+    readonly maxAttachments: number;
+    readonly isBusy: boolean;
+    readonly isLocked: boolean;
+    readonly isReplying: boolean;
+    readonly canSend: boolean;
+    readonly send: () => Promise<void>;
+    readonly stop: () => void;
+    readonly inputFocusHandlers: {
+        readonly onFocus: () => void;
+        readonly onBlur: () => void;
+    };
+    readonly canRecord: boolean;
+    readonly recording: AssistantRecording;
+    readonly startRecording: () => Promise<void>;
+    readonly sendRecording: () => Promise<void>;
+    readonly cancelRecording: () => void;
+}
+export type UseAssistantComposer = () => UseAssistantComposerResult;
+/**
+ * Hook to write a message to the assistant, as the panel's composer does. The text of the message lives
+ * as long as the component that uses the hook; its attachments live in the assistant system
+ * (`composerAttachments$`), so an annotation made from elsewhere, such as a drawing, is attached here too.
+ * The thumbnails' object URLs are the hook's own, revoked once their attachment is gone or the component
+ * unmounts. It does not render again with every chunk of a reply.
+ *
+ * Images added are prepared at once and attached up to `maxAttachments` per message; one that cannot be prepared,
+ * or one too many, is not attached, and `notice` says why. The message keeps its text and images until the chat
+ * takes it, also when the upload of its images fails.
+ */
+export declare const useAssistantComposer: UseAssistantComposer;

package/dist/configurator/ui/assistant/use-assistant-composer.js

@@ -0,0 +1,2 @@
+import{useTheme as t}from"@mui/material";import{useCallback as e,useEffect as n,useMemo as r,useReducer as a,useRef as i,useState as o}from"react";import{skip as s}from"rxjs/operators";import{useEagerObservableSelector as c,useEagerObservableValue as l}from"#package/react-sdk";import{MAX_COMPOSER_ATTACHMENTS as m,useConfigurator as u}from"../../application-runtime/index.js";import{prepareImage as d}from"./attachments/index.js";import{useVoiceRecording as h}from"./voice/index.js";export const useAssistantComposer=()=>{let{assistantSystem:p}=u(),[f,g]=o(""),v=l(p.composerAttachments$),[y,b]=o(0),[A,L]=o(),[R,w]=o(!1),k=i(new Map),[U,j]=a(t=>t+1,0),x=i(v);x.current=v,n(()=>{let t=k.current;for(let[e,n]of t)v.some(t=>t.id===e)||(URL.revokeObjectURL(n),t.delete(e))},[v]),n(()=>{let t=k.current;return 0===t.size&&x.current.length>0&&j(),()=>{for(let e of t.values())URL.revokeObjectURL(e);t.clear()}},[]);let $=i(!1),F=e(t=>{$.current=!0;try{return t()}finally{$.current=!1}},[]);n(()=>{let t=p.composerAttachments$.pipe(s(1)).subscribe(()=>{$.current||L(void 0)});return()=>t.unsubscribe()},[p]);let{isReplying:S,isResuming:E,isLocked:I,isVoiceEnabled:O}=c(p.chat$,t=>({isReplying:t.isLoading,isResuming:t.isResuming,isLocked:t.isLocked,isVoiceEnabled:t.isVoiceEnabled}),[]),C=f.trim(),P=E||R,V=!S&&!P&&!I&&0===y&&(C.length>0||v.length>0),z=e(async t=>{if(0===t.length)return;let e=[];for(let n of t){let t=p.reserveAttachmentSlot();if(!t)break;e.push(t)}let n=t.slice(0,e.length);L(n.length<t.length?"limit":void 0),0!==n.length&&(b(t=>t+n.length),await Promise.all(n.map(async(t,n)=>{let r;try{r=await d(t)}catch{L("unreadable")}finally{b(t=>t-1)}if(e[n]?.()&&r){let t=r;F(()=>p.attach(t))}})))},[p,F]),B=e(async()=>{p.hasFreeAttachmentSlot$.value?(L(void 0),await p.annotate()):L("limit")},[p]),{palette:M}=t(),q=M.background.default,D=e(async t=>{L(void 0),await p.annotate({attachmentId:t,background:q})},[p,q]),G=e(t=>{p.removeAttachment(t),L(void 0)},[p]),H=i(!0);n(()=>(H.current=!0,()=>{H.current=!1}),[]);let J=e(t=>{F(()=>t.forEach(({id:t})=>p.removeAttachment(t))),L(void 0),w(!1)},[p,F]),K=e(t=>{L(F(()=>p.restoreAttachments(t))?void 0:"limit")},[p,F]),N=e(async()=>{if(V){w(!0);try{await p.send(C,v.map(({blob:t,pins:e,source:n})=>e?{blob:t,pins:e,source:n}:t),{onSent:()=>{g(""),J(v)},onUnsent:()=>{g(t=>t.trim()?`${t}
+${f}`:f),K(v)}})}finally{w(!1)}}},[p,v,V,C,f,K,J]),Q=i(async()=>{}),T=h({onLimitReached:()=>void Q.current()}),{recording:W,finish:X,clear:Y,restore:Z}=T,{start:_,cancel:tt}=T,te=O&&"unavailable"!==W.status&&!I,tn=e(async()=>{if(!te||S||P)return;let t=await X();if(t&&!(y>0)){w(!0);try{await p.send("",v.map(({blob:t,pins:e,source:n})=>e?{blob:t,pins:e,source:n}:t),{audio:t,onSent:()=>{Y(),J(v)},onUnsent:()=>{K(v),H.current&&Z(t)}})}finally{w(!1)}}},[p,v,te,Y,X,P,S,y,K,Z,J]);Q.current=tn;let tr=e(async()=>{!te||S||P||await _()},[te,P,S,_]),ta=e(()=>{p.stop()},[p]),ti=r(()=>({onFocus:()=>p.setInputFocused(!0),onBlur:()=>p.setInputFocused(!1)}),[p]);return{draft:f,setDraft:g,attachments:r(()=>v.map(({id:t,blob:e,pins:n})=>{let r=k.current.get(t);return void 0===r&&(r=URL.createObjectURL(e),k.current.set(t,r)),{id:t,previewUrl:r,isAnnotation:null!=n,pinCount:n?.length??0}}),[v,U]),addFiles:z,annotate:B,annotateAttachment:D,removeAttachment:G,isPreparing:y>0,notice:A,maxAttachments:m,isBusy:P,isLocked:I,isReplying:S,canSend:V,send:N,stop:ta,inputFocusHandlers:ti,canRecord:te,recording:W,startRecording:tr,sendRecording:tn,cancelRecording:tt}};

package/dist/configurator/ui/assistant/use-assistant-thread.d.ts

@@ -0,0 +1,52 @@
+import { type AssistantFailure } from './assistant-failure.js';
+import { type AssistantThreadItem } from './thread-items.js';
+/**
+ * The conversation with the assistant, laid out as the panel's thread renders it.
+ * - `items`: the blocks of the current thread in reading order: user messages, assistant text, rows of tool calls.
+ * - `earlierItems`: the closed threads loaded above it, oldest first, each ended by a separator.
+ * - `isLoaded` and `isLoadingThread`: whether the thread has been read, and whether the panel shows that it is
+ *   being read.
+ * - `isEmpty`: whether there is nothing to show, so the panel greets the user.
+ * - `isReplying`: whether a reply runs. `isThinking`: whether it runs with nothing in the thread showing that it
+ *   does yet. `isResuming`: whether a thread this session may not continue is being resumed before a message.
+ * - `failure` and `retry()`: what went wrong with the assistant, and reading the thread again when that may help
+ *   (`failure.canRetry`). A ban of the user on this configuration is a failure of kind `locked`, also when the thread
+ *   read itself succeeded.
+ * - `hasOlderMessages`, `isLoadingOlderMessages` and `loadOlderMessages()`: the older pages of the current thread.
+ * - `canLoadEarlierThread`, `isLoadingEarlierThread` and `loadEarlierThread()`: the closed thread before the
+ *   loaded ones, offered once the current thread is loaded whole.
+ * - `undoableToolCallId` and `undo(toolCallIds)`: the tool call whose change a row of tool calls may undo, never
+ *   while a reply runs, and undoing the changes of a row.
+ * - `newestMessageKey` and `firstMessageId`: what a scrolling thread follows. `newestMessageKey` is an opaque value,
+ *   compared by identity, that changes whenever the newest message does, also with every chunk of a reply, but not
+ *   when an older page is loaded above it, which builds every item again. `firstMessageId` changes when an older page
+ *   is loaded, so the thread can keep the reader's place.
+ */
+export interface UseAssistantThreadResult {
+    readonly items: readonly AssistantThreadItem[];
+    readonly earlierItems: readonly AssistantThreadItem[];
+    readonly isLoaded: boolean;
+    readonly isLoadingThread: boolean;
+    readonly isEmpty: boolean;
+    readonly isReplying: boolean;
+    readonly isThinking: boolean;
+    readonly isResuming: boolean;
+    readonly failure: AssistantFailure | undefined;
+    readonly retry: () => void;
+    readonly hasOlderMessages: boolean;
+    readonly isLoadingOlderMessages: boolean;
+    readonly loadOlderMessages: () => void;
+    readonly canLoadEarlierThread: boolean;
+    readonly isLoadingEarlierThread: boolean;
+    readonly loadEarlierThread: () => void;
+    readonly undoableToolCallId: string | undefined;
+    readonly undo: (toolCallIds: ReadonlySet<string>) => void;
+    readonly newestMessageKey: object | undefined;
+    readonly firstMessageId: string | undefined;
+}
+export type UseAssistantThread = () => UseAssistantThreadResult;
+/**
+ * Hook to render the conversation with the assistant, as the panel's thread does. It renders again with every
+ * chunk of a reply; render each item with `AssistantThreadItemView`, or with the item components it uses.
+ */
+export declare const useAssistantThread: UseAssistantThread;

package/dist/configurator/ui/assistant/use-assistant-thread.js

@@ -0,0 +1 @@
+import{useMemo as e}from"react";import{useEagerObservableValue as a}from"#package/react-sdk";import{useConfigurator as s}from"../../application-runtime/index.js";import{describeAssistantFailure as r}from"./assistant-failure.js";import{buildEarlierThreadItems as d,buildThreadView as i}from"./thread-items.js";export const useAssistantThread=()=>{let{assistantSystem:o}=s(),l=a(o.chat$),{messages:t,isLoading:n,isResuming:g,earlierThreads:h}=l,m=a(o.undoTipToolCallId$),T=n?void 0:m,{items:p,isThinking:L}=e(()=>i(t,n,g),[t,n,g]),u=e(()=>d(h),[h]),M=t.at(-1),f=e(()=>M?{}:void 0,[M]),{error:O,failedStatus:c,retryAfterSeconds:E,isLocked:j,isNetworkLocked:v}=l,I=e(()=>O||j?r(c,E,j,v):void 0,[O,c,E,j,v]),k=null!==l.earlierThreadId&&!l.hasOlderMessages&&!l.isLoadingEarlierThread,x=!l.isLoaded&&0===u.length&&!g&&!I,C=l.isLoaded&&0===p.length&&0===u.length&&!n&&!g&&!I;return{items:p,earlierItems:u,isLoaded:l.isLoaded,isLoadingThread:x,isEmpty:C,isReplying:n,isThinking:L,isResuming:g,failure:I,retry:o.reloadThread,hasOlderMessages:l.hasOlderMessages,isLoadingOlderMessages:l.isLoadingOlderMessages,loadOlderMessages:o.loadOlderMessages,canLoadEarlierThread:k,isLoadingEarlierThread:l.isLoadingEarlierThread,loadEarlierThread:o.loadEarlierThread,undoableToolCallId:T,undo:o.undoToolCalls,newestMessageKey:f,firstMessageId:t[0]?.id}};

package/dist/configurator/ui/assistant/use-follow-stream.js

@@ -1 +1 @@
-import{useCallback as r,useEffect as e,useLayoutEffect as t,useRef as l,useState as c}from"react";export const useFollowStream=(o,n)=>{let s=l(null),u=l(!0),[i,g]=c(!1),h=r(()=>{let r=s.current;u.current=!0,g(!1),r&&(r.scrollTop=r.scrollHeight)},[]),H=r(()=>{let r=s.current;r&&(u.current=r.scrollHeight-r.scrollTop-r.clientHeight<=24,u.current&&g(!1))},[]);return t(()=>{h()},[n,h]),t(()=>{let r=s.current;r&&(u.current?r.scrollTop=r.scrollHeight:r.scrollHeight>r.clientHeight&&g(!0))},[o]),e(()=>{let r=s.current;if(!r)return;let e=new ResizeObserver(()=>{u.current&&(r.scrollTop=r.scrollHeight)});return e.observe(r),()=>{e.disconnect()}},[]),{scrollerRef:s,hasUnseenContent:i,handleScroll:H,scrollToEnd:h}};
+import{useCallback as e,useEffect as r,useLayoutEffect as t,useRef as l,useState as c}from"react";export const useFollowStream=(o,n)=>{let s=l(null),i=l(!0),[u,g]=c(!1),h=e(()=>{let e=s.current;i.current=!0,g(!1),e&&(e.scrollTop=e.scrollHeight)},[]),H=e(()=>{let e=s.current;e&&(i.current=e.scrollHeight-e.scrollTop-e.clientHeight<=24,i.current&&g(!1))},[]);return t(()=>{h()},[n,h]),t(()=>{let e=s.current;e&&(i.current?e.scrollTop=e.scrollHeight:e.scrollHeight>e.clientHeight&&g(!0))},[o]),r(()=>{let e=s.current;if(!e)return;let r=()=>{i.current&&(e.scrollTop=e.scrollHeight)},t=new ResizeObserver(r);return t.observe(e),e.addEventListener("load",r,!0),()=>{t.disconnect(),e.removeEventListener("load",r,!0)}},[]),{scrollerRef:s,hasUnseenContent:u,handleScroll:H,scrollToEnd:h}};

package/dist/configurator/ui/assistant/use-load-older-on-top.d.ts

@@ -0,0 +1,22 @@
+import { type RefObject } from 'react';
+export interface LoadOlderOnTopOptions {
+    /** True while there is an older page to load and none is loading. */
+    readonly enabled: boolean;
+    readonly onReachTop: () => void;
+    /** Changes when a page is painted above the thread, such as the id of its first message. */
+    readonly firstItemKey: unknown;
+}
+/**
+ * Loads older messages when the user scrolls the thread to its top: a sentinel above the first
+ * message is watched within the scroller, and `onReachTop` runs when it comes into view. A page
+ * that does not fill the scroller leaves the sentinel in view, so the next page loads too. An
+ * attempt that painted nothing, because it failed, is tried again only once the user scrolls the
+ * sentinel out of view and back.
+ *
+ * The page lands above what the user reads, so the reading position is kept: the distance from the
+ * end of the thread is restored once the page is painted, before the browser shows it, and again
+ * each time an image in the thread finishes loading, until the user scrolls: an image reserves no
+ * height, so one that loads above the reader grows the thread there. CSS scroll anchoring would do
+ * the same, but Safari does not support it.
+ */
+export declare const useLoadOlderOnTop: <SCROLLER extends HTMLElement, SENTINEL extends HTMLElement>(scrollerRef: RefObject<SCROLLER>, sentinelRef: RefObject<SENTINEL>, { enabled, onReachTop, firstItemKey }: LoadOlderOnTopOptions) => void;

package/dist/configurator/ui/assistant/use-load-older-on-top.js

@@ -0,0 +1 @@
+import{useEffect as r,useLayoutEffect as e,useRef as t}from"react";let n=Symbol("no attempt");export const useLoadOlderOnTop=(l,c,{enabled:o,onReachTop:u,firstItemKey:s})=>{let i=t(null),p=t(n),a=t(null),d=t({onReachTop:u,firstItemKey:s});d.current={onReachTop:u,firstItemKey:s},r(()=>{let r=l.current;if(!r)return;let e=()=>{null!==i.current&&(i.current=r.scrollHeight-r.scrollTop),a.current&&Math.abs(r.scrollTop-a.current.scrollTop)>1&&(a.current=null)},t=()=>{a.current&&(r.scrollTop=r.scrollHeight-a.current.distanceFromEnd,a.current={...a.current,scrollTop:r.scrollTop})};return r.addEventListener("scroll",e,{passive:!0}),r.addEventListener("load",t,!0),()=>{r.removeEventListener("scroll",e),r.removeEventListener("load",t,!0)}},[l]),r(()=>{let r=l.current,e=c.current;if(!o||!r||!e)return;let t=new IntersectionObserver(([e])=>{if(!e?.isIntersecting){p.current=n;return}p.current!==d.current.firstItemKey&&(p.current=d.current.firstItemKey,a.current=null,i.current=r.scrollHeight-r.scrollTop,d.current.onReachTop())},{root:r});return t.observe(e),()=>t.disconnect()},[o,l,c]),e(()=>{let r=l.current;r&&null!==i.current&&(r.scrollTop=r.scrollHeight-i.current,a.current={distanceFromEnd:i.current,scrollTop:r.scrollTop}),i.current=null},[s,l])};