@tangle-network/agent-app 0.43.24 → 0.43.26

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

@@ -1,105 +1,15 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { InteractionField, InteractionRequest, InteractionData } from '@tangle-network/agent-interface';
+import { C as ChatInteraction, a as ChatInteractionField, b as ChatInteractionStatus, c as ChatSelectField, g as InteractionCancelData, i as InteractionRequestWire } from '../contract-DYbTzEDf.js';
+export { d as ComposerAnswerDelivery, I as INTERACTION_CANCEL_EVENT, e as INTERACTION_EVENT, f as INTERACTION_RESOLVED_EVENT, h as InteractionPersistedPart, N as NoticeKind, j as NoticePersistedPart, P as ParseInteractionResult, k as canTransitionInteractionStatus, l as cancelStatusFor, m as composerAnswerData, n as composerAnswerDeliveries, o as dedupeQuestionInteractionsByContent, p as fieldAcceptsFreeText, q as interactionFromWireRequest, r as interactionPartKey, s as interactionToPersistedPart, t as isRenderableInteractionKind, u as isSafeInteractionFieldKey, v as isTerminalInteractionStatus, w as noticePart, x as noticePartKey, y as parseInteractionCancel, z as parseInteractionRequest, A as persistedPartToInteraction, B as questionInteractionContentSignature } from '../contract-DYbTzEDf.js';
+import { InteractionData } from '@tangle-network/agent-interface';
 export { InteractionData, InteractionOutcome, InteractionRequest } from '@tangle-network/agent-interface';
 import { S as StepAgentActivity } from '../agent-activity-C8ZG0F0M.js';
 import { a as FlowTrace } from '../flow-types-Cb_AblZs.js';
 export { S as SandboxTerminalConnection, a as SandboxTerminalConnectionResponse, U as UseSandboxTerminalConnectionOptions, b as UseSandboxTerminalConnectionResult, t as tabTerminalConnectionId, u as useSandboxTerminalConnection } from '../sandbox-terminal-BIIC__CP.js';
 import { CatalogModel } from '../catalog/index.js';
 import { Harness } from '../harness/index.js';
