@tangle-network/agent-app 0.45.28 → 0.45.30

package/dist/{DesignCanvas-3RRPVPCP.js → DesignCanvas-RSWQCXM3.js}

@@ -1,10 +1,10 @@
 import {
   DesignCanvas
-} from "./chunk-NC2V63EL.js";
+} from "./chunk-FNM7JYME.js";
 import "./chunk-X5DQ5QOP.js";
 import "./chunk-DRB77FYL.js";
 import "./chunk-F7VH4G5C.js";
 export {
   DesignCanvas
 };
-//# sourceMappingURL=DesignCanvas-3RRPVPCP.js.map
+//# sourceMappingURL=DesignCanvas-RSWQCXM3.js.map

package/dist/{DesignCanvasEditor-KAMMEX7E.js → DesignCanvasEditor-XZMGIST7.js}

@@ -1,13 +1,13 @@
 import {
   DesignCanvasEditor
-} from "./chunk-OYGM5WLD.js";
-import "./chunk-NC2V63EL.js";
+} from "./chunk-PURHUAOR.js";
+import "./chunk-FNM7JYME.js";
 import "./chunk-LSQR6HM6.js";
-import "./chunk-4QVG4WJQ.js";
+import "./chunk-OYTMILRK.js";
 import "./chunk-X5DQ5QOP.js";
 import "./chunk-DRB77FYL.js";
 import "./chunk-F7VH4G5C.js";
 export {
   DesignCanvasEditor
 };
-//# sourceMappingURL=DesignCanvasEditor-KAMMEX7E.js.map
+//# sourceMappingURL=DesignCanvasEditor-XZMGIST7.js.map

package/dist/{use-file-mentions-CZ-Ua_sb.d.ts → agent-session-controls-BwImzYKC.d.ts}

@@ -1,5 +1,8 @@
+import * as react from 'react';
 import { ReactNode } from 'react';
 import { F as FileMention } from './wire-DOZ-O6hD.js';
+import { Harness } from './harness/index.js';
+import { CatalogModel } from './catalog/index.js';
 
 /**
  * `useFileMentions` — the glue a host passes straight into `AgentComposer`'s
@@ -95,4 +98,32 @@ interface UseFileMentionsResult {
 /** Resolve and manage file mention data with configurable fetching and state handling */
 declare function useFileMentions(options: UseFileMentionsOptions): UseFileMentionsResult;
 
-export { type ComposerMentionProp as C, DEFAULT_MENTION_EMPTY_TEXT as D, INDEX_REFRESH_AFTER_MS as I, type MentionItem as M, type UseFileMentionsResult as U, DEFAULT_MENTION_LIMIT as a, type UseFileMentionsOptions as b, rankFileMentions as r, useFileMentions as u };
+interface AgentSessionControlsProps {
+    /** Catalog models — canonical provider-prefixed ids. */
+    models: CatalogModel[];
+    modelsLoading?: boolean;
+    /** Selected canonical model id. */
+    model: string;
+    onModelChange(modelId: string): void;
+    /** Current harness; harness↔model coherence is enforced on every change. */
+    harness: Harness;
+    onHarnessChange(harness: Harness): void;
+    /** Harnesses to offer; defaults to the labeled set. */
+    availableHarnesses?: ReadonlyArray<Harness>;
+    /** Reasoning-effort value + setter. Shown only when the selected model
+     *  `supportsReasoning`, matching `EffortPicker`'s guidance. */
+    effort: string;
+    onEffortChange(effort: string): void;
+    /**
+     * `inline` (default): model, harness, effort side by side — the prior
+     * behavior. `compact`: model inline, harness + effort behind a gear popover.
+     */
+    layout?: 'inline' | 'compact';
+    /** Hide the harness control entirely (single-harness products). */
+    showHarness?: boolean;
+    renderProviderBadge?: (provider: string) => ReactNode;
+    className?: string;
+}
+declare function AgentSessionControls(props: AgentSessionControlsProps): react.JSX.Element;
+
+export { type AgentSessionControlsProps as A, type ComposerMentionProp as C, DEFAULT_MENTION_EMPTY_TEXT as D, INDEX_REFRESH_AFTER_MS as I, type MentionItem as M, type UseFileMentionsResult as U, AgentSessionControls as a, DEFAULT_MENTION_LIMIT as b, type UseFileMentionsOptions as c, rankFileMentions as r, useFileMentions as u };

