@tangle-network/agent-app 0.60.235 → 0.60.237
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{DesignCanvas-SNE3H3TH.js → DesignCanvas-OW3W2QXW.js} +2 -2
- package/dist/{DesignCanvasEditor-G5O75CUT.js → DesignCanvasEditor-TCHZF25W.js} +3 -3
- package/dist/VaultPane-RXL3WLA2.js +7 -0
- package/dist/assistant/index.js +7 -7
- package/dist/chat-react/index.js +4 -4
- package/dist/{chunk-BNFUJNPS.js → chunk-A77IBQ7S.js} +456 -431
- package/dist/chunk-A77IBQ7S.js.map +1 -0
- package/dist/{chunk-JYIMW5U5.js → chunk-BGDQ7245.js} +3571 -3546
- package/dist/chunk-BGDQ7245.js.map +1 -0
- package/dist/{chunk-232KA6MR.js → chunk-CI53V6DD.js} +3 -3
- package/dist/{chunk-4JAXSEYW.js → chunk-DLVMKDFX.js} +3 -3
- package/dist/{chunk-I57SNMX4.js → chunk-EWOJATDS.js} +3 -3
- package/dist/{chunk-JYVUFRRV.js → chunk-FUZETA6Z.js} +2 -2
- package/dist/{chunk-P2NJIDLE.js → chunk-JH3CKHF4.js} +380 -366
- package/dist/chunk-JH3CKHF4.js.map +1 -0
- package/dist/{chunk-XIN7DOAB.js → chunk-R4X5474U.js} +35 -33
- package/dist/chunk-R4X5474U.js.map +1 -0
- package/dist/{chunk-IDQU36M5.js → chunk-RL3Z747H.js} +708 -659
- package/dist/chunk-RL3Z747H.js.map +1 -0
- package/dist/{chunk-3KXYYAY4.js → chunk-VBWYH7UZ.js} +243 -232
- package/dist/chunk-VBWYH7UZ.js.map +1 -0
- package/dist/{chunk-5IZRAZEZ.js → chunk-ZDPUC6CM.js} +3 -3
- package/dist/design-canvas-react/components/Toolbar.d.ts +1 -2
- package/dist/design-canvas-react/components/toolbar-fields.d.ts +65 -0
- package/dist/design-canvas-react/components/toolbar-page-controls.d.ts +20 -0
- package/dist/design-canvas-react/components/toolbar-selection-controls.d.ts +22 -0
- package/dist/design-canvas-react/components/use-workspace-keyboard.d.ts +24 -0
- package/dist/design-canvas-react/components/use-workspace-viewport.d.ts +16 -0
- package/dist/design-canvas-react/components/workspace-gesture-state.d.ts +10 -0
- package/dist/design-canvas-react/index.js +3 -3
- package/dist/design-canvas-react/lazy.js +1 -1
- package/dist/{mention-editor-6FJ6HRSN.js → mention-editor-B23OMFT2.js} +2 -2
- package/dist/public-consultation/index.d.ts +1 -1
- package/dist/settings-react/index.js +1 -1
- package/dist/studio-react/index.js +1 -1
- package/dist/vault/SourceEditor.d.ts +8 -0
- package/dist/vault/VaultCreateDialog.d.ts +14 -0
- package/dist/vault/VaultDocumentToolbar.d.ts +29 -0
- package/dist/vault/VaultPaneNavigation.d.ts +10 -0
- package/dist/vault/VaultPaneStates.d.ts +59 -0
- package/dist/vault/VaultTreePanel.d.ts +19 -0
- package/dist/vault/index.js +1 -1
- package/dist/vault/lazy.js +1 -1
- package/dist/vault/useVaultDockPlacement.d.ts +5 -0
- package/dist/vault/useVaultSearch.d.ts +13 -0
- package/dist/vault/vault-tree-paths.d.ts +12 -0
- package/dist/web-react/agent-profile-editor.js +4 -4
- package/dist/web-react/chat-composer-types.d.ts +301 -0
- package/dist/web-react/chat-composer.d.ts +2 -300
- package/dist/web-react/chat-empty-state.d.ts +27 -0
- package/dist/web-react/chat-message-body.d.ts +23 -0
- package/dist/web-react/chat-message-metrics.d.ts +6 -0
- package/dist/web-react/chat-message-types.d.ts +158 -0
- package/dist/web-react/chat-messages.d.ts +17 -0
- package/dist/web-react/chat-tool-call.d.ts +31 -0
- package/dist/web-react/composer-glyphs.d.ts +28 -0
- package/dist/web-react/index.d.ts +6 -245
- package/dist/web-react/index.js +7 -7
- package/dist/web-react/record-grid-editors.d.ts +31 -0
- package/dist/web-react/record-grid-review-actions.d.ts +13 -0
- package/dist/web-react/record-grid-source-marker.d.ts +27 -0
- package/dist/web-react/record-grid-types.d.ts +86 -0
- package/dist/web-react/record-grid.d.ts +2 -85
- package/dist/web-react/run-drill-in.d.ts +28 -0
- package/dist/web-react/use-composer-commands.d.ts +25 -0
- package/dist/web-react/use-composer-file-intake.d.ts +20 -0
- package/dist/web-react/use-composer-send.d.ts +34 -0
- package/dist/workspace-react/index.js +3 -3
- package/package.json +1 -1
- package/dist/VaultPane-QEG35UAZ.js +0 -7
- package/dist/chunk-3KXYYAY4.js.map +0 -1
- package/dist/chunk-BNFUJNPS.js.map +0 -1
- package/dist/chunk-IDQU36M5.js.map +0 -1
- package/dist/chunk-JYIMW5U5.js.map +0 -1
- package/dist/chunk-P2NJIDLE.js.map +0 -1
- package/dist/chunk-XIN7DOAB.js.map +0 -1
- /package/dist/{DesignCanvas-SNE3H3TH.js.map → DesignCanvas-OW3W2QXW.js.map} +0 -0
- /package/dist/{DesignCanvasEditor-G5O75CUT.js.map → DesignCanvasEditor-TCHZF25W.js.map} +0 -0
- /package/dist/{VaultPane-QEG35UAZ.js.map → VaultPane-RXL3WLA2.js.map} +0 -0
- /package/dist/{chunk-232KA6MR.js.map → chunk-CI53V6DD.js.map} +0 -0
- /package/dist/{chunk-4JAXSEYW.js.map → chunk-DLVMKDFX.js.map} +0 -0
- /package/dist/{chunk-I57SNMX4.js.map → chunk-EWOJATDS.js.map} +0 -0
- /package/dist/{chunk-JYVUFRRV.js.map → chunk-FUZETA6Z.js.map} +0 -0
- /package/dist/{chunk-5IZRAZEZ.js.map → chunk-ZDPUC6CM.js.map} +0 -0
- /package/dist/{mention-editor-6FJ6HRSN.js.map → mention-editor-B23OMFT2.js.map} +0 -0
|
@@ -34,304 +34,6 @@
|
|
|
34
34
|
* tokens — the input renders on-palette instead of collapsing to unstyled
|
|
35
35
|
* fallbacks when a host hasn't defined a private chat-token set.
|
|
36
36
|
*/
|
|
37
|
-
import {
|
|
38
|
-
|
|
39
|
-
import { type DictationAudio } from './use-dictation';
|
|
40
|
-
import type { ComposerMentionProp } from './use-file-mentions';
|
|
41
|
-
/** Prompt-part descriptor an uploaded file carries (the upload route's
|
|
42
|
-
* `UploadedChatFile.part`), echoed back in the turn body on send. Mirrors
|
|
43
|
-
* `/chat-routes`' wire shape structurally — no server import here. */
|
|
44
|
-
export interface ComposerFilePart {
|
|
45
|
-
type: 'image' | 'file';
|
|
46
|
-
filename?: string;
|
|
47
|
-
mediaType?: string;
|
|
48
|
-
url?: string;
|
|
49
|
-
path?: string;
|
|
50
|
-
content?: string;
|
|
51
|
-
}
|
|
52
|
-
export interface ComposerFile {
|
|
53
|
-
id: string;
|
|
54
|
-
name: string;
|
|
55
|
-
size?: number;
|
|
56
|
-
kind: 'file' | 'folder';
|
|
57
|
-
/** Number of files inside, for a folder chip. */
|
|
58
|
-
fileCount?: number;
|
|
59
|
-
status: 'pending' | 'uploading' | 'ready' | 'error';
|
|
60
|
-
/** Uploaded part descriptor; set once the upload route returns. Only
|
|
61
|
-
* `status: 'ready'` files with a part travel on a parts-aware send. */
|
|
62
|
-
part?: ComposerFilePart;
|
|
63
|
-
/** Object URL for an image thumbnail on the chip. The host owns the URL's
|
|
64
|
-
* whole life — `URL.createObjectURL` when the file is staged,
|
|
65
|
-
* `URL.revokeObjectURL` when it leaves — and the composer only reads it.
|
|
66
|
-
* `useComposerAttachments` already does both. */
|
|
67
|
-
previewUrl?: string;
|
|
68
|
-
/** Why this file failed, shown on the chip while `status: 'error'`. Without
|
|
69
|
-
* it an error chip is red and mute, which tells the user nothing. */
|
|
70
|
-
errorMessage?: string;
|
|
71
|
-
}
|
|
72
|
-
/** A piece of context the agent will see beside the next message — an open
|
|
73
|
-
* file, a selected record, a pinned document. Rendered as its own chip row,
|
|
74
|
-
* separate from staged attachments: context is what the turn already carries,
|
|
75
|
-
* an attachment is what the user is adding to it. */
|
|
76
|
-
export interface ComposerContextItem {
|
|
77
|
-
id: string;
|
|
78
|
-
label: string;
|
|
79
|
-
icon?: ReactNode;
|
|
80
|
-
/** Omit for a chip the user cannot dismiss. */
|
|
81
|
-
onRemove?: () => void;
|
|
82
|
-
}
|
|
83
|
-
/** A send the host refused. `error` is shown verbatim in the composer's notice;
|
|
84
|
-
* omit it for the generic copy. */
|
|
85
|
-
export interface ComposerSendRejected {
|
|
86
|
-
ok: false;
|
|
87
|
-
error?: string;
|
|
88
|
-
}
|
|
89
|
-
/**
|
|
90
|
-
* What a send handler reports back. `void` — what every handler returned before
|
|
91
|
-
* this existed — reads as accepted, so wiring stays unchanged; a thrown error, a
|
|
92
|
-
* rejected promise, or `{ ok: false }` is the rejection that restores the draft.
|
|
93
|
-
* A handler that resolves only when the whole turn finishes still reports
|
|
94
|
-
* correctly: the input already cleared on dispatch, so the answer only decides
|
|
95
|
-
* whether the draft comes back.
|
|
96
|
-
*/
|
|
97
|
-
export type ComposerSendOutcome = void | {
|
|
98
|
-
ok: true;
|
|
99
|
-
} | ComposerSendRejected;
|
|
100
|
-
export type ComposerSendResult = ComposerSendOutcome | Promise<ComposerSendOutcome>;
|
|
101
|
-
/**
|
|
102
|
-
* A send handler, typed as a UNION with the legacy `=> void` signature rather
|
|
103
|
-
* than as `(…) => ComposerSendResult` alone.
|
|
104
|
-
*
|
|
105
|
-
* TypeScript's return-type-`void` rule accepts a function returning ANYTHING
|
|
106
|
-
* where a `=> void` is expected, and that rule fires only when the target's
|
|
107
|
-
* return type is exactly `void` — not when it is a union that contains `void`.
|
|
108
|
-
* So narrowing this prop to `ComposerSendResult` would reject handler shapes
|
|
109
|
-
* that compiled against the shipped `onSend?: (message: string) => void`:
|
|
110
|
-
* `onSend={(m) => rows.push(m)}` (returns `number`) and
|
|
111
|
-
* `onSend={(m) => append({ role: 'user', content: m })}` (an ai-sdk append
|
|
112
|
-
* returns `Promise<string | null | undefined>`) both stop compiling, on a
|
|
113
|
-
* package whose pinned consumers must never need a source edit to take a minor.
|
|
114
|
-
*
|
|
115
|
-
* The union keeps both: a legacy handler lands on the first member, and a
|
|
116
|
-
* handler that reports an outcome lands on the second. A call through it
|
|
117
|
-
* resolves to `void | ComposerSendResult`, which IS `ComposerSendResult`, so
|
|
118
|
-
* the composer reads the outcome exactly as before.
|
|
119
|
-
*/
|
|
120
|
-
export type ComposerSendHandler = ((message: string) => void) | ((message: string) => ComposerSendResult);
|
|
121
|
-
/** @see ComposerSendHandler — the parts-aware arity, same union for the same reason. */
|
|
122
|
-
export type ComposerSendPartsHandler = ((message: string, parts: ComposerFilePart[]) => void) | ((message: string, parts: ComposerFilePart[]) => ComposerSendResult);
|
|
123
|
-
/** The rejected send, handed to `onSendFailed` so the host can undo whatever it
|
|
124
|
-
* cleared optimistically — most importantly the staged attachments, which the
|
|
125
|
-
* composer does not own (`pendingFiles` is a prop). */
|
|
126
|
-
export interface ComposerSendFailure {
|
|
127
|
-
/** The reason as the composer renders it. */
|
|
128
|
-
message: string;
|
|
129
|
-
/** The user's exact draft, untrimmed. */
|
|
130
|
-
text: string;
|
|
131
|
-
/** The parts the rejected send carried. */
|
|
132
|
-
parts: ComposerFilePart[];
|
|
133
|
-
/** Whatever the handler threw / rejected with, or the `{ ok: false }` value. */
|
|
134
|
-
error: unknown;
|
|
135
|
-
/** True when the draft was put back in the textarea (the box was empty).
|
|
136
|
-
* False means the user had typed a replacement, so the unsent text is held in
|
|
137
|
-
* the notice instead. */
|
|
138
|
-
restored: boolean;
|
|
139
|
-
}
|
|
140
|
-
/**
|
|
141
|
-
* One `/` command the composer offers. Typing `/` at position 0 opens the
|
|
142
|
-
* command menu; the rest of the token filters it (the same prefix > substring
|
|
143
|
-
* > token-order ranking as the command palette). Picking a command CLEARS the
|
|
144
|
-
* token from the draft and calls `run` — what the command does (a route, a
|
|
145
|
-
* dialog, a draft transformation) is the product's business.
|
|
146
|
-
*/
|
|
147
|
-
export interface SlashCommand {
|
|
148
|
-
/** Command name without the leading slash: `model`, `clear`. */
|
|
149
|
-
name: string;
|
|
150
|
-
/** One line of what it does, rendered beside the name. */
|
|
151
|
-
description: string;
|
|
152
|
-
run: () => void;
|
|
153
|
-
}
|
|
154
|
-
/** A skill the host has made eligible for this turn. The id is the value the
|
|
155
|
-
* host validates and sends; the name and description are display metadata. */
|
|
156
|
-
export interface ComposerSkillOption {
|
|
157
|
-
id: string;
|
|
158
|
-
name: string;
|
|
159
|
-
description: string;
|
|
160
|
-
}
|
|
161
|
-
export interface ChatComposerProps {
|
|
162
|
-
/** Send the trimmed message, or an empty message when a skill is selected.
|
|
163
|
-
* Attached files travel separately via
|
|
164
|
-
* `onAttach` + `pendingFiles` (the host consumes and clears them on send).
|
|
165
|
-
* Optional when `onSendParts` is wired.
|
|
166
|
-
*
|
|
167
|
-
* Report a refused send by throwing, rejecting, or returning `{ ok: false }`
|
|
168
|
-
* — the composer restores the draft rather than losing it. */
|
|
169
|
-
onSend?: ComposerSendHandler;
|
|
170
|
-
/** Parts-aware send: receives the trimmed message plus the `part`
|
|
171
|
-
* descriptors of every `ready` pending file. Takes precedence over
|
|
172
|
-
* `onSend`; enables file-only sends (empty text, ≥1 ready part).
|
|
173
|
-
*
|
|
174
|
-
* Same rejection contract as `onSend`. */
|
|
175
|
-
onSendParts?: ComposerSendPartsHandler;
|
|
176
|
-
/** Notified when a send is rejected, after the composer has restored what it
|
|
177
|
-
* owns. The host uses it to put back the `pendingFiles` it consumed. */
|
|
178
|
-
onSendFailed?: (failure: ComposerSendFailure) => void;
|
|
179
|
-
/** Notice copy when the handler names no reason of its own. */
|
|
180
|
-
sendFailureMessage?: string;
|
|
181
|
-
/** Stop the in-flight turn; shown in place of Send while `isStreaming`. */
|
|
182
|
-
onCancel?: () => void;
|
|
183
|
-
isStreaming?: boolean;
|
|
184
|
-
/** Block input + send (e.g. while restoring). Distinct from `isStreaming`,
|
|
185
|
-
* which keeps the textarea editable so the next turn can be composed. */
|
|
186
|
-
disabled?: boolean;
|
|
187
|
-
/** Block sending while keeping the draft editable (e.g. model choices load). */
|
|
188
|
-
sendDisabled?: boolean;
|
|
189
|
-
placeholder?: string;
|
|
190
|
-
/** Controlled value. Omit for self-managed internal state (cleared on send). */
|
|
191
|
-
value?: string;
|
|
192
|
-
onValueChange?: (value: string) => void;
|
|
193
|
-
/** Initial text in uncontrolled mode; ignored when `value` is provided. */
|
|
194
|
-
initialValue?: string;
|
|
195
|
-
/** One-shot external prefill: when this becomes a non-null string the
|
|
196
|
-
* composer adopts it as the draft (replacing any current draft), focuses the
|
|
197
|
-
* input with the caret at the end, and reports consumption via
|
|
198
|
-
* `onSeedApplied` so the host can clear its seed state. */
|
|
199
|
-
seed?: string | null;
|
|
200
|
-
onSeedApplied?: () => void;
|
|
201
|
-
/** Inline controls (e.g. `<ModelPicker/>` + `<EffortPicker/>` or
|
|
202
|
-
* `<AgentSessionControls/>`). */
|
|
203
|
-
controls?: ReactNode;
|
|
204
|
-
/**
|
|
205
|
-
* Where {@link controls} sit. `inline` (default) puts them on the card's own
|
|
206
|
-
* action row, beside attach and Send — the model a turn will use reads as
|
|
207
|
-
* part of the input rather than as a separate widget floating above it.
|
|
208
|
-
* `above` keeps them outside the card, for a host that wants the input to be
|
|
209
|
-
* nothing but the input.
|
|
210
|
-
*/
|
|
211
|
-
controlsPlacement?: 'above' | 'inline';
|
|
212
|
-
/** Attachments are opt-in: pass `onAttach` to show the attach button, accept
|
|
213
|
-
* drag-and-drop and clipboard paste onto the input, and render
|
|
214
|
-
* `pendingFiles` chips. */
|
|
215
|
-
onAttach?: (files: FileList) => void;
|
|
216
|
-
onAttachFolder?: (files: FileList) => void;
|
|
217
|
-
pendingFiles?: ComposerFile[];
|
|
218
|
-
onRemoveFile?: (id: string) => void;
|
|
219
|
-
/** Pass it and a chip with `status: 'error'` gains a retry button. */
|
|
220
|
-
onRetryFile?: (id: string) => void;
|
|
221
|
-
/**
|
|
222
|
-
* File types the composer takes, in the native `<input accept>` grammar.
|
|
223
|
-
* Enforced on every ingress route — the picker dialog (which the user can
|
|
224
|
-
* override with "All Files"), drag-and-drop, and clipboard paste — so a type
|
|
225
|
-
* the picker will not offer cannot arrive by another route. A non-matching
|
|
226
|
-
* file goes to `onRejectFiles` and never reaches `onAttach`. Folder attach is
|
|
227
|
-
* exempt: directory selection has no native accept semantics.
|
|
228
|
-
*/
|
|
229
|
-
accept?: string;
|
|
230
|
-
/** Called with the files `accept` removed from a pick, drop, or paste, each
|
|
231
|
-
* with a reason. Without it a refusal is silent — the same feedback the
|
|
232
|
-
* native picker gives for a type it will not offer. */
|
|
233
|
-
onRejectFiles?: (rejections: ComposerFileRejection[]) => void;
|
|
234
|
-
dropTitle?: string;
|
|
235
|
-
dropDescription?: string;
|
|
236
|
-
/** Context the agent will see beside the next message, as its own chip row
|
|
237
|
-
* above the input. */
|
|
238
|
-
contextItems?: ReadonlyArray<ComposerContextItem>;
|
|
239
|
-
/**
|
|
240
|
-
* Let a staged file stand in for message text, so the send control stays live
|
|
241
|
-
* while an upload is in flight instead of going dead with nothing to explain
|
|
242
|
-
* it. Default false, where an empty message needs a `ready` file.
|
|
243
|
-
*
|
|
244
|
-
* It does NOT make an unfinished file sendable. A turn whose only content is a
|
|
245
|
-
* file that is still uploading or has failed never reaches the send handler —
|
|
246
|
-
* it would arrive empty and the attachment would be lost. The composer
|
|
247
|
-
* refuses it and names the reason in its notice
|
|
248
|
-
* ({@link attachmentsNotReadyMessage}). So the flag decides whether the
|
|
249
|
-
* control is live, and the composer keeps the integrity gate rather than
|
|
250
|
-
* leaving each host to re-derive it.
|
|
251
|
-
*/
|
|
252
|
-
canSubmitAttachmentsOnly?: boolean;
|
|
253
|
-
/** Notice copy when a send is refused because no staged file is ready yet.
|
|
254
|
-
* Defaults to wording chosen from whether a file failed or is still
|
|
255
|
-
* uploading. */
|
|
256
|
-
attachmentsNotReadyMessage?: string;
|
|
257
|
-
/**
|
|
258
|
-
* Let Enter and Send keep firing while `isStreaming`, for a surface that
|
|
259
|
-
* queues the next turn rather than blocking on the current one. Default
|
|
260
|
-
* false. The button still flips to Stop while a turn streams, so this opens
|
|
261
|
-
* the keyboard path, not a second button.
|
|
262
|
-
*/
|
|
263
|
-
canSubmitWhileBusy?: boolean;
|
|
264
|
-
/** Focus the input on mount — for a surface whose whole job is the input
|
|
265
|
-
* (an entry/hero composer), never for one docked under a transcript. */
|
|
266
|
-
autoFocus?: boolean;
|
|
267
|
-
/** Rows the input shows before it grows. Default 2. */
|
|
268
|
-
minRows?: number;
|
|
269
|
-
/** Pixel height the input grows to before it scrolls. Default 168. */
|
|
270
|
-
maxHeight?: number;
|
|
271
|
-
/** Content between the controls slot and Send — a token meter, a cost, a
|
|
272
|
-
* status line, a model picker. It sits outside the controls slot, so a
|
|
273
|
-
* wrapping picker set cannot push it away; it travels with Send onto its
|
|
274
|
-
* own line when the row is too narrow for both, and wraps inside that line
|
|
275
|
-
* rather than overflowing the card. */
|
|
276
|
-
trailing?: ReactNode;
|
|
277
|
-
/**
|
|
278
|
-
* Opt-in `@`-mentions. Present ⇒ the textarea is swapped for a lazily
|
|
279
|
-
* loaded TipTap rich input that renders mentions as atomic pills and
|
|
280
|
-
* serializes them to `@<id>` in the value; absent ⇒ exactly the plain
|
|
281
|
-
* textarea, with no TipTap in the bundle. Wire `useFileMentions().mention`
|
|
282
|
-
* straight in. The six `@tiptap/*` packages (core, extension-mention, pm,
|
|
283
|
-
* react, starter-kit, suggestion) are OPTIONAL peers — a consumer installs
|
|
284
|
-
* them to use this prop.
|
|
285
|
-
*
|
|
286
|
-
* General `slashCommands` remain disabled while `mention` is set; the
|
|
287
|
-
* skill picker has explicit keyboard handling in both input modes. Seed and
|
|
288
|
-
* failed-send drafts still apply in mention mode, but caret placement (a
|
|
289
|
-
* textarea affordance) degrades to content-only.
|
|
290
|
-
*/
|
|
291
|
-
mention?: ComposerMentionProp;
|
|
292
|
-
/** `/` commands offered when the draft is exactly a leading slash token.
|
|
293
|
-
* Omit (or pass []) and `/` types as ordinary text. Inert while `mention`
|
|
294
|
-
* is set — see {@link mention}. */
|
|
295
|
-
slashCommands?: SlashCommand[];
|
|
296
|
-
/** Skills available in the current authenticated workspace and harness.
|
|
297
|
-
* The host resolves eligibility; this list only drives selection UI. */
|
|
298
|
-
eligibleSkills?: ReadonlyArray<ComposerSkillOption>;
|
|
299
|
-
/** The host-owned skill selected for the next turn. */
|
|
300
|
-
selectedSkillId?: string | null;
|
|
301
|
-
/** Picking or removing a skill reports its typed id and display metadata.
|
|
302
|
-
* The host persists selection through queued turns and rejected sends. */
|
|
303
|
-
onSelectedSkillChange?: (skill: ComposerSkillOption | null) => void;
|
|
304
|
-
/** Dictation is opt-in: pass `onDictate` and the action row gains a mic
|
|
305
|
-
* button (browsers without `MediaRecorder`/`getUserMedia` render none).
|
|
306
|
-
* Click starts the capture; the button flips to a stop control with the
|
|
307
|
-
* running elapsed seconds; stop hands the recorded audio blob here. The
|
|
308
|
-
* composer owns capture only — turning the audio into text (e.g. the
|
|
309
|
-
* Whisper provider from `sequences-react`) is the host's. */
|
|
310
|
-
onDictate?: (audio: DictationAudio) => void;
|
|
311
|
-
/** Capture failures (a denied mic prompt, no device), after the composer has
|
|
312
|
-
* shown its own dismissible notice. For hosts that log or track. */
|
|
313
|
-
onDictateError?: (message: string) => void;
|
|
314
|
-
/** Cmd/Ctrl+L focuses the input and shows the hint. Default true. */
|
|
315
|
-
focusShortcut?: boolean;
|
|
316
|
-
/** Called when focus enters the composer: the input or any of its controls.
|
|
317
|
-
* Default: the surrounding workspace shell's prewarm `reassert`
|
|
318
|
-
* (`AgentWorkspaceLayout` with `prewarm`), so a box that suspended while the
|
|
319
|
-
* tab sat open starts resuming before the member sends. */
|
|
320
|
-
onFocusWithin?: () => void;
|
|
321
|
-
/** Float the card on a soft two-layer foreground-tinted shadow (opt-in).
|
|
322
|
-
* Elevation only — radius, ring, and control layout are unchanged. */
|
|
323
|
-
floating?: boolean;
|
|
324
|
-
/** Send button label. Default "Send". */
|
|
325
|
-
sendLabel?: string;
|
|
326
|
-
/** Send control shape. `pill` (default) is the labeled button; `icon` is the
|
|
327
|
-
* 34px circular inverted arrow (streaming: circular outlined stop) — the
|
|
328
|
-
* grammar sandbox-ui's legacy AgentComposer used and the current agent-app
|
|
329
|
-
* canon for new surfaces. */
|
|
330
|
-
sendVariant?: 'pill' | 'icon';
|
|
331
|
-
/** Circular icon send colour. `contrast` (default) preserves the inverted
|
|
332
|
-
* foreground/background canon; `primary` opts into the host brand tokens.
|
|
333
|
-
* The labeled pill already uses primary and is unchanged. */
|
|
334
|
-
sendTone?: 'contrast' | 'primary';
|
|
335
|
-
className?: string;
|
|
336
|
-
}
|
|
37
|
+
import type { ChatComposerProps } from './chat-composer-types';
|
|
38
|
+
export * from './chat-composer-types';
|
|
337
39
|
export declare function ChatComposer({ onSend, onSendParts, onSendFailed, sendFailureMessage, onCancel, isStreaming, disabled, sendDisabled, 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, mention, slashCommands, eligibleSkills, selectedSkillId, onSelectedSkillChange, onDictate, onDictateError, focusShortcut, onFocusWithin, floating, sendLabel, sendVariant, sendTone, className, }: ChatComposerProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
import type { ReactNode } from 'react';
|
|
2
|
+
/** One starting "door" in the chat first-run state — a concrete, labeled action
|
|
3
|
+
* (start from a template, do it by hand, ask the agent), not a placeholder. */
|
|
4
|
+
export interface ChatEmptyDoor {
|
|
5
|
+
label: string;
|
|
6
|
+
description?: string;
|
|
7
|
+
onSelect: () => void;
|
|
8
|
+
/** Optional glyph rendered left of the label. */
|
|
9
|
+
icon?: ReactNode;
|
|
10
|
+
}
|
|
11
|
+
/** Define properties for rendering the chat empty state with customizable text and starting doors */
|
|
12
|
+
export interface ChatEmptyStateProps {
|
|
13
|
+
/** Product name shown next to the Tangle mark. Default "Agent". */
|
|
14
|
+
productName?: string;
|
|
15
|
+
/** Headline. Default frames delegation, not messaging. */
|
|
16
|
+
headline?: string;
|
|
17
|
+
/** Subline under the headline. */
|
|
18
|
+
subline?: string;
|
|
19
|
+
/** Up to three concrete starting doors. Omit for a mark-and-prompt-only state. */
|
|
20
|
+
doors?: ChatEmptyDoor[];
|
|
21
|
+
}
|
|
22
|
+
/**
|
|
23
|
+
* Branded chat first-run state: the Tangle mark, a delegation-framed prompt, and
|
|
24
|
+
* up to three concrete doors. Replaces the blank thread that read as "empty or
|
|
25
|
+
* broken". Concrete + actionable — never a "coming soon" placeholder.
|
|
26
|
+
*/
|
|
27
|
+
export declare function ChatEmptyState({ productName, headline, subline, doors, }: ChatEmptyStateProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
/** Chronological text, tool, and notice segments within one turn. */
|
|
2
|
+
import { type ReactNode } from 'react';
|
|
3
|
+
import type { ChatToolCallInfo, ChatUiMessage, ChatMessageSegment, ProposalApprovalHandlers, ToolDetailRenderers } from './chat-message-types';
|
|
4
|
+
/** The blinking insertion caret shown at the end of streaming answer text.
|
|
5
|
+
* Shared by the segmented and legacy branches so their streaming cue can't
|
|
6
|
+
* visually diverge. */
|
|
7
|
+
export declare function StreamingCaret(): import("react").JSX.Element;
|
|
8
|
+
/** Renders a turn's ordered text/tool segments interleaved. The trailing text
|
|
9
|
+
* run carries the streaming caret; if the last segment is instead a tool, a
|
|
10
|
+
* trailing caret keeps the gap before the next run from looking frozen. Any
|
|
11
|
+
* `toolCalls` not represented in `segments` (a partially-migrated producer that
|
|
12
|
+
* set both) still render, so a tool row is never silently dropped. A settled
|
|
13
|
+
* run of many tool calls collapses into one disclosure — see below. */
|
|
14
|
+
export declare function SegmentedBody({ segments, msg, streaming, renderBody, approval, onToolCallClick, toolRenderers, messageClassName, }: {
|
|
15
|
+
segments: ChatMessageSegment[];
|
|
16
|
+
msg: ChatUiMessage;
|
|
17
|
+
streaming: boolean;
|
|
18
|
+
renderBody: (content: string) => ReactNode;
|
|
19
|
+
approval?: ProposalApprovalHandlers;
|
|
20
|
+
onToolCallClick?: (call: ChatToolCallInfo, message: ChatUiMessage) => void;
|
|
21
|
+
toolRenderers?: ToolDetailRenderers;
|
|
22
|
+
messageClassName: string;
|
|
23
|
+
}): import("react").JSX.Element;
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import type { CatalogModel } from '../runtime/model-catalog';
|
|
2
|
+
import type { ChatMessageMetrics } from './chat-message-types';
|
|
3
|
+
/** "$0.0042" from token counts × catalogue per-token pricing; null when unknown. */
|
|
4
|
+
export declare function formatModelCost(msg: ChatMessageMetrics, models: CatalogModel[]): string | null;
|
|
5
|
+
/** "38 tok/s" from completion tokens over first-token→end duration; null when unknown. */
|
|
6
|
+
export declare function formatTokensPerSecond(msg: ChatMessageMetrics): string | null;
|
|
@@ -0,0 +1,158 @@
|
|
|
1
|
+
/** Message-thread and tool-rendering contracts. */
|
|
2
|
+
import type { ReactNode } from 'react';
|
|
3
|
+
import type { ChatAuthor } from '@tangle-network/ui/types';
|
|
4
|
+
import type { CatalogModel } from '../runtime/model-catalog';
|
|
5
|
+
import type { TurnPhaseData } from '../chat-routes/turn-progress';
|
|
6
|
+
import type { DurableChatCardsProps } from './durable-chat-cards';
|
|
7
|
+
import type { ChatAttachmentPart } from './chat-attachments';
|
|
8
|
+
import type { WorkProductPersistedPart } from '../work-product/types';
|
|
9
|
+
import type { ChatEmptyStateProps } from './chat-empty-state';
|
|
10
|
+
/** Describe metrics related to a chat message including model, token counts, and duration */
|
|
11
|
+
export interface ChatMessageMetrics {
|
|
12
|
+
modelUsed?: string;
|
|
13
|
+
promptTokens?: number;
|
|
14
|
+
completionTokens?: number;
|
|
15
|
+
durationMs?: number;
|
|
16
|
+
}
|
|
17
|
+
/** Describe the structure and state of a tool call within a chat interaction */
|
|
18
|
+
export interface ChatToolCallInfo {
|
|
19
|
+
id: string;
|
|
20
|
+
name: string;
|
|
21
|
+
status: 'running' | 'done' | 'error';
|
|
22
|
+
/** The call arguments, captured from the tool_call event — shown in the
|
|
23
|
+
* expanded card so users see exactly what the agent invoked. */
|
|
24
|
+
args?: Record<string, unknown>;
|
|
25
|
+
/** The tool outcome (`{ok, result}` shape). When `result.status` is
|
|
26
|
+
* 'queued_for_approval' the card renders the approval state. */
|
|
27
|
+
result?: unknown;
|
|
28
|
+
}
|
|
29
|
+
/** One ordered piece of an assistant turn: a run of answer text, or a tool
|
|
30
|
+
* call, in the sequence the agent emitted them. A message carrying `segments`
|
|
31
|
+
* is rendered in order — interleaving text and tool rows — so the agent's
|
|
32
|
+
* pre- and post-tool reasoning reads chronologically instead of as one text
|
|
33
|
+
* blob with the tool rows collected after it. */
|
|
34
|
+
export type ChatMessageSegment = {
|
|
35
|
+
kind: 'text';
|
|
36
|
+
content: string;
|
|
37
|
+
} | {
|
|
38
|
+
kind: 'tool';
|
|
39
|
+
call: ChatToolCallInfo;
|
|
40
|
+
}
|
|
41
|
+
/** An out-of-band transcript notice — a failed turn's error, a warning —
|
|
42
|
+
* rendered in its status tone so it never reads as answer prose. Map a
|
|
43
|
+
* persisted `notice` part (`noticeKind: 'error' | 'warning'`) to this. */
|
|
44
|
+
| {
|
|
45
|
+
kind: 'notice';
|
|
46
|
+
tone: ChatNoticeTone;
|
|
47
|
+
content: string;
|
|
48
|
+
};
|
|
49
|
+
/** Status tone of a {@link ChatMessageSegment} notice. */
|
|
50
|
+
export type ChatNoticeTone = 'error' | 'warning';
|
|
51
|
+
/** Describe the structure and properties of a chat message with roles, content, and optional metadata */
|
|
52
|
+
export interface ChatUiMessage extends ChatMessageMetrics {
|
|
53
|
+
id: string;
|
|
54
|
+
role: 'user' | 'assistant' | 'system';
|
|
55
|
+
content: string;
|
|
56
|
+
/** The model's reasoning for this message, shown in a {@link ReasoningRow} above the answer. */
|
|
57
|
+
reasoning?: string;
|
|
58
|
+
/** When the model started reasoning (epoch ms): `ChatReasoningState.startedAt` from the stream or the saved parts. */
|
|
59
|
+
reasoningStartedAt?: number;
|
|
60
|
+
/** When the reasoning ended (epoch ms). Set, the row reads "Thought for N seconds"; unset while streaming, it is still thinking. */
|
|
61
|
+
reasoningEndedAt?: number;
|
|
62
|
+
toolCalls?: ChatToolCallInfo[];
|
|
63
|
+
/** Ordered text/tool sequence for true chronological interleaving. When
|
|
64
|
+
* present and non-empty it is rendered in place of `content` + `toolCalls`;
|
|
65
|
+
* both remain the fallback for producers that don't segment a turn. */
|
|
66
|
+
segments?: ChatMessageSegment[];
|
|
67
|
+
/** Persisted assistant parts. When `ChatMessages.durableCards` is supplied,
|
|
68
|
+
* shared plan/question cards render directly from these projections. */
|
|
69
|
+
parts?: Array<Record<string, unknown>>;
|
|
70
|
+
/** Who wrote the message, when more than one person shares the thread: a
|
|
71
|
+
* client, an attorney and the agent. A user message whose author is not
|
|
72
|
+
* `ChatMessages.viewerId` is someone else's: start-aligned on a card under
|
|
73
|
+
* their avatar, name and role. An assistant message's author replaces the
|
|
74
|
+
* agent label. Absent → today's rendering, byte-identical. */
|
|
75
|
+
author?: ChatAuthor;
|
|
76
|
+
}
|
|
77
|
+
/** Define properties for rendering chat messages with optional models, markdown, extras, and durable cards */
|
|
78
|
+
export interface ChatMessagesProps {
|
|
79
|
+
messages: ChatUiMessage[];
|
|
80
|
+
/** Shared reading scale for both user and assistant prose. Defaults to 16px
|
|
81
|
+
* at a 1.6 line height; `large` uses 17px at the same leading without
|
|
82
|
+
* enlarging labels, tool chrome, or metadata. */
|
|
83
|
+
messageSize?: 'default' | 'large';
|
|
84
|
+
/** Transcript chrome. `labeled` (default) keeps the always-on role label +
|
|
85
|
+
* model/tok-s/cost meta line and the primary-tinted user bubble. `quiet`
|
|
86
|
+
* drops the label row into a fixed-height meta lane at each row's bottom
|
|
87
|
+
* (copy + the demoted meta, revealed on hover/focus, always visible on
|
|
88
|
+
* touch) and renders user bubbles neutral with a symmetric radius.
|
|
89
|
+
* Everything else — tool rows, reasoning, streaming — is identical. */
|
|
90
|
+
chrome?: 'labeled' | 'quiet';
|
|
91
|
+
/** Catalogue models, for per-message cost from pricing. Pass [] to skip cost. */
|
|
92
|
+
models?: CatalogModel[];
|
|
93
|
+
/** Markdown renderer for assistant content; default renders pre-wrapped text. */
|
|
94
|
+
renderMarkdown?: (content: string) => ReactNode;
|
|
95
|
+
/** Extra per-message content (artifacts, custom panels) appended after the body. */
|
|
96
|
+
renderExtras?: (message: ChatUiMessage) => ReactNode;
|
|
97
|
+
/** Canonical durable plan/question card wiring. Apps inject only transport,
|
|
98
|
+
* access, and optional visual callbacks; card selection/dedupe stays shared. */
|
|
99
|
+
durableCards?: Omit<DurableChatCardsProps, 'parts' | 'renderMarkdown'>;
|
|
100
|
+
userLabel?: string;
|
|
101
|
+
agentLabel?: string;
|
|
102
|
+
/** Render the trailing "agent is thinking" row. */
|
|
103
|
+
loading?: boolean;
|
|
104
|
+
/** The pending turn's latest stage from its `session.run.phase` events. The
|
|
105
|
+
* trailing row shows it in place of "Thinking…" until the first output. */
|
|
106
|
+
turnPhase?: Pick<TurnPhaseData, 'message'> | null;
|
|
107
|
+
/** Approve/Reject handlers for proposals awaiting approval. When omitted the
|
|
108
|
+
* card still shows "awaiting approval" but without action buttons. */
|
|
109
|
+
approval?: ProposalApprovalHandlers;
|
|
110
|
+
/** Open a full-transcript view (e.g. {@link RunDrillIn}) from a tool row's
|
|
111
|
+
* actions slot. */
|
|
112
|
+
onToolCallClick?: (call: ChatToolCallInfo, message: ChatUiMessage) => void;
|
|
113
|
+
/** Per-tool custom detail renderers for the expanded tool row body. */
|
|
114
|
+
toolRenderers?: ToolDetailRenderers;
|
|
115
|
+
/** Stream-error affordance: when the turn failed (a thrown transport error or
|
|
116
|
+
* a loop-level `onErrorEvent`), pass the message here to render an error row.
|
|
117
|
+
* A failed turn otherwise just stops with no UI signal. */
|
|
118
|
+
error?: string | null;
|
|
119
|
+
/** Retry control shown on the error row; omit to render the error without a
|
|
120
|
+
* retry button (e.g. when the product retries automatically). */
|
|
121
|
+
onRetry?: () => void;
|
|
122
|
+
/** Zero-state renderer, shown when there are no messages and the turn is
|
|
123
|
+
* neither loading nor errored. When omitted, a branded first-run state is
|
|
124
|
+
* shown ({@link ChatEmptyState}); pass `() => null` to render nothing. */
|
|
125
|
+
renderEmpty?: () => ReactNode;
|
|
126
|
+
/** First-run state config used when `renderEmpty` is not supplied. Lets a
|
|
127
|
+
* product set the headline and the "doors" (e.g. start from a template, ask
|
|
128
|
+
* the agent) without replacing the whole zero-state. */
|
|
129
|
+
emptyState?: ChatEmptyStateProps;
|
|
130
|
+
/** Optional branded header slot rendered above the thread. Off by default to
|
|
131
|
+
* preserve the current layout; pass `{ title }` (or your own node via
|
|
132
|
+
* `header`) to show the Tangle mark + product title in the chat shell. */
|
|
133
|
+
header?: ReactNode;
|
|
134
|
+
/** Resolve a raw-bytes download URL for one attachment part. When set, any
|
|
135
|
+
* message carrying attachment parts (`file`/`image` parts with a `path`,
|
|
136
|
+
* see `attachmentPartsFromMessageParts`) renders them as a `MessageAttachments`
|
|
137
|
+
* row next to the bubble — thumbnails for images, download chips for files.
|
|
138
|
+
* Absent → today's rendering, byte-identical (no attachment row). */
|
|
139
|
+
resolveAttachmentUrl?: (part: ChatAttachmentPart) => string;
|
|
140
|
+
/** Render persisted `type:'work_product'` anchor parts as `WorkProductCard`
|
|
141
|
+
* rows under the message body — the chat card that keeps chat the driver
|
|
142
|
+
* surface for review. `onOpen` opens the product's queue/detail surface.
|
|
143
|
+
* Absent → today's rendering, byte-identical (no card row). */
|
|
144
|
+
workProductCards?: {
|
|
145
|
+
onOpen?: (part: WorkProductPersistedPart) => void;
|
|
146
|
+
};
|
|
147
|
+
/** The reader's participant id, compared with each user message's
|
|
148
|
+
* `author.id`. A user message without an author is always the reader's. */
|
|
149
|
+
viewerId?: string;
|
|
150
|
+
}
|
|
151
|
+
/** Handle approval and rejection actions for proposals with asynchronous support */
|
|
152
|
+
export interface ProposalApprovalHandlers {
|
|
153
|
+
onApprove: (proposalId: string, toolCallId: string) => void | Promise<void>;
|
|
154
|
+
onReject: (proposalId: string, toolCallId: string) => void | Promise<void>;
|
|
155
|
+
}
|
|
156
|
+
/** Per-tool custom detail renderers for the expanded card body — keyed by
|
|
157
|
+
* tool name. Return null to fall back to the generic detail view. */
|
|
158
|
+
export type ToolDetailRenderers = Record<string, (call: ChatToolCallInfo, message: ChatUiMessage) => ReactNode>;
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import type { ChatMessagesProps } from './chat-message-types';
|
|
2
|
+
/** Whole seconds elapsed while `active`, ticking once a second; counts from
|
|
3
|
+
* when `active` first turns true and freezes when it clears. Kept for
|
|
4
|
+
* existing consumers: `ReasoningRow` times reasoning from the stream's own
|
|
5
|
+
* start instead. */
|
|
6
|
+
export declare function useThinkingSeconds(active: boolean): number;
|
|
7
|
+
/**
|
|
8
|
+
* The message thread: one centered column; user messages are right-aligned
|
|
9
|
+
* bubbles with a User label; agent messages carry an Agent meta line with
|
|
10
|
+
* model id, tokens/sec, and cost, plus a collapsible thinking section and
|
|
11
|
+
* tool rows. `chrome="quiet"` opts into the label-free variant: the
|
|
12
|
+
* label/meta row becomes a hover-revealed meta lane under each row.
|
|
13
|
+
* A thread shared by several people passes each message's `author` and the
|
|
14
|
+
* reader's `viewerId`: the reader's own messages stay right-aligned, everyone
|
|
15
|
+
* else's are named, and a named agent replaces the agent label.
|
|
16
|
+
*/
|
|
17
|
+
export declare function ChatMessages({ messages, messageSize, chrome, models, renderMarkdown, renderExtras, durableCards, userLabel, agentLabel, loading, turnPhase, approval, onToolCallClick, toolRenderers, error, onRetry, renderEmpty, emptyState, header, resolveAttachmentUrl, workProductCards, viewerId, }: ChatMessagesProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import type { ToolPart } from '@tangle-network/ui/types';
|
|
2
|
+
import type { ChatToolCallInfo, ChatUiMessage, ProposalApprovalHandlers, ToolDetailRenderers } from './chat-message-types';
|
|
3
|
+
/** Extract `{proposalId, status}` from a tool outcome when it is a proposal
|
|
4
|
+
* awaiting human approval; null otherwise. */
|
|
5
|
+
export declare function pendingApprovalOf(call: ChatToolCallInfo): {
|
|
6
|
+
proposalId: string;
|
|
7
|
+
} | null;
|
|
8
|
+
/** A call that failed — by status OR by an `ok:false` outcome envelope. Shared
|
|
9
|
+
* by the row adapter, the collapse guard, and the card itself so the three can
|
|
10
|
+
* never disagree about what "failed" means. */
|
|
11
|
+
export declare function toolCallFailed(call: ChatToolCallInfo): boolean;
|
|
12
|
+
/**
|
|
13
|
+
* Adapt a chat tool call to the canonical `@tangle-network/ui` `ToolPart`, so
|
|
14
|
+
* the row renders through ui's `InlineToolItem` — one run-row grammar shared
|
|
15
|
+
* with every other Tangle run view (the same adapter pattern ui's own
|
|
16
|
+
* `ToolCallStep` uses for its flat props). `sandbox_run_command` maps to ui's
|
|
17
|
+
* canonical `bash` name so the row takes the command category (terminal icon);
|
|
18
|
+
* every other tool keeps its real name. agent-app carries no per-call timings,
|
|
19
|
+
* so `state.time` stays unset and the row shows no duration.
|
|
20
|
+
*/
|
|
21
|
+
export declare function chatToolCallPart(call: ChatToolCallInfo): ToolPart;
|
|
22
|
+
export declare function ToolCallCard({ call, message, approval, onOpenRun, renderers, staggerIndex, }: {
|
|
23
|
+
call: ChatToolCallInfo;
|
|
24
|
+
message: ChatUiMessage;
|
|
25
|
+
approval?: ProposalApprovalHandlers;
|
|
26
|
+
onOpenRun?: (call: ChatToolCallInfo, message: ChatUiMessage) => void;
|
|
27
|
+
renderers?: ToolDetailRenderers;
|
|
28
|
+
/** Position in the surrounding run, so a group of rows arrives as a
|
|
29
|
+
* sequence. Frozen at mount by `useArrivalStyle`. */
|
|
30
|
+
staggerIndex?: number;
|
|
31
|
+
}): import("react").JSX.Element;
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
/** Inline action glyphs for the message composer. */
|
|
2
|
+
export declare function SendGlyph({ className }: {
|
|
3
|
+
className?: string;
|
|
4
|
+
}): import("react").JSX.Element;
|
|
5
|
+
export declare function StopGlyph({ className }: {
|
|
6
|
+
className?: string;
|
|
7
|
+
}): import("react").JSX.Element;
|
|
8
|
+
export declare function ArrowUpGlyph({ className }: {
|
|
9
|
+
className?: string;
|
|
10
|
+
}): import("react").JSX.Element;
|
|
11
|
+
export declare function PaperclipGlyph({ className }: {
|
|
12
|
+
className?: string;
|
|
13
|
+
}): import("react").JSX.Element;
|
|
14
|
+
export declare function FolderGlyph({ className }: {
|
|
15
|
+
className?: string;
|
|
16
|
+
}): import("react").JSX.Element;
|
|
17
|
+
export declare function CloseGlyph({ className }: {
|
|
18
|
+
className?: string;
|
|
19
|
+
}): import("react").JSX.Element;
|
|
20
|
+
export declare function RetryGlyph({ className }: {
|
|
21
|
+
className?: string;
|
|
22
|
+
}): import("react").JSX.Element;
|
|
23
|
+
export declare function UploadGlyph({ className }: {
|
|
24
|
+
className?: string;
|
|
25
|
+
}): import("react").JSX.Element;
|
|
26
|
+
export declare function MicGlyph({ className }: {
|
|
27
|
+
className?: string;
|
|
28
|
+
}): import("react").JSX.Element;
|