-
-/** Sidecar → client: the agent raised an ask; data = `{ request }`. */
-declare const INTERACTION_EVENT: "interaction";
-/** Sidecar → client: the ask was withdrawn; data = `{ id, reason? }`. */
-declare const INTERACTION_CANCEL_EVENT: "interaction.cancel";
-/** An ask was answered; data = `{ id, status }`. In the wire contract so a
- *  server broadcast and a client-local mark share one event name. */
-declare const INTERACTION_RESOLVED_EVENT: "interaction.resolved";
-declare function isRenderableInteractionKind(kind: string): boolean;
-/** Answer/field keys the sidecar will accept: identifier-safe and never a
- *  prototype-pollution vector. */
-declare function isSafeInteractionFieldKey(key: string): boolean;
-type ChatSelectField = Extract<InteractionField, {
-    type: 'select';
-}> & {
-    allowCustom?: boolean;
-};
-type ChatInteractionField = Exclude<InteractionField, {
-    type: 'select';
-}> | ChatSelectField;
-/** `InteractionRequest` whose select fields may carry `allowCustom`. */
-type InteractionRequestWire = Omit<InteractionRequest, 'answerSpec'> & {
-    answerSpec: {
-        fields: ChatInteractionField[];
-    };
-};
-type ChatInteractionStatus = 'pending' | 'answered' | 'declined' | 'cancelled' | 'expired';
-/** The client/persisted view of one ask. `fields` come verbatim off the wire. */
-interface ChatInteraction {
-    id: string;
-    kind: string;
-    title: string;
-    body?: string;
-    fields: ChatInteractionField[];
-    status: ChatInteractionStatus;
-    /** Set when status came from an `interaction.cancel` (e.g. "timeout"). */
-    cancelReason?: string;
-}
-declare function isTerminalInteractionStatus(status: ChatInteractionStatus): boolean;
-/** Statuses only move forward (pending → terminal); a replayed/stale `pending`
- *  must never resurrect a resolved card. */
-declare function canTransitionInteractionStatus(from: ChatInteractionStatus, to: ChatInteractionStatus): boolean;
-/** Maps an `interaction.cancel` reason to the card's terminal status. */
-declare function cancelStatusFor(reason: string | undefined): ChatInteractionStatus;
-/** Content identity for duplicate safety nets. Excludes volatile ids/statuses. */
-declare function questionInteractionContentSignature(interaction: ChatInteraction): string | null;
-declare function dedupeQuestionInteractionsByContent(interactions: ChatInteraction[]): ChatInteraction[];
-type ParseInteractionResult = {
-    succeeded: true;
-    value: InteractionRequestWire;
-} | {
-    succeeded: false;
-    error: string;
-};
-/** Parses an `interaction` event's data (`{ request }`). Validates the shape
- *  with the agent-interface schema but returns the raw request so a field a
- *  pinned schema predates (`allowCustom`) survives. */
-declare function parseInteractionRequest(data: Record<string, unknown> | undefined): ParseInteractionResult;
-interface InteractionCancelData {
-    id: string;
-    reason?: string;
-}
-declare function parseInteractionCancel(data: Record<string, unknown> | undefined): {
-    succeeded: true;
-    value: InteractionCancelData;
-} | {
-    succeeded: false;
-    error: string;
-};
-declare function fieldAcceptsFreeText(field: ChatInteractionField): boolean;
-interface ComposerAnswerDelivery {
-    interactionId: string;
-    field: ChatInteractionField;
-}
-/** One delivery per pending ask: the first free-text-capable field, else the
- *  first field. Zero-field asks are skipped (nothing to carry the text). */
-declare function composerAnswerDeliveries(pending: ChatInteraction[]): ComposerAnswerDelivery[];
-/** Shapes composer text into the respond payload for the routed field
- *  (select answers are string arrays on the wire; text answers are strings). */
-declare function composerAnswerData(field: ChatInteractionField, text: string): InteractionData;
-declare function interactionPartKey(id: string): string;
-declare function noticePartKey(id: string): string;
-type NoticeKind = 'warning' | 'auto-declined';
-/** Builds the persisted/streamed `notice` part — a one-line transcript notice
- *  explaining an out-of-band event (warning, auto-declined interaction). */
-declare function noticePart(noticeKind: NoticeKind, id: string, text: string): Record<string, unknown>;
-/** Reads a wire request into the client's pending `ChatInteraction`. */
-declare function interactionFromWireRequest(request: InteractionRequestWire): ChatInteraction;
-/** Builds the persisted/streamed `interaction` part from a wire request. */
-declare function interactionToPersistedPart(request: InteractionRequestWire, status: ChatInteractionStatus, cancelReason?: string): Record<string, unknown>;
-/** Reads a persisted/streamed `interaction` part back into a `ChatInteraction`.
- *  Returns null (caller logs) when the part is not one of ours. */
-declare function persistedPartToInteraction(part: Record<string, unknown>): ChatInteraction | null;
+export { b as ChatTurnFilePartInput, a as ChatTurnPartInput, C as ChatTurnRequestPayload, f as chatTurnRequestInit } from '../wire-BaUF66AS.js';
 
 /**
  * Client-side chat-stream consumption — the NDJSON parse loop every agent
@@ -143,7 +53,10 @@ interface ChatStreamCallbacks {
         completionTokens: number;
     }) => void;
     onMetadata?: (data: Record<string, unknown>) => void;
-    /** A loop-level error event (the turn failed server-side). */
+    /** A loop-level error event (the turn failed server-side). Optional, but the
+     *  error never vanishes: when omitted, the message is synthesized into the
+     *  transcript via `onText` (rendered by ChatMessages as a text segment) and
+     *  logged with `console.error`. */
     onErrorEvent?: (message: string) => void;
     /** A sidecar interaction ask (kind: "question"/"plan"/…). The run is BLOCKED
      *  in the broker until the user answers; a pending ask is "waiting on the
@@ -181,6 +94,17 @@ interface StreamChatOptions {
  */
 declare function streamChatTurn(opts: StreamChatOptions): Promise<ConsumeChatStreamResult>;
 
