@tangle-network/agent-app 0.45.64 → 0.45.66

package/dist/web-react/chat-composer.d.ts

@@ -1,9 +1,17 @@
 /**
  * ChatComposer — the shared message input every agent app used to hand-roll:
  * an auto-resizing textarea (Enter sends, Shift+Enter inserts a newline), an
- * opt-in attach + drag-and-drop surface with pending-file chips, a streaming
- * Stop/Send toggle, a slot for inline controls (model picker, reasoning
- * effort), and a Cmd/Ctrl+L focus shortcut.
+ * opt-in attach + drag-and-drop + clipboard-paste surface with pending-file
+ * chips, a streaming Stop/Send toggle, a slot for inline controls (model
+ * picker, reasoning effort), and a Cmd/Ctrl+L focus shortcut.
+ *
+ * Files arrive by three routes — the picker dialog, a drop, and a paste — and
+ * all three funnel through `accept` (`./composer-file-accept`) before they
+ * reach `onAttach`, so a type the picker will not offer cannot get in by
+ * another route. What `accept` refuses goes to `onRejectFiles` with a reason;
+ * without that prop a refusal is silent, which is what the native picker also
+ * does. Size and count limits stay the host's job — `useComposerAttachments`
+ * owns them, because they depend on what is already staged.
  *
  * A REJECTED send never destroys the draft. The input clears optimistically —
  * the composer stays editable while a turn streams precisely so the next
@@ -25,6 +33,7 @@
  * fallbacks when a host hasn't defined a private chat-token set.
  */
 import { type ReactNode } from 'react';
+import { type ComposerFileRejection } from './composer-file-accept';
 import { type DictationAudio } from './use-dictation';
 /** Prompt-part descriptor an uploaded file carries (the upload route's
  *  `UploadedChatFile.part`), echoed back in the turn body on send. Mirrors
@@ -48,6 +57,25 @@ export interface ComposerFile {
     /** Uploaded part descriptor; set once the upload route returns. Only
      *  `status: 'ready'` files with a part travel on a parts-aware send. */
     part?: ComposerFilePart;
+    /** Object URL for an image thumbnail on the chip. The host owns the URL's
+     *  whole life — `URL.createObjectURL` when the file is staged,
+     *  `URL.revokeObjectURL` when it leaves — and the composer only reads it.
+     *  `useComposerAttachments` already does both. */
+    previewUrl?: string;
+    /** Why this file failed, shown on the chip while `status: 'error'`. Without
+     *  it an error chip is red and mute, which tells the user nothing. */
+    errorMessage?: string;
+}
+/** A piece of context the agent will see beside the next message — an open
+ *  file, a selected record, a pinned document. Rendered as its own chip row,
+ *  separate from staged attachments: context is what the turn already carries,
+ *  an attachment is what the user is adding to it. */
+export interface ComposerContextItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    /** Omit for a chip the user cannot dismiss. */
+    onRemove?: () => void;
 }
 /** A send the host refused. `error` is shown verbatim in the composer's notice;
  *  omit it for the generic copy. */
