@pluno/product-agent-web 0.1.230 → 0.1.233

package/dist/core/conversation/selectors.d.ts

@@ -0,0 +1,59 @@
+import type { PAConversationScopeId, PAViewId } from "../kernel/state";
+import type { PADirectoryState } from "../session-directory/contracts";
+import type { PAConversationProjection, PAConversationRecord, PAConversationSegment, PAConversationState } from "./contracts";
+export declare function selectConversationScope(state: PAConversationState, directory: PADirectoryState, scope: PAConversationScopeId): PAConversationProjection;
+export declare function selectComposerHandoff(projection: PAConversationProjection, viewId: PAViewId, rendererRevision: number): Readonly<{
+    viewId: PAViewId;
+    userMessageId: string;
+    acceptedRendererRevision: number;
+}> | null;
+export declare function selectConversationRetryTarget(projection: PAConversationProjection, explicitId?: string): {
+    type: "delivery";
+    userMessageId: string;
+    sessionId?: undefined;
+} | {
+    type: "execution";
+    userMessageId: string;
+    sessionId: import("..").PASessionId;
+} | null;
+export declare function selectConversation(state: PAConversationState, directory: PADirectoryState): {
+    scopes: {
+        [k: string]: Readonly<{
+            preparation?: "pending" | "busy" | null;
+            selectionKey?: string;
+            isDraftSession: boolean;
+            proactiveQuestion: Readonly<{
+                id: string;
+                content: string;
+            }> | null;
+            followUps: readonly import("./display").PAConversationFollowUp[];
+            sessionId: import("..").PASessionId | null;
+            submissions: readonly import("./contracts").PAOwnedSubmission[];
+            deliveries: Readonly<Record<string, import("./deliveryContracts").PAConversationDelivery>>;
+            items: readonly import("./display").PADisplayItem[];
+            optimistic: readonly import("./contracts").PAOwnedSubmission[];
+            removedItems: Readonly<Record<string, string>>;
+            streamStates: Readonly<Record<string, import("./display").PAStreamLifecycle["state"] | "awaiting_content">>;
+            stop: (import("./contracts").PAConversationStop & Readonly<{
+                pending: boolean;
+            }>) | null;
+            segments: readonly PAConversationSegment[];
+            activity: Readonly<{
+                phase: import("./display").PAExecutionState["phase"] | "submitting" | "awaiting_execution";
+                activeItemId: string | null;
+                userMessageId?: string | null;
+            }>;
+            receipts: readonly Readonly<{
+                viewId: PAViewId;
+                userMessageId: string;
+                acceptedRendererRevision: number;
+            }>[];
+        }>;
+    };
+};
+export declare function isConversationTurnTerminal(record: PAConversationRecord, userMessageId: string | null): boolean;
+export declare function selectConversationCompletion(projection: PAConversationProjection, record: PAConversationRecord | undefined): {
+    version: number;
+    userMessageIds: readonly string[];
+    answer: string;
+} | null;

package/dist/core/conversation/state.d.ts

@@ -0,0 +1,6 @@
+import { type PAAuthorityId, type PASessionId } from "../kernel/state";
+import type { PAConversationRecord, PAConversationState } from "./contracts";
+export declare function freezeConversationValue<T>(value: T): T;
+export declare function ownConversationValue<T>(value: T): T;
+export declare function createConversationState(authorityId?: PAAuthorityId, generation?: number): PAConversationState;
+export declare function createConversationRecord(sessionId: PASessionId): PAConversationRecord;

package/dist/core/index.d.ts

@@ -1,5 +1,11 @@
 export * from "./browser-execution/contracts";
 export * from "./conversation/contracts";
+export * from "./conversation/display";
+export * from "./conversation/state";
+export * from "./conversation/reducer";
+export * from "./conversation/selectors";
+export * from "./conversation/deliveryContracts";
+export * from "./conversation/delivery";
 export * from "./interactions/contracts";
 export * from "./kernel/capabilities";
 export * from "./kernel/commands";

package/dist/core/model-selection/commands.d.ts

@@ -16,7 +16,7 @@ export type PAModelCommand = Readonly<{
 }> | Readonly<{
     type: "model.submission_capture";
     clientMessageId: string;
-    requestedModel?: PAProductAgentModel;
+    requestedModel?: PAProductAgentModel | null;
 }> | Readonly<{
     type: "model.scope_close";
 }>);

package/dist/displayedErrors.d.ts

@@ -1,3 +1,3 @@
 export declare function reportProductAgentTimelineJump(hasUserScrolled: boolean, report: (reason: string) => void): void;