+/** Prompt-part descriptor an uploaded file carries (the upload route's
+ *  `UploadedChatFile.part`), echoed back in the turn body on send. Mirrors
+ *  `/chat-routes`' wire shape structurally — no server import here. */
+interface ComposerFilePart {
+    type: 'image' | 'file';
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+    path?: string;
+    content?: string;
+}
 interface ComposerFile {
     id: string;
     name: string;
@@ -189,11 +113,19 @@ interface ComposerFile {
     /** Number of files inside, for a folder chip. */
     fileCount?: number;
     status: 'pending' | 'uploading' | 'ready' | 'error';
+    /** Uploaded part descriptor; set once the upload route returns. Only
+     *  `status: 'ready'` files with a part travel on a parts-aware send. */
+    part?: ComposerFilePart;
 }
 interface ChatComposerProps {
     /** Send the trimmed, non-empty message. Attached files travel separately via
-     *  `onAttach` + `pendingFiles` (the host consumes and clears them on send). */
-    onSend: (message: string) => void;
+     *  `onAttach` + `pendingFiles` (the host consumes and clears them on send).
+     *  Optional when `onSendParts` is wired. */
+    onSend?: (message: string) => void;
+    /** Parts-aware send: receives the trimmed message plus the `part`
+     *  descriptors of every `ready` pending file. Takes precedence over
+     *  `onSend`; enables file-only sends (empty text, ≥1 ready part). */
+    onSendParts?: (message: string, parts: ComposerFilePart[]) => void;
     /** Stop the in-flight turn; shown in place of Send while `isStreaming`. */
     onCancel?: () => void;
     isStreaming?: boolean;
@@ -225,7 +157,205 @@ interface ChatComposerProps {
     sendLabel?: string;
     className?: string;
 }
-declare function ChatComposer({ onSend, onCancel, isStreaming, disabled, placeholder, value, onValueChange, initialValue, controls, controlsPlacement, onAttach, onAttachFolder, pendingFiles, onRemoveFile, accept, dropTitle, dropDescription, focusShortcut, sendLabel, className, }: ChatComposerProps): react.JSX.Element;
+declare function ChatComposer({ onSend, onSendParts, onCancel, isStreaming, disabled, placeholder, value, onValueChange, initialValue, controls, controlsPlacement, onAttach, onAttachFolder, pendingFiles, onRemoveFile, accept, dropTitle, dropDescription, focusShortcut, sendLabel, className, }: ChatComposerProps): react.JSX.Element;
+
+/**
+ * Shared answer-building + submit plumbing for the interaction cards
+ * (question, plan). Client-safe, no React: cards own their state, this owns
+ * the wire. Lifted from the gtm-agent fork (the most fix-absorbed of the three
+ * product copies), including the 30s submit timeout that keeps a dead route
+ * from wedging a card in "Submitting…".
+ */
+
+/** Status-badge labels for an interaction card. `cancelled`/`expired` read the
+ *  same across cards; each card supplies its own verbs for the other states
+ *  (a question is answered/declined; a plan is approved/rejected). */
+declare function interactionStatusLabels(labels: {
+    pending: string;
+    answered: string;
+    declined: string;
+}): Record<ChatInteractionStatus, string>;
+/** Terminal-state notes for an interaction card. The expiry/withdrawal lines
+ *  share one shape around the card's noun ("question"/"plan"); any extra notes
+ *  (e.g. a plan's `declined` revision line) merge on top. */
+declare function interactionTerminalNotes(noun: string, extra?: Partial<Record<ChatInteractionStatus, string>>): Partial<Record<ChatInteractionStatus, string>>;
+type FieldValues = Record<string, {
+    selected?: string[];
+    text?: string;
+    custom?: string;
+}>;
+/** The submitted value for one field, or null when it has no answer yet. */
+declare function fieldAnswer(field: ChatInteractionField, values: FieldValues): InteractionData[string] | null;
+/** All required fields answered → the respond payload; else null (not
+ *  submittable yet). Optional unanswered fields are omitted. */
+declare function buildAnswerData(fields: ChatInteractionField[], values: FieldValues): InteractionData | null;
+declare function isLateAnswerableStatus(status: ChatInteractionStatus): boolean;
+/** Secrets must never leave the sidecar answer channel for the visible chat
+ *  transcript, so a secret-bearing ask cannot be late-answered. */
+declare function hasSecretField(fields: ChatInteractionField[]): boolean;
+/** Renders the late answer as a self-contained chat message: the original
+ *  question, its context, and the user's answer(s). */
+declare function lateAnswerMessage(interaction: ChatInteraction, data: InteractionData): string;
+declare const INTERACTION_SUBMIT_TIMEOUT_MS = 30000;
+declare const INTERACTION_SUBMIT_TIMEOUT_MESSAGE = "Could not reach the agent. Try again.";
+/** One card submission: which ask, resolved how, with what answers. */
+interface InteractionAnswerSubmission {
+    id: string;
+    outcome: 'accepted' | 'declined';
+    data?: InteractionData;
+}
+type InteractionSubmitResult = {
+    ok: true;
+} | {
+    ok: false;
+    expired: boolean;
+    message: string;
+};
+/** The cards' only side-effect seam: POST one resolution, report the normalized
+ *  outcome. Products bind their route URL + routing fields (workspaceId,
+ *  threadId, session path param) via `createInteractionAnswerSubmitter` or a
+ *  hand-rolled implementation. */
+type SubmitInteractionAnswer = (submission: InteractionAnswerSubmission) => Promise<InteractionSubmitResult>;
+/** Extracts the most specific error message a route returned. */
+declare function responseErrorMessage(res: Response): Promise<{
+    code?: string;
+    message: string;
+}>;
+interface InteractionAnswerSubmitterOptions {
+    /** The product's answer route (the POST half of `createInteractionAnswerRoute`).
+     *  A function when the URL carries the session (e.g. `/api/sessions/${id}/interactions`). */
+    url: string | ((submission: InteractionAnswerSubmission) => string);
+    /** Extra routing fields merged into the POST body (e.g. workspaceId, threadId). */
+    body?: Record<string, unknown> | ((submission: InteractionAnswerSubmission) => Record<string, unknown>);
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Builds the `SubmitInteractionAnswer` the cards consume: POSTs
+ * `{ ...routingFields, id, outcome, data? }` with an abortable timeout and
+ * normalizes the outcome. `expired` is the 410 path — the ask is gone
+ * (answered elsewhere, timed out, or the session moved on) and the card must
+ * flip to the same dead state a cancel event produces.
+ */
+declare function createInteractionAnswerSubmitter(options: InteractionAnswerSubmitterOptions): SubmitInteractionAnswer;
+
+type InteractionBadgeVariant = 'outline' | 'default' | 'destructive';
+declare function InteractionBadge({ variant, children }: {
+    variant: InteractionBadgeVariant;
+    children: string;
+}): react.JSX.Element;
+declare function InteractionActionButton({ variant, onClick, disabled, children, }: {
+    variant?: 'primary' | 'outline';
+    onClick: () => void;
+    disabled?: boolean;
+    children: string;
+}): react.JSX.Element;
+interface QuestionOptionListProps {
+    /** Radio/checkbox group name — unique per field so selection is isolated. */
+    groupName: string;
+    /** Stable prefix for per-option input ids (label htmlFor pairing). */
+    idPrefix: string;
+    options: ChatSelectField['options'];
+    /** Checkbox (multi-select) vs radio (single). */
+    multi: boolean;
+    selectedValues: string[];
+    disabled: boolean;
+    onToggle: (value: string) => void;
+}
+/** The radio/checkbox option rows for a select field. Renders a fragment of
+ *  option `<label>` rows so a card keeps its own wrapping layout and appends
+ *  its own write-in input. */
+declare function QuestionOptionList({ groupName, idPrefix, options, multi, selectedValues, disabled, onToggle, }: QuestionOptionListProps): react.JSX.Element;
+interface InteractionQuestionCardProps {
+    interaction: ChatInteraction;
+    /** Viewer-vs-editor gate: false renders everything read-only. */
+    canWrite: boolean;
+    /** POST one resolution to the product's answer route (see
+     *  `createInteractionAnswerSubmitter`). Never called for late answers. */
+    submitAnswer: SubmitInteractionAnswer;
+    /** Fired when this card resolves locally (answered, or discovered expired
+     *  via a 410) so the stream/route state stays in sync. */
+    onResolved?: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>) => void;
+    /** Delivers a late answer (the ask expired/was withdrawn) as a fresh chat
+     *  turn. Return/resolve `false` when the send was rejected so the card stays
+     *  retryable. Omit to hide the late-answer affordance entirely. */
+    onLateAnswer?: (message: string) => boolean | void | Promise<boolean | void>;
+    className?: string;
+}
+declare function InteractionQuestionCard({ interaction, canWrite, submitAnswer, onResolved, onLateAnswer, className, }: InteractionQuestionCardProps): react.JSX.Element;
+
+interface InteractionPlanCardProps {
+    interaction: ChatInteraction;
+    /** Viewer-vs-editor gate: false renders everything read-only. */
+    canWrite: boolean;
+    /** POST one resolution to the product's answer route (see
+     *  `createInteractionAnswerSubmitter`). */
+    submitAnswer: SubmitInteractionAnswer;
+    /** Fired when this card resolves locally (approved/rejected, or discovered
+     *  expired via a 410) so the stream/route state stays in sync. */
+    onResolved?: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>) => void;
+    /** Renders the plan body (markdown). Falls back to pre-wrapped plain text. */
+    renderMarkdown?: (markdown: string) => ReactNode;
+    className?: string;
+}
+declare function InteractionPlanCard({ interaction, canWrite, submitAnswer, onResolved, renderMarkdown, className, }: InteractionPlanCardProps): react.JSX.Element;
+
+/**
+ * useChatInteractions — the interaction-state wiring every consumer of
+ * `ChatStreamCallbacks.onInteraction` re-implements: an id-keyed,
+ * insertion-ordered list with
+ *
+ *   - forward-only status transitions (a replayed/stale `pending` never
+ *     resurrects a resolved card),
+ *   - pending-question content dedupe (a re-emitted duplicate ask never renders
+ *     a second card),
+ *   - cancel-event application (`interaction.cancel` → cancelled/expired),
+ *   - local resolution marking (the card's `onResolved`),
+ *   - reload restore from the answer route's GET list (sidecar registry is the
+ *     source of truth after a reload),
+ *   - turn-end settling (client mirror of the server's finalize pass: a turn
+ *     that completed without a cancel was answered; a failed turn can make no
+ *     such claim).
+ *
+ * The reducer functions are pure and exported for non-React consumers/tests;
+ * the hook is a thin `useState` shell over them.
+ */
+
+/** Insert or update one interaction. A terminal existing entry wins over any
+ *  incoming state for the same id; a new pending ask that duplicates another
+ *  pending ask's content is dropped. Returns the same array when unchanged. */
+declare function upsertChatInteraction(list: ChatInteraction[], interaction: ChatInteraction): ChatInteraction[];
+/** Applies an `interaction.cancel` event: only a pending ask moves, to
+ *  `expired` (reason:"timeout") or `cancelled`. */
+declare function cancelChatInteraction(list: ChatInteraction[], cancel: InteractionCancelData): ChatInteraction[];
+/** Marks one ask resolved locally (the card's `onResolved`). Forward-only. */
+declare function resolveChatInteraction(list: ChatInteraction[], id: string, status: Exclude<ChatInteractionStatus, 'pending'>): ChatInteraction[];
+/** Settles every still-pending ask when the turn ends: `answered` for a turn
+ *  that completed cleanly, `expired` for one that failed. */
+declare function terminalizePendingChatInteractions(list: ChatInteraction[], status: Extract<ChatInteractionStatus, 'answered' | 'expired'>): ChatInteraction[];
+/** Reload restore from the answer route's GET list: every listed ask is
+ *  outstanding (upserted pending), and every previously-pending ask the sidecar
+ *  no longer lists was resolved while we were away (settled as answered). */
+declare function restoreChatInteractions(list: ChatInteraction[], outstanding: InteractionRequestWire[]): ChatInteraction[];
+interface UseChatInteractionsResult {
+    /** All known interactions, insertion-ordered. */
+    interactions: ChatInteraction[];
+    /** The asks currently blocking the run (waiting on the user). */
+    pending: ChatInteraction[];
+    /** Wire to `ChatStreamCallbacks.onInteraction` (and persisted-part replay). */
+    upsert: (interaction: ChatInteraction) => void;
+    /** Wire to `interaction.cancel` events. */
+    applyCancel: (cancel: InteractionCancelData) => void;
+    /** Wire to the cards' `onResolved`. */
+    markResolved: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>) => void;
+    /** Wire to the answer route's GET list after a reload/reconnect. */
+    restore: (outstanding: InteractionRequestWire[]) => void;
+    /** Settle still-pending asks when the turn ends. */
+    terminalizePending: (status: Extract<ChatInteractionStatus, 'answered' | 'expired'>) => void;
+    /** Drop everything (thread switch). */
+    reset: () => void;
+}
+declare function useChatInteractions(): UseChatInteractionsResult;
 
 /**
  * Provider brand marks — real logo path data (simple-icons / SVG Logos, both
@@ -656,4 +786,4 @@ declare function useThinkingSeconds(active: boolean): number;
  */
 declare function ChatMessages({ messages, models, renderMarkdown, renderExtras, userLabel, agentLabel, loading, approval, onToolCallClick, toolRenderers, error, onRetry, renderEmpty, emptyState, header, }: ChatMessagesProps): react.JSX.Element;
 
