@tangle-network/agent-app 0.43.41 → 0.43.43

package/dist/teams/invitations-api.js

@@ -2,6 +2,9 @@ import {
   SeatLimitError
 } from "../chunk-SWUVTGMR.js";
 import "../chunk-3SVAA3MA.js";
+import {
+  hasWorkspaceRole
+} from "../chunk-63CE7FEZ.js";
 import {
   generateInvitationToken,
   getInvitationExpiresAt,
@@ -9,9 +12,6 @@ import {
   normalizeInvitationEmail,
   parseInvitationPermission
 } from "../chunk-WEBBJBDH.js";
-import {
-  hasWorkspaceRole
-} from "../chunk-63CE7FEZ.js";
 
 // src/teams/invitations-api.ts
 import { and, eq, lte, sql } from "drizzle-orm";

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

@@ -1,7 +1,8 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-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 { a as ChatInteractionField, h as InteractionAnswers, b as ChatInteractionStatus, C as ChatInteraction, i as InteractionCancelData, c as ChatSelectField, k as InteractionRequestWire } from '../contract-KfqJh_au.js';
+export { d as ComposerAnswerDelivery, I as INTERACTION_CANCEL_EVENT, e as INTERACTION_EVENT, f as INTERACTION_RESOLVED_EVENT, g as InteractionAnswerValue, j as InteractionPersistedPart, N as NoticeKind, l as NoticePersistedPart, P as ParseInteractionAnswersResult, m as ParseInteractionResult, n as canTransitionInteractionStatus, o as cancelStatusFor, p as composerAnswerData, q as composerAnswerDeliveries, r as dedupeQuestionInteractionsByContent, s as fieldAcceptsFreeText, t as interactionFromWireRequest, u as interactionPartKey, v as interactionToPersistedPart, w as isRenderableInteractionKind, x as isSafeInteractionFieldKey, y as isTerminalInteractionStatus, z as noticePart, A as noticePartKey, B as parseInteractionAnswers, D as parseInteractionCancel, E as parseInteractionRequest, F as persistedPartToInteraction, G as questionInteractionContentSignature, H as stampInteractionAnswers } from '../contract-KfqJh_au.js';
+import { ChatPlan } from '../plans/index.js';
 import { InteractionData } from '@tangle-network/agent-interface';
 export { InteractionData, InteractionOutcome, InteractionRequest } from '@tangle-network/agent-interface';
 import { j as FileMention } from '../file-index-Bw_IQE_G.js';
@@ -12,6 +13,189 @@ export { S as SandboxTerminalConnection, a as SandboxTerminalConnectionResponse,
 import { CatalogModel } from '../catalog/index.js';
 import { Harness } from '../harness/index.js';
 
+type DurablePlanDecision = 'approved' | 'rejected';
+/** Stable authority receipt for the follow-up turn dispatched by a plan
+ * decision. Consumers must make `attachFollowUp` idempotent by `receiptId`;
+ * reload and retry deliberately invoke it again. */
+interface DurablePlanFollowUpReceipt {
+    receiptId: string;
+    planId: string;
+    revision: number;
+    turnId: string;
+    state: string;
+}
+interface DurablePlanDecisionResult {
+    plan: ChatPlan;
+    followUp?: DurablePlanFollowUpReceipt;
+    idempotent: boolean;
+    projectionPending?: boolean;
+    effectPending?: boolean;
+}
+interface DurablePlanDecisionInput {
+    planId: string;
+    revision: number;
+    decision: DurablePlanDecision;
+    feedback?: string;
+}
+interface DurablePlanCurrentInput {
+    planId: string;
+    revision?: number;
+}
+interface DurablePlanDecisionClient {
+    current: (input: DurablePlanCurrentInput) => Promise<DurablePlanDecisionResult>;
+    decide: (input: DurablePlanDecisionInput) => Promise<DurablePlanDecisionResult>;
+}
+declare class DurablePlanClientError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly currentPlan?: ChatPlan | undefined;
+    constructor(message: string, status: number, code?: string | undefined, currentPlan?: ChatPlan | undefined);
+}
+interface DurablePlanDecisionClientOptions {
+    url: string | ((input: DurablePlanCurrentInput | DurablePlanDecisionInput) => string);
+    body?: Record<string, unknown> | ((input: DurablePlanDecisionInput) => Record<string, unknown>);
+    fetchImpl?: typeof fetch;
+}
+/** Browser client for the shared durable-plan route. The route URL and all
+ * product routing fields are injected; workspace/session identity is still
+ * resolved and authorized on the server. */
+declare function createDurablePlanDecisionClient(options: DurablePlanDecisionClientOptions): DurablePlanDecisionClient;
+interface UseDurablePlanFlowOptions {
+    plan: ChatPlan;
+    client: DurablePlanDecisionClient;
+    /** Must be idempotent by receipt.receiptId. */
+    attachFollowUp?: (receipt: DurablePlanFollowUpReceipt) => Promise<void> | void;
+    onUpdated?: (plan: ChatPlan) => void;
+}
+interface UseDurablePlanFlowResult {
+    plan: ChatPlan;
+    deciding: DurablePlanDecision | null;
+    restoring: boolean;
+    error: string | null;
+    decide: (decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
+    restore: () => Promise<DurablePlanDecisionResult | null>;
+    clearError: () => void;
+}
+/** Shared plan decision controller. It coalesces only concurrent attachment
+ * attempts; a later retry/restore calls the consumer's idempotent transport
+ * again so a lost response cannot strand an already-dispatched follow-up. */
+declare function useDurablePlanFlow(options: UseDurablePlanFlowOptions): UseDurablePlanFlowResult;
+
+/**
+ * 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;
+}>;
+/** Converts acknowledged, persisted answers back into the local field state
+ * consumed by the shared cards. Persisted values are authoritative: this is
+ * intentionally used only when an interaction carries `answers`, never to
+ * guess an answer from the absence of an outstanding sidecar ask. */
+declare function fieldValuesFromAnswers(fields: ChatInteractionField[], answers: InteractionAnswers | undefined): FieldValues;
+/** 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 DurableChatCard = {
+    kind: 'plan';
+    key: string;
+    plan: ChatPlan;
+} | {
+    kind: 'interaction';
+    key: string;
+    interaction: ChatInteraction;
+};
+/** Converts persisted/live parts to canonical cards. Legacy interaction-plan
+ * cards are suppressed only when their raw part carries an explicit planId and
+ * revision matching a durable plan. Identical markdown alone is never proof. */
+declare function durableChatCardsFromParts(parts: Array<Record<string, unknown>>): DurableChatCard[];
+interface DurableChatCardsProps {
+    parts: Array<Record<string, unknown>>;
+    canWrite: boolean;
+    submitInteraction: SubmitInteractionAnswer;
+    decidePlan: (plan: ChatPlan, decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
+    decidingPlan?: (plan: ChatPlan) => DurablePlanDecision | null;
+    planError?: (plan: ChatPlan) => string | null;
+    onInteractionResolved?: (id: string, status: Exclude<ChatInteraction['status'], 'pending'>, answers?: InteractionAnswers) => void;
+    onLateAnswer?: (message: string) => boolean | void | Promise<boolean | void>;
+    renderMarkdown?: (markdown: string) => ReactNode;
+    className?: string;
+}
+/** Ready-to-embed canonical question/plan card lane for persisted assistant
+ * parts. Apps inject transport and styling callbacks instead of rebuilding the
+ * lifecycle/render switch. */
+declare function DurableChatCards({ parts, canWrite, submitInteraction, decidePlan, decidingPlan, planError, onInteractionResolved, onLateAnswer, renderMarkdown, className, }: DurableChatCardsProps): react.JSX.Element | 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
@@ -64,6 +248,10 @@ interface ChatStreamCallbacks {
      *  user", not "model working". Optional — a consumer that doesn't wire it
      *  parses the same stream unchanged. */
     onInteraction?: (interaction: ChatInteraction) => void;
+    /** A terminal withdrawal/timeout for a previously emitted interaction. */
+    onInteractionCancel?: (cancel: InteractionCancelData) => void;
+    /** A durable-plan snapshot from any plan lifecycle event. */
+    onPlan?: (plan: ChatPlan) => void;
 }
 interface ConsumeChatStreamResult {
     turnId: string | null;
@@ -166,86 +354,6 @@ interface ChatComposerProps {
 }
 declare function ChatComposer({ onSend, onSendParts, onCancel, isStreaming, disabled, placeholder, value, onValueChange, initialValue, seed, onSeedApplied, 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;
@@ -282,7 +390,7 @@ interface InteractionQuestionCardProps {
     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;
+    onResolved?: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>, answers?: ChatInteraction['answers']) => 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. */
@@ -307,6 +415,34 @@ interface InteractionPlanCardProps {
 }
 declare function InteractionPlanCard({ interaction, canWrite, submitAnswer, onResolved, renderMarkdown, className, }: InteractionPlanCardProps): react.JSX.Element;
 
+interface DurablePlanCardProps {
+    plan: ChatPlan;
+    canWrite: boolean;
+    decide: (decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
+    deciding?: DurablePlanDecision | null;
+    error?: string | null;
+    renderMarkdown?: (markdown: string) => ReactNode;
+    className?: string;
+}
+declare function DurablePlanCard({ plan, canWrite, decide, deciding, error, renderMarkdown, className, }: DurablePlanCardProps): react.JSX.Element;
+
+interface InteractionAttemptStore {
+    get(interactionId: string, submissionSignature: string): string | null;
+    set(interactionId: string, submissionSignature: string, attemptKey: string): void;
+    delete(interactionId: string, submissionSignature: string): void;
+}
+declare function createSessionInteractionAttemptStore(storage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>, namespace?: string): InteractionAttemptStore;
+declare function createMemoryInteractionAttemptStore(): InteractionAttemptStore;
+declare function interactionSubmissionSignature(submission: InteractionAnswerSubmission): string;
+interface DurableInteractionAnswerSubmitterOptions extends InteractionAnswerSubmitterOptions {
+    attempts: InteractionAttemptStore;
+    createAttemptKey?: () => string;
+}
+/** Answer submitter for a durable interaction route. One opaque attempt key is
+ * retained for an ambiguous transport/5xx result and reused after reload. A
+ * changed answer has a different signature and therefore a new attempt. */
+declare function createDurableInteractionAnswerSubmitter(options: DurableInteractionAnswerSubmitterOptions): SubmitInteractionAnswer;
+
 /**
  * useChatInteractions — the interaction-state wiring every consumer of
  * `ChatStreamCallbacks.onInteraction` re-implements: an id-keyed,
@@ -336,14 +472,28 @@ declare function upsertChatInteraction(list: ChatInteraction[], interaction: Cha
  *  `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[];
+declare function resolveChatInteraction(list: ChatInteraction[], id: string, status: Exclude<ChatInteractionStatus, 'pending'>, answers?: InteractionAnswers): 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[];
+type ChatInteractionRestoreMode = 'legacy' | 'durable';
+interface RestoreChatInteractionsOptions {
+    /**
+     * `legacy` settles pending asks absent from the sidecar list as answered,
+     * preserving the pre-durable restore contract. `durable` leaves them
+     * pending because absence is ambiguous until `hydrateChatInteractions`
+     * applies the durable projection.
+     */
+    mode?: ChatInteractionRestoreMode;
+}
+/** Reload restore from the answer route's GET list. Legacy consumers retain
+ * the historical absence→answered behavior; durable consumers opt into the
+ * ambiguity-preserving mode and apply terminal parts through `hydrate`. */
+declare function restoreChatInteractions(list: ChatInteraction[], outstanding: InteractionRequestWire[], options?: RestoreChatInteractionsOptions): ChatInteraction[];
+/** Applies transcript/state-store projections after reload. Terminal state and
+ * acknowledged answer values enrich an existing pending card without relying
+ * on the sidecar's outstanding-list absence. */
+declare function hydrateChatInteractions(list: ChatInteraction[], persisted: ChatInteraction[]): ChatInteraction[];
 interface UseChatInteractionsResult {
     /** All known interactions, insertion-ordered. */
     interactions: ChatInteraction[];
@@ -354,15 +504,18 @@ interface UseChatInteractionsResult {
     /** Wire to `interaction.cancel` events. */
     applyCancel: (cancel: InteractionCancelData) => void;
     /** Wire to the cards' `onResolved`. */
-    markResolved: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>) => void;
+    markResolved: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>, answers?: InteractionAnswers) => void;
     /** Wire to the answer route's GET list after a reload/reconnect. */
-    restore: (outstanding: InteractionRequestWire[]) => void;
+    restore: (outstanding: InteractionRequestWire[], options?: RestoreChatInteractionsOptions) => void;
+    /** Apply durable transcript/state projections after a reload. */
+    hydrate: (persisted: ChatInteraction[]) => 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;
+type UseChatInteractionsOptions = RestoreChatInteractionsOptions;
+declare function useChatInteractions(options?: UseChatInteractionsOptions): UseChatInteractionsResult;
 
 /**
  * `useFileMentions` — the glue a host passes straight into `AgentComposer`'s
@@ -801,6 +954,9 @@ interface ChatUiMessage extends ChatMessageMetrics {
      *  present and non-empty it is rendered in place of `content` + `toolCalls`;
      *  both remain the fallback for producers that don't segment a turn. */
     segments?: ChatMessageSegment[];
+    /** Persisted assistant parts. When `ChatMessages.durableCards` is supplied,
+     * shared plan/question cards render directly from these projections. */
+    parts?: Array<Record<string, unknown>>;
 }
 interface ChatMessagesProps {
     messages: ChatUiMessage[];
@@ -810,6 +966,9 @@ interface ChatMessagesProps {
     renderMarkdown?: (content: string) => ReactNode;
     /** Extra per-message content (artifacts, custom panels) appended after the body. */
     renderExtras?: (message: ChatUiMessage) => ReactNode;
+    /** Canonical durable plan/question card wiring. Apps inject only transport,
+     * access, and optional visual callbacks; card selection/dedupe stays shared. */
+    durableCards?: Omit<DurableChatCardsProps, 'parts' | 'renderMarkdown'>;
     userLabel?: string;
     agentLabel?: string;
     /** Render the trailing "agent is thinking" row. */
@@ -882,6 +1041,6 @@ declare function useThinkingSeconds(active: boolean): number;
  * model id, tokens/sec, and cost, plus a collapsible thinking section and
  * tool-call chips.
  */
-declare function ChatMessages({ messages, models, renderMarkdown, renderExtras, userLabel, agentLabel, loading, approval, onToolCallClick, toolRenderers, error, onRetry, renderEmpty, emptyState, header, }: ChatMessagesProps): react.JSX.Element;
+declare function ChatMessages({ messages, models, renderMarkdown, renderExtras, durableCards, 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, 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 ComposerMentionProp, type ConsumeChatStreamResult, DEFAULT_EFFORT_LEVELS, DEFAULT_MENTION_EMPTY_TEXT, DEFAULT_MENTION_LIMIT, type EffortLevel, EffortPicker, type EffortPickerProps, type FieldValues, FileMention, FlowWaterfall, type FlowWaterfallProps, INDEX_REFRESH_AFTER_MS, 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, type MentionItem, 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 UseFileMentionsOptions, type UseFileMentionsResult, type WaterfallRow, activityTone, buildAnswerData, cancelChatInteraction, consumeChatStream, createInteractionAnswerSubmitter, dispatchChatStreamLine, fieldAnswer, formatActivityCost, formatActivityDuration, formatModelCost, formatTokensPerSecond, hasSecretField, interactionStatusLabels, interactionTerminalNotes, isLateAnswerableStatus, lateAnswerMessage, mergeActivityPages, nextRevealCount, pendingApprovalOf, rankFileMentions, resolveChatInteraction, responseErrorMessage, restoreChatInteractions, streamChatTurn, terminalizePendingChatInteractions, upsertChatInteraction, useChatInteractions, useFileMentions, 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, type ChatInteractionRestoreMode, ChatInteractionStatus, type ChatMessageMetrics, type ChatMessageSegment, ChatMessages, type ChatMessagesProps, ChatSelectField, type ChatStreamCallbacks, type ChatStreamToolCall, type ChatStreamToolResult, type ChatToolCallInfo, type ChatUiMessage, type ComposerFile, type ComposerFilePart, type ComposerMentionProp, type ConsumeChatStreamResult, DEFAULT_EFFORT_LEVELS, DEFAULT_MENTION_EMPTY_TEXT, DEFAULT_MENTION_LIMIT, type DurableChatCard, DurableChatCards, type DurableChatCardsProps, type DurableInteractionAnswerSubmitterOptions, DurablePlanCard, type DurablePlanCardProps, DurablePlanClientError, type DurablePlanCurrentInput, type DurablePlanDecision, type DurablePlanDecisionClient, type DurablePlanDecisionClientOptions, type DurablePlanDecisionInput, type DurablePlanDecisionResult, type DurablePlanFollowUpReceipt, type EffortLevel, EffortPicker, type EffortPickerProps, type FieldValues, FileMention, FlowWaterfall, type FlowWaterfallProps, INDEX_REFRESH_AFTER_MS, INTERACTION_SUBMIT_TIMEOUT_MESSAGE, INTERACTION_SUBMIT_TIMEOUT_MS, InteractionActionButton, type InteractionAnswerSubmission, type InteractionAnswerSubmitterOptions, InteractionAnswers, type InteractionAttemptStore, InteractionBadge, type InteractionBadgeVariant, InteractionCancelData, InteractionPlanCard, type InteractionPlanCardProps, InteractionQuestionCard, type InteractionQuestionCardProps, InteractionRequestWire, type InteractionSubmitResult, type MentionItem, MissionActivityLane, type MissionActivityLaneProps, ModelPicker, type ModelPickerProps, type ProposalApprovalHandlers, ProviderLogo, type ProviderLogoProps, QuestionOptionList, type QuestionOptionListProps, type RestoreChatInteractionsOptions, RunDrillIn, type RunDrillInProps, SeatPaywall, type SeatPaywallProps, type SmoothRevealOptions, type StreamChatOptions, type SubmitInteractionAnswer, type ToolDetailRenderers, type ToolRunRecord, type ToolRunStep, type UseChatInteractionsOptions, type UseChatInteractionsResult, type UseDurablePlanFlowOptions, type UseDurablePlanFlowResult, type UseFileMentionsOptions, type UseFileMentionsResult, type WaterfallRow, activityTone, buildAnswerData, cancelChatInteraction, consumeChatStream, createDurableInteractionAnswerSubmitter, createDurablePlanDecisionClient, createInteractionAnswerSubmitter, createMemoryInteractionAttemptStore, createSessionInteractionAttemptStore, dispatchChatStreamLine, durableChatCardsFromParts, fieldAnswer, fieldValuesFromAnswers, formatActivityCost, formatActivityDuration, formatModelCost, formatTokensPerSecond, hasSecretField, hydrateChatInteractions, interactionStatusLabels, interactionSubmissionSignature, interactionTerminalNotes, isLateAnswerableStatus, lateAnswerMessage, mergeActivityPages, nextRevealCount, pendingApprovalOf, rankFileMentions, resolveChatInteraction, responseErrorMessage, restoreChatInteractions, streamChatTurn, terminalizePendingChatInteractions, upsertChatInteraction, useChatInteractions, useDurablePlanFlow, useFileMentions, usePending, usePopover, useSmoothText, useThinkingSeconds, waterfallLayout };

package/dist/web-react/index.js

@@ -7,6 +7,9 @@ import {
   DEFAULT_EFFORT_LEVELS,
   DEFAULT_MENTION_EMPTY_TEXT,
   DEFAULT_MENTION_LIMIT,
+  DurableChatCards,
+  DurablePlanCard,
+  DurablePlanClientError,
   EffortPicker,
   FlowWaterfall,
   INDEX_REFRESH_AFTER_MS,
@@ -26,15 +29,23 @@ import {
   buildAnswerData,
   cancelChatInteraction,
   consumeChatStream,
+  createDurableInteractionAnswerSubmitter,
+  createDurablePlanDecisionClient,
   createInteractionAnswerSubmitter,
+  createMemoryInteractionAttemptStore,
+  createSessionInteractionAttemptStore,
   dispatchChatStreamLine,
+  durableChatCardsFromParts,
   fieldAnswer,
+  fieldValuesFromAnswers,
   formatActivityCost,
   formatActivityDuration,
   formatModelCost,
   formatTokensPerSecond,
   hasSecretField,
+  hydrateChatInteractions,
   interactionStatusLabels,
+  interactionSubmissionSignature,
   interactionTerminalNotes,
   isLateAnswerableStatus,
   lateAnswerMessage,
@@ -49,13 +60,14 @@ import {
   terminalizePendingChatInteractions,
   upsertChatInteraction,
   useChatInteractions,
+  useDurablePlanFlow,
   useFileMentions,
   usePending,
   usePopover,
   useSmoothText,
   useThinkingSeconds,
   waterfallLayout
-} from "../chunk-KM766NN3.js";
+} from "../chunk-PEUBCJXF.js";
 import {
   tabTerminalConnectionId,
   useSandboxTerminalConnection
@@ -85,11 +97,14 @@ import {
   isTerminalInteractionStatus,
   noticePart,
   noticePartKey,
+  parseInteractionAnswers,
   parseInteractionCancel,
   parseInteractionRequest,
   persistedPartToInteraction,
-  questionInteractionContentSignature
-} from "../chunk-4TXDD6P2.js";
+  questionInteractionContentSignature,
+  stampInteractionAnswers
+} from "../chunk-XAWFPMAR.js";
+import "../chunk-SIXYZ2FB.js";
 import "../chunk-E7QYOOON.js";
 export {
   AgentActivityPanel,
@@ -100,6 +115,9 @@ export {
   DEFAULT_EFFORT_LEVELS,
   DEFAULT_MENTION_EMPTY_TEXT,
   DEFAULT_MENTION_LIMIT,
+  DurableChatCards,
+  DurablePlanCard,
+  DurablePlanClientError,
   EffortPicker,
   FlowWaterfall,
   INDEX_REFRESH_AFTER_MS,
@@ -128,20 +146,28 @@ export {
   composerAnswerData,
   composerAnswerDeliveries,
   consumeChatStream,
+  createDurableInteractionAnswerSubmitter,
+  createDurablePlanDecisionClient,
   createInteractionAnswerSubmitter,
+  createMemoryInteractionAttemptStore,
+  createSessionInteractionAttemptStore,
   dedupeQuestionInteractionsByContent,
   dispatchChatStreamLine,
+  durableChatCardsFromParts,
   fieldAcceptsFreeText,
   fieldAnswer,
+  fieldValuesFromAnswers,
   fileMentionsToParts,
   formatActivityCost,
   formatActivityDuration,
   formatModelCost,
   formatTokensPerSecond,
   hasSecretField,
+  hydrateChatInteractions,
   interactionFromWireRequest,
   interactionPartKey,
   interactionStatusLabels,
+  interactionSubmissionSignature,
   interactionTerminalNotes,
   interactionToPersistedPart,
   isLateAnswerableStatus,
@@ -154,6 +180,7 @@ export {
   nextRevealCount,
   noticePart,
   noticePartKey,
+  parseInteractionAnswers,
   parseInteractionCancel,
   parseInteractionRequest,
   pendingApprovalOf,
@@ -163,11 +190,13 @@ export {
   resolveChatInteraction,
   responseErrorMessage,
   restoreChatInteractions,
+  stampInteractionAnswers,
   streamChatTurn,
   tabTerminalConnectionId,
   terminalizePendingChatInteractions,
   upsertChatInteraction,
   useChatInteractions,
+  useDurablePlanFlow,
   useFileMentions,
   usePending,
   usePopover,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.43.41",
+  "version": "0.43.43",
   "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": [
@@ -182,6 +182,16 @@
       "import": "./dist/interactions/index.js",
       "default": "./dist/interactions/index.js"
     },
+    "./plans": {
+      "types": "./dist/plans/index.d.ts",
+      "import": "./dist/plans/index.js",
+      "default": "./dist/plans/index.js"
+    },
+    "./durable-chat": {
+      "types": "./dist/durable-chat/index.d.ts",
+      "import": "./dist/durable-chat/index.js",
+      "default": "./dist/durable-chat/index.js"
+    },
     "./missions": {
       "types": "./dist/missions/index.d.ts",
       "import": "./dist/missions/index.js",

package/dist/chunk-4TXDD6P2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/interactions/contract.ts"],"sourcesContent":["// Shared contract for agent interaction events (kind: \"question\" et al) — the\n// generalized human-in-the-loop primitive on the chat stream. Framework-agnostic\n// (no server- or React-only imports) so a producer (chat route) and a consumer\n// (stream parser, transcript, question card) agree on one wire shape and one\n// persisted-part shape.\n//\n// An `interaction` event means the run is BLOCKED inside the sidecar's\n// InteractionBroker until the user answers, the agent withdraws the ask\n// (`interaction.cancel`), or the broker times out. A pending interaction is\n// \"waiting on the user\", not \"model working\".\n\nimport {\n  InteractionRequestSchema,\n  type InteractionData,\n  type InteractionField,\n  type InteractionOutcome,\n  type InteractionRequest,\n} from '@tangle-network/agent-interface'\n\nexport type { InteractionData, InteractionOutcome, InteractionRequest }\n\n// ---------------------------------------------------------------------------\n// Event names\n\n/** Sidecar → client: the agent raised an ask; data = `{ request }`. */\nexport const INTERACTION_EVENT = 'interaction' as const\n/** Sidecar → client: the ask was withdrawn; data = `{ id, reason? }`. */\nexport const INTERACTION_CANCEL_EVENT = 'interaction.cancel' as const\n/** An ask was answered; data = `{ id, status }`. In the wire contract so a\n *  server broadcast and a client-local mark share one event name. */\nexport const INTERACTION_RESOLVED_EVENT = 'interaction.resolved' as const\n\n/** Interaction kinds a product typically renders a card for. Anything else is\n *  auto-declined by the chat producer's safety net and never reaches a client.\n *  A pure default; a product may substitute its own renderable set. */\nconst RENDERABLE_INTERACTION_KINDS: ReadonlySet<string> = new Set(['question', 'plan'])\n\nexport function isRenderableInteractionKind(kind: string): boolean {\n  return RENDERABLE_INTERACTION_KINDS.has(kind)\n}\n\n/** Answer/field keys the sidecar will accept: identifier-safe and never a\n *  prototype-pollution vector. */\nexport function isSafeInteractionFieldKey(key: string): boolean {\n  return /^[A-Za-z0-9_-]+$/.test(key) && key !== '__proto__' && key !== 'constructor' && key !== 'prototype'\n}\n\n// ---------------------------------------------------------------------------\n// Field types\n//\n// `allowCustom` (a select that also accepts a write-in value) is defined by\n// newer agent-interface schemas; older pinned schemas strip unknown keys on\n// parse. The wire/persisted field types below carry the flag so a card can gate\n// its write-in input, and `parseInteractionRequest` returns the RAW payload\n// (schema-validated, not schema-parsed) so the flag survives.\n\nexport type ChatSelectField = Extract<InteractionField, { type: 'select' }> & {\n  allowCustom?: boolean\n}\nexport type ChatInteractionField = Exclude<InteractionField, { type: 'select' }> | ChatSelectField\n\n/** `InteractionRequest` whose select fields may carry `allowCustom`. */\nexport type InteractionRequestWire = Omit<InteractionRequest, 'answerSpec'> & {\n  answerSpec: { fields: ChatInteractionField[] }\n}\n\n// ---------------------------------------------------------------------------\n// Interaction lifecycle\n\nexport type ChatInteractionStatus = 'pending' | 'answered' | 'declined' | 'cancelled' | 'expired'\n\n/** The client/persisted view of one ask. `fields` come verbatim off the wire. */\nexport interface ChatInteraction {\n  id: string\n  kind: string\n  title: string\n  body?: string\n  fields: ChatInteractionField[]\n  status: ChatInteractionStatus\n  /** Set when status came from an `interaction.cancel` (e.g. \"timeout\"). */\n  cancelReason?: string\n}\n\nexport function isTerminalInteractionStatus(status: ChatInteractionStatus): boolean {\n  return status !== 'pending'\n}\n\n/** Statuses only move forward (pending → terminal); a replayed/stale `pending`\n *  must never resurrect a resolved card. */\nexport function canTransitionInteractionStatus(\n  from: ChatInteractionStatus,\n  to: ChatInteractionStatus,\n): boolean {\n  return from === 'pending' && to !== from\n}\n\n/** Maps an `interaction.cancel` reason to the card's terminal status. */\nexport function cancelStatusFor(reason: string | undefined): ChatInteractionStatus {\n  return reason === 'timeout' ? 'expired' : 'cancelled'\n}\n\nfunction stableValue(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map(stableValue)\n  if (!value || typeof value !== 'object') return value\n  return Object.fromEntries(\n    Object.entries(value as Record<string, unknown>)\n      .sort(([left], [right]) => left.localeCompare(right))\n      .map(([key, nested]) => [key, stableValue(nested)]),\n  )\n}\n\nfunction normalizedInteractionText(value: string | undefined): string {\n  return (value ?? '').replace(/\\s+/g, ' ').trim()\n}\n\n/** Content identity for duplicate safety nets. Excludes volatile ids/statuses. */\nexport function questionInteractionContentSignature(interaction: ChatInteraction): string | null {\n  if (interaction.kind !== 'question') return null\n  return JSON.stringify(stableValue({\n    kind: interaction.kind,\n    title: normalizedInteractionText(interaction.title),\n    body: normalizedInteractionText(interaction.body),\n    fields: interaction.fields,\n  }))\n}\n\nexport function dedupeQuestionInteractionsByContent(interactions: ChatInteraction[]): ChatInteraction[] {\n  const seen = new Set<string>()\n  return interactions.filter((interaction) => {\n    const signature = questionInteractionContentSignature(interaction)\n    if (!signature) return true\n    if (seen.has(signature)) return false\n    seen.add(signature)\n    return true\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Wire parsing — typed outcomes, fail loud at the caller (log + skip; never a\n// half-rendered card).\n\nexport type ParseInteractionResult =\n  | { succeeded: true; value: InteractionRequestWire }\n  | { succeeded: false; error: string }\n\n/** Parses an `interaction` event's data (`{ request }`). Validates the shape\n *  with the agent-interface schema but returns the raw request so a field a\n *  pinned schema predates (`allowCustom`) survives. */\nexport function parseInteractionRequest(data: Record<string, unknown> | undefined): ParseInteractionResult {\n  const request = data?.request\n  if (!request || typeof request !== 'object') {\n    return { succeeded: false, error: 'interaction event carried no request object' }\n  }\n  const validation = InteractionRequestSchema.safeParse(request)\n  if (!validation.success) {\n    return { succeeded: false, error: `malformed interaction request: ${validation.error.message}` }\n  }\n  return { succeeded: true, value: request as InteractionRequestWire }\n}\n\nexport interface InteractionCancelData {\n  id: string\n  reason?: string\n}\n\nexport function parseInteractionCancel(\n  data: Record<string, unknown> | undefined,\n): { succeeded: true; value: InteractionCancelData } | { succeeded: false; error: string } {\n  const id = typeof data?.id === 'string' && data.id ? data.id : null\n  if (!id) return { succeeded: false, error: 'interaction.cancel event carried no id' }\n  const reason = typeof data?.reason === 'string' && data.reason ? data.reason : undefined\n  return { succeeded: true, value: { id, ...(reason ? { reason } : {}) } }\n}\n\n// ---------------------------------------------------------------------------\n// Composer-as-answer delivery: while asks are pending the composer never\n// blocks — typed text is delivered verbatim to every open ask and the agent\n// decides what it means. No interpretation here; the sidecar validates answers\n// fail-closed (invalid free text on an option-only ask → 400).\n\nexport function fieldAcceptsFreeText(field: ChatInteractionField): boolean {\n  if (field.type === 'text') return true\n  if (field.type === 'select') return (field as ChatSelectField).allowCustom === true\n  return false\n}\n\nexport interface ComposerAnswerDelivery {\n  interactionId: string\n  field: ChatInteractionField\n}\n\n/** One delivery per pending ask: the first free-text-capable field, else the\n *  first field. Zero-field asks are skipped (nothing to carry the text). */\nexport function composerAnswerDeliveries(pending: ChatInteraction[]): ComposerAnswerDelivery[] {\n  const deliveries: ComposerAnswerDelivery[] = []\n  for (const interaction of pending) {\n    // Only questions take a composer-routed answer. A non-question ask (a plan)\n    // is POSTed as outcome:\"accepted\" when answered — routing composer text to\n    // it would silently APPROVE it. Approval is an explicit card click, so the\n    // composer skips it and the plan card stays the only path.\n    if (interaction.kind !== 'question') continue\n    const field = interaction.fields.find(fieldAcceptsFreeText) ?? interaction.fields[0]\n    if (!field) continue\n    deliveries.push({ interactionId: interaction.id, field })\n  }\n  return deliveries\n}\n\n/** Shapes composer text into the respond payload for the routed field\n *  (select answers are string arrays on the wire; text answers are strings). */\nexport function composerAnswerData(field: ChatInteractionField, text: string): InteractionData {\n  return { [field.name]: field.type === 'select' ? [text] : text }\n}\n\n// ---------------------------------------------------------------------------\n// Part keys + codecs (persisted `messages.parts` entries and live stream parts\n// share these shapes).\n\nexport function interactionPartKey(id: string): string {\n  return `interaction:${id}`\n}\n\nexport function noticePartKey(id: string): string {\n  return `notice:${id}`\n}\n\nexport type NoticeKind = 'warning' | 'auto-declined'\n\n/**\n * Persisted-part shapes the codecs below produce — the SAME rows\n * `/chat-store`'s `ChatInteractionPart`/`ChatNoticePart` store, typed at the\n * source so a product pushing them into a `ChatMessagePart[]` transcript needs\n * no cast. Type aliases (not interfaces) on purpose: the implicit index\n * signature keeps them assignable to the `Record<string, unknown>` these\n * codecs previously returned, so existing consumers stay source-compatible.\n */\nexport type InteractionPersistedPart = {\n  type: 'interaction'\n  id: string\n  kind: string\n  title: string\n  body?: string\n  answerSpec: { fields: ChatInteractionField[] }\n  status: ChatInteractionStatus\n  cancelReason?: string\n}\n\nexport type NoticePersistedPart = {\n  type: 'notice'\n  id: string\n  noticeKind: NoticeKind\n  text: string\n}\n\n/** Builds the persisted/streamed `notice` part — a one-line transcript notice\n *  explaining an out-of-band event (warning, auto-declined interaction). */\nexport function noticePart(noticeKind: NoticeKind, id: string, text: string): NoticePersistedPart {\n  return { type: 'notice', id, noticeKind, text }\n}\n\n/** Reads a wire request into the client's pending `ChatInteraction`. */\nexport function interactionFromWireRequest(request: InteractionRequestWire): ChatInteraction {\n  return {\n    id: request.id,\n    kind: request.kind,\n    title: request.title,\n    ...(request.body ? { body: request.body } : {}),\n    fields: request.answerSpec.fields,\n    status: 'pending',\n  }\n}\n\n/** Builds the persisted/streamed `interaction` part from a wire request. */\nexport function interactionToPersistedPart(\n  request: InteractionRequestWire,\n  status: ChatInteractionStatus,\n  cancelReason?: string,\n): InteractionPersistedPart {\n  return {\n    type: 'interaction',\n    id: request.id,\n    kind: request.kind,\n    title: request.title,\n    ...(request.body ? { body: request.body } : {}),\n    answerSpec: { fields: request.answerSpec.fields },\n    status,\n    ...(cancelReason ? { cancelReason } : {}),\n  }\n}\n\n/** Reads a persisted/streamed `interaction` part back into a `ChatInteraction`.\n *  Returns null (caller logs) when the part is not one of ours. */\nexport function persistedPartToInteraction(part: Record<string, unknown>): ChatInteraction | null {\n  if (String(part.type ?? '') !== 'interaction') return null\n  const id = typeof part.id === 'string' && part.id ? part.id : null\n  const kind = typeof part.kind === 'string' && part.kind ? part.kind : null\n  const title = typeof part.title === 'string' ? part.title : ''\n  const answerSpec = part.answerSpec as { fields?: unknown } | undefined\n  const fields = Array.isArray(answerSpec?.fields) ? (answerSpec.fields as ChatInteractionField[]) : null\n  const status = part.status as ChatInteractionStatus | undefined\n  const validStatus = status && ['pending', 'answered', 'declined', 'cancelled', 'expired'].includes(status)\n  if (!id || !kind || !fields || !validStatus) return null\n  return {\n    id,\n    kind,\n    title,\n    ...(typeof part.body === 'string' && part.body ? { body: part.body } : {}),\n    fields,\n    status,\n    ...(typeof part.cancelReason === 'string' && part.cancelReason ? { cancelReason: part.cancelReason } : {}),\n  }\n}\n"],"mappings":"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","names":[]}