package/dist/alerting/index.d.ts

@@ -0,0 +1,178 @@
+/**
+ * `/alerting` — post an operational alert to Slack, and say honestly when it
+ * did not arrive.
+ *
+ * WHY THIS EXISTS: on 2026-08-06 an audit of every Slack credential the org
+ * held found three of four dead — the fleet incoming webhook 404ing
+ * (`no_service`), a second company webhook likewise, and the bot token
+ * answering `account_inactive`. One ops webhook was still live. Nobody knew
+ * which was which until each was tested by hand, and that is the actual
+ * problem: the credentials were indistinguishable from where the code stood.
+ *
+ * This failure has already been paid for once, with numbers: in
+ * `agent-dev-container`, a revoked webhook let the CI healthcheck sit dead for
+ * 18 days — 2,567 consecutive failures, 27 successes, zero alerts — because
+ * fifteen call sites across six workflows posted with no body inspection and
+ * then asserted delivery. That repo fixed the reporting (its `post-slack.sh`
+ * confirms 2xx AND Slack's literal `ok` body, and fails closed otherwise) and
+ * that half of the lesson is theirs, adopted here.
+ *
+ * What their fix cannot do, and this module can, is answer the question BEFORE
+ * an alert needs to fire. A fail-closed post still only discovers a dead
+ * credential at the moment a page is lost. That is the second half.
+ *
+ * Two design consequences, and they are the whole module:
+ *
+ * 1. **A bot token and `chat.postMessage` is the preferred transport; an
+ *    incoming webhook is supported because one is usually what you already
+ *    have.** A token reaches every channel (a webhook is bolted to one), is
+ *    revocable and rotatable in place, and — the part that matters — is
+ *    VERIFIABLE: `auth.test` answers whether the credential is alive without
+ *    posting anything, which is what lets `/preflight` fail a deploy on a dead
+ *    alerting channel instead of discovering it during an incident. A webhook
+ *    can only be tested by posting to it, which is why the three dead
+ *    credentials above went unnoticed. A token is never fallen back FROM: if
+ *    one is configured and dead, delivering over a webhook instead would hide
+ *    the very condition worth reporting.
+ *
+ * 2. **Slack answers `ok:false` under HTTP 200.** `invalid_auth`,
+ *    `channel_not_found` and `not_in_channel` all arrive as a successful
+ *    response with a failure inside it, so a status check reads a dead channel
+ *    as a delivered page. The body is always parsed, and the outcome
+ *    distinguishes a MISSING credential (configuration absent — not an
+ *    incident) from a DEAD one (the alerting channel itself is broken — the
+ *    loudest thing this module can report). A summary that calls those two the
+ *    same thing is the defect wearing a different hat.
+ *
+ * The caller decides what to do with a non-delivery; this module never throws
+ * on one, because an alerting path that can take down the thing it reports on
+ * is worse than the outage it was watching for. It is also never the only
+ * channel: a durable record (an issue, an audit row) is the caller's job, and
+ * that is what survives the credential going dead again.
+ *
+ * Server-only: holds a bot token. This subpath must never reach a browser
+ * bundle.
+ */
+/**
+ * Why an alert did not reach Slack. The split is by what a human must DO about
+ * it, since that is the only distinction a caller can act on.
+ */
+type SlackFailureReason = 
+/** No token or no channel configured. Configuration is absent, nothing is broken. */
+'not-configured'
+/**
+ * The token is dead — revoked, or its app removed from the workspace. No
+ * alert will EVER arrive until a human mints a new one. This is itself an
+ * incident and the caller should escalate it on a channel that does not
+ * depend on Slack.
+ */
+ | 'credential'
+/**
+ * The credential is alive but cannot post HERE: the channel is wrong,
+ * archived, or the bot was never invited to it. One human action fixes it.
+ */
+ | 'channel'
+/** Slack asked us to slow down. Transient; the alert is worth retrying. */
+ | 'rate-limited'
+/** The request never got an answer — network, DNS, timeout. Transient. */
+ | 'transport'
+/** Slack refused for some other reason; `detail` carries its error code. */
+ | 'api';
+/** An alert that did not arrive, and why. Named because the classifiers only ever produce this half. */
+interface SlackAlertFailure {
+    delivered: false;
+    reason: SlackFailureReason;
+    /** One line naming what is wrong and what fixes it. Safe to log; carries no token. */
+    detail: string;
+}
+/** What one `postSlackAlert` call did. Never a bare boolean — the caller pages differently per reason. */
+type SlackAlertOutcome = {
+    delivered: true;
+    /** The channel id Slack resolved (not necessarily the name that was passed). */
+    channel: string;
+    /** Slack's message timestamp — the message's identity, for a later thread reply. */
+    ts: string;
+} | SlackAlertFailure;
+/** Define configuration options for posting an alert message to a Slack channel */
+interface SlackAlertOptions {
+    /**
+     * Slack bot token (`xoxb-…`) with `chat:write`. The PREFERRED transport,
+     * because it is the only one whose liveness can be checked before an alert
+     * needs it. An empty or absent value is `not-configured`, never an error — a
+     * product that has not adopted Slack yet must not fail its alerting path.
+     */
+    token?: string | undefined;
+    /**
+     * Channel to post to: a name (`#infra-alerts`) or an id (`C01234567`). The
+     * bot must be a member; Slack answers `not_in_channel` otherwise. Required
+     * with `token`, meaningless with `webhookUrl` (a webhook carries its own
+     * channel, fixed when it was created).
+     */
+    channel?: string | undefined;
+    /**
+     * Slack incoming-webhook URL, used only when no `token` is configured.
+     *
+     * It works and it needs no setup, which is why it is supported — but it
+     * cannot be verified without posting, cannot be pointed at a second channel,
+     * and gives back an error token instead of a code. Two of the three webhooks
+     * this org has held were found revoked. Treat it as the transport you have,
+     * not the one you want.
+     *
+     * When a `token` is also configured this is IGNORED rather than used as a
+     * fallback: a dead token must surface as the incident it is, and quietly
+     * succeeding over a second transport is how the last outage stayed invisible.
+     */
+    webhookUrl?: string | undefined;
+    /** Message body as Slack mrkdwn. Newlines are preserved. */
+    text: string;
+    /**
+     * Attempts for a TRANSIENT failure (429 / 5xx / transport). Default 3. A
+     * dead credential or a wrong channel is never retried — the answer will not
+     * change, and retrying an auth failure is how a token gets rate-limited.
+     */
+    attempts?: number;
+    /** Per-request deadline. Default 10s. */
+    timeoutMs?: number;
+    /** Injection seam for tests; defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+    /** Injection seam for tests; defaults to a real delay between retries. */
+    sleepImpl?: (ms: number) => Promise<void>;
+}
+/**
+ * Post one alert to a Slack channel.
+ *
+ * Never throws and never retries a failure whose answer cannot change. The
+ * returned outcome is the whole result — a caller that ignores it has an
+ * alerting path it cannot prove works, which is the failure this module was
+ * written for.
+ */
+declare function postSlackAlert(options: SlackAlertOptions): Promise<SlackAlertOutcome>;
+/** Define configuration options for verifying that a Slack bot token is live */
+interface SlackCredentialCheckOptions {
+    token: string | undefined;
+    /** Per-request deadline. Default 10s. */
+    timeoutMs?: number;
+    /** Injection seam for tests; defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/** What `checkSlackCredential` concluded. `team`/`botId` are present only when live. */
+type SlackCredentialVerdict = {
+    live: true;
+    team: string;
+    botId: string;
+} | {
+    live: false;
+    reason: SlackFailureReason;
+    detail: string;
+};
+/**
+ * Ask Slack whether the bot token is alive, WITHOUT posting anything.
+ *
+ * This is the check that was missing. An incoming webhook offers no equivalent
+ * — the only way to test one is to post to it — which is how a revoked webhook
+ * sat in a repo secret for months looking configured. Wire it into `/preflight`
+ * so a dead alerting channel fails a deploy rather than an incident.
+ */
+declare function checkSlackCredential(options: SlackCredentialCheckOptions): Promise<SlackCredentialVerdict>;
+
+export { type SlackAlertFailure, type SlackAlertOptions, type SlackAlertOutcome, type SlackCredentialCheckOptions, type SlackCredentialVerdict, type SlackFailureReason, checkSlackCredential, postSlackAlert };

package/dist/alerting/index.js

@@ -0,0 +1,9 @@
+import {
+  checkSlackCredential,
+  postSlackAlert
+} from "../chunk-COP2K4LF.js";
+export {
+  checkSlackCredential,
+  postSlackAlert
+};
+//# sourceMappingURL=index.js.map

package/dist/alerting/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/assistant/index.d.ts

@@ -1,13 +1,15 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { ToolDetailRenderers, ChatUiMessage } from '../web-react/index.js';
+import { ToolDetailRenderers, ComposerFile, ChatUiMessage } from '../web-react/index.js';
 import '../contract-OxG_jVMx.js';
 import '@tangle-network/agent-interface';
 import '../plans/index.js';
 import '../parts-BqIHMdyu.js';
 import '../types-CCeYywdS.js';
 import '../wire-DOZ-O6hD.js';
-import '../use-file-mentions-CZ-Ua_sb.js';
+import '../agent-session-controls-BwImzYKC.js';
+import '../harness/index.js';
+import '../catalog/index.js';
 import '../agent-activity-C8ZG0F0M.js';
 import '../flow-types-CJxEmaRy.js';
 import '../queue-VTBA5ONX.js';
@@ -16,8 +18,6 @@ import '../billing-BibxgALe.js';
 import '../billing/index.js';
 import '../session-shell/index.js';
 import '../web-react/async/index.js';
-import '../catalog/index.js';
-import '../harness/index.js';
 import '../attachment-validation-BfJDBU1g.js';
 import '../stream-normalizer-DKRxyVlZ.js';
 
@@ -609,43 +609,6 @@ interface AssistantThreads {
 /** Resolve and manage assistant threads state for a given user including pending deletions and refresh logic */
 declare function useAssistantThreads(userId: string | null): AssistantThreads;
 
-interface AssistantDockProps {
-    /** The signed-in user this conversation belongs to (null when signed out). */
-    userId: string | null;
-    /** Host navigation for error CTAs and connect targets. */
-    navigate?: (path: string) => void;
-    balanceUsd?: number | null;
-    formatMoney?: (usd: number | null) => string;
-    /** Render workflow YAML as a node graph in a proposal card. */
-    renderGraph?: (yaml: string) => ReactNode;
-    /** Render the brand icon for a proposal requirement's integration provider.
-     *  The host owns the provider→icon mapping (its integrations catalog); when
-     *  absent, the card falls back to its built-in provider mark. */
-    renderProviderIcon?: (provider: string) => ReactNode;
-    /** Called after a workflow-mutating tool is confirmed (host re-fetches its list). */
-    onWorkflowMutation?: () => void;
-    /** In-place connect handler for a proposal's integration requirements. The host
-     *  runs its own connect flow (OAuth popup, api-key modal, app install) and
-     *  resolves whether the requirement is now satisfied; the proposal card then
-     *  flips it to connected. Host-agnostic — when omitted, the card falls back to
-     *  navigating the requirement's connect target via `navigate`. */
-    onConnectRequirement?: (requirement: ConnectionRequirement) => Promise<ConnectRequirementResult>;
-    /** Markdown renderer for assistant message content (plain text when absent). */
-    renderMarkdown?: (content: string) => ReactNode;
-    /** Per-tool custom detail renderers for expanded tool cards in the transcript. */
-    toolRenderers?: ToolDetailRenderers;
-    /** Render a prominent card for a CONFIRMED tool's result (e.g. a one-time
-     *  API-key reveal for `create_api_key`), shown inline after the action's status
-     *  line. The result's `output` may carry a one-time secret — see
-     *  {@link ConfirmedResult} for the never-persist/never-to-model contract. */
-    renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
-    /** Swap the conversation rendering for a host-supplied renderer (see
-     *  {@link AssistantPanelProps.renderTranscript}); the dock chrome, composer,
-     *  transport, and proposal flow stay owned by the panel. */
-    renderTranscript?: (view: AssistantTranscriptView) => ReactNode;
-}
-declare function AssistantDock({ userId, navigate, balanceUsd, formatMoney, renderGraph, renderProviderIcon, onWorkflowMutation, onConnectRequirement, renderMarkdown, toolRenderers, renderConfirmedResult, renderTranscript, }: AssistantDockProps): react.JSX.Element;
-
 interface AssistantPanelProps {
     chat: AssistantChat;
     userId: string | null;
@@ -684,8 +647,68 @@ interface AssistantPanelProps {
      *  clears its seed state (consume-once). */
     composerSeed?: string | null;
     onComposerSeedApplied?: () => void;
+    /** Opt-in attachment surface for the composer, mirroring `ChatComposer`'s
+     *  attachment props: pass `onAttach` to show the attach button and accept
+     *  drag-and-drop, and drive the staged-file chips with `pendingFiles` /
+     *  `onRemoveFile` (web-react's `useComposerAttachments` owns that lifecycle).
+     *  Omitted, the composer stays text-only. The assistant wire carries text
+     *  only, so a host that stages files owns getting their content to the model
+     *  (e.g. inlined on the next `chat.send`); `onComposerSend` is the signal to
+     *  consume and clear the staged set. */
+    composerAttachments?: {
+        onAttach: (files: FileList) => void;
+        onAttachFolder?: (files: FileList) => void;
+        pendingFiles?: ComposerFile[];
+        onRemoveFile?: (id: string) => void;
+        accept?: string;
+    };
+    /** Fired when the composer sends (alongside `chat.send`) — the host's signal
+     *  to consume and clear its staged attachments. */
+    onComposerSend?: (message: string) => void;
+}
+declare function AssistantPanel({ chat, userId, onClose, navigate, balanceUsd, formatMoney, renderGraph, renderProviderIcon, renderMarkdown, toolRenderers, renderConfirmedResult, renderTranscript, composerSeed, onComposerSeedApplied, composerAttachments, onComposerSend, }: AssistantPanelProps): react.JSX.Element;
+
+interface AssistantDockProps {
+    /** The signed-in user this conversation belongs to (null when signed out). */
+    userId: string | null;
+    /** Host navigation for error CTAs and connect targets. */
+    navigate?: (path: string) => void;
+    balanceUsd?: number | null;
+    formatMoney?: (usd: number | null) => string;
+    /** Render workflow YAML as a node graph in a proposal card. */
+    renderGraph?: (yaml: string) => ReactNode;
+    /** Render the brand icon for a proposal requirement's integration provider.
+     *  The host owns the provider→icon mapping (its integrations catalog); when
+     *  absent, the card falls back to its built-in provider mark. */
+    renderProviderIcon?: (provider: string) => ReactNode;
+    /** Called after a workflow-mutating tool is confirmed (host re-fetches its list). */
+    onWorkflowMutation?: () => void;
+    /** In-place connect handler for a proposal's integration requirements. The host
+     *  runs its own connect flow (OAuth popup, api-key modal, app install) and
+     *  resolves whether the requirement is now satisfied; the proposal card then
+     *  flips it to connected. Host-agnostic — when omitted, the card falls back to
+     *  navigating the requirement's connect target via `navigate`. */
+    onConnectRequirement?: (requirement: ConnectionRequirement) => Promise<ConnectRequirementResult>;
+    /** Markdown renderer for assistant message content (plain text when absent). */
+    renderMarkdown?: (content: string) => ReactNode;
+    /** Per-tool custom detail renderers for expanded tool cards in the transcript. */
+    toolRenderers?: ToolDetailRenderers;
+    /** Render a prominent card for a CONFIRMED tool's result (e.g. a one-time
+     *  API-key reveal for `create_api_key`), shown inline after the action's status
+     *  line. The result's `output` may carry a one-time secret — see
+     *  {@link ConfirmedResult} for the never-persist/never-to-model contract. */
+    renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
+    /** Swap the conversation rendering for a host-supplied renderer (see
+     *  {@link AssistantPanelProps.renderTranscript}); the dock chrome, composer,
+     *  transport, and proposal flow stay owned by the panel. */
+    renderTranscript?: (view: AssistantTranscriptView) => ReactNode;
+    /** Opt-in attachment surface for the dock's composer — forwarded to
+     *  {@link AssistantPanelProps.composerAttachments}. */
+    composerAttachments?: AssistantPanelProps["composerAttachments"];
+    /** Forwarded to {@link AssistantPanelProps.onComposerSend}. */
+    onComposerSend?: AssistantPanelProps["onComposerSend"];
 }
-declare function AssistantPanel({ chat, userId, onClose, navigate, balanceUsd, formatMoney, renderGraph, renderProviderIcon, renderMarkdown, toolRenderers, renderConfirmedResult, renderTranscript, composerSeed, onComposerSeedApplied, }: AssistantPanelProps): react.JSX.Element;
+declare function AssistantDock({ userId, navigate, balanceUsd, formatMoney, renderGraph, renderProviderIcon, onWorkflowMutation, onConnectRequirement, renderMarkdown, toolRenderers, renderConfirmedResult, renderTranscript, composerAttachments, onComposerSend, }: AssistantDockProps): react.JSX.Element;
 
 /**
  * True while a turn is streaming but the model hasn't emitted its first answer

package/dist/assistant/index.js

@@ -1,17 +1,18 @@
-import {
-  AsyncView
-} from "../chunk-YIQHOAHN.js";
 import {
   ChatComposer,
-  ChatMessages,
-  ModelPicker,
-  ProviderLogo
-} from "../chunk-WC43OQMR.js";
+  ChatMessages
+} from "../chunk-IFYJDX3J.js";
 import "../chunk-FBVLEGEG.js";
 import "../chunk-HZ4WCA37.js";
 import "../chunk-GEYACSFW.js";
-import "../chunk-E4DHYENH.js";
+import {
+  ModelPicker,
+  ProviderLogo
+} from "../chunk-L7FHRORY.js";
 import "../chunk-BATKJP3P.js";
+import {
+  AsyncView
+} from "../chunk-YIQHOAHN.js";
 import "../chunk-PC2WYTK7.js";
 import "../chunk-QY4BRKRJ.js";
 import "../chunk-CCVG2TL6.js";
@@ -2391,7 +2392,9 @@ function AssistantPanel({
   renderConfirmedResult,
   renderTranscript,
   composerSeed = null,
-  onComposerSeedApplied
+  onComposerSeedApplied,
+  composerAttachments,
+  onComposerSend
 }) {
   const models = useAssistantModels();
   const threads = useAssistantThreads(userId);
@@ -2712,6 +2715,7 @@ function AssistantPanel({
           onSend: (message) => {
             setView("chat");
             chat.send(message);
+            onComposerSend?.(message);
           },
           onCancel: chat.stop,
           isStreaming: streaming,
@@ -2719,6 +2723,11 @@ function AssistantPanel({
           placeholder: "Message the assistant\u2026",
           seed: composerSeed,
           onSeedApplied: onComposerSeedApplied,
+          onAttach: composerAttachments?.onAttach,
+          onAttachFolder: composerAttachments?.onAttachFolder,
+          pendingFiles: composerAttachments?.pendingFiles,
+          onRemoveFile: composerAttachments?.onRemoveFile,
+          accept: composerAttachments?.accept,
           controls: pickerModels.length > 0 ? /* @__PURE__ */ jsx5(
             ModelPicker,
             {
@@ -2868,7 +2877,9 @@ function AssistantDock({
   renderMarkdown,
   toolRenderers,
   renderConfirmedResult,
-  renderTranscript
+  renderTranscript,
+  composerAttachments,
+  onComposerSend
 }) {
   const { open, openAssistant, closeAssistant, seed, clearSeed } = useAssistantLauncher();
   const chat = useAssistantChat(userId, {
@@ -2884,7 +2895,13 @@ function AssistantDock({
   useEffect7(() => {
     if (!open) return;
     const onKeyDown = (e) => {
-      if (e.key === "Escape") closeAssistant();
+      if (e.key !== "Escape") return;
+      if (dialogRef.current?.querySelector(
+        '[aria-haspopup="true"][aria-expanded="true"]'
+      )) {
+        return;
+      }
+      closeAssistant();
     };
     document.addEventListener("keydown", onKeyDown);
     return () => document.removeEventListener("keydown", onKeyDown);
@@ -2982,7 +2999,9 @@ function AssistantDock({
               renderConfirmedResult,
               renderTranscript,
               composerSeed: seed,
-              onComposerSeedApplied: clearSeed
+              onComposerSeedApplied: clearSeed,
+              composerAttachments,
+              onComposerSend
             },
             userId ?? "anon"
           ),