-export { type ActivityTone, type AgentActivityPage, AgentActivityPanel, type AgentActivityPanelProps, type AgentActivityRecord, AgentSessionControls, type AgentSessionControlsProps, CatalogModel, ChatComposer, type ChatComposerProps, type ChatEmptyDoor, ChatEmptyState, type ChatEmptyStateProps, type ChatInteraction, type ChatInteractionField, type ChatInteractionStatus, type ChatMessageMetrics, type ChatMessageSegment, ChatMessages, type ChatMessagesProps, type ChatSelectField, type ChatStreamCallbacks, type ChatStreamToolCall, type ChatStreamToolResult, type ChatToolCallInfo, type ChatUiMessage, type ComposerAnswerDelivery, type ComposerFile, type ConsumeChatStreamResult, DEFAULT_EFFORT_LEVELS, type EffortLevel, EffortPicker, type EffortPickerProps, FlowWaterfall, type FlowWaterfallProps, INTERACTION_CANCEL_EVENT, INTERACTION_EVENT, INTERACTION_RESOLVED_EVENT, type InteractionCancelData, type InteractionRequestWire, MissionActivityLane, type MissionActivityLaneProps, ModelPicker, type ModelPickerProps, type NoticeKind, type ParseInteractionResult, type ProposalApprovalHandlers, ProviderLogo, type ProviderLogoProps, RunDrillIn, type RunDrillInProps, SeatPaywall, type SeatPaywallProps, type SmoothRevealOptions, type StreamChatOptions, type ToolDetailRenderers, type ToolRunRecord, type ToolRunStep, type WaterfallRow, activityTone, canTransitionInteractionStatus, cancelStatusFor, composerAnswerData, composerAnswerDeliveries, consumeChatStream, dedupeQuestionInteractionsByContent, dispatchChatStreamLine, fieldAcceptsFreeText, formatActivityCost, formatActivityDuration, formatModelCost, formatTokensPerSecond, interactionFromWireRequest, interactionPartKey, interactionToPersistedPart, isRenderableInteractionKind, isSafeInteractionFieldKey, isTerminalInteractionStatus, mergeActivityPages, nextRevealCount, noticePart, noticePartKey, parseInteractionCancel, parseInteractionRequest, pendingApprovalOf, persistedPartToInteraction, questionInteractionContentSignature, streamChatTurn, usePending, usePopover, useSmoothText, useThinkingSeconds, waterfallLayout };
+export { type ActivityTone, type AgentActivityPage, AgentActivityPanel, type AgentActivityPanelProps, type AgentActivityRecord, AgentSessionControls, type AgentSessionControlsProps, CatalogModel, ChatComposer, type ChatComposerProps, type ChatEmptyDoor, ChatEmptyState, type ChatEmptyStateProps, ChatInteraction, ChatInteractionField, ChatInteractionStatus, type ChatMessageMetrics, type ChatMessageSegment, ChatMessages, type ChatMessagesProps, ChatSelectField, type ChatStreamCallbacks, type ChatStreamToolCall, type ChatStreamToolResult, type ChatToolCallInfo, type ChatUiMessage, type ComposerFile, type ComposerFilePart, type ConsumeChatStreamResult, DEFAULT_EFFORT_LEVELS, type EffortLevel, EffortPicker, type EffortPickerProps, type FieldValues, FlowWaterfall, type FlowWaterfallProps, INTERACTION_SUBMIT_TIMEOUT_MESSAGE, INTERACTION_SUBMIT_TIMEOUT_MS, InteractionActionButton, type InteractionAnswerSubmission, type InteractionAnswerSubmitterOptions, InteractionBadge, type InteractionBadgeVariant, InteractionCancelData, InteractionPlanCard, type InteractionPlanCardProps, InteractionQuestionCard, type InteractionQuestionCardProps, InteractionRequestWire, type InteractionSubmitResult, MissionActivityLane, type MissionActivityLaneProps, ModelPicker, type ModelPickerProps, type ProposalApprovalHandlers, ProviderLogo, type ProviderLogoProps, QuestionOptionList, type QuestionOptionListProps, RunDrillIn, type RunDrillInProps, SeatPaywall, type SeatPaywallProps, type SmoothRevealOptions, type StreamChatOptions, type SubmitInteractionAnswer, type ToolDetailRenderers, type ToolRunRecord, type ToolRunStep, type UseChatInteractionsResult, type WaterfallRow, activityTone, buildAnswerData, cancelChatInteraction, consumeChatStream, createInteractionAnswerSubmitter, dispatchChatStreamLine, fieldAnswer, formatActivityCost, formatActivityDuration, formatModelCost, formatTokensPerSecond, hasSecretField, interactionStatusLabels, interactionTerminalNotes, isLateAnswerableStatus, lateAnswerMessage, mergeActivityPages, nextRevealCount, pendingApprovalOf, resolveChatInteraction, responseErrorMessage, restoreChatInteractions, streamChatTurn, terminalizePendingChatInteractions, upsertChatInteraction, useChatInteractions, usePending, usePopover, useSmoothText, useThinkingSeconds, waterfallLayout };