-export declare function observeProductAgentDisplayedErrors(root: HTMLElement, report: (reason: string, errorFingerprint: string, displayedMessage: string) => void): () => void;
+export declare function observeProductAgentDisplayedErrors(root: HTMLElement, report: (reason: string, errorFingerprint: string, displayedMessage: string, itemId?: string) => void): () => void;
 export declare function observeProductAgentDuplicateProactiveQuestions(root: HTMLElement, report: (reason: string, clientMessageId: string) => void): () => void;

package/dist/entrySurface.d.ts

@@ -0,0 +1,2 @@
+import type { ProductAgentEntrySurface, ProductAgentLegacyEntrySurface } from "./index";
+export declare function normalizeProductAgentEntrySurface(value: ProductAgentEntrySurface | ProductAgentLegacyEntrySurface | undefined): ProductAgentEntrySurface;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
+import { type OperationTiming } from "./operationTiming";
 import type { ActiveUsersCounterValue } from "./activeUsersCounter";
+import { type RenderedErrorEvidence, type UiInvariantEvidence } from "./renderDiagnostics";
 import type { ProductAgentTaskStatus } from "./taskPageTitle";
 import type { ProductAgentEntityQueryData, ProductAgentAccountProjection, ProductAgentSubmissionContext, ProductAgentInteraction, ProductAgentInteractionAction, ProductAgentQueryState } from "./runtimeState";
 export type ProductAgentModel = "anthropic/claude-opus-5" | "anthropic/claude-sonnet-5" | "deepseek/deepseek-chat-v3.1" | "deepseek/deepseek-v4-flash" | "gpt-5.4-nano" | "gpt-5.4-mini" | "gpt-5.4" | "gpt-5.6-luna" | "gpt-5.6-terra" | "gpt-5.6-sol";
