@percena/weft 0.4.0-next.7 → 0.4.0-next.9

package/dist/index.d.cts

@@ -3124,13 +3124,13 @@ interface TimelineStream {
 }
 
 /**
- * FlitroHttpClient
+ * WeftHttpClient
  *
- * Typed HTTP client for the Flitro Go Agent Server REST API.
- * All methods map 1-to-1 with Flitro's HTTP endpoints.
+ * Typed HTTP client for the Weft Server REST API.
+ * All methods map 1-to-1 with the server's HTTP endpoints.
  */
-interface FlitroClientOptions {
-    /** Base URL of the Flitro server, e.g. http://localhost:8080 */
+interface WeftHttpClientOptions {
+    /** Base URL of the Weft server, e.g. http://localhost:8080 */
     baseUrl: string;
     /** Optional bearer token for API-key auth */
     apiKey?: string;
@@ -3139,7 +3139,7 @@ interface FlitroClientOptions {
     /** Optional timeout in milliseconds (default: 30000) */
     timeout?: number;
     /**
-     * Scoped embed session token minted by the host backend via Flitro's
+     * Scoped embed session token minted by the host backend via
      * `POST /v1/embed/sessions`. Sent as the Authorization bearer; the token
      * already carries tenant and session scope, so apiKey/tenantId are not
      * needed (and are ignored) when it is set.
@@ -3152,7 +3152,7 @@ interface FlitroClientOptions {
      */
     onTokenExpired?: () => Promise<string | undefined> | string | undefined;
 }
-interface FlitroSession {
+interface WeftSession {
     session_id: string;
     tenant_id: string;
     app_id?: string;
@@ -3172,7 +3172,7 @@ interface FlitroSession {
     created_at: string;
     updated_at: string;
 }
-interface FlitroRun {
+interface WeftRun {
     run_id: string;
     session_id: string;
     tenant_id?: string;
@@ -3198,7 +3198,7 @@ interface FlitroRun {
     created_at: string;
     updated_at: string;
 }
-interface FlitroCapabilityReport {
+interface WeftCapabilityReport {
     provider: string;
     runtimeKind: string;
     selected: string;
@@ -3219,25 +3219,25 @@ interface FlitroCapabilityReport {
     automationCapabilities: Record<string, unknown>;
     hostToolCapabilities: Record<string, unknown>;
 }
-interface FlitroPatchSessionOptions {
+interface WeftPatchSessionOptions {
     title?: string;
     status?: string;
     labels?: string[];
     flagged?: boolean;
     topic?: string;
 }
-interface FlitroModelInfo {
+interface WeftModelInfo {
     id: string;
     provider: string;
     display_name?: string;
     aliases?: string[];
     capabilities: Record<string, unknown>;
 }
-interface FlitroModelListResult {
-    models: FlitroModelInfo[];
+interface WeftModelListResult {
+    models: WeftModelInfo[];
     default?: string;
 }
-interface FlitroTimelineItem {
+interface WeftTimelineItem {
     sessionId: string;
     provider: string;
     seq: number;
@@ -3245,28 +3245,30 @@ interface FlitroTimelineItem {
     timestamp: number;
     item: Record<string, unknown>;
 }
-interface FlitroTimelineFetchResult {
-    items: FlitroTimelineItem[];
+interface WeftTimelineFetchResult {
+    items: WeftTimelineItem[];
     nextCursor: {
         epoch: string;
         afterSeq: number;
     };
     hasGap: boolean;
 }
-declare class FlitroHttpClient {
+declare class WeftHttpClient {
     private readonly baseUrl;
     private readonly timeout;
     private readonly apiKey;
     private readonly tenantId;
     private readonly onTokenExpired?;
     private token;
-    constructor(options: FlitroClientOptions);
+    private readonly embedMode;
+    constructor(options: WeftHttpClientOptions);
+    private sessionPath;
     /** Current Authorization bearer (scoped token wins over apiKey). */
     getBearerToken(): string;
     /** Replace the scoped token (e.g. after a host-backend refresh). */
     setToken(token: string): void;
     private buildHeaders;
-    preflight(): Promise<FlitroCapabilityReport>;
+    preflight(): Promise<WeftCapabilityReport>;
     health(): Promise<{
         status: string;
     }>;
@@ -3275,8 +3277,8 @@ declare class FlitroHttpClient {
         model?: string;
         skillNames?: string[];
         mcpServerNames?: string[];
-    }): Promise<FlitroSession>;
-    getSession(sessionId: string): Promise<FlitroSession>;
+    }): Promise<WeftSession>;
+    getSession(sessionId: string): Promise<WeftSession>;
     sendMessage(sessionId: string, message: string, options?: {
         model?: string;
         skillNames?: string[];
@@ -3290,7 +3292,7 @@ declare class FlitroHttpClient {
             maxTokens?: number;
             maxWallTimeSec?: number;
         };
-    }): Promise<FlitroRun>;
+    }): Promise<WeftRun>;
     cancelRun(runId: string): Promise<{
         status: string;
     }>;
@@ -3306,9 +3308,9 @@ declare class FlitroHttpClient {
         type: string;
         requestId: string;
     }>;
-    patchSession(sessionId: string, patch: FlitroPatchSessionOptions): Promise<FlitroSession>;
-    listModels(): Promise<FlitroModelListResult>;
-    fetchTimeline(sessionId: string, afterSeq?: number, limit?: number): Promise<FlitroTimelineFetchResult>;
+    patchSession(sessionId: string, patch: WeftPatchSessionOptions): Promise<WeftSession>;
+    listModels(): Promise<WeftModelListResult>;
+    fetchTimeline(sessionId: string, afterSeq?: number, limit?: number): Promise<WeftTimelineFetchResult>;
     /** Returns the SSE stream URL for a session's canonical timeline. */
     sessionTimelineUrl(sessionId: string): string;
     private get;
@@ -3318,13 +3320,13 @@ declare class FlitroHttpClient {
 }
 
 /**
- * FlitroSseTimelineStream
+ * WeftSseTimelineStream
  *
- * Consumes Flitro's session-scoped SSE timeline endpoint and exposes it as
- * a Weft TimelineStream.  Handles reconnection with cursor tracking.
+ * Consumes the session-scoped SSE timeline endpoint and exposes it as
+ * a Weft TimelineStream. Handles reconnection with cursor tracking.
  */
 
-interface FlitroSseTimelineStreamOptions {
+interface WeftSseTimelineStreamOptions {
     /** Full URL to the session timeline SSE endpoint */
     url: string;
     /** Optional bearer token */
@@ -3349,7 +3351,7 @@ interface FlitroSseTimelineStreamOptions {
      */
     onTokenExpired?: () => Promise<string | undefined> | string | undefined;
 }
-declare class FlitroSseTimelineStream implements TimelineStream {
+declare class WeftSseTimelineStream implements TimelineStream {
     private listeners;
     private eventSource;
     private disposed;
@@ -3357,7 +3359,7 @@ declare class FlitroSseTimelineStream implements TimelineStream {
     private afterSeq;
     private readonly getBearerToken?;
     private readonly options;
-    constructor(options: FlitroSseTimelineStreamOptions);
+    constructor(options: WeftSseTimelineStreamOptions);
     connect(onEvent: (event: TimelineEnvelope) => void, onError?: (error: Error) => void, onClose?: () => void): void;
     disconnect(): void;
     isConnected(): boolean;
@@ -3370,7 +3372,7 @@ declare class FlitroSseTimelineStream implements TimelineStream {
  * In Node.js environments (Node 18+) EventSource may not be available globally.
  * This minimal polyfill wraps the fetch API for SSE consumption.
  */
-declare class FlitroFetchSseTimelineStream implements TimelineStream {
+declare class WeftFetchSseTimelineStream implements TimelineStream {
     private listeners;
     private abortController;
     private connected;
@@ -3381,7 +3383,7 @@ declare class FlitroFetchSseTimelineStream implements TimelineStream {
     private readonly getBearerToken?;
     private readonly onTokenExpired?;
     private readonly options;
-    constructor(options: FlitroSseTimelineStreamOptions);
+    constructor(options: WeftSseTimelineStreamOptions);
     connect(onEvent: (event: TimelineEnvelope) => void, onError?: (error: Error) => void, onClose?: () => void): void;
     disconnect(): void;
     isConnected(): boolean;
@@ -3392,16 +3394,16 @@ declare class FlitroFetchSseTimelineStream implements TimelineStream {
     private emitError;
 }
 /**
- * Create an SSE stream for the Flitro timeline endpoint.
+ * Create an SSE stream for the timeline endpoint.
  * Always uses the fetch-based implementation so credentials are sent via
  * Authorization header rather than URL query parameters.
  */
-declare function createFlitroTimelineStream(options: FlitroSseTimelineStreamOptions): TimelineStream;
+declare function createTimelineStream(options: WeftSseTimelineStreamOptions): TimelineStream;
 
 /**
  * WeftClient — the public L2 ("headless") contract.
  *
- * A thin namespaced facade over FlitroHttpClient + the SSE timeline stream:
+ * A thin namespaced facade over WeftHttpClient + the SSE timeline stream:
  *
  * ```ts
  * const client = new WeftClient({ server, token })
@@ -3429,21 +3431,21 @@ interface WeftClientOptions {
      * Called on HTTP 401 with a scoped token. Return a fresh token (e.g. by
      * re-asking your backend) to retry once; return undefined to surface the 401.
      */
-    onTokenExpired?: FlitroClientOptions['onTokenExpired'];
+    onTokenExpired?: WeftHttpClientOptions['onTokenExpired'];
 }
 interface TimelineSubscription extends TimelineStream, AsyncIterable<TimelineEnvelope> {
 }
 declare class WeftClient {
     /** The underlying 1:1 HTTP client, for endpoints not wrapped below. */
-    readonly http: FlitroHttpClient;
+    readonly http: WeftHttpClient;
     private readonly options;
     constructor(options: WeftClientOptions);
     /** Replace the scoped token (e.g. after a backend-driven refresh). */
     setToken(token: string): void;
     readonly sessions: {
-        create: (options?: Parameters<FlitroHttpClient["createSession"]>[0]) => Promise<FlitroSession>;
-        get: (sessionId: string) => Promise<FlitroSession>;
-        patch: (sessionId: string, patch: FlitroPatchSessionOptions) => Promise<FlitroSession>;
+        create: (options?: Parameters<WeftHttpClient["createSession"]>[0]) => Promise<WeftSession>;
+        get: (sessionId: string) => Promise<WeftSession>;
+        patch: (sessionId: string, patch: WeftPatchSessionOptions) => Promise<WeftSession>;
         respondToPermission: (sessionId: string, requestId: string, allowed: boolean, options?: {
             remember?: boolean;
             text?: string;
@@ -3457,7 +3459,7 @@ declare class WeftClient {
     readonly runs: {
         create: (sessionId: string, options: {
             message: string;
-        } & NonNullable<Parameters<FlitroHttpClient["sendMessage"]>[2]>) => Promise<FlitroRun>;
+        } & NonNullable<Parameters<WeftHttpClient["sendMessage"]>[2]>) => Promise<WeftRun>;
         cancel: (runId: string) => Promise<{
             status: string;
         }>;
@@ -3466,17 +3468,17 @@ declare class WeftClient {
         }>;
     };
     readonly timeline: {
-        fetch: (sessionId: string, afterSeq?: number, limit?: number) => Promise<FlitroTimelineFetchResult>;
+        fetch: (sessionId: string, afterSeq?: number, limit?: number) => Promise<WeftTimelineFetchResult>;
         /**
          * Subscribe to the session's SSE timeline. Reconnects automatically with
          * cursor tracking; usable both callback-style (`connect`) and as an
          * async iterable (`for await`).
          */
-        subscribe: (sessionId: string, options?: Partial<Omit<FlitroSseTimelineStreamOptions, "url">>) => TimelineSubscription;
+        subscribe: (sessionId: string, options?: Partial<Omit<WeftSseTimelineStreamOptions, "url">>) => TimelineSubscription;
     };
 }
 
-export { type FlitroCapabilityReport, type FlitroClientOptions, FlitroFetchSseTimelineStream, FlitroHttpClient, type FlitroModelInfo, type FlitroModelListResult, type FlitroPatchSessionOptions, type FlitroRun, type FlitroSession, FlitroSseTimelineStream, type FlitroSseTimelineStreamOptions, type FlitroTimelineFetchResult, type FlitroTimelineItem, type TimelineEnvelope, type TimelineStream, type TimelineSubscription, WeftClient, type WeftClientOptions, createFlitroTimelineStream };
+export { type TimelineEnvelope, type TimelineStream, type TimelineSubscription, type WeftCapabilityReport, WeftClient, type WeftClientOptions, WeftFetchSseTimelineStream, WeftHttpClient, type WeftHttpClientOptions, type WeftModelInfo, type WeftModelListResult, type WeftPatchSessionOptions, type WeftRun, type WeftSession, WeftSseTimelineStream, type WeftSseTimelineStreamOptions, type WeftTimelineFetchResult, type WeftTimelineItem, createTimelineStream };
 
 // ── inlined from @weft/provider-flitro ──
 // -- @weft/provider-flitro/index.d.ts --
@@ -3501,7 +3503,7 @@ interface FlitroProviderRuntimeDriver {
     dispose?(): Promise<void>;
 }
 interface CreateFlitroDriverOptions {
-    client: FlitroHttpClient;
+    client: WeftHttpClient;
     sessionId: string;
     /** LLM model override sent to Flitro */
     model?: string;
@@ -3542,7 +3544,7 @@ interface FlitroCapabilityProbeResult {
  * process (the Go agentd binary) that the TypeScript provider communicates
  * with over HTTP.
  */
-declare function probeFlitroCapabilities(client: FlitroHttpClient): Promise<FlitroCapabilityProbeResult>;
+declare function probeFlitroCapabilities(client: WeftHttpClient): Promise<FlitroCapabilityProbeResult>;
 
 /**
  * @weft/provider-flitro
@@ -3575,7 +3577,7 @@ interface CreateFlitroRuntimeCapabilityReportOptions {
 declare function createFlitroRuntimeCapabilityReport(options: CreateFlitroRuntimeCapabilityReportOptions): RuntimeCapabilityReport;
 interface CreateFlitroProviderRuntimeOptions extends CreateFlitroRuntimeCapabilityReportOptions {
     /** Flitro server connection options */
-    server: FlitroClientOptions;
+    server: WeftHttpClientOptions;
     /** Session ID — if omitted a new session is created on first sendMessage */
     sessionId?: string;
     /** Epoch string for the timeline (default: derived from sessionId) */
@@ -3635,7 +3637,7 @@ interface CreateFlitroEmbedRuntimeOptions {
 declare function createFlitroEmbedRuntime(options: CreateFlitroEmbedRuntimeOptions): AgentRuntime;
 interface CreateFlitroRuntimeOptions {
     /** Flitro server connection options */
-    server: FlitroClientOptions;
+    server: WeftHttpClientOptions;
     sessionId?: string;
     epoch?: string;
     now?: () => number;
@@ -3654,1728 +3656,3 @@ interface CreateFlitroRuntimeOptions {
 declare function createFlitroRuntime(options: CreateFlitroRuntimeOptions): Promise<AgentRuntime>;
 
 export { type CreateFlitroDriverOptions, type CreateFlitroEmbedRuntimeOptions, type CreateFlitroProviderRuntimeOptions, type CreateFlitroRuntimeCandidatesOptions, type CreateFlitroRuntimeCapabilityReportOptions, type CreateFlitroRuntimeOptions, type FlitroCapabilityProbeResult, type FlitroProviderRuntimeDriver, createFlitroDriver, createFlitroEmbedRuntime, createFlitroProviderRuntime, createFlitroRuntime, createFlitroRuntimeCandidates, createFlitroRuntimeCapabilityReport, probeFlitroCapabilities };
-
-// ── inlined from @weft/ui ──
-// -- @weft/ui/index.d.ts --
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as React$1 from 'react';
-import React__default, { ReactNode } from 'react';
-
-type ActivityStatus = 'pending' | 'running' | 'completed' | 'error' | 'backgrounded';
-type ActivityType = 'tool' | 'thinking' | 'intermediate' | 'status' | 'plan';
-type AnnotationInteractionMode = 'interactive' | 'tooltip-only';
-type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'interrupted';
-interface TodoItem {
-    /** Task content/description */
-    content: string;
-    /** Current status */
-    status: TodoStatus;
-    /** Present continuous form shown when in_progress (e.g., "Running tests") */
-    activeForm?: string;
-}
-interface ActivityItem {
-    id: string;
-    type: ActivityType;
-    status: ActivityStatus;
-    toolName?: string;
-    toolUseId?: string;
-    toolInput?: Record<string, unknown>;
-    content?: string;
-    intent?: string;
-    /** Optional backing message id (used by plan activities for branching/annotations) */
-    messageId?: string;
-    /** Optional persisted annotations (used by plan activities) */
-    annotations?: AnnotationV1[];
-    displayName?: string;
-    toolDisplayMeta?: ToolDisplayMeta;
-    timestamp: number;
-    error?: string;
-    parentId?: string;
-    depth?: number;
-    statusType?: string;
-    taskId?: string;
-    shellId?: string;
-    elapsedSeconds?: number;
-    isBackground?: boolean;
-}
-interface ResponseContent {
-    text: string;
-    isStreaming: boolean;
-    streamStartTime?: number;
-    /** Whether this response is a plan (renders with plan variant) */
-    isPlan?: boolean;
-    /** ID of the underlying message (for branching + annotations) */
-    messageId?: string;
-    /** Persisted annotations attached to the response message */
-    annotations?: AnnotationV1[];
-}
-/** Represents one complete assistant turn */
-interface AssistantTurn {
-    type: 'assistant';
-    turnId: string;
-    activities: ActivityItem[];
-    response?: ResponseContent;
-    intent?: string;
-    isStreaming: boolean;
-    isComplete: boolean;
-    timestamp: number;
-    /** Extracted from TodoWrite tool - latest todo state in this turn */
-    todos?: TodoItem[];
-}
-/** Represents a user message */
-interface UserTurn {
-    type: 'user';
-    message: Message;
-    timestamp: number;
-}
-/** Represents a system/info/error message that stands alone */
-interface SystemTurn {
-    type: 'system';
-    message: Message;
-    timestamp: number;
-}
-/** Represents an auth request (credential input, OAuth flow) */
-interface AuthRequestTurn {
-    type: 'auth-request';
-    message: Message;
-    timestamp: number;
-}
-type Turn = AssistantTurn | UserTurn | SystemTurn | AuthRequestTurn;
-type OpenAnnotationRequest = {
-    messageId: string;
-    annotationId: string;
-    mode: 'view' | 'edit';
-    anchorX?: number;
-    anchorY?: number;
-    nonce: number;
-};
-
-/**
- * turn-phase.ts
- *
- * Turn lifecycle phase detection for assistant turns.
- */
-
-/**
- * Build a stable UI identity key for an assistant turn card.
- *
- * Why this exists:
- * - Backend turnId can be reused across visually split assistant cards
- *   (e.g., steer/interruption boundaries).
- * - Expansion state must be keyed by UI-card identity, not raw backend turnId.
- */
-declare function getAssistantTurnUiKey(turn: AssistantTurn, index: number): string;
-
-/**
- * turn-grouping.ts
- *
- * Core groupMessagesByTurn function plus internal helpers for converting
- * a flat Message[] array into grouped Turn[] for TurnCard rendering.
- */
-
-/**
- * Groups messages into turns for TurnCard rendering
- *
- * Rules:
- * - User messages flush and start fresh context
- * - Tool messages + intermediate assistant messages belong to current turn
- * - Final assistant message (non-streaming, non-intermediate) flushes the turn
- * - Error/status/info messages are standalone system turns
- *
- * Note: We intentionally ignore turnId for grouping. The SDK generates a new
- * turnId for each API message, but from a user perspective, all work between
- * a user message and the final response should be ONE turn. We use isIntermediate
- * as the signal: isIntermediate=true means more work coming, isIntermediate=false
- * means final response.
- */
-declare function groupMessagesByTurn(messages: Message[]): Turn[];
-
-/**
- * Global size configuration for TurnCard components.
- * Adjust these values to scale the entire component uniformly.
- */
-/** Shared size configuration for activity UI - exported for reuse in inline execution */
-declare const SIZE_CONFIG: {
-    /** Base font size class for all text */
-    readonly fontSize: "text-[13px]";
-    /** Icon size class (width and height) */
-    readonly iconSize: "w-3 h-3";
-    /** Spinner text size class */
-    readonly spinnerSize: "text-[10px]";
-    /** Small spinner for header */
-    readonly spinnerSizeSmall: "text-[8px]";
-    /** Activity row height in pixels (approx for calculation) */
-    readonly activityRowHeight: 24;
-    /** Max visible activities before scrolling (show ~15 items) */
-    readonly maxVisibleActivities: 15;
-    /** Number of items before which we apply staggered animation */
-    readonly staggeredAnimationLimit: 10;
-};
-type BufferReason = 'complete' | 'min_time' | 'timeout' | 'code_block' | 'list' | 'header' | 'question' | 'threshold_met' | 'high_word_count' | 'buffering';
-
-/**
- * tool-display.ts
- *
- * Tool display formatting functions extracted from TurnCard.tsx.
- * No JSX — pure string/object formatting logic.
- */
-
-/**
- * Determine if buffered content should be shown.
- * This is the core buffering decision function.
- *
- * @param text - The accumulated response text
- * @param isStreaming - Whether the response is still streaming
- * @param streamStartTime - When streaming started (for timeout calculation)
- * @returns Decision with reason for debugging
- */
-declare function shouldShowStreamingContent(text: string, isStreaming: boolean, streamStartTime?: number): {
-    shouldShow: boolean;
-    reason: BufferReason;
-    wordCount: number;
-};
-
-interface ResponseCardProps {
-    /** The content to display (markdown) */
-    text: string;
-    /** Whether the content is still streaming */
-    isStreaming: boolean;
-    /** When streaming started - used for buffering timeout calculation */
-    streamStartTime?: number;
-    /** Callback to open file in editor */
-    onOpenFile?: (path: string) => void;
-    /** Callback to open URL */
-    onOpenUrl?: (url: string) => void;
-    /** Callback to open response in Monaco editor */
-    onPopOut?: () => void;
-    /** Card variant - 'response' for AI messages, 'plan' for plan messages */
-    variant?: 'response' | 'plan';
-    /** Parent session ID (used to reset local annotation/island UI state on session switches) */
-    sessionId?: string;
-    /** Underlying message ID for annotation actions */
-    messageId?: string;
-    /** Persisted annotations for this response */
-    annotations?: AnnotationV1[];
-    /** Callback when user accepts the plan (plan variant only) */
-    onAccept?: () => void;
-    /** Callback when user accepts the plan with compaction (compact first, then execute) */
-    onAcceptWithCompact?: () => void;
-    /** Whether this is the last response in the session (shows Accept Plan button only for last response) */
-    isLastResponse?: boolean;
-    /** Whether to show the Accept Plan button (default: true) */
-    showAcceptPlan?: boolean;
-    /** Hide footer for compact embedding (EditPopover) */
-    compactMode?: boolean;
-    /** Callback to branch the session from this response */
-    onBranch?: (options?: {
-        newPanel?: boolean;
-    }) => void;
-    /** Callback to add annotation from selected text */
-    onAddAnnotation?: (messageId: string, annotation: AnnotationV1) => void;
-    /** Callback to remove persisted annotation */
-    onRemoveAnnotation?: (messageId: string, annotationId: string) => void;
-    /** Callback to update persisted annotation */
-    onUpdateAnnotation?: (messageId: string, annotationId: string, patch: Partial<AnnotationV1>) => void;
-    /** Input send key behavior used by follow-up editor */
-    sendMessageKey?: 'enter' | 'cmd-enter';
-    /** Callback when follow-up is saved via "Save & Send" action */
-    onSaveAndSendFollowUp?: (target: {
-        messageId: string;
-        annotationId: string;
-        note: string;
-        selectedText: string;
-    }) => void;
-    /** Whether there are active pending follow-up annotations in the session */
-    hasActiveFollowUpAnnotations?: boolean;
-    /** External request to open a specific annotation in this response */
-    openAnnotationRequest?: OpenAnnotationRequest | null;
-    /** Annotation interaction mode (viewer uses tooltip-only to suppress the island) */
-    annotationInteractionMode?: AnnotationInteractionMode;
-}
-/**
- * ResponseCard - Unified card component for AI responses and plans
- *
- * Variants:
- * - 'response': Buffered streaming response with smart content gating
- * - 'plan': Plan message with header and Accept Plan button
- *
- * Response variant implements smart buffering:
- * - Waits for 40+ words with structure OR
- * - High-confidence patterns (code blocks, headers, lists) with lower threshold OR
- * - Timeout after 2.5 seconds
- *
- * Performance optimization: Uses throttled static snapshots instead of re-rendering
- * on every character. Content updates every 300ms during streaming, avoiding
- * expensive markdown parsing on every delta.
- */
-declare function ResponseCard({ text, isStreaming, streamStartTime, onOpenFile, onOpenUrl, onPopOut, variant, sessionId, messageId, annotations, onAccept, onAcceptWithCompact, isLastResponse, showAcceptPlan, compactMode, onBranch, onAddAnnotation, onRemoveAnnotation, onUpdateAnnotation, sendMessageKey, onSaveAndSendFollowUp, hasActiveFollowUpAnnotations, openAnnotationRequest, annotationInteractionMode, }: ResponseCardProps): react_jsx_runtime.JSX.Element | null;
-
-interface TurnCardProps {
-    /** Session ID for state persistence (optional in shared context) */
-    sessionId?: string;
-    /** Turn ID for state persistence */
-    turnId: string;
-    /** All activities in this turn (tools, thinking, intermediate text) */
-    activities: ActivityItem[];
-    /** Final response content (may be streaming) */
-    response?: ResponseContent;
-    /** Primary intent/goal for this turn (shown in collapsed preview) */
-    intent?: string;
-    /** Whether content is still being received */
-    isStreaming: boolean;
-    /** Whether this turn is fully complete */
-    isComplete: boolean;
-    /** Start in expanded state */
-    defaultExpanded?: boolean;
-    /** Controlled expansion state (overrides internal state) */
-    isExpanded?: boolean;
-    /** Callback when expansion state changes */
-    onExpandedChange?: (expanded: boolean) => void;
-    /** Controlled expansion state for activity groups */
-    expandedActivityGroups?: Set<string>;
-    /** Callback when activity group expansion changes */
-    onExpandedActivityGroupsChange?: (groups: Set<string>) => void;
-    /** Callback when file path is clicked */
-    onOpenFile?: (path: string) => void;
-    /** Callback when URL is clicked */
-    onOpenUrl?: (url: string) => void;
-    /** Callback to open response in Monaco editor */
-    onPopOut?: (text: string) => void;
-    /** Callback to open turn details in a new window */
-    onOpenDetails?: () => void;
-    /** Callback to open individual activity details in Monaco */
-    onOpenActivityDetails?: (activity: ActivityItem) => void;
-    /** Callback to open all edits/writes in multi-file diff view */
-    onOpenMultiFileDiff?: () => void;
-    /** Whether this turn has any Edit or Write activities */
-    hasEditOrWriteActivities?: boolean;
-    /** TodoWrite tool state - shown at bottom of turn */
-    todos?: TodoItem[];
-    /** Optional render prop for actions menu (Electron provides dropdown) */
-    renderActionsMenu?: () => React$1.ReactNode;
-    /** Callback when user accepts the plan (plan responses only) */
-    onAcceptPlan?: () => void;
-    /** Callback when user accepts the plan with compaction (compact conversation first, then execute) */
-    onAcceptPlanWithCompact?: () => void;
-    /** Whether this is the last response in the session (shows Accept Plan button only for last response) */
-    isLastResponse?: boolean;
-    /** Session folder path for stripping from file paths in tool display */
-    sessionFolderPath?: string;
-    /** Display mode: 'detailed' shows all info, 'informative' hides MCP/API names and params */
-    displayMode?: 'informative' | 'detailed';
-    /** Animate response appearance (for playground demos) */
-    animateResponse?: boolean;
-    /** Hide footers for compact embedding (EditPopover) */
-    compactMode?: boolean;
-    /** Callback to branch the session from a specific message */
-    onBranch?: (messageId: string, options?: {
-        newPanel?: boolean;
-    }) => void;
-    /** Callback to add an annotation to a response message */
-    onAddAnnotation?: (messageId: string, annotation: AnnotationV1) => void;
-    /** Callback to remove a persisted annotation from a response message */
-    onRemoveAnnotation?: (messageId: string, annotationId: string) => void;
-    /** Callback to update a persisted annotation */
-    onUpdateAnnotation?: (messageId: string, annotationId: string, patch: Partial<AnnotationV1>) => void;
-    /** Input send key behavior used by follow-up editor */
-    sendMessageKey?: 'enter' | 'cmd-enter';
-    /** Callback when follow-up is saved via "Save & Send" action */
-    onSaveAndSendFollowUp?: (target: {
-        messageId: string;
-        annotationId: string;
-        note: string;
-        selectedText: string;
-    }) => void;
-    /** Whether there are active pending follow-up annotations in the session */
-    hasActiveFollowUpAnnotations?: boolean;
-    /** External request to open a specific annotation in the follow-up island */
-    openAnnotationRequest?: OpenAnnotationRequest | null;
-    /** Annotation interaction mode (viewer uses tooltip-only to suppress the island) */
-    annotationInteractionMode?: AnnotationInteractionMode;
-}
-/**
- * TurnCard - Email-like display for one assistant turn
- *
- * Batches all activities (tools, thinking) into a collapsible section
- * with the final response displayed separately below.
- *
- * Memoized to prevent re-renders of completed turns during session switches.
- * Only complete, non-streaming turns are memoized - active turns always re-render.
- */
-declare const TurnCard: React$1.MemoExoticComponent<({ sessionId, turnId, activities, response, intent, isStreaming, isComplete, defaultExpanded, isExpanded: externalIsExpanded, onExpandedChange, expandedActivityGroups: externalExpandedActivityGroups, onExpandedActivityGroupsChange, onOpenFile, onOpenUrl, onPopOut, onOpenDetails, onOpenActivityDetails, onOpenMultiFileDiff, hasEditOrWriteActivities, todos, renderActionsMenu, onAcceptPlan, onAcceptPlanWithCompact, isLastResponse, sessionFolderPath, displayMode, animateResponse, compactMode, onBranch, onAddAnnotation, onRemoveAnnotation, onUpdateAnnotation, sendMessageKey, onSaveAndSendFollowUp, hasActiveFollowUpAnnotations, openAnnotationRequest, annotationInteractionMode, }: TurnCardProps) => react_jsx_runtime.JSX.Element | null>;
-
-type InlineExecutionStatus = 'executing' | 'success' | 'error';
-interface InlineActivityItem {
-    id: string;
-    name: string;
-    status: ActivityStatus;
-    description?: string;
-}
-interface InlineExecutionProps {
-    /** Current execution status */
-    status: InlineExecutionStatus;
-    /** Activities to display (simplified from full ActivityItem) */
-    activities: InlineActivityItem[];
-    /** Result message on success */
-    result?: string;
-    /** Error message on failure */
-    error?: string;
-    /** Callback to cancel execution */
-    onCancel?: () => void;
-    /** Callback to dismiss (on success/error) */
-    onDismiss?: () => void;
-    /** Callback to retry (on error) */
-    onRetry?: () => void;
-    /** Optional className */
-    className?: string;
-}
-declare function InlineExecution({ status, activities, result, error, onCancel, onDismiss, onRetry, className, }: InlineExecutionProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Platform-specific actions for UI components.
- * Consumers provide these via PlatformProvider.
- */
-interface PlatformActions {
-    /** Open a file in the system editor/Finder */
-    onOpenFile?: (path: string) => void;
-    /** Open a URL in the system browser */
-    onOpenUrl?: (url: string) => void;
-    /** Open a markdown preview popover */
-    onOpenMarkdownPreview?: (sessionId: string, markdown: string) => void;
-    /** Open turn details in a new window/panel */
-    onOpenTurnDetails?: (sessionId: string, turnId: string) => void;
-    /** Open activity details */
-    onOpenActivityDetails?: (sessionId: string, activityId: string) => void;
-    /** Open multi-file diff view for a turn */
-    onOpenMultiFileDiff?: (sessionId: string, turnId: string) => void;
-    /** Respond to a permission or auth request */
-    onPermissionAllow?: (requestId: string, allowed: boolean, remember?: boolean) => void;
-}
-/**
- * Provider that injects platform-specific actions into the component tree.
- */
-declare function PlatformProvider({ actions, children, }: {
-    actions: PlatformActions;
-    children: React__default.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-interface ChatTranscriptProps {
-    messages: Message[];
-    platformActions?: PlatformActions;
-    className?: string;
-    onTurnClick?: (turnId: string) => void;
-    onActivityClick?: (activity: ActivityItem) => void;
-    defaultExpanded?: boolean;
-    displayMode?: 'informative' | 'detailed';
-    animateResponse?: boolean;
-    annotationInteractionMode?: AnnotationInteractionMode;
-    sessionId?: string;
-    sessionFolderPath?: string;
-    children?: ReactNode;
-}
-declare function ChatTranscript({ messages, platformActions, className, onTurnClick, onActivityClick, defaultExpanded, displayMode, animateResponse, annotationInteractionMode, sessionId, sessionFolderPath, children, }: ChatTranscriptProps): react_jsx_runtime.JSX.Element;
-
-type SessionViewerMode = 'interactive' | 'readonly';
-interface SessionViewerProps {
-    session: StoredSession;
-    mode?: SessionViewerMode;
-    platformActions?: PlatformActions;
-    className?: string;
-    onTurnClick?: (turnId: string) => void;
-    onActivityClick?: (activity: ActivityItem) => void;
-    defaultExpanded?: boolean;
-    header?: ReactNode;
-    footer?: ReactNode;
-    sessionFolderPath?: string;
-}
-declare function SessionViewer({ session, mode, platformActions, className, onTurnClick, onActivityClick, defaultExpanded, header, footer, sessionFolderPath, }: SessionViewerProps): react_jsx_runtime.JSX.Element;
-
-interface PendingIndicatorProps {
-    isReconnecting?: boolean;
-}
-declare function PendingIndicator({ isReconnecting, }: PendingIndicatorProps): react_jsx_runtime.JSX.Element;
-
-interface UserMessageBubbleProps {
-    /** Message content (markdown supported) */
-    content: string;
-    /** Additional className for the outer container */
-    className?: string;
-    /** Callback when a URL is clicked */
-    onUrlClick?: (url: string) => void;
-    /** Callback when a file path is clicked */
-    onFileClick?: (path: string) => void;
-    /** Stored attachments (images, documents) */
-    attachments?: StoredAttachment[];
-    /** Content badges for inline display (sources, skills) */
-    badges?: ContentBadge[];
-    /** Whether the message is awaiting backend confirmation. User bubbles stay visually stable. */
-    isPending?: boolean;
-    /** Whether the message is queued (badge shown) */
-    isQueued?: boolean;
-    /** Compact mode - reduces padding for popover embedding */
-    compactMode?: boolean;
-}
-declare function UserMessageBubble({ content, className, onUrlClick, onFileClick, attachments, badges, isQueued, compactMode, }: UserMessageBubbleProps): react_jsx_runtime.JSX.Element;
-
-/**
- * SystemMessage - Displays system/info/error/warning messages
- *
- * Used for displaying non-conversational messages like errors, warnings,
- * info notices, and general system messages. Supports different visual
- * styles based on the message type.
- *
- * Error and warning types use shadow-tinted for a softer, more polished appearance.
- * System and info types use a simple bordered style.
- */
-type SystemMessageType = 'error' | 'info' | 'warning' | 'system';
-interface SystemMessageProps {
-    /** Message content (markdown supported) */
-    content: string;
-    /** Message type determining visual style */
-    type: SystemMessageType;
-    /** Additional className for the outer container */
-    className?: string;
-}
-/**
- * SystemMessage - Renders a styled message bubble based on type
- */
-declare function SystemMessage({ content, type, className, }: SystemMessageProps): react_jsx_runtime.JSX.Element;
-
-/**
- * PermissionRequestCard - Inline permission prompt for agent tool approval
- *
- * Renders when the agent is paused awaiting user approval for a tool
- * invocation (e.g. bash command, file write, MCP mutation). Displays
- * the tool name, input preview, and reason, with Allow/Deny/Remember
- * action buttons.
- *
- * Styling follows the Weft design system:
- * - Rounded-[8px] card with shadow-minimal
- * - Accent-coloured header strip for tool identity
- * - Truncated input preview in a subtle code block
- * - Two or three action buttons (Allow, Deny, Remember)
- */
-interface PermissionRequestCardProps {
-    /** Unique request ID matching the runtime permission request */
-    requestId: string;
-    /** Tool name requesting approval (e.g. "Bash", "Write", "Edit") */
-    toolName: string;
-    /** Optional scope descriptor (session, workspace, source, skill, tool-call) */
-    scope?: {
-        type: string;
-        label?: string;
-    };
-    /** Optional input preview (command, file path, MCP payload) */
-    input?: Record<string, unknown>;
-    /** Optional reason text explaining why permission is needed */
-    reason?: string;
-    /** Whether this request is currently active (not yet resolved) */
-    isActive?: boolean;
-    /** Previous resolution if re-shown for context (allowed/denied) */
-    previousResolution?: {
-        allowed: boolean;
-        remember?: boolean;
-        reason?: string;
-    };
-    /** Callback when user approves the request */
-    onAllow?: (requestId: string, remember?: boolean) => void;
-    /** Callback when user denies the request */
-    onDeny?: (requestId: string) => void;
-    /** Additional className */
-    className?: string;
-}
-declare function PermissionRequestCard({ requestId, toolName, scope, input, reason, isActive, previousResolution, onAllow, onDeny, className, }: PermissionRequestCardProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Standard assistant-turn presentation: a TurnCard with local expand state that
- * stays open while the turn streams, the detailed display mode, and a click
- * handler that surfaces a step for inspection. Shared so the web app and the
- * embeddable chat panel render thinking steps identically.
- */
-declare function AssistantTurnCard({ sessionId, turn, isLast, onInspectActivity, }: {
-    sessionId: string;
-    turn: Extract<Turn, {
-        type: 'assistant';
-    }>;
-    isLast: boolean;
-    onInspectActivity: (activity: ActivityItem) => void;
-}): react_jsx_runtime.JSX.Element;
-
-/**
- * Renders a single activity's input / output / error for inspection. Shared by
- * the web app's side panel and the embeddable chat panel's detail popup so the
- * step-detail view stays identical across hosts.
- */
-declare function ActivityInspector({ activity, onClose, }: {
-    activity: ActivityItem | null;
-    onClose?: () => void;
-}): react_jsx_runtime.JSX.Element;
-
-/**
- * Modal popup wrapping ActivityInspector: centered, dismissable via backdrop
- * click or Escape. Open it from a TurnCard's onOpenActivityDetails callback.
- */
-declare function ActivityDetailsPanel({ activity, onClose, }: {
-    activity: ActivityItem | null;
-    onClose: () => void;
-}): react_jsx_runtime.JSX.Element | null;
-
-declare function PermissionModeMenu({ value, onChange, onClose, isOpen, onToggle, }: {
-    value: PermissionMode;
-    onChange: (mode: PermissionMode) => void;
-    onClose?: () => void;
-    isOpen: boolean;
-    onToggle: () => void;
-}): react_jsx_runtime.JSX.Element;
-
-interface CodeBlockProps {
-    code: string;
-    language?: string;
-    className?: string;
-    /**
-     * Render mode affects code block styling:
-     * - 'terminal': Minimal, keeps control chars visible
-     * - 'minimal': Clean code, basic styling
-     * - 'full': Rich styling with background, copy button, etc.
-     */
-    mode?: 'terminal' | 'minimal' | 'full';
-    /**
-     * Force a specific theme. If not provided, detects from document.documentElement.classList
-     */
-    forcedTheme?: 'light' | 'dark';
-}
-/**
- * CodeBlock - Syntax highlighted code block using Shiki
- *
- * Uses VS Code's syntax highlighting engine for accurate highlighting.
- * Lazy-loads highlighting and caches results for performance.
- */
-declare function CodeBlock({ code, language, className, mode, forcedTheme }: CodeBlockProps): react_jsx_runtime.JSX.Element;
-/**
- * InlineCode - Styled inline code span
- * Features: subtle background (3%), no border, 75% opacity text
- */
-declare function InlineCode({ children, className }: {
-    children: React$1.ReactNode;
-    className?: string;
-}): react_jsx_runtime.JSX.Element;
-
-declare function CollapsibleMarkdownProvider({ children, }: {
-    children: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-/**
- * Render modes for markdown content:
- *
- * - 'terminal': Raw output with minimal formatting, control chars visible
- *   Best for: Debug output, raw logs, when you want to see exactly what's there
- *
- * - 'minimal': Clean rendering with syntax highlighting but no extra chrome
- *   Best for: Chat messages, inline content, when you want readability without clutter
- *
- * - 'full': Rich rendering with beautiful tables, styled code blocks, proper typography
- *   Best for: Documentation, long-form content, when presentation matters
- */
-type RenderMode = 'terminal' | 'minimal' | 'full';
-interface MarkdownProps {
-    children: string;
-    /**
-     * Render mode controlling formatting level
-     * @default 'minimal'
-     */
-    mode?: RenderMode;
-    className?: string;
-    /**
-     * Message ID for memoization (optional)
-     * When provided, memoizes parsed blocks to avoid re-parsing during streaming
-     */
-    id?: string;
-    /**
-     * Callback when a URL is clicked
-     */
-    onUrlClick?: (url: string) => void;
-    /**
-     * Callback when a file path is clicked
-     */
-    onFileClick?: (path: string) => void;
-    /**
-     * Enable collapsible headings
-     * Requires wrapping in CollapsibleMarkdownProvider
-     * @default false
-     */
-    collapsible?: boolean;
-    /**
-     * Hide expand button on first mermaid block (when message starts with mermaid)
-     * Used in chat to avoid overlap with TurnCard's fullscreen button
-     * @default true
-     */
-    hideFirstMermaidExpand?: boolean;
-}
-/**
- * Markdown - Customizable markdown renderer with multiple render modes
- *
- * Features:
- * - Three render modes: terminal, minimal, full
- * - Syntax highlighting via Shiki
- * - GFM support (tables, task lists, strikethrough)
- * - Clickable links and file paths
- * - Memoization for streaming performance
- */
-declare function Markdown({ children, mode, className, id, onUrlClick, onFileClick, collapsible, hideFirstMermaidExpand, }: MarkdownProps): react_jsx_runtime.JSX.Element;
-/**
- * MemoizedMarkdown - Optimized for streaming scenarios
- *
- * Splits content into blocks and memoizes each block separately,
- * so only new/changed blocks re-render during streaming.
- */
-declare const MemoizedMarkdown: React$1.MemoExoticComponent<typeof Markdown>;
-
-interface AnchoredSelection {
-    anchorX: number;
-    anchorY: number;
-    start: number;
-    end: number;
-    exact: string;
-    selectedText?: string;
-    prefix?: string;
-    suffix?: string;
-}
-
-/**
- * annotation-core — stub for annotation overlay core utilities.
- *
- * Provides type definitions and utility functions for annotation rendering.
- * Full implementation will be ported from the upstream source project.
- */
-
-interface AnnotationOverlayRect {
-    id: string;
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    color: string;
-}
-type AnnotationOverlayChip = {
-    id: string;
-    index: number;
-    left: number;
-    top: number;
-    sentFollowUp: boolean;
-};
-declare function hasExistingTextRangeAnnotation(annotations: AnnotationV1[], start: number, end: number): boolean;
-declare function createSelectionPreviewAnnotation(messageId: string, sessionIdOrSelection: string | AnchoredSelection, startOrSessionId?: number | string, end?: number, exact?: string): AnnotationV1;
-declare function createTextSelectionAnnotation(messageId: string, sessionId: string, start: number, end: number, exact: string, note: string): AnnotationV1;
-interface TextSegment {
-    start: number;
-    end: number;
-    node: Text;
-}
-declare function collectTextSegments(_content: string | HTMLElement, _annotations: AnnotationV1[]): TextSegment[];
-/** Stub — full implementation will compute canonical text from DOM */
-declare function getCanonicalText(_content: string | HTMLElement): string;
-/**
- * Stub — resolves character offset within a DOM node.
- * Full implementation will walk the DOM tree to compute text offset.
- */
-declare function resolveNodeOffset(_root: string | HTMLElement, _node?: Node, _offset?: number): number | null;
-
-/**
- * annotation-overlay-geometry — stub for annotation overlay geometry computation.
- */
-
-interface AnnotationOverlayGeometryResult {
-    rects: AnnotationOverlayRect[];
-    chips: AnnotationOverlayChip[];
-    unresolved: Array<{
-        annotation: AnnotationV1;
-        reason: string;
-    }>;
-}
-declare function computeAnnotationOverlayGeometry(_containerOrOpts: HTMLElement | {
-    root: HTMLElement;
-    renderedAnnotations: AnnotationV1[];
-    persistedAnnotations?: AnnotationV1[];
-}, _annotations?: AnnotationV1[], _content?: string): AnnotationOverlayGeometryResult;
-
-interface AnnotationOverlayLayerProps {
-    rects: AnnotationOverlayRect[];
-    chips: AnnotationOverlayChip[];
-    annotations?: AnnotationV1[];
-    getTooltipText?: (annotation: AnnotationV1, index: number) => string;
-    /** Whether clicking a chip should open the annotation island/details view. */
-    allowChipOpen?: boolean;
-    onChipOpen: (params: {
-        annotationId: string;
-        index: number;
-        anchorX: number;
-        anchorY: number;
-        mode: 'view' | 'edit';
-    }) => void;
-}
-declare function AnnotationOverlayLayer({ rects, chips, annotations, getTooltipText, allowChipOpen, onChipOpen, }: AnnotationOverlayLayerProps): react_jsx_runtime.JSX.Element | null;
-
-/**
- * IslandTransitionConfig — type stub for annotation island transition animations.
- */
-interface IslandTransitionConfig {
-    duration?: number;
-    easing?: string;
-}
-
-/**
- * AnnotationIslandMenu — stub for annotation island menu component.
- * Accepts all props used by TurnCard but renders nothing.
- */
-
-interface AnnotationIslandMenuProps {
-    anchor?: {
-        x: number;
-        y: number;
-    } | null;
-    sourceKey?: string;
-    replayNonce?: number;
-    isVisible?: boolean;
-    activeView?: string | null;
-    mode?: string;
-    draft?: string;
-    onDraftChange?: (draft: string) => void;
-    onOpenFollowUp?: () => void;
-    onCancel?: () => void;
-    onRequestBack?: () => boolean;
-    onRequestEdit?: () => void;
-    onSubmit?: (note: string) => void;
-    onSubmitAndSend?: (...args: any[]) => void;
-    onDelete?: () => void;
-    sendMessageKey?: string;
-    transitionConfig?: Record<string, unknown> | IslandTransitionConfig;
-    onExitComplete?: () => void;
-    usePortal?: boolean;
-    className?: string;
-}
-declare function AnnotationIslandMenu(_props: AnnotationIslandMenuProps): React$1.ReactNode;
-
-/**
- * island-motion — stub for annotation island motion/animation utilities.
- */
-interface PointerSnapshot {
-    x: number;
-    y: number;
-    timestamp: number;
-}
-declare function buildAnnotationChipEntryTransition(_snapshot?: PointerSnapshot | null): Record<string, unknown>;
-declare function buildSelectionEntryTransition(_primary?: PointerSnapshot | null, _secondary?: PointerSnapshot | null): Record<string, unknown>;
-
-/**
- * Event Processor Types
- *
- * Defines the state and event types for the centralized event processor.
- * All agent events flow through a single pure function for consistent state transitions.
- */
-
-/**
- * Runtime Session type — extends core Session with messages and processing state.
- * Aliased from ProtocolSession which includes all runtime fields needed by the processor.
- */
-type Session = ProtocolSession;
-
-/**
- * Streaming state for a session - replaces streamingTextRef
- */
-interface StreamingState {
-    content: string;
-    turnId?: string;
-    parentToolUseId?: string;
-}
-/**
- * Complete state for a session - combines session + streaming
- */
-interface SessionState {
-    session: Session;
-    streaming: StreamingState | null;
-}
-/**
- * Text delta event - streaming text content
- */
-interface TextDeltaEvent {
-    type: 'text_delta';
-    sessionId: string;
-    delta: string;
-    turnId?: string;
-    /** Timestamp from canonical timeline for stable ordering */
-    timestamp?: number;
-    /** When true, this delta belongs to a reasoning/thinking block (intermediate content). */
-    isIntermediate?: boolean;
-}
-/**
- * Text complete event - finalizes streaming text
- */
-interface TextCompleteEvent {
-    type: 'text_complete';
-    sessionId: string;
-    text: string;
-    turnId?: string;
-    isIntermediate?: boolean;
-    parentToolUseId?: string;
-    /** Timestamp from main process for consistent ordering with session.jsonl */
-    timestamp?: number;
-    /** Authoritative message ID from main process for persistence/branching parity */
-    messageId?: string;
-}
-/**
- * Tool start event - begins tool execution
- * Field names match SessionEvent from @weft/protocol
- */
-interface ToolStartEvent {
-    type: 'tool_start';
-    sessionId: string;
-    toolUseId: string;
-    toolName: string;
-    toolInput?: Record<string, unknown>;
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-    turnId?: string;
-    parentToolUseId?: string;
-    toolIntent?: string;
-    toolDisplayName?: string;
-    /** Tool display metadata with base64-encoded icon for viewer compatibility */
-    toolDisplayMeta?: ToolDisplayMeta;
-}
-/**
- * Tool result event - completes tool execution
- */
-interface ToolResultEvent {
-    type: 'tool_result';
-    sessionId: string;
-    toolUseId: string;
-    toolName?: string;
-    result: string;
-    isError?: boolean;
-    turnId?: string;
-    parentToolUseId?: string;
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-}
-/**
- * Tool delta event - appends streaming output to an executing tool.
- */
-interface ToolDeltaEvent {
-    type: 'tool_delta';
-    sessionId: string;
-    toolUseId: string;
-    delta: string;
-    stream?: string;
-    turnId?: string;
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-}
-/**
- * Complete event - agent loop finished
- */
-interface CompleteEvent {
-    type: 'complete';
-    sessionId: string;
-    tokenUsage?: Session['tokenUsage'];
-    /** Explicit unread flag - set by main process based on viewing state */
-    hasUnread?: boolean;
-}
-/**
- * Error event - agent error occurred
- */
-interface ErrorEvent {
-    type: 'error';
-    sessionId: string;
-    error: string;
-    code?: string;
-    title?: string;
-    details?: string;
-    original?: string;
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-}
-/**
- * Permission request event
- * Matches SessionEvent shape from @weft/protocol
- */
-interface PermissionRequestEvent {
-    type: 'permission_request';
-    sessionId: string;
-    request: PermissionRequest;
-}
-/**
- * Sources changed event
- */
-interface SourcesChangedEvent {
-    type: 'sources_changed';
-    sessionId: string;
-    enabledSourceSlugs: string[];
-}
-/**
- * Labels changed event
- */
-interface LabelsChangedEvent {
-    type: 'labels_changed';
-    sessionId: string;
-    labels: string[];
-}
-/**
- * Todo state changed event (external metadata change or agent tool)
- */
-interface SessionStatusChangedEvent {
-    type: 'session_status_changed';
-    sessionId: string;
-    sessionStatus?: string;
-}
-/**
- * Session flagged/unflagged events (external metadata change)
- */
-interface SessionFlaggedEvent {
-    type: 'session_flagged';
-    sessionId: string;
-}
-interface SessionUnflaggedEvent {
-    type: 'session_unflagged';
-    sessionId: string;
-}
-/**
- * Session archived/unarchived events (external metadata change)
- */
-interface SessionArchivedEvent {
-    type: 'session_archived';
-    sessionId: string;
-}
-interface SessionUnarchivedEvent {
-    type: 'session_unarchived';
-    sessionId: string;
-}
-/**
- * Session name changed event (external metadata change)
- */
-interface NameChangedEvent {
-    type: 'name_changed';
-    sessionId: string;
-    name?: string;
-}
-/**
- * Plan submitted event
- */
-interface PlanSubmittedEvent {
-    type: 'plan_submitted';
-    sessionId: string;
-    message: Message;
-}
-/**
- * Typed error event
- */
-interface TypedErrorEvent {
-    type: 'typed_error';
-    sessionId: string;
-    error: TypedError;
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-}
-/**
- * Status event
- */
-interface StatusEvent {
-    type: 'status';
-    sessionId: string;
-    message: string;
-    statusType?: 'compacting';
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-}
-/**
- * Info event
- */
-interface InfoEvent {
-    type: 'info';
-    sessionId: string;
-    message: string;
-    statusType?: 'compaction_complete';
-    level?: 'info' | 'warning' | 'error' | 'success';
-    /** Timestamp from main process for consistent ordering */
-    timestamp?: number;
-}
-/**
- * Interrupted event
- */
-interface InterruptedEvent {
-    type: 'interrupted';
-    sessionId: string;
-    message?: Message;
-    /** Messages that were queued but not processed — should be restored to input field */
-    queuedMessages?: string[];
-}
-/**
- * Title generated event
- */
-interface TitleGeneratedEvent {
-    type: 'title_generated';
-    sessionId: string;
-    title: string;
-    preview?: string;
-}
-/**
- * Title regenerating event - indicates title regeneration has started/finished
- * Used to show shimmer effect on title during regeneration
- * @deprecated Use AsyncOperationEvent instead
- */
-interface TitleRegeneratingEvent {
-    type: 'title_regenerating';
-    sessionId: string;
-    isRegenerating: boolean;
-}
-/**
- * Generic async operation state event
- * Used to show shimmer effect during any async operation (sharing, updating, revoking, title regeneration)
- */
-interface AsyncOperationEvent {
-    type: 'async_operation';
-    sessionId: string;
-    isOngoing: boolean;
-}
-/**
- * Working directory changed event (user-initiated via UI)
- */
-interface WorkingDirectoryChangedEvent {
-    type: 'working_directory_changed';
-    sessionId: string;
-    workingDirectory: string;
-}
-/**
- * Working directory error event - server rejected the path (cross-platform, not found, etc.)
- */
-interface WorkingDirectoryErrorEvent {
-    type: 'working_directory_error';
-    sessionId: string;
-    error: string;
-}
-/**
- * Permission mode changed event
- */
-interface PermissionModeChangedEvent {
-    type: 'permission_mode_changed';
-    sessionId: string;
-    permissionMode: PermissionMode;
-    previousPermissionMode?: PermissionMode;
-    transitionDisplay?: string;
-    modeVersion?: number;
-    changedAt?: string;
-    changedBy?: 'user' | 'system' | 'restore' | 'automation' | 'unknown';
-}
-/**
- * Session model changed event
- */
-interface SessionModelChangedEvent {
-    type: 'session_model_changed';
-    sessionId: string;
-    model: string | null;
-}
-/**
- * LLM connection changed event - syncs session.llmConnection to renderer
- */
-interface LLMConnectionChangedEvent {
-    type: 'connection_changed';
-    sessionId: string;
-    connectionSlug: string;
-    supportsBranching?: boolean;
-}
-/**
- * Credential request event - prompts user for credentials
- */
-interface CredentialRequestEvent {
-    type: 'credential_request';
-    sessionId: string;
-    request: CredentialRequest;
-}
-/**
- * Task backgrounded event - background agent started
- */
-interface TaskBackgroundedEvent {
-    type: 'task_backgrounded';
-    sessionId: string;
-    toolUseId: string;
-    taskId: string;
-    intent?: string;
-    turnId?: string;
-}
-/**
- * Shell backgrounded event - background bash shell started
- */
-interface ShellBackgroundedEvent {
-    type: 'shell_backgrounded';
-    sessionId: string;
-    toolUseId: string;
-    shellId: string;
-    intent?: string;
-    turnId?: string;
-}
-/**
- * Task progress event - live progress updates for background tasks
- */
-interface TaskProgressEvent {
-    type: 'task_progress';
-    sessionId: string;
-    toolUseId: string;
-    elapsedSeconds: number;
-    turnId?: string;
-}
-/**
- * Task completed event - background task finished execution
- * Updates the tool message status and result when a background task completes.
- */
-interface TaskCompletedEvent {
-    type: 'task_completed';
-    sessionId: string;
-    taskId: string;
-    status: 'completed' | 'failed' | 'stopped';
-    outputFile?: string;
-    summary?: string;
-    turnId?: string;
-}
-/**
- * User message event - backend confirmation of optimistic user message
- * Used for optimistic UI: frontend shows message immediately,
- * backend confirms/updates status via this event
- */
-interface UserMessageEvent {
-    type: 'user_message';
-    sessionId: string;
-    message: Message;
-    status: 'accepted' | 'queued' | 'processing';
-    /** Frontend's optimistic message ID for reliable matching */
-    optimisticMessageId?: string;
-}
-/**
- * Message annotation update event
- */
-interface MessageAnnotationsUpdatedEvent {
-    type: 'message_annotations_updated';
-    sessionId: string;
-    messageId: string;
-    annotations: NonNullable<Message['annotations']>;
-}
-/**
- * Session shared event - session was shared to viewer
- */
-interface SessionSharedEvent {
-    type: 'session_shared';
-    sessionId: string;
-    sharedUrl: string;
-}
-/**
- * Session unshared event - session share was revoked
- */
-interface SessionUnsharedEvent {
-    type: 'session_unshared';
-    sessionId: string;
-}
-/**
- * Auth request event - unified auth flow (credential or OAuth)
- * Adds auth-request message to session and displays inline auth UI
- */
-interface AuthRequestEvent {
-    type: 'auth_request';
-    sessionId: string;
-    message: Message;
-    request: AuthRequest;
-}
-/**
- * Auth completed event - auth request was completed (success, failure, or cancelled)
- * Updates the auth-request message status
- */
-interface AuthCompletedEvent {
-    type: 'auth_completed';
-    sessionId: string;
-    requestId: string;
-    success: boolean;
-    cancelled?: boolean;
-    error?: string;
-}
-/**
- * Source activated event - a source was auto-activated mid-turn
- * Caller should re-send the original message to retry with the now-active source
- */
-interface SourceActivatedEvent {
-    type: 'source_activated';
-    sessionId: string;
-    sourceSlug: string;
-    originalMessage: string;
-}
-/**
- * Usage update event - real-time context usage during processing
- * Allows UI to show growing context as agent processes, not just on complete
- */
-interface UsageUpdateEvent {
-    type: 'usage_update';
-    sessionId: string;
-    tokenUsage: {
-        inputTokens: number;
-        contextWindow?: number;
-    };
-}
-/**
- * Union of all agent events
- */
-type ChatEvent = TextDeltaEvent | TextCompleteEvent | ToolStartEvent | ToolDeltaEvent | ToolResultEvent | CompleteEvent | ErrorEvent | TypedErrorEvent | PermissionRequestEvent | CredentialRequestEvent | SourcesChangedEvent | LabelsChangedEvent | SessionStatusChangedEvent | SessionFlaggedEvent | SessionUnflaggedEvent | SessionArchivedEvent | SessionUnarchivedEvent | NameChangedEvent | PlanSubmittedEvent | StatusEvent | InfoEvent | InterruptedEvent | TitleGeneratedEvent | TitleRegeneratingEvent | AsyncOperationEvent | WorkingDirectoryChangedEvent | WorkingDirectoryErrorEvent | PermissionModeChangedEvent | SessionModelChangedEvent | LLMConnectionChangedEvent | TaskBackgroundedEvent | ShellBackgroundedEvent | TaskProgressEvent | TaskCompletedEvent | UserMessageEvent | MessageAnnotationsUpdatedEvent | SessionSharedEvent | SessionUnsharedEvent | AuthRequestEvent | AuthCompletedEvent | SourceActivatedEvent | UsageUpdateEvent;
-/**
- * Side effects that need to be handled outside the pure processor
- */
-type Effect = {
-    type: 'permission_request';
-    request: PermissionRequest;
-} | {
-    type: 'credential_request';
-    request: CredentialRequest;
-} | {
-    type: 'generate_title';
-    sessionId: string;
-    userMessage: string;
-} | {
-    type: 'permission_mode_changed';
-    sessionId: string;
-    permissionMode: PermissionMode;
-    previousPermissionMode?: PermissionMode;
-    transitionDisplay?: string;
-    modeVersion?: number;
-    changedAt?: string;
-    changedBy?: 'user' | 'system' | 'restore' | 'automation' | 'unknown';
-} | {
-    type: 'auto_retry';
-    sessionId: string;
-    originalMessage: string;
-    sourceSlug: string;
-} | {
-    type: 'restore_input';
-    text: string;
-} | {
-    type: 'toast_error';
-    message: string;
-};
-/**
- * Result of processing an event
- */
-interface ProcessResult {
-    state: SessionState;
-    /** Side effects to execute (permissions, etc.) */
-    effects: Effect[];
-}
-
-/**
- * Event Processor
- *
- * Central pure function that processes all agent events.
- * Guarantees consistent state transitions and always returns new references.
- *
- * Benefits:
- * - Single source of truth for event handling
- * - Pure functions - easy to test
- * - No race conditions - single update path
- * - Always new references - atom sync always works
- * - Message lookup by ID - never position-based
- */
-
-/**
- * Process an agent event, returning new state and any side effects
- *
- * This is a PURE FUNCTION - no side effects, always returns new state.
- * Guaranteed to return a new session reference (no referential equality issues).
- *
- * @param state - Current session state (session + streaming)
- * @param event - Agent event to process
- * @returns New state and any side effects to execute
- */
-declare function processEvent(state: SessionState, event: ChatEvent): ProcessResult;
-
-/**
- * Map a core AgentEvent to the processor's session-scoped event format.
- *
- * Core AgentEvent is the raw SDK/runtime format. The processor expects
- * session-scoped events with its own field names. Keeping this as a pure
- * function makes local-runtime, tests, and React hooks share one mapping.
- */
-declare function mapCoreEventToProcessorEvent(coreEvent: AgentEvent, sessionId: string): ChatEvent;
-declare function mapTimelineEnvelopeToProcessorEvent(envelope: TimelineEnvelope): ChatEvent;
-
-/**
- * Message Operation Helpers
- *
- * Pure utility functions for finding and updating messages.
- * All lookups are by ID (turnId, toolUseId) - NEVER by position.
- */
-
-/**
- * Generate a unique message ID
- * Delegates to core's generateMessageId for uniqueness
- */
-declare function generateMessageId(): string;
-/**
- * Find streaming assistant message by turnId
- * Falls back to last streaming assistant if no turnId
- */
-declare function findStreamingMessage(messages: Message[], turnId?: string): number;
-/**
- * Find assistant message by turnId (streaming or not)
- */
-declare function findAssistantMessage(messages: Message[], turnId?: string): number;
-/**
- * Find tool message by toolUseId
- */
-declare function findToolMessage(messages: Message[], toolUseId: string): number;
-/**
- * Update message at index, returning new session
- * Always creates new references (immutable update)
- * @param updateTimestamp - If true, also update lastMessageAt
- */
-declare function updateMessageAt(session: Session, index: number, updates: Partial<Message>, updateTimestamp?: boolean): Session;
-/**
- * Append message to session, returning new session
- * @param updateTimestamp - If false, don't update lastMessageAt (for intermediate/tool messages)
- */
-declare function appendMessage(session: Session, message: Message, updateTimestamp?: boolean): Session;
-
-/**
- * Event Source Interface
- *
- * Generic abstraction for receiving SessionEvent streams.
- * Replaces Electron IPC (window.electronAPI.onSessionEvent) with
- * a provider-agnostic interface that works in any runtime:
- * - WebSocket (browser/server)
- * - HTTP SSE (server)
- * - stdin/stdout (CLI)
- * - In-process (testing)
- */
-
-/**
- * Event source callback — receives events from the source.
- */
-type EventSourceCallback = (event: AgentEvent) => void;
-/**
- * Error callback — receives errors from the source.
- */
-type EventSourceErrorCallback = (error: Error) => void;
-/**
- * Close callback — called when the source is disconnected.
- */
-type EventSourceCloseCallback = () => void;
-/**
- * Generic event source interface.
- * Implementations provide events from different transports.
- */
-interface EventSource {
-    /**
-     * Start receiving events.
-     * @param onEvent - Callback for each AgentEvent
-     * @param onError - Callback for transport errors
-     * @param onClose - Callback when source disconnects
-     */
-    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
-    /**
-     * Stop receiving events and clean up resources.
-     */
-    disconnect(): void;
-    /**
-     * Check if the source is currently connected.
-     */
-    isConnected(): boolean;
-}
-/**
- * WebSocket-based EventSource implementation.
- * Receives SessionEvent messages over a WebSocket connection.
- */
-declare class WebSocketEventSource implements EventSource {
-    private ws;
-    private connected;
-    private url;
-    private protocols?;
-    constructor(url: string, protocols?: string | string[]);
-    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
-    disconnect(): void;
-    isConnected(): boolean;
-}
-/**
- * SSE (Server-Sent Events) EventSource implementation.
- * Receives SessionEvent messages over an HTTP SSE connection.
- */
-declare class SSEEventSource implements EventSource {
-    private source;
-    private connected;
-    private url;
-    constructor(url: string);
-    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
-    disconnect(): void;
-    isConnected(): boolean;
-}
-/**
- * In-process EventSource for testing.
- * Events are pushed directly via enqueue().
- */
-declare class InProcessEventSource implements EventSource {
-    private listeners;
-    private connected;
-    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
-    disconnect(): void;
-    isConnected(): boolean;
-    /**
-     * Push an event directly to the connected listener.
-     * Useful for testing and in-process scenarios.
-     */
-    enqueue(event: AgentEvent): void;
-    /**
-     * Simulate an error.
-     */
-    simulateError(error: Error): void;
-    /**
-     * Simulate a disconnect.
-     */
-    simulateClose(): void;
-}
-
-/**
- * Event Processor Hook
- *
- * Provides the event processor for use in React apps.
- * Manages streaming state per session and returns processed events.
- *
- * Accepts an EventSource (WebSocket, SSE, in-process) instead of
- * Electron IPC (window.electronAPI). Uses React useState/useRef
- * instead of Jotai atoms for state management.
- */
-
-interface UseEventProcessorOptions {
-    /** EventSource to receive agent events from */
-    eventSource: EventSource;
-    /** Session ID to associate with incoming events */
-    sessionId: string;
-    /** Workspace ID for creating new sessions */
-    workspaceId: string;
-    /** Workspace name for creating new sessions */
-    workspaceName?: string;
-    /** Callback for side effects (permissions, toasts, etc.) */
-    onEffect?: (effect: Effect) => void;
-    /** Callback for errors from the event source */
-    onError?: (error: Error) => void;
-    /** Callback when event source disconnects */
-    onClose?: () => void;
-}
-interface UseEventProcessorResult {
-    /** Current session state (messages, processing status, etc.) */
-    session: Session | null;
-    /** Current streaming state for the session */
-    streamingState: StreamingState | null;
-    /**
-     * Process an agent event and return the updated session + any side effects
-     *
-     * @param event - The core AgentEvent to process
-     * @returns Updated session and any side effects to execute
-     */
-    processAgentEvent: (event: AgentEvent) => {
-        session: Session;
-        effects: Effect[];
-    };
-    /**
-     * Clear streaming state for the session (e.g., on error or complete)
-     */
-    clearStreamingState: () => void;
-    /**
-     * Get current streaming state (for debugging/testing)
-     */
-    getStreamingState: () => StreamingState | null;
-    /**
-     * Whether the event source is currently connected
-     */
-    isConnected: boolean;
-}
-/**
- * Hook that provides the event processor connected to an EventSource.
- *
- * Manages streaming state per session using React useRef (not Jotai atoms).
- * All event processing goes through pure functions.
- *
- * Connects to the EventSource on mount and disconnects on unmount.
- */
-declare function useEventProcessor(options: UseEventProcessorOptions): UseEventProcessorResult;
-
-export { ActivityDetailsPanel, ActivityInspector, type ActivityItem, type ActivityStatus, AnnotationIslandMenu, type AnnotationIslandMenuProps, type AnnotationOverlayChip, type AnnotationOverlayGeometryResult, AnnotationOverlayLayer, type AnnotationOverlayLayerProps, type AnnotationOverlayRect, type AssistantTurn, AssistantTurnCard, type AuthRequestTurn, type ChatEvent, ChatTranscript, type ChatTranscriptProps, CodeBlock, CollapsibleMarkdownProvider, type Effect, type EventSource, type EventSourceCallback, type EventSourceCloseCallback, type EventSourceErrorCallback, InProcessEventSource, type InlineActivityItem, InlineCode, InlineExecution, type InlineExecutionProps, type InlineExecutionStatus, type IslandTransitionConfig, Markdown, type MarkdownProps, MemoizedMarkdown, PendingIndicator, type PendingIndicatorProps, PermissionModeMenu, PermissionRequestCard, type PermissionRequestCardProps, type PlatformActions, PlatformProvider, type PointerSnapshot, type ProcessResult, type RenderMode, ResponseCard, type ResponseCardProps, type ResponseContent, SIZE_CONFIG, SSEEventSource, type Session, type SessionState, SessionViewer, type SessionViewerMode, type SessionViewerProps, type StreamingState, SystemMessage, type SystemMessageProps, type SystemMessageType, type SystemTurn, type TextSegment, type TodoItem, type Turn, TurnCard, type TurnCardProps, UserMessageBubble, type UserMessageBubbleProps, type UserTurn, WebSocketEventSource, appendMessage, buildAnnotationChipEntryTransition, buildSelectionEntryTransition, collectTextSegments, computeAnnotationOverlayGeometry, createSelectionPreviewAnnotation, createTextSelectionAnnotation, findAssistantMessage, findStreamingMessage, findToolMessage, generateMessageId, getAssistantTurnUiKey, getCanonicalText, groupMessagesByTurn, hasExistingTextRangeAnnotation, mapCoreEventToProcessorEvent, mapTimelineEnvelopeToProcessorEvent, processEvent, resolveNodeOffset, shouldShowStreamingContent, updateMessageAt, useEventProcessor };
-
-// -- @weft/ui/lib/en-fallback.d.ts --
-/**
- * English fallback translations for UI components.
- *
- * Used by:
- * - `TurnCard.tsx` `t()` wrapper — when i18next is uninitialized or has no resource for a key
- * - `apps/demo/src/i18n-init.ts` — as the primary `en` resource bundle
- *
- * Single source of truth — add new keys here, both consumers stay synchronized.
- */
-declare const EN_FALLBACK: Record<string, string>;
-
-export { EN_FALLBACK };
-
-// ── inlined from @weft/local-chat ──
-// -- @weft/local-chat/index.d.ts --
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
-interface LocalChatAuthDetection {
-    provider: string;
-    configured: boolean;
-    source?: string;
-    error?: string;
-}
-interface LocalChatRuntimeState {
-    status: 'idle' | 'preflighting' | 'running' | 'ready' | 'failed' | string;
-}
-interface LocalChatEventSource {
-    connect(onEvent: (event: AgentEvent) => void, onError?: (error: Error) => void, onClose?: () => void): void;
-    disconnect(): void;
-    isConnected(): boolean;
-}
-interface LocalChatCommandSink {
-    sendMessage(message: string): Promise<void>;
-    abort(reason?: string): Promise<void>;
-    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
-}
-interface LocalChatSessionRuntime {
-    sessionId: string;
-    provider: string;
-    events: LocalChatEventSource;
-    commands: LocalChatCommandSink;
-    preflight(): Promise<LocalChatAuthDetection>;
-    getState(): LocalChatRuntimeState;
-}
-interface AgentChatSessionModel {
-    session: Session | null;
-    turns: Turn[];
-    isRunning: boolean;
-    auth: LocalChatAuthDetection | null;
-    error: Error | null;
-    sendMessage(message: string): Promise<void>;
-    abort(): Promise<void>;
-    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
-}
-interface UseAgentChatSessionOptions {
-    runtime: LocalChatSessionRuntime;
-    workspaceId?: string;
-    workspaceName?: string;
-}
-interface TimelineChatPanelModel {
-    session: Session;
-    turns: Turn[];
-}
-type TimelineDetailKind = 'permission' | 'runtime' | 'source' | 'skill' | 'automation' | 'host' | 'tool';
-interface TimelineDetailItem {
-    id: string;
-    kind: TimelineDetailKind;
-    title: string;
-    summary?: string;
-    status?: string;
-    timestamp: number;
-    detail: unknown;
-    envelope: TimelineEnvelope;
-}
-interface TimelineAgentChatSessionModel extends TimelineChatPanelModel {
-    timeline: TimelineEnvelope[];
-    isRunning: boolean;
-    isConnected: boolean;
-    isReconnecting: boolean;
-    hasGap: boolean;
-    capabilityReport: RuntimeCapabilityReport | null;
-    error: Error | null;
-    sendMessage(message: string, options?: SendMessageOptions): Promise<void>;
-    abort(): Promise<void>;
-    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
-}
-interface UseTimelineAgentChatSessionOptions {
-    runtime: AgentRuntime;
-    workspaceId?: string;
-    workspaceName?: string;
-}
-declare function createAgentChatPanelModel(args: {
-    session: Session | null;
-    runtime: LocalChatSessionRuntime;
-    auth?: LocalChatAuthDetection | null;
-    error?: Error | null;
-}): Pick<AgentChatSessionModel, 'turns' | 'isRunning' | 'auth' | 'error'>;
-declare function createAgentChatPanelModelFromTimeline(args: {
-    timeline: TimelineEnvelope[];
-    sessionId: string;
-    workspaceId: string;
-    workspaceName?: string;
-}): TimelineChatPanelModel;
-declare function createTimelineAgentChatPanelModel(args: {
-    timeline: TimelineEnvelope[];
-    sessionId: string;
-    workspaceId: string;
-    workspaceName?: string;
-    runtimeState: AgentRuntimeState;
-    capabilityReport: RuntimeCapabilityReport | null;
-    error: Error | null;
-}): Pick<TimelineAgentChatSessionModel, 'session' | 'turns' | 'isRunning' | 'capabilityReport' | 'error'>;
-declare function createTimelineDetailItems(timeline: TimelineEnvelope[]): TimelineDetailItem[];
-declare function useAgentChatSession(options: UseAgentChatSessionOptions): AgentChatSessionModel;
-declare function useTimelineAgentChatSession(options: UseTimelineAgentChatSessionOptions): TimelineAgentChatSessionModel;
-
-interface AgentChatPanelProps {
-    runtime: LocalChatSessionRuntime;
-    workspaceId?: string;
-    workspaceName?: string;
-    platformActions?: PlatformActions;
-    placeholder?: string;
-    className?: string;
-}
-declare function AgentChatPanel({ runtime, workspaceId, workspaceName, platformActions, placeholder, className, }: AgentChatPanelProps): react_jsx_runtime.JSX.Element;
-
-interface TimelineAgentChatPanelProps {
-    /** Agent runtime instance from runtime-core */
-    runtime: AgentRuntime;
-    /** Workspace identifier */
-    workspaceId?: string;
-    /** Workspace display name */
-    workspaceName?: string;
-    /** Platform actions for file/URL handling */
-    platformActions?: PlatformActions;
-    /** Placeholder text for the input area */
-    placeholder?: string;
-    /** Whether to show the runtime status bar */
-    showStatusBar?: boolean;
-    /** Whether to show the runtime detail sidebar panel */
-    showDetailPanel?: boolean;
-    /** Additional className */
-    className?: string;
-}
-declare function TimelineAgentChatPanel({ runtime, workspaceId, workspaceName, platformActions, placeholder, showStatusBar, showDetailPanel, className, }: TimelineAgentChatPanelProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Find the active (unresolved) permission request from timeline envelopes.
- *
- * Walks the timeline backwards to find the most recent permission_requested
- * envelope that has not been resolved by a matching permission_resolved.
- */
-declare function findActivePermissionRequest(timeline: TimelineEnvelope[]): {
-    requestId: string;
-    toolName: string;
-    input?: Record<string, unknown>;
-    reason?: string;
-    scope?: {
-        type: string;
-        label?: string;
-    };
-} | null;
-
-/**
- * Convert a processor Session (returned by useAgentChatSession) into a
- * StoredSession that SessionViewer can render.
- *
- * Consumers embedding AgentChatPanel don't need this — it's called internally.
- * This utility is exported for consumers who use useAgentChatSession directly
- * and build their own panel around SessionViewer.
- */
-declare function toStoredSession(session: Session, fallbackWorkspaceId?: string): StoredSession;
-/**
- * Build an empty StoredSession placeholder for the initial state
- * before the event processor has received any events.
- */
-declare function createEmptyStoredSession(sessionId: string, workspaceId?: string, workspaceName?: string): StoredSession;
-
-export { AgentChatPanel, type AgentChatPanelProps, type AgentChatSessionModel, type LocalChatAuthDetection, type LocalChatCommandSink, type LocalChatEventSource, type LocalChatRuntimeState, type LocalChatSessionRuntime, TimelineAgentChatPanel, type TimelineAgentChatPanelProps, type TimelineAgentChatSessionModel, type TimelineChatPanelModel, type TimelineDetailItem, type TimelineDetailKind, type UseAgentChatSessionOptions, type UseTimelineAgentChatSessionOptions, createAgentChatPanelModel, createAgentChatPanelModelFromTimeline, createEmptyStoredSession, createTimelineAgentChatPanelModel, createTimelineDetailItems, findActivePermissionRequest, toStoredSession, useAgentChatSession, useTimelineAgentChatSession };