package/dist/web-react/index.js

@@ -7,54 +7,81 @@ import {
   DEFAULT_EFFORT_LEVELS,
   EffortPicker,
   FlowWaterfall,
-  INTERACTION_CANCEL_EVENT,
-  INTERACTION_EVENT,
-  INTERACTION_RESOLVED_EVENT,
+  INTERACTION_SUBMIT_TIMEOUT_MESSAGE,
+  INTERACTION_SUBMIT_TIMEOUT_MS,
+  InteractionActionButton,
+  InteractionBadge,
+  InteractionPlanCard,
+  InteractionQuestionCard,
   MissionActivityLane,
   ModelPicker,
   ProviderLogo,
+  QuestionOptionList,
   RunDrillIn,
   SeatPaywall,
   activityTone,
-  canTransitionInteractionStatus,
-  cancelStatusFor,
-  composerAnswerData,
-  composerAnswerDeliveries,
+  buildAnswerData,
+  cancelChatInteraction,
   consumeChatStream,
-  dedupeQuestionInteractionsByContent,
+  createInteractionAnswerSubmitter,
   dispatchChatStreamLine,
-  fieldAcceptsFreeText,
+  fieldAnswer,
   formatActivityCost,
   formatActivityDuration,
   formatModelCost,
   formatTokensPerSecond,
-  interactionFromWireRequest,
-  interactionPartKey,
-  interactionToPersistedPart,
-  isRenderableInteractionKind,
-  isSafeInteractionFieldKey,
-  isTerminalInteractionStatus,
+  hasSecretField,
+  interactionStatusLabels,
+  interactionTerminalNotes,
+  isLateAnswerableStatus,
+  lateAnswerMessage,
   mergeActivityPages,
   nextRevealCount,
-  noticePart,
-  noticePartKey,
-  parseInteractionCancel,
-  parseInteractionRequest,
   pendingApprovalOf,
-  persistedPartToInteraction,
-  questionInteractionContentSignature,
+  resolveChatInteraction,
+  responseErrorMessage,
+  restoreChatInteractions,
   streamChatTurn,
+  terminalizePendingChatInteractions,
+  upsertChatInteraction,
+  useChatInteractions,
   usePending,
   usePopover,
   useSmoothText,
   useThinkingSeconds,
   waterfallLayout
-} from "../chunk-VMY4TKMN.js";
+} from "../chunk-FCQP75JT.js";
 import {
   tabTerminalConnectionId,
   useSandboxTerminalConnection
 } from "../chunk-65P3HJY3.js";
