@tangle-network/agent-app 0.45.54 → 0.45.55

package/dist/assets/schema.d.ts

@@ -0,0 +1,264 @@
+import { z } from 'zod';
+import type { AssetSpec } from './types';
+/** Validate brand token properties including colors, font, logo URL, business name, and voice */
+export declare const BrandTokensSchema: z.ZodObject<{
+    primaryColor: z.ZodString;
+    accentColor: z.ZodString;
+    textColor: z.ZodString;
+    fontFamily: z.ZodString;
+    logoUrl: z.ZodOptional<z.ZodString>;
+    businessName: z.ZodString;
+    voice: z.ZodString;
+}, z.core.$strip>;
+/** Validate and parse email content objects with subject, optional preheader, and sections */
+export declare const EmailContentSchema: z.ZodObject<{
+    subject: z.ZodString;
+    preheader: z.ZodOptional<z.ZodString>;
+    sections: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"hero">;
+        headline: z.ZodString;
+        subheadline: z.ZodOptional<z.ZodString>;
+        imageUrl: z.ZodOptional<z.ZodString>;
+        ctaLabel: z.ZodOptional<z.ZodString>;
+        ctaUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"body">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"feature">;
+        headline: z.ZodString;
+        description: z.ZodString;
+        imageUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"testimonial">;
+        quote: z.ZodString;
+        author: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        avatarUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"cta">;
+        label: z.ZodString;
+        url: z.ZodString;
+        subtext: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"divider">;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/** Validate image content with an array of one or more slides containing background details */
+export declare const ImageContentSchema: z.ZodObject<{
+    slides: z.ZodArray<z.ZodObject<{
+        background: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"color">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"gradient">;
+            from: z.ZodString;
+            to: z.ZodString;
+            direction: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodString;
+            overlay: z.ZodOptional<z.ZodString>;
+            overlayOpacity: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>], "type">;
+        layers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+            fontSize: z.ZodOptional<z.ZodNumber>;
+            fontWeight: z.ZodOptional<z.ZodEnum<{
+                bold: "bold";
+                normal: "normal";
+            }>>;
+            color: z.ZodOptional<z.ZodString>;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodOptional<z.ZodNumber>;
+            align: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+                center: "center";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            opacity: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"shape">;
+            shape: z.ZodEnum<{
+                rect: "rect";
+                circle: "circle";
+                "rounded-rect": "rounded-rect";
+            }>;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fill: z.ZodOptional<z.ZodString>;
+            opacity: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"logo">;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Define the schema for validating video content including duration, scenes, audio, captions, and rendered URL */
+export declare const VideoContentSchema: z.ZodObject<{
+    durationSeconds: z.ZodNumber;
+    scenes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text-animation">;
+        durationSeconds: z.ZodNumber;
+        headline: z.ZodString;
+        subtext: z.ZodOptional<z.ZodString>;
+        animation: z.ZodOptional<z.ZodEnum<{
+            fade: "fade";
+            "slide-up": "slide-up";
+            typewriter: "typewriter";
+        }>>;
+        background: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"color">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"gradient">;
+            from: z.ZodString;
+            to: z.ZodString;
+            direction: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodString;
+            overlay: z.ZodOptional<z.ZodString>;
+            overlayOpacity: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image-reveal">;
+        durationSeconds: z.ZodNumber;
+        imageUrl: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"slide">;
+        durationSeconds: z.ZodNumber;
+        slide: z.ZodObject<{
+            background: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"color">;
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"gradient">;
+                from: z.ZodString;
+                to: z.ZodString;
+                direction: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodString;
+                overlay: z.ZodOptional<z.ZodString>;
+                overlayOpacity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "type">;
+            layers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+                fontSize: z.ZodOptional<z.ZodNumber>;
+                fontWeight: z.ZodOptional<z.ZodEnum<{
+                    bold: "bold";
+                    normal: "normal";
+                }>>;
+                color: z.ZodOptional<z.ZodString>;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodOptional<z.ZodNumber>;
+                align: z.ZodOptional<z.ZodEnum<{
+                    left: "left";
+                    right: "right";
+                    center: "center";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodString;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                opacity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"shape">;
+                shape: z.ZodEnum<{
+                    rect: "rect";
+                    circle: "circle";
+                    "rounded-rect": "rounded-rect";
+                }>;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                fill: z.ZodOptional<z.ZodString>;
+                opacity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"logo">;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"countdown">;
+        durationSeconds: z.ZodNumber;
+        from: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    audioUrl: z.ZodOptional<z.ZodString>;
+    captions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startSeconds: z.ZodNumber;
+        endSeconds: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    renderedUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Validate and parse copy content with headline, body, optional hashtags, platform, and character count */
+export declare const CopyContentSchema: z.ZodObject<{
+    headline: z.ZodString;
+    body: z.ZodString;
+    hashtags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    platform: z.ZodEnum<{
+        x: "x";
+        linkedin: "linkedin";
+        tiktok: "tiktok";
+        instagram: "instagram";
+        sms: "sms";
+        "email-subject": "email-subject";
+    }>;
+    characterCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Validate approval event data including asset, action, user, timestamp, and optional fields */
+export declare const ApprovalEventSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    variantId: z.ZodOptional<z.ZodString>;
+    action: z.ZodEnum<{
+        scheduled: "scheduled";
+        approved: "approved";
+        rejected: "rejected";
+        edited: "edited";
+    }>;
+    editedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userId: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+/** Validate conversion metrics with nonnegative impressions, clicks, conversions, CTR, and CVR fields */
+export declare const ConversionMetricsSchema: z.ZodObject<{
+    impressions: z.ZodNumber;
+    clicks: z.ZodNumber;
+    conversions: z.ZodNumber;
+    ctr: z.ZodNumber;
+    cvr: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Validates an unknown value as an AssetSpec, including format-specific
+ * content validation. Throws ZodError on invalid input.
+ */
+export declare function parseAssetSpec(raw: unknown): AssetSpec;
+/**
+ * Safe parse — returns null instead of throwing.
+ */
+export declare function safeParseAssetSpec(raw: unknown): AssetSpec | null;

package/dist/assets/types.d.ts

@@ -0,0 +1,237 @@
+/** Define brand identity tokens including colors, font, logo, business name, and voice */
+export interface BrandTokens {
+    primaryColor: string;
+    accentColor: string;
+    textColor: string;
+    fontFamily: string;
+    logoUrl?: string;
+    businessName: string;
+    voice: string;
+}
+/** Define valid asset format strings for various media and copy types */
+export type AssetFormat = 'email' | 'image:feed' | 'image:story' | 'image:carousel' | 'video:reel' | 'video:feed' | 'copy:caption' | 'copy:headline' | 'copy:sms';
+/** Define possible states representing the lifecycle status of an asset */
+export type AssetStatus = 'draft' | 'pending_review' | 'approved' | 'rejected' | 'scheduled' | 'published';
+/** Define the structure for a hero section in an email with headline, image, and call-to-action fields */
+export interface EmailHeroSection {
+    type: 'hero';
+    headline: string;
+    subheadline?: string;
+    imageUrl?: string;
+    ctaLabel?: string;
+    ctaUrl?: string;
+}
+/** Define the structure for the body section of an email containing plain text content */
+export interface EmailBodySection {
+    type: 'body';
+    text: string;
+}
+/** Define a feature section with headline, description, and optional image for email content */
+export interface EmailFeatureSection {
+    type: 'feature';
+    headline: string;
+    description: string;
+    imageUrl?: string;
+}
+/** Define the structure for an email testimonial section with quote, author, and optional details */
+export interface EmailTestimonialSection {
+    type: 'testimonial';
+    quote: string;
+    author: string;
+    role?: string;
+    avatarUrl?: string;
+}
+/** Define a call-to-action section with label, URL, and optional subtext for email content */
+export interface EmailCtaSection {
+    type: 'cta';
+    label: string;
+    url: string;
+    subtext?: string;
+}
+/** Define a section representing a divider in an email layout */
+export interface EmailDividerSection {
+    type: 'divider';
+}
+/** Define a union type representing different sections of an email template */
+export type EmailSection = EmailHeroSection | EmailBodySection | EmailFeatureSection | EmailTestimonialSection | EmailCtaSection | EmailDividerSection;
+/** Define the structure for email content including subject, optional preheader, and sections */
+export interface EmailContent {
+    subject: string;
+    preheader?: string;
+    sections: EmailSection[];
+}
+/** Define image layer categories for text, image, shape, or logo elements */
+export type ImageLayerType = 'text' | 'image' | 'shape' | 'logo';
+/** Define properties for a text layer with position, style, and alignment options in an image */
+export interface ImageTextLayer {
+    type: 'text';
+    text: string;
+    fontSize?: number;
+    fontWeight?: 'normal' | 'bold';
+    color?: string;
+    x: number;
+    y: number;
+    width?: number;
+    align?: 'left' | 'center' | 'right';
+}
+/** Define properties for an image layer including position, size, URL, and optional opacity */
+export interface ImageImageLayer {
+    type: 'image';
+    url: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    opacity?: number;
+}
+/** Define properties for a shape layer representing rectangular or circular image elements */
+export interface ImageShapeLayer {
+    type: 'shape';
+    shape: 'rect' | 'circle' | 'rounded-rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill?: string;
+    opacity?: number;
+}
+/** Define properties for positioning and sizing a logo image layer in a layout */
+export interface ImageLogoLayer {
+    type: 'logo';
+    x: number;
+    y: number;
+    width?: number;
+}
+/** Resolve a union type representing different kinds of image layers */
+export type ImageLayer = ImageTextLayer | ImageImageLayer | ImageShapeLayer | ImageLogoLayer;
+/** Define image background styles as color, gradient, or image with optional overlay settings */
+export type ImageBackground = {
+    type: 'color';
+    value: string;
+} | {
+    type: 'gradient';
+    from: string;
+    to: string;
+    direction?: string;
+} | {
+    type: 'image';
+    url: string;
+    overlay?: string;
+    overlayOpacity?: number;
+};
+/** Define the structure for an image slide with a background and multiple layers */
+export interface ImageSlide {
+    background: ImageBackground;
+    layers: ImageLayer[];
+}
+/** Define the structure for image content containing an array of image slides */
+export interface ImageContent {
+    slides: ImageSlide[];
+}
+/** Define properties for a video scene displaying animated text with optional background and effects */
+export interface VideoTextAnimationScene {
+    type: 'text-animation';
+    durationSeconds: number;
+    headline: string;
+    subtext?: string;
+    animation?: 'fade' | 'slide-up' | 'typewriter';
+    background?: ImageBackground;
+}
+/** Define a scene that reveals an image with optional caption over a specified duration */
+export interface VideoImageRevealScene {
+    type: 'image-reveal';
+    durationSeconds: number;
+    imageUrl: string;
+    caption?: string;
+}
+/** Define a video slide scene with duration and associated image slide details */
+export interface VideoSlideScene {
+    type: 'slide';
+    durationSeconds: number;
+    slide: ImageSlide;
+}
+/** Define a countdown scene with duration, start time, and optional label for video sequences */
+export interface VideoCountdownScene {
+    type: 'countdown';
+    durationSeconds: number;
+    from: number;
+    label?: string;
+}
+/** Resolve a video scene as one of several specific animation or reveal types */
+export type VideoScene = VideoTextAnimationScene | VideoImageRevealScene | VideoSlideScene | VideoCountdownScene;
+/** Define video caption segments with start and end times and associated text content */
+export interface VideoCaption {
+    startSeconds: number;
+    endSeconds: number;
+    text: string;
+}
+/** Describe video content including duration, scenes, optional audio, captions, and rendered URL */
+export interface VideoContent {
+    durationSeconds: number;
+    scenes: VideoScene[];
+    audioUrl?: string;
+    captions?: VideoCaption[];
+    renderedUrl?: string;
+}
+/** Define platform options for copy content across various social media and communication channels */
+export type CopyPlatform = 'instagram' | 'tiktok' | 'x' | 'linkedin' | 'sms' | 'email-subject';
+/** Define the structure for content with headline, body, platform, and optional hashtags and character count */
+export interface CopyContent {
+    headline: string;
+    body: string;
+    hashtags?: string[];
+    platform: CopyPlatform;
+    characterCount?: number;
+}
+/** Map asset keys to their corresponding content types for various media and copy formats */
+export type AssetContentMap = {
+    email: EmailContent;
+    'image:feed': ImageContent;
+    'image:story': ImageContent;
+    'image:carousel': ImageContent;
+    'video:reel': VideoContent;
+    'video:feed': VideoContent;
+    'copy:caption': CopyContent;
+    'copy:headline': CopyContent;
+    'copy:sms': CopyContent;
+};
+/** Define the structure and metadata for an asset including its format, brand, content, and status */
+export interface AssetSpec<F extends AssetFormat = AssetFormat> {
+    id: string;
+    workspaceId: string;
+    campaignId?: string;
+    format: F;
+    brand: BrandTokens;
+    content: AssetContentMap[F];
+    status: AssetStatus;
+    scheduledAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Describe an asset variant with identification, approval status, and edit history details */
+export interface AssetVariant {
+    id: string;
+    parentId: string;
+    label: string;
+    spec: AssetSpec;
+    approvedAt?: string;
+    rejectedAt?: string;
+    editLog: ApprovalEvent[];
+}
+/** Describe an approval event with action details, user info, and optional edited fields */
+export interface ApprovalEvent {
+    assetId: string;
+    variantId?: string;
+    action: 'approved' | 'rejected' | 'edited' | 'scheduled';
+    editedFields?: string[];
+    userId: string;
+    timestamp: string;
+}
+/** Define metrics for tracking impressions, clicks, conversions, and related rates */
+export interface ConversionMetrics {
+    impressions: number;
+    clicks: number;
+    conversions: number;
+    ctr: number;
+    cvr: number;
+}

package/dist/assistant/AssistantDock.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Persistent assistant entry point: a floating launcher that opens the chat
+ * panel as a right-side drawer (full-screen on small viewports), with focus
+ * trapping and a resizable width. Owns the chat state (via useAssistantChat) so
+ * the conversation survives the drawer closing — host-shell concerns (the user,
+ * navigation, balance, money formatting, the graph renderer, and the workflow-
+ * mutation signal) are injected.
+ *
+ * Mount inside an <AssistantClientProvider> (transport) and an
+ * <AssistantLauncherProvider> (open/seed state).
+ */
+import { type ReactNode } from "react";
+import { type ToolDetailRenderers } from "../web-react";
+import { type AssistantPanelProps } from "./AssistantPanel";
+import type { AssistantTranscriptView, ConfirmedResult, ConnectionRequirement, ConnectRequirementResult } from "./types";
+export interface AssistantDockProps {
+    /** The signed-in user this conversation belongs to (null when signed out). */
+    userId: string | null;
+    /** Host navigation for error CTAs and connect targets. */
+    navigate?: (path: string) => void;
+    balanceUsd?: number | null;
+    formatMoney?: (usd: number | null) => string;
+    /** Render workflow YAML as a node graph in a proposal card. */
+    renderGraph?: (yaml: string) => ReactNode;
+    /** Render the brand icon for a proposal requirement's integration provider.
+     *  The host owns the provider→icon mapping (its integrations catalog); when
+     *  absent, the card falls back to its built-in provider mark. */
+    renderProviderIcon?: (provider: string) => ReactNode;
+    /** Called after a workflow-mutating tool is confirmed (host re-fetches its list). */
+    onWorkflowMutation?: () => void;
+    /** In-place connect handler for a proposal's integration requirements. The host
+     *  runs its own connect flow (OAuth popup, api-key modal, app install) and
+     *  resolves whether the requirement is now satisfied; the proposal card then
+     *  flips it to connected. Host-agnostic — when omitted, the card falls back to
+     *  navigating the requirement's connect target via `navigate`. */
+    onConnectRequirement?: (requirement: ConnectionRequirement) => Promise<ConnectRequirementResult>;
+    /** Markdown renderer for assistant message content (plain text when absent). */
+    renderMarkdown?: (content: string) => ReactNode;
+    /** Per-tool custom detail renderers for expanded tool cards in the transcript. */
+    toolRenderers?: ToolDetailRenderers;
+    /** Render a prominent card for a CONFIRMED tool's result (e.g. a one-time
+     *  API-key reveal for `create_api_key`), shown inline after the action's status
+     *  line. The result's `output` may carry a one-time secret — see
+     *  {@link ConfirmedResult} for the never-persist/never-to-model contract. */
+    renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
+    /** Swap the conversation rendering for a host-supplied renderer (see
+     *  {@link AssistantPanelProps.renderTranscript}); the dock chrome, composer,
+     *  transport, and proposal flow stay owned by the panel. */
+    renderTranscript?: (view: AssistantTranscriptView) => ReactNode;
+    /** Opt-in attachment surface for the dock's composer — forwarded to
+     *  {@link AssistantPanelProps.composerAttachments}. */
+    composerAttachments?: AssistantPanelProps["composerAttachments"];
+    /** Forwarded to {@link AssistantPanelProps.onComposerSend}. */
+    onComposerSend?: AssistantPanelProps["onComposerSend"];
+}
+export declare function AssistantDock({ userId, navigate, balanceUsd, formatMoney, renderGraph, renderProviderIcon, onWorkflowMutation, onConnectRequirement, renderMarkdown, toolRenderers, renderConfirmedResult, renderTranscript, composerAttachments, onComposerSend, }: AssistantDockProps): import("react").JSX.Element;

package/dist/assistant/AssistantHistory.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The assistant's conversation history as a full-panel view: a searchable,
+ * recency-sorted list of past threads, each showing its title and a relative
+ * "last active" time, with inline delete. Replaces the cramped header dropdown —
+ * inside an already-narrow side panel, a full-height list is far easier to scan
+ * and navigate. Selection, deletion, and refresh are owned by the host panel;
+ * this component is presentational and holds only its own search query.
+ *
+ * The four states the list can be in are rendered through `web-react/async`'s
+ * `AsyncView` rather than a local ternary, because the ternary is what shipped
+ * the defect: with no `error` branch, a failed thread fetch fell through to
+ * "No past conversations yet." and told a user with a full history that they had
+ * none, with no retry. `AsyncView` cannot render `error` as `empty` — they are
+ * different variants — so the branch cannot go missing again. The load itself
+ * stays in `useAssistantThreads` (whose owner-masking and pending-delete rules
+ * are transport-specific); this component consumes its outcome.
+ */
+import type { AssistantThreadSummary } from "./client";
+export interface AssistantHistoryProps {
+    threads: AssistantThreadSummary[];
+    /** True once a fetch has settled at least once (drives empty-vs-loading copy). */
+    loaded: boolean;
+    /** Why the load failed, from `useAssistantThreads`. Non-null renders the error
+     *  branch with a retry instead of an empty list. REQUIRED: a caller that never
+     *  has to answer "did the load fail?" is the caller that renders a failure as
+     *  an empty list. */
+    error: string | null;
+    /** Re-runs the load — `useAssistantThreads().refresh`. Required so the error
+     *  branch's button can never be inert. */
+    onRetry: () => void;
+    /** The thread the live conversation is on, highlighted in the list. */
+    activeThreadId: string | null;
+    /** Whether the active thread is mid-turn — its delete is disabled (the stream
+     *  is still writing to it). */
+    activeBusy: boolean;
+    /** Whether the transport supports deletion (drives the delete affordance). */
+    canRemove: boolean;
+    onSelect: (threadId: string) => void;
+    onDelete: (threadId: string) => void;
+}
+export declare function AssistantHistory({ threads, loaded, error, onRetry, activeThreadId, activeBusy, canRemove, onSelect, onDelete, }: AssistantHistoryProps): import("react").JSX.Element;

package/dist/assistant/AssistantPanel.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The assistant chat panel, built on web-react's chat components. The reducer
+ * state is rendered by `AssistantTranscript` (web-react `ChatMessages`: transcript,
+ * tool chips, reasoning preview, cost, proposal cards) and the composer is a
+ * `ChatComposer` carrying the `ModelPicker` in its controls slot. The header's
+ * history toggle swaps the conversation area for a full-panel, searchable history
+ * view. App-shell concerns — the signed-in user, navigation, the credit balance,
+ * money formatting, the markdown + tool-detail renderers, and the workflow-graph
+ * renderer — are injected so the panel is portable across hosts. Chat state is
+ * owned by the dock and passed in, so the conversation survives the drawer closing.
+ */
+import { type ReactNode } from "react";
+import type { CatalogModel } from "../runtime/model-catalog";
+import { type ComposerFile, type ToolDetailRenderers } from "../web-react";
+import type { AssistantModels } from "./client";
+import type { AssistantTranscriptView, ConfirmedResult } from "./types";
+import type { AssistantChat } from "./useAssistantChat";
+export interface AssistantPanelProps {
+    chat: AssistantChat;
+    userId: string | null;
+    onClose: () => void;
+    /** Host navigation for error CTAs and connect targets. */
+    navigate?: (path: string) => void;
+    /** The user's credit balance, for the header tile + low-balance nudge. */
+    balanceUsd?: number | null;
+    /** Format a USD amount; defaults to Intl currency formatting. */
+    formatMoney?: (usd: number | null) => string;
+    /** Render workflow YAML as a node graph in a proposal card (the `./workflows`
+     *  WorkflowGraph). When absent, proposals show YAML as text. */
+    renderGraph?: (yaml: string) => ReactNode;
+    /** Render the brand icon for a proposal requirement's integration provider.
+     *  When absent, the card falls back to its built-in provider mark. */
+    renderProviderIcon?: (provider: string) => ReactNode;
+    /** Markdown renderer for assistant message content. When absent, content
+     *  renders as plain pre-wrapped text. */
+    renderMarkdown?: (content: string) => ReactNode;
+    /** Per-tool custom detail renderers for expanded tool cards in the transcript. */
+    toolRenderers?: ToolDetailRenderers;
+    /** Render a prominent card for a CONFIRMED tool's result (e.g. a one-time
+     *  API-key reveal for `create_api_key`), shown inline after the action's status
+     *  line. Ignored when a host swaps the whole transcript via `renderTranscript`. */
+    renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
+    /** Swap ONLY the conversation rendering for a host-supplied renderer (e.g. a
+     *  different chat-message component), while the panel keeps owning the header,
+     *  composer, model picker, history, transport, and proposal orchestration.
+     *  Receives the transcript slice plus a bound proposal card to place. When
+     *  absent, the built-in transcript (web-react `ChatMessages`) renders the
+     *  conversation. */
+    renderTranscript?: (view: AssistantTranscriptView) => ReactNode;
+    /** One-shot composer prefill from the host's launcher (e.g. a page's "Create
+     *  with assistant" button passing `openAssistant(seed)`). The panel adopts it
+     *  as the composer draft and calls `onComposerSeedApplied` once, so the host
+     *  clears its seed state (consume-once). */
+    composerSeed?: string | null;
+    onComposerSeedApplied?: () => void;
+    /** Opt-in attachment surface for the composer, mirroring `ChatComposer`'s
+     *  attachment props: pass `onAttach` to show the attach button and accept
+     *  drag-and-drop, and drive the staged-file chips with `pendingFiles` /
+     *  `onRemoveFile` (web-react's `useComposerAttachments` owns that lifecycle).
+     *  Omitted, the composer stays text-only. The assistant wire carries text
+     *  only, so a host that stages files owns getting their content to the model
+     *  (e.g. inlined on the next `chat.send`); `onComposerSend` is the signal to
+     *  consume and clear the staged set. */
+    composerAttachments?: {
+        onAttach: (files: FileList) => void;
+        onAttachFolder?: (files: FileList) => void;
+        pendingFiles?: ComposerFile[];
+        onRemoveFile?: (id: string) => void;
+        accept?: string;
+    };
+    /** Fired when the composer sends (alongside `chat.send`) — the host's signal
+     *  to consume and clear its staged attachments. */
+    onComposerSend?: (message: string) => void;
+}
+export declare function toPickerModels(models: AssistantModels, selected: string | null): CatalogModel[];
+/**
+ * The chat-state value to store for a model id chosen in the picker. Picking the
+ * server default clears the preference to `null` — preserving the native-select
+ * contract where "default" means "omit the model and follow whatever the server
+ * default is", rather than pinning the default's slug (which would freeze the
+ * user to it even after the server default changes). Any other id is stored as-is.
+ */
+export declare function nextModelSelection(id: string, defaultSlug: string | null): string | null;
+export declare function AssistantPanel({ chat, userId, onClose, navigate, balanceUsd, formatMoney, renderGraph, renderProviderIcon, renderMarkdown, toolRenderers, renderConfirmedResult, renderTranscript, composerSeed, onComposerSeedApplied, composerAttachments, onComposerSend, }: AssistantPanelProps): import("react").JSX.Element;