@@ -169,14 +197,68 @@ export interface ChatComposerProps {
      */
     controlsPlacement?: 'above' | 'inline';
     /** Attachments are opt-in: pass `onAttach` to show the attach button, accept
-     *  drag-and-drop onto the input, and render `pendingFiles` chips. */
+     *  drag-and-drop and clipboard paste onto the input, and render
+     *  `pendingFiles` chips. */
     onAttach?: (files: FileList) => void;
     onAttachFolder?: (files: FileList) => void;
     pendingFiles?: ComposerFile[];
     onRemoveFile?: (id: string) => void;
+    /** Pass it and a chip with `status: 'error'` gains a retry button. */
+    onRetryFile?: (id: string) => void;
+    /**
+     * File types the composer takes, in the native `<input accept>` grammar.
+     * Enforced on every ingress route — the picker dialog (which the user can
+     * override with "All Files"), drag-and-drop, and clipboard paste — so a type
+     * the picker will not offer cannot arrive by another route. A non-matching
+     * file goes to `onRejectFiles` and never reaches `onAttach`. Folder attach is
+     * exempt: directory selection has no native accept semantics.
+     */
     accept?: string;
+    /** Called with the files `accept` removed from a pick, drop, or paste, each
+     *  with a reason. Without it a refusal is silent — the same feedback the
+     *  native picker gives for a type it will not offer. */
+    onRejectFiles?: (rejections: ComposerFileRejection[]) => void;
     dropTitle?: string;
     dropDescription?: string;
+    /** Context the agent will see beside the next message, as its own chip row
+     *  above the input. */
+    contextItems?: ReadonlyArray<ComposerContextItem>;
+    /**
+     * Let a staged file stand in for message text, so the send control stays live
+     * while an upload is in flight instead of going dead with nothing to explain
+     * it. Default false, where an empty message needs a `ready` file.
+     *
+     * It does NOT make an unfinished file sendable. A turn whose only content is a
+     * file that is still uploading or has failed never reaches the send handler —
+     * it would arrive empty and the attachment would be lost. The composer
+     * refuses it and names the reason in its notice
+     * ({@link attachmentsNotReadyMessage}). So the flag decides whether the
+     * control is live, and the composer keeps the integrity gate rather than
+     * leaving each host to re-derive it.
+     */
+    canSubmitAttachmentsOnly?: boolean;
+    /** Notice copy when a send is refused because no staged file is ready yet.
+     *  Defaults to wording chosen from whether a file failed or is still
+     *  uploading. */
+    attachmentsNotReadyMessage?: string;
+    /**
+     * Let Enter and Send keep firing while `isStreaming`, for a surface that
+     * queues the next turn rather than blocking on the current one. Default
+     * false. The button still flips to Stop while a turn streams, so this opens
+     * the keyboard path, not a second button.
+     */
+    canSubmitWhileBusy?: boolean;
+    /** Focus the input on mount — for a surface whose whole job is the input
+     *  (an entry/hero composer), never for one docked under a transcript. */
+    autoFocus?: boolean;
+    /** Rows the input shows before it grows. Default 2. */
+    minRows?: number;
+    /** Pixel height the input grows to before it scrolls. Default 168. */
+    maxHeight?: number;
+    /** Content between the controls slot and Send — a token meter, a cost, a
+     *  status line. It sits outside the controls slot and never shrinks, so a
+     *  wrapping picker set cannot push it away. */
+    trailing?: ReactNode;
     /** `/` commands offered when the draft is exactly a leading slash token.
      *  Omit (or pass []) and `/` types as ordinary text. */
     slashCommands?: SlashCommand[];
@@ -204,4 +286,4 @@ export interface ChatComposerProps {
     sendVariant?: 'pill' | 'icon';
     className?: string;
 }
-export declare function ChatComposer({ onSend, onSendParts, onSendFailed, sendFailureMessage, onCancel, isStreaming, disabled, placeholder, value, onValueChange, initialValue, seed, onSeedApplied, controls, controlsPlacement, onAttach, onAttachFolder, pendingFiles, onRemoveFile, accept, dropTitle, dropDescription, slashCommands, onDictate, onDictateError, focusShortcut, floating, sendLabel, sendVariant, className, }: ChatComposerProps): import("react").JSX.Element;
+export declare function ChatComposer({ onSend, onSendParts, onSendFailed, sendFailureMessage, onCancel, isStreaming, disabled, placeholder, value, onValueChange, initialValue, seed, onSeedApplied, controls, controlsPlacement, onAttach, onAttachFolder, pendingFiles, onRemoveFile, onRetryFile, accept, onRejectFiles, dropTitle, dropDescription, contextItems, canSubmitAttachmentsOnly, attachmentsNotReadyMessage, canSubmitWhileBusy, autoFocus, minRows, maxHeight, trailing, slashCommands, onDictate, onDictateError, focusShortcut, floating, sendLabel, sendVariant, className, }: ChatComposerProps): import("react").JSX.Element;

package/dist/web-react/composer-file-accept.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The composer's file-ingress filter, and the clipboard rename that goes with
+ * it.
+ *
+ * A file reaches a composer by three routes — the picker dialog, a drag-and-drop,
+ * and a clipboard paste — and only the picker gets a native `accept` filter (one
+ * the user can defeat with "All Files"). Every route therefore funnels through
+ * {@link filterAcceptedFiles}, so a type the picker will not offer cannot arrive
+ * by another route instead.
+ *
+ * One route can still reach a different verdict, and it does so deliberately.
+ * Paste is the only route that RENAMES, and {@link renamePastedImages} names a
+ * file after the type it declares. So a clipboard bitmap called `image.png` that
+ * declares `image/heic` is judged as `.heic` on paste, while the picker and a
+ * drop judge the name they were handed and admit it under `accept=".png"`. The
+ * filter is the same on all three; what differs is the name it is given, and
+ * paste is stricter precisely because a rename that kept the contradicting name
+ * would let the composer manufacture its own way past the filter.
+ *
+ * ONE accept matcher serves the package: `ChatComposer` gates its ingress on it
+ * and `useComposerAttachments` gates `addFiles` on it. A second implementation
+ * of the `accept` grammar is how the two ends of the same staging path start
+ * disagreeing about what a file is.
+ *
+ * Pure data in, pure data out — nothing here throws, logs, or touches the DOM,
+ * so a caller decides how a rejection is surfaced. Import-free beyond the
+ * browser's own `File`, which keeps it usable from `/web-react`'s client bundle.
+ */
+/** A file the `accept` list refused, with the reason to show for it. */
+export interface ComposerFileRejection {
+    file: File;
+    reason: string;
+}
+/**
+ * Checks one file against a comma-separated `accept` list, using the grammar of
+ * the native `<input accept>` attribute: extensions (`.png`), exact MIME types
+ * (`image/png`), and MIME wildcards (`image/*`). An absent or empty list accepts
+ * everything, which is what an unset `accept` prop means.
+ */
+export declare function isAcceptedFileType(file: File, accept?: string): boolean;
+/** The reason an `accept` list refused a file. One wording for every ingress
+ *  route, so the same file reads the same whether it was picked or dropped. */
+export declare function acceptRejectionReason(file: File, accept: string): string;
+/**
+ * Splits a batch into what the `accept` list admits and what it refuses. Size
+ * and count limits are NOT applied here: they belong to the staging queue, which
+ * knows what is already staged (`useComposerAttachments`), while this runs at the
+ * composer's edge where that is unknown.
+ */
+export declare function filterAcceptedFiles(files: File[] | FileList, accept?: string): {
+    accepted: File[];
+    rejected: ComposerFileRejection[];
+};
+/**
+ * Gives every generically-named clipboard image a distinct
+ * `pasted-image-<n>.<ext>` name. Two pastes of the same bitmap otherwise arrive
+ * as `image.png` twice, and a staging queue that keys on the name treats the
+ * second as a duplicate of the first.
+ *
+ * A number is never reused. The search avoids every `pasted-image-<n>` already
+ * present in `stagedNames` (the queue the host still holds, which outlives this
+ * composer's own count) and in the batch itself (one paste can carry a file
+ * already named that way beside a raw bitmap), so a collision is not reachable
+ * rather than merely unlikely. `startIndex` is the caller's running count, and
+ * `nextIndex` is the count to hand the next paste.
+ *
+ * Files that already carry a real name pass through untouched, so a copied
+ * `report.pdf` keeps being `report.pdf`. So does an image whose extension
+ * cannot be derived from what it declares — a renamed file must never claim a
+ * format it is not. Only the name changes: the bytes, the type and the
+ * modification time travel with it, so downstream fingerprinting still sees
+ * the file the user pasted.
+ */
+export declare function renamePastedImages(files: File[], startIndex: number, stagedNames?: Iterable<string>): {
+    files: File[];
+    nextIndex: number;
+};

package/dist/web-react/index.d.ts

@@ -30,6 +30,7 @@ import type { WorkProductPersistedPart } from '../work-product/types';
 export * from './chat-stream';
 export * from './chat-interactions';
 export * from './chat-composer';
+export * from './composer-file-accept';
 export * from './interaction-card-support';
 export * from './interaction-question-card';
 export * from './interaction-plan-card';

package/dist/web-react/index.js

@@ -137,7 +137,7 @@ import {
   withoutRecordGridCreated,
   withoutRecordGridRemoved,
   withoutRecordGridUpdate
-} from "../chunk-OMGV3CX2.js";
+} from "../chunk-AWM4H5XR.js";
 import "../chunk-FBVLEGEG.js";
 import {
   EvidenceLineageTable,
@@ -165,14 +165,18 @@ import {
   OVERLAY_SHADOW,
   POPOVER_SURFACE_ATTR,
   PopoverSurface,
+  acceptRejectionReason,
   effortLevelLabel,
   effortLevelsFromIds,
   effortMeterFill,
+  filterAcceptedFiles,
+  isAcceptedFileType,
   reconcileEffortLevels,
+  renamePastedImages,
   useComposerAttachments,
   usePending,
   usePopover
-} from "../chunk-FZKNVQYP.js";
+} from "../chunk-23J72UUA.js";
 import {
   ProviderLogo
 } from "../chunk-MLG6XKPV.js";