+import {
+  chatTurnRequestInit
+} from "../chunk-5SV5PSU7.js";
 import "../chunk-2QI7XV2T.js";
+import {
+  INTERACTION_CANCEL_EVENT,
+  INTERACTION_EVENT,
+  INTERACTION_RESOLVED_EVENT,
+  canTransitionInteractionStatus,
+  cancelStatusFor,
+  composerAnswerData,
+  composerAnswerDeliveries,
+  dedupeQuestionInteractionsByContent,
+  fieldAcceptsFreeText,
+  interactionFromWireRequest,
+  interactionPartKey,
+  interactionToPersistedPart,
+  isRenderableInteractionKind,
+  isSafeInteractionFieldKey,
+  isTerminalInteractionStatus,
+  noticePart,
+  noticePartKey,
+  parseInteractionCancel,
+  parseInteractionRequest,
+  persistedPartToInteraction,
+  questionInteractionContentSignature
+} from "../chunk-4TXDD6P2.js";
 import "../chunk-E7QYOOON.js";
 export {
   AgentActivityPanel,
@@ -68,30 +95,47 @@ export {
   INTERACTION_CANCEL_EVENT,
   INTERACTION_EVENT,
   INTERACTION_RESOLVED_EVENT,
+  INTERACTION_SUBMIT_TIMEOUT_MESSAGE,
+  INTERACTION_SUBMIT_TIMEOUT_MS,
+  InteractionActionButton,
+  InteractionBadge,
+  InteractionPlanCard,
+  InteractionQuestionCard,
   MissionActivityLane,
   ModelPicker,
   ProviderLogo,
+  QuestionOptionList,
   RunDrillIn,
   SeatPaywall,
   activityTone,
+  buildAnswerData,
   canTransitionInteractionStatus,
+  cancelChatInteraction,
   cancelStatusFor,
+  chatTurnRequestInit,
   composerAnswerData,
   composerAnswerDeliveries,
   consumeChatStream,
+  createInteractionAnswerSubmitter,
   dedupeQuestionInteractionsByContent,
   dispatchChatStreamLine,
   fieldAcceptsFreeText,
+  fieldAnswer,
   formatActivityCost,
   formatActivityDuration,
   formatModelCost,
   formatTokensPerSecond,
+  hasSecretField,
   interactionFromWireRequest,
   interactionPartKey,
+  interactionStatusLabels,
+  interactionTerminalNotes,
   interactionToPersistedPart,
+  isLateAnswerableStatus,
   isRenderableInteractionKind,
   isSafeInteractionFieldKey,
   isTerminalInteractionStatus,
+  lateAnswerMessage,
   mergeActivityPages,
   nextRevealCount,
   noticePart,
@@ -101,8 +145,14 @@ export {
   pendingApprovalOf,
   persistedPartToInteraction,
   questionInteractionContentSignature,
+  resolveChatInteraction,
+  responseErrorMessage,
+  restoreChatInteractions,
   streamChatTurn,
   tabTerminalConnectionId,
+  terminalizePendingChatInteractions,
+  upsertChatInteraction,
+  useChatInteractions,
   usePending,
   usePopover,
   useSandboxTerminalConnection,

package/dist/wire-BaUF66AS.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Wire contract between the chat client (composer + `streamChatTurn`) and the
+ * assembled server vertical (`createChatTurnRoutes`). Import-free on purpose:
+ * `/web-react` re-exports these types into browser bundles, so nothing here may
+ * reach a Node builtin or an engine package.
+ *
+ * The part shape mirrors the sandbox SDK's `PromptInputPart` structurally
+ * (text | image | file with filename/mediaType/url/path/content) — derived
+ * here, not imported, so the client bundle never touches the SDK.
+ */
+interface ChatTurnTextPartInput {
+    type: 'text';
+    text: string;
+}
+/** A non-text prompt part the upload route hands back and the client echoes
+ *  on send. `url` carries an inline `data:` URI for small files; `path` is a
+ *  sandbox workspace reference for large ones (the >1 MiB gateway body cap
+ *  makes the two-step upload mandatory). */
+interface ChatTurnFilePartInput {
+    type: 'image' | 'file';
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+    path?: string;
+    content?: string;
+}
+type ChatTurnPartInput = ChatTurnTextPartInput | ChatTurnFilePartInput;
+/** POST body for the turn route. `content` may be empty when `parts` carry the
+ *  message (an image-only send). Product routing fields (workspaceId etc.) ride
+ *  alongside and are read by the product's `authorize` seam. */
+interface ChatTurnRequestPayload {
+    threadId: string;
+    content?: string;
+    /** Non-text parts from the upload route, echoed back verbatim. */
+    parts?: ChatTurnFilePartInput[];
+    model?: string;
+    effort?: 'auto' | 'low' | 'medium' | 'high';
+    harness?: string;
+    /** Client-generated idempotency key for the logical turn (retry-safe). */
+    turnId?: string;
+    [key: string]: unknown;
+}
+/** `fetch` init for the turn route — the one place the client wire shape is
+ *  serialized, so composer glue and products never drift from the server's
+ *  parser. */
+declare function chatTurnRequestInit(payload: ChatTurnRequestPayload): RequestInit;
+declare const INLINE_PARTS_MAX_BYTES = 950000;
+declare class ChatTurnInputError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message: string, status?: number, code?: string);
+}
+declare function promptPartsByteSize(parts: ChatTurnPartInput[]): number;
+/** Throws `ChatTurnInputError` (413) when the parts' inline payload would blow
+ *  the gateway cap. Path-ref parts are tiny by construction and always pass. */
+declare function assertPromptPartsWithinCap(parts: ChatTurnPartInput[], maxBytes?: number): void;
+/** Validates the untyped `parts` array off the wire. Returns the typed parts
+ *  or throws `ChatTurnInputError` (400) naming the offending entry. */
+declare function parseChatTurnParts(raw: unknown): ChatTurnFilePartInput[];
+
+export { type ChatTurnRequestPayload as C, INLINE_PARTS_MAX_BYTES as I, type ChatTurnPartInput as a, type ChatTurnFilePartInput as b, ChatTurnInputError as c, type ChatTurnTextPartInput as d, assertPromptPartsWithinCap as e, chatTurnRequestInit as f, promptPartsByteSize as g, parseChatTurnParts as p };