@tangle-network/agent-app 0.43.24 → 0.43.25

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

@@ -1,6 +1,8 @@
 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';
@@ -8,99 +10,6 @@ export { S as SandboxTerminalConnection, a as SandboxTerminalConnectionResponse,
 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;
-
 /**
  * Client-side chat-stream consumption — the NDJSON parse loop every agent
  * app's chat UI hand-rolls (and breaks). Normalizes the three line shapes the
@@ -143,7 +52,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
@@ -227,6 +139,204 @@ interface ChatComposerProps {
 }
 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;
 
+/**
+ * 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
  * CC0) inlined so the picker shows actual provider identity instead of
@@ -656,4 +766,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 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,78 @@ 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-PEPXQTJ3.js";
 import {
   tabTerminalConnectionId,
   useSandboxTerminalConnection
 } from "../chunk-65P3HJY3.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 +92,46 @@ 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,
   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 +141,14 @@ export {
   pendingApprovalOf,
   persistedPartToInteraction,
   questionInteractionContentSignature,
+  resolveChatInteraction,
+  responseErrorMessage,
+  restoreChatInteractions,
   streamChatTurn,
   tabTerminalConnectionId,
+  terminalizePendingChatInteractions,
+  upsertChatInteraction,
+  useChatInteractions,
   usePending,
   usePopover,
   useSandboxTerminalConnection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.43.24",
+  "version": "0.43.25",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent→app tool side channel, integration-hub client, per-workspace billing, and crypto — composed over the Tangle agent substrate through typed seams.",
   "keywords": [
@@ -53,6 +53,11 @@
       "import": "./dist/platform/index.js",
       "default": "./dist/platform/index.js"
     },
+    "./app-auth": {
+      "types": "./dist/app-auth/index.d.ts",
+      "import": "./dist/app-auth/index.js",
+      "default": "./dist/app-auth/index.js"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js",
@@ -133,6 +138,11 @@
       "import": "./dist/billing/index.js",
       "default": "./dist/billing/index.js"
     },
+    "./chat-store": {
+      "types": "./dist/chat-store/index.d.ts",
+      "import": "./dist/chat-store/index.js",
+      "default": "./dist/chat-store/index.js"
+    },
     "./crypto": {
       "types": "./dist/crypto/index.d.ts",
       "import": "./dist/crypto/index.js",
@@ -148,6 +158,11 @@
       "import": "./dist/integrations/index.js",
       "default": "./dist/integrations/index.js"
     },
+    "./interactions": {
+      "types": "./dist/interactions/index.d.ts",
+      "import": "./dist/interactions/index.js",
+      "default": "./dist/interactions/index.js"
+    },
     "./missions": {
       "types": "./dist/missions/index.d.ts",
       "import": "./dist/missions/index.js",
@@ -396,6 +411,7 @@
     "@tangle-network/sandbox": ">=0.9.7",
     "@tangle-network/sandbox-ui": ">=0.72.0",
     "@xyflow/react": ">=12.0.0",
+    "better-auth": ">=1.6.16",
     "drizzle-orm": ">=0.36",
     "konva": ">=9",
     "lucide-react": ">=1",
@@ -408,6 +424,9 @@
     "@huggingface/transformers": {
       "optional": true
     },
+    "better-auth": {
+      "optional": true
+    },
     "@tangle-network/agent-knowledge": {
       "optional": true
     },