@@ -303,6 +307,7 @@ export {
   Sparkline,
   WorkProductCard,
   __resetAttachmentFileCacheForTests,
+  acceptRejectionReason,
   activityTone,
   attachmentInputToPart,
   attachmentKindForMime,
@@ -338,6 +343,7 @@ export {
   fieldAnswer,
   fieldValuesFromAnswers,
   fileMentionsToParts,
+  filterAcceptedFiles,
   formatActivityCost,
   formatActivityDuration,
   formatDictationElapsed,
@@ -360,6 +366,7 @@ export {
   interactionSubmissionSignature,
   interactionTerminalNotes,
   interactionToPersistedPart,
+  isAcceptedFileType,
   isChatAttachmentPart,
   isLateAnswerableStatus,
   isRecordGridCellApplicable,
@@ -401,6 +408,7 @@ export {
   recordGridFail,
   recordGridOk,
   recordGridRowLabel,
+  renamePastedImages,
   resolveChatInteraction,
   resolveProvenanceStanding,
   responseErrorMessage,

package/dist/web-react/use-composer-attachments.d.ts

@@ -15,10 +15,9 @@
  *     the URL and a `RequestInit` override, e.g. an auth header);
  *   - `sonner` toasts become `onReject` (client pre-validation, never hits the
  *     network) and `onError` (a request that reached the server and failed);
- *   - the sandbox-ui `validateComposerFiles` import becomes a small
- *     accept-list matcher re-implemented locally (`isAcceptedFileType`,
- *     mirroring its `accept`-string matching byte-for-byte) — this module
- *     stays free of the sandbox-ui peer;
+ *   - the `accept`-string gate comes from `./composer-file-accept`, the one
+ *     matcher `ChatComposer` also funnels its picker/drop/paste ingress
+ *     through, so both ends of the staging path admit the same files;
  *   - the response is expected to be `{ files: ChatAttachmentInput[] }` (full
  *     server-authoritative descriptors — size/mediaType/kind — not gtm's
  *     `{path, name}`), so `references` is a verbatim pass-through with no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.45.64",
+  "version": "0.45.66",
   "packageManager": "pnpm@11.17.0",
   "description": "Build agent applications with typed chat, tools, sandboxes, integrations, billing, and evaluation.",
   "keywords": [