@@ -50,6 +52,7 @@ export type ProductAgentMessage = {
     sharePromptAllowed?: boolean;
     attachments?: ProductAgentAttachment[];
     loading?: boolean;
+    streamState?: "open" | "awaiting_content" | "finished" | "failed" | "stopped";
     steered?: boolean;
     retryable?: boolean;
     integrationAuthRequest?: ProductAgentIntegrationAuthRequest;
@@ -130,6 +133,8 @@ export type ProductAgentAppearance = {
 };
 export type ProductAgentTurnPhase = "sending" | "starting" | "thinking";
 export type ProductAgentState = {
+    selectionKey?: string;
+    isDraftSession?: boolean;
     submissionContext?: ProductAgentSubmissionContext;
     activeUsersCount?: number | null;
     status: "idle" | "connecting" | "connected" | "reconnecting" | "closed" | "error";
@@ -139,7 +144,25 @@ export type ProductAgentState = {
     starterPromptsLoading: boolean;
     appearance: ProductAgentAppearance | null;
     messages: ProductAgentMessage[];
+    removedItems?: Readonly<Record<string, string>>;
+    segments?: readonly Readonly<{
+        id: string;
+        userMessageId: string | null;
+        activityIds: readonly string[];
+        outcomeIds: readonly string[];
+        collapsed: boolean;
+    }>[];
+    activity?: Readonly<{
+        phase: "idle" | "queued" | "thinking" | "steering" | "stopping" | "completed" | "failed" | "stopped" | "submitting" | "awaiting_execution";
+        activeItemId: string | null;
+    }>;
+    receipts?: readonly Readonly<{
+        viewId: string;
+        userMessageId: string;
+        acceptedRendererRevision: number;
+    }>[];
     activeScheduledFollowUps: ProductAgentActiveScheduledFollowUp[] | null;
+    historyPreparation?: "pending" | "busy" | null;
     isLoadingSession: boolean;
     assistantDraft: string;
     assistantDraftItemId: string | null;
@@ -276,8 +299,12 @@ export declare const PRODUCT_AGENT_PROVIDER_INPUT_ATTACHMENT_ACCEPT = ".pdf,.png
 export declare function calculateReconnectDelay(attempt: number, random?: () => number): number;
 export declare class ProductAgentSessionEngine {
     private readonly options;
-    private readonly assistantDeltaReplayGuard;
     private readonly clientRuntime;
+    private conversationObservation;
+    private conversationAdapterGeneration;
+    private conversationUnsubscribe;
+    private composerRevision;
+    private submissionIntentRevision;
     private readonly listeners;
     private socket;
     private reconnectTimer;
@@ -291,6 +318,9 @@ export declare class ProductAgentSessionEngine {
     private token;
     private rejectedTransportToken;
     private refreshingDefaultCredentials;
+    private credentialRecovery;
+    private credentialRecoveryFailure;
+    private authenticationFailure;
     private tokenExpiresAtMs;
     private tokenRequest;
     private tokenAbortController;
@@ -302,18 +332,14 @@ export declare class ProductAgentSessionEngine {
     private queuedClientEvents;
     private readonly pendingRetainedCommandDeliveries;
     private pendingWidgetLifecycleEvents;
-    private pendingPassiveWarmupEvent;
-    private pendingComposerWarmup;
     private activeComposerWarmupId;
-    private activeComposerWarmupScope;
-    private pendingWarmupAckTimer;
+    private readonly authenticatingWarmupHints;
     private directoryAuthority;
     private readonly directoryHttp;
     private directoryScope;
     private directoryObservation;
     private directoryConversationScopeId;
     private directoryProvisionalId;
-    private readonly conversationRecoveries;
     private account;
     private usingPaidCreditFallback;
     private readonly accountListeners;
@@ -324,57 +350,15 @@ export declare class ProductAgentSessionEngine {
     private integrationAuthStatusByRequestId;
     private integrationAuthErrorByRequestId;
     private tabGroupsPermissionNeeded;
-    private sessionLoadRequestId;
-    private sessionLoadRequestTimer;
-    private pendingSessionSubscription;
-    private sessionHistoryHydration;
-    private sessionActivityRequestId;
     private readonly transportIdentity;
-    private retryAttemptsByClientMessageId;
-    private pendingDeliveryIssued;
-    private queuedDeliveryRetryAttempt;
-    private retryTimersByClientMessageId;
     private readonly reportedHealthSignalKeys;
     private readonly firstResponseTimersByClientMessageId;
-    private lastProjectedTurnPhase;
-    private lastProjectedTurnClientMessageId;
-    private readonly clientMessageIdsByUserMessageItemId;
-    private readonly backgroundSessionIds;
-    private readonly backgroundClientMessageIds;
-    private readonly deferredSessionUpdatedSessionIds;
-    private readonly sessionTimelineCache;
-    private readonly detachedSessionIds;
-    private readonly detachedClientMessageIds;
-    private readonly deferredDetachedSessionEvents;
-    private readonly retryableFailureRunIdsAwaitingDone;
-    private thinkingWatchdogTimer;
-    private runAckWatchdogTimer;
-    private runAckResyncRetryTimer;
-    private pendingDeliveryAckTimer;
-    private pendingDeliveryRetryTimer;
-    private pendingDeliveryReconciliationRequestId;
-    private pendingClientMessageId;
-    private pendingUserMessageEvent;
-    private failedUserMessageEvent;
     private readonly modelClientScopeId;
-    private activeClientMessageId;
-    private activeRunAckObserved;
-    private activeResponseUserMessageId;
-    private activeResponseRunId;
-    private activeUserMessageEvent;
-    private latestRecoverableClientMessageId;
     private lastUserMessagePageUrl;
-    private thinkingWatchdogResyncAttemptsByClientMessageId;
-    private retryableClientMessageId;
-    private stagedProactiveSuggestionQuestionMessageId;
     private runtimeHelperJavascript;
     private readonly attachmentFiles;
     private sessionBrowserApisCleanup;
     private readonly activeBrowserToolCalls;
-    private readonly cancelledSubmissions;
-    private readonly stoppedTurns;
-    private readonly pendingToolLoadingByCallId;
-    private readonly terminalToolCallIds;
     private readonly nonTranscriptToolCallIds;
     private pageLifecycleCleanup;
     private transientStarterPromptsRequestInFlight;
@@ -382,15 +366,19 @@ export declare class ProductAgentSessionEngine {
     private locationChangeCleanup;
     private starterPromptUrlRefreshTimer;
     private lastStarterPromptPageUrl;
-    private state;
+    private platformState;
+    private get state();
+    private set state(value);
     private constructor();
     static init(options: ProductAgentInitOptions): Promise<ProductAgentSessionEngine>;
-    private createConversationRecovery;
     private createDirectoryAdapters;
+    private operationTimingReporter;
+    reportOperationTiming(timing: OperationTiming): void;
+    private initializeConversation;
     private initializeDirectory;
     private handleDirectoryTransportError;
+    private retainNavigatedConversation;
     private beginDirectoryProvisional;
-    private selectDirectorySession;
     on<T extends EventName>(eventName: T, listener: Listener<T>): () => void;
     getState(): ProductAgentState;
     stageProactiveSuggestionQuestion(question: string): void;
@@ -411,22 +399,20 @@ export declare class ProductAgentSessionEngine {
         submittedAt?: number;
     }): Promise<string | null>;
     reportResponseVisibility(observation: ResponseVisibilityObservation): void;
-    reportInvalidStateTransition(reason: string, clientMessageId?: string): void;
-    reportDisplayedError(reason: string, errorFingerprint: string, displayedMessage?: string): void;
+    reportInvalidStateTransition(reason: string, clientMessageId?: string, uiInvariant?: UiInvariantEvidence): void;
+    reportDisplayedError(reason: string, errorFingerprint: string, displayedMessage?: string, renderedError?: RenderedErrorEvidence): void;
     getModel(): ProductAgentModel | undefined;
     setModel(model: ProductAgentModel): void;
     retryLastMessage(): boolean;
     createLocalAttachment(file: File): ProductAgentAttachment;
     uploadAttachment(file: File): Promise<ProductAgentAttachment>;
-    private uploadAttachmentForMessage;
-    private updateAttachmentInState;
     private prepareEmbedAttachmentUpload;
-    private fetchEmbedAttachmentUpload;
-    private getStopClientMessageId;
     stop(): void;
+    private stopConversation;
     startNewSession(options?: {
         notifyTransport?: boolean;
     }): void;
+    private resetConversationSelection;
     listSessions(options?: {
         cursor?: string | null;
         limit?: number;
@@ -447,21 +433,14 @@ export declare class ProductAgentSessionEngine {
         feedback?: string;
         snoozeUntil?: string;
     }): Promise<void>;
+    private createConversationInteractionPort;
     private refreshRuntimeInteractions;
     private rebuildRuntimeInteractions;
     getAccount(): ProductAgentAccountProjection | null;
     subscribeAccount(listener: (account: ProductAgentAccountProjection | null) => void): () => void;
     refreshAccount(): Promise<void>;
     loadSession(sessionId: string): void;
-    private canLoadSessionHistoryOverHttp;
-    private loadSessionHistoryOverHttp;
-    private subscribeToSessionBeforeHistory;
-    private autoLoadSessionActivity;
-    private fetchSessionHistoryPageUntilCurrent;
-    private fetchSessionHistoryPageOnce;
-    private failSessionHistoryRequest;
     private send;
-    private getUploadToken;
     private sendNow;
     private reportHealthSignal;
     private startFirstResponseTimer;
@@ -469,9 +448,6 @@ export declare class ProductAgentSessionEngine {
     private reportFirstResponseSlow;
     private clearFirstResponseTimer;
     private clearAllFirstResponseTimers;
-    private rememberPendingDeliveryForRecovery;
-    private persistCurrentPendingDeliveryRecovery;
-    private clearPersistedPendingDelivery;
     private requestTransientStarterPrompts;
     private startStarterPromptUrlWatcher;
     private handleStarterPromptUrlChange;
@@ -480,56 +456,13 @@ export declare class ProductAgentSessionEngine {
     private flushQueuedClientEvents;
     private resetForAuthenticationScopeChange;
     private applyAuthenticatedDirectoryIdentity;
-    private rememberSessionTimeline;
-    private getCachedSessionTimeline;
+    private waitForAuthentication;
     private flushPendingWidgetLifecycleEvents;
-    private flushPendingPassiveWarmup;
-    private flushPendingComposerWarmup;
-    private findStoppedTurn;
-    private findStoppedTurnForEvent;
-    private rememberDurablyStoppedTurn;
-    private forgetSupersededTaskTabClosedTurn;
-    private shouldIgnoreStoppedTurnEvent;
-    private filterStoppedSnapshotItems;
     private handleServerEvent;
     private applyAccountSubmissionError;
     private updatePersonalModelFromSession;
     private updateAccountFallbackFromSession;
-    private shouldIgnoreBackgroundSessionEvent;
-    private updateInactiveSessionTimelineCache;
-    private shouldIgnoreDetachedSessionEvent;
-    private shouldDeferDetachedSessionEvent;
-    private rememberCurrentRunAsDetached;
-    private rememberCurrentRunAsBackground;
-    private handleRetryableRecoveryError;
-    private clearRetryTimers;
-    private rememberUserMessageClientMessageIds;
-    private clearSessionLoadRequest;
-    private markThinkingProgress;
-    private scheduleThinkingWatchdog;
-    private clearThinkingWatchdog;
-    private handleRunAck;
-    private promotePendingDelivery;
-    private promotePendingDeliveryFromResponseEvidence;
-    private getResponseEvidenceUserMessageId;
-    private getResponseEvidenceClientMessageId;
-    private promotePendingDeliveryFromSnapshotResponseEvidence;
-    private acknowledgePendingDeliveryAcceptance;
-    private shouldDeferPendingDeliveryPromotion;
-    private schedulePendingDeliveryAck;
-    private retryPendingDelivery;
-    private requestPendingDeliveryReconciliation;
-    private failPendingDelivery;
-    private clearPendingDeliveryTimers;
-    private handleRunSteered;
-    private scheduleRunAckWatchdog;
-    private recoverMissedRunAck;
-    private clearRunAckResyncRetryTimer;
-    private clearRunAckTimers;
-    private recoverStuckThinking;
-    private resyncThinkingSession;
     private executeToolCall;
-    private setToolMessageLoading;
     private startPageLifecycleRecovery;
     private installSessionBrowserApis;
     private cleanupSessionBrowserApis;
@@ -538,19 +471,19 @@ export declare class ProductAgentSessionEngine {
     private enqueueNetworkEvent;
     private scheduleReconnect;
     private replaceDefaultTransportCredentials;
+    private stopAuthentication;
+    private recoverHttpAuthentication;
+    private refreshCredentials;
     private refreshDefaultTransportCredentials;
     private startHeartbeat;
     private stopHeartbeat;
     private clearHeartbeatAckTimer;
-    private clearPendingWarmupAckTimer;
-    private clearPendingComposerWarmup;
     private clearSocketConnectTimer;
     private clearSocketAuthTimer;
     private clearSocketPhaseTimers;
     private replaceTimedOutSocket;
     private setState;
     private setReconnectingState;
-    private applySessionRecoverySnapshot;
     private emit;
 }
 declare global {

package/dist/interactionManager.d.ts

@@ -12,6 +12,9 @@ export type ProductAgentInteractionDecisionStorage = {
 };
 export declare class ProductAgentInteractionManager {
     private readonly storage;
+    private conversationReader;
+    private sources;
+    private invalidateAuth;
     private decisions;
     private scheduledEligibility;
     private initialized;

package/dist/interruptState.d.ts

@@ -1,2 +1,2 @@
 import type { ProductAgentState } from "./index";
-export declare function projectInterruptedState(state: ProductAgentState, stoppedAt: string): ProductAgentState;
+export declare function projectInterruptedState<T extends Pick<ProductAgentState, "messages" | "assistantDraftRespondsToUserMessageId" | "activeResponseUserMessageId" | "segments" | "isLoadingSession">>(state: T, stoppedAt: string, phase?: "stopping" | "stopped", userMessageIds?: readonly string[]): T;

package/dist/operationTiming.d.ts

@@ -0,0 +1,21 @@
+export declare const OPERATION_TIMING_STAGES: readonly ["submit", "stop", "staging_ipc", "send_ipc", "stop_ipc", "attachment_transfer", "tab_lookup", "tab_recovery", "session_recovery", "conversation_scope", "local_stage", "view_publication", "page_access", "authentication", "community", "preferences", "page_capture", "session_tabs", "context_ready", "first_frame", "checkpoint", "command_http", "http_authentication", "http_request", "receipt_http", "attachment_upload", "runtime_reading", "runtime_stopping", "runtime_progress", "runtime_stopped", "message_painted", "reading_painted", "stopping_painted", "progress_painted", "stopped_painted"];
+export type OperationTimingStage = typeof OPERATION_TIMING_STAGES[number];
+export type OperationTiming = {
+    entrySurface?: "extension_sidepanel" | "extension_widget" | "main_web_chat" | "embedded_widget" | "embedded_custom_ui" | "automation" | "mcp" | "whatsapp";
+    operation: "send" | "stop";
+    layer: "renderer" | "sdk" | "extension" | "http";
+    stage: OperationTimingStage;
+    status: "started" | "completed" | "failed" | "observed";
+    spanId: string;
+    requestId: string;
+    clientMessageId: string | null;
+    sessionId: string | null;
+    occurredAt: string;
+    durationMs: number;
+};
+export declare function isOperationTiming(value: unknown): value is OperationTiming;
+export declare function createOperationTimer(report: ((timing: OperationTiming) => void) | undefined, identity: Pick<OperationTiming, "operation" | "layer" | "requestId" | "clientMessageId" | "sessionId" | "entrySurface">): {
+    mark: (stage: OperationTimingStage) => void;
+    measure<T>(stage: OperationTimingStage, work: () => Promise<T>): Promise<T>;
+};
+export declare function batchOperationTimings(report: (timings: OperationTiming[]) => void): (timing: OperationTiming) => void;