@pluno/product-agent-web 0.1.229 → 0.1.232

package/dist/adapters/web/backendHttp.d.ts

@@ -1,4 +1,5 @@
-import { type ProductAgentSocketAuth } from './socketIOTransport';
+import type { createOperationTimer } from "../../operationTiming";
+import { ProductAgentSocketError, type ProductAgentSocketAuth } from './socketIOTransport';
 export declare class ProductAgentHttpTransport {
     private readonly options;
     private readonly requests;
@@ -6,7 +7,20 @@ export declare class ProductAgentHttpTransport {
     constructor(options: {
         backendUrl: string;
         auth: ProductAgentSocketAuth;
+        authority?: () => string;
+        authenticationFailure?: () => ProductAgentSocketError | null;
+        pendingAuthentication?: () => Promise<void> | null;
+        recoverAuthentication?: (token: string, error: ProductAgentSocketError, retryAllowed: boolean) => Promise<void>;
+        executorConnection?: () => string | null;
+        restoreExecutor?: (connectionId: string) => Promise<void>;
     });
     dispose(): void;
-    request<T = unknown>(path: string, params?: Record<string, unknown>, body?: unknown, method?: string, namespace?: 'runtime' | 'extension' | 'embed', cancellation?: AbortSignal): Promise<T>;
+    resolveUrl(path: string): URL;
+    request<T = unknown>(path: string, params?: Record<string, unknown>, body?: unknown, method?: string, namespace?: 'runtime' | 'extension' | 'embed' | 'conversations', recovery?: {
+        readOnly?: boolean;
+        timing?: ReturnType<typeof createOperationTimer>;
+        skipAuthentication?: boolean;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    private requestOnce;
 }

package/dist/adapters/web/backendTransport.d.ts

@@ -10,6 +10,7 @@ type Options = {
     currentSession: (page?: Record<string, any>) => string | null;
     contextKey?: (event: WireEvent) => string;
     sessionReferences: () => readonly string[];
+    displaySchema?: "legacy" | "canonical";
     entrySurface?: string;
 };
 export declare class ProductAgentBackendTransport extends EventTarget {
@@ -40,6 +41,8 @@ export declare class ProductAgentBackendTransport extends EventTarget {
     initialReadinessExpired: boolean;
     constructor(options: Options);
     get directoryRooms(): Pick<ProductAgentSocketIOTransport, 'retain' | 'release'>;
+    get connectionId(): string | null;
+    restoreExecutor(connectionId: string): Promise<void>;
     get connectionAttempt(): import("./socketIOTransport").ProductAgentConnectionAttempt | null;
     retryReadiness(): void;
     private startInitialReadinessBudget;

package/dist/adapters/web/conversationAdapters.d.ts

@@ -0,0 +1,59 @@
+import { type OperationTiming } from "../../operationTiming";
+import type { ProductAgentPrepareAttachmentUploadInput, ProductAgentAttachmentUpload } from "../../index";
+import type { PAConversationPorts, PAConversationSnapshotLane } from "../../core/conversation/contracts";
+import type { PAUploadedAttachment, PAConversationDeliveryCheckpoint, PAConversationWireCommand } from "../../core/conversation/deliveryContracts";
+import type { PAConversationDisplayEvent } from "../../core/conversation/display";
+import type { PADirectoryAuthority } from "../../core/session-directory/contracts";
+import type { PASessionId } from "../../core/kernel/state";
+import type { PAClientRuntime } from "../../runtime/composition";
+import { ProductAgentHttpTransport } from "./backendHttp";
+import type { ProductAgentSocketIOTransport } from "./socketIOTransport";
+type Boundary = {
+    authority: PADirectoryAuthority;
+    runtime: () => PAClientRuntime;
+    isCurrent?: () => boolean;
+};
+export declare function createConversationPorts(options: Boundary & {
+    http: ProductAgentHttpTransport;
+    connectionId: () => string | null;
+    readAttachment: (sourceId: string) => Promise<Blob>;
+    saveDelivery: (checkpoint: PAConversationDeliveryCheckpoint) => Promise<void>;
+    onError?: (error: unknown) => void;
+    onCommand?: (command: PAConversationWireCommand) => void;
+    onTiming?: (timing: OperationTiming) => void;
+    now: () => number;
+    onUploaded?: (sourceId: string, sessionId: string, attachment: PAUploadedAttachment) => Promise<void>;
+    prepareUpload?: (input: ProductAgentPrepareAttachmentUploadInput) => Promise<ProductAgentAttachmentUpload>;
+    persistUpload?: (input: ProductAgentPrepareAttachmentUploadInput, bytes: File) => Promise<Pick<ProductAgentAttachmentUpload, "sessionId" | "attachment">>;
+}): Omit<PAConversationPorts, "conversation.interactions">;
+export declare class ProductAgentConversationObservationAdapter {
+    private readonly options;
+    private readonly observations;
+    private readonly waiters;
+    private readonly unsubscribe;
+    private readonly unsubscribeDispose;
+    private disposed;
+    private readonly owner;
+    private readonly deliveryRecovery;
+    constructor(options: Boundary & {
+        socket: Pick<ProductAgentSocketIOTransport, "retain" | "release">;
+        nextRequestId: () => string;
+        now: () => number;
+        wakeup: {
+            start: () => void;
+            stop: () => void;
+        };
+        onError: (error: unknown) => void;
+        enabled?: () => boolean;
+    });
+    private reconcile;
+    refresh(sessionId: PASessionId, lane?: PAConversationSnapshotLane): Promise<void>;
+    receive(event: PAConversationDisplayEvent): void;
+    wake(): void;
+    private report;
+    private hasUncertainDelivery;
+    private hasRunningDelivery;
+    private waitForDelivery;
+    dispose(): void;
+}
+export {};

package/dist/adapters/web/conversationCheckpoint.d.ts

@@ -0,0 +1,16 @@
+import type { PAConversationState, PAOwnedSubmission } from "../../core/conversation/contracts";
+import type { PAConversationDeliveryCheckpoint, PAConversationWireCommand } from "../../core/conversation/deliveryContracts";
+import type { PAClientScopeId, PAConversationScopeId, PASessionId, PAViewId } from "../../core/kernel/state";
+import type { PAProductAgentModel } from "../../core/model-selection/contracts";
+export declare function importLegacyConversationSubmissions(state: PAConversationState, inputs: readonly Readonly<{
+    command: PAConversationWireCommand;
+    requestedModel: PAProductAgentModel | null;
+    clientScopeId: PAClientScopeId;
+    conversationScopeId: PAConversationScopeId;
+    viewId: PAViewId;
+    sessionId: PASessionId | null;
+    entrySurface: PAOwnedSubmission["entrySurface"];
+    submittedAt: number;
+}>[]): PAConversationDeliveryCheckpoint;
+export declare function readConversationStorage(key: string): string | null;
+export declare function rememberConversationAuthority(clientId: string, authorityId: string): void;

package/dist/adapters/web/conversationInteractionAdapter.d.ts

@@ -0,0 +1,11 @@
+import type { PAConversationPorts } from "../../core/conversation/contracts";
+import type { PADirectoryAuthority } from "../../core/session-directory/contracts";
+import type { ProductAgentInteractionManager } from "../../interactionManager";
+import type { PAClientRuntime } from "../../runtime/composition";
+export declare function createConversationInteractionPort(options: {
+    authority: PADirectoryAuthority;
+    runtime: () => PAClientRuntime;
+    manager: ProductAgentInteractionManager;
+    invalidateAuth: (requestId: string) => void;
+    notify: () => void;
+}): PAConversationPorts["conversation.interactions"];

package/dist/adapters/web/conversationPresentation.d.ts

@@ -0,0 +1,4 @@
+import type { ProductAgentState } from "../../index";
+import type { PAConversationProjection, PAConversationRecord } from "../../core/conversation/contracts";
+export type PAConversationPresentation = Pick<ProductAgentState, "historyPreparation" | "selectionKey" | "isDraftSession" | "sessionId" | "messages" | "removedItems" | "activeScheduledFollowUps" | "isLoadingSession" | "assistantDraft" | "assistantDraftItemId" | "assistantDraftPhase" | "assistantDraftRespondsToUserMessageId" | "assistantDraftRunId" | "activeResponseUserMessageId" | "pendingMessageStatus" | "turnPhase" | "isThinking" | "taskStatus" | "lastError" | "lastErrorCode" | "lastErrorSecuritySettingsUrl"> & Required<Pick<ProductAgentState, "segments" | "activity" | "receipts">>;
+export declare function projectConversationPresentation(projection: PAConversationProjection, query: PAConversationRecord["queries"]["current"] | undefined, backendUrl: string): PAConversationPresentation;

package/dist/adapters/web/directoryAdapters.d.ts

@@ -52,8 +52,8 @@ export declare class ProductAgentDirectoryObservationAdapter {
         runtime: PAClientRuntime;
         authority: PADirectoryAuthority;
         http: ProductAgentHttpTransport;
-        socket: Pick<ProductAgentSocketIOTransport, 'retain' | 'release'>;
-        recovery: (sessionId: string) => PADirectoryRecoveryHandles;
+        socket?: Pick<ProductAgentSocketIOTransport, 'retain' | 'release'>;
+        recovery?: (sessionId: string) => PADirectoryRecoveryHandles;
         isActiveTurn: (sessionId: string) => boolean;
         nextRequestId: () => string;
         onError: (error: unknown) => void;

package/dist/adapters/web/socketIOTransport.d.ts

@@ -34,6 +34,7 @@ type Options = {
     onError: (error: ProductAgentSocketError) => void;
     requestTimeoutMs?: number;
     reconnect?: boolean;
+    displaySchema?: "legacy" | "canonical";
     bootstrapRequired?: boolean;
     onAttempt?: (attempt: ProductAgentConnectionAttempt) => void;
 };
@@ -61,12 +62,15 @@ export declare class ProductAgentSocketIOTransport {
     private operations;
     private queuedOperations;
     private uploadingResult;
+    private executorRecovery;
     private admissionTimer;
     private readinessTimer;
     private attemptCount;
     private attempt;
     constructor(options: Options);
     connect(): void;
+    get connectionId(): string | null;
+    restoreExecutor(connectionId: string): Promise<void>;
     replaceCredentials(auth: ProductAgentSocketAuth, authorityChanged: boolean): void;
     suspend(): void;
     disconnect(): void;

package/dist/chatPresentation.d.ts

@@ -1,2 +1,9 @@
 export declare const EMPTY_CONVERSATION_MESSAGE = "Looks like no message is sent yet";
 export declare function getChatErrorPlacement(code: string | null | undefined): "bottom_notice" | "conversation";
+export declare function getConversationFeedback(state: {
+    lastError?: string | null;
+    lastErrorCode?: string | null;
+}): {
+    showProgress: boolean;
+    actions: readonly ("retry_history" | "retry_message" | "new_chat")[];
+};

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

@@ -1,10 +1,18 @@
-import type { PAClientScopeId, PARequestId, PASessionId, PAViewId } from "../kernel/state";
+import type { PAClientScopeId, PAConversationScopeId, PARequestId, PAEffectId, PASessionId, PAViewId } from "../kernel/state";
 import type { PAJsonObject } from "../protocol/json";
+import type { PAEffectHandlers } from "../kernel/effects";
+import type { PAQueryState } from "../kernel/state";
+import type { PADirectoryAuthority } from "../session-directory/contracts";
+import type { PAProductAgentModel } from "../model-selection/contracts";
+import type { PATransportedError } from "../protocol/errors";
+import type { PAConversationInteractionSource, PAConversationFollowUp, PAConversationDisplayEvent, PADisplayItem, PADisplaySnapshot, PAEntrySurface, PAExecutionState, PAInvocation, PAStreamLifecycle } from "./display";
+import type { PAConversationDelivery, PAConversationDeliveryCommand, PAConversationDeliveryEffects, PAConversationOperation, PAUploadedAttachment } from "./deliveryContracts";
 export type PAAttachmentSource = Readonly<{
     sourceId: string;
     name: string;
     mimeType: string;
     sizeBytes: number;
+    uploaded?: PAUploadedAttachment;
 }>;
 export type PARendererComposerSubmission = Readonly<{
     viewId: PAViewId;
@@ -19,3 +27,175 @@ export type PASubmissionReceipt = Readonly<{
     sessionId: PASessionId;
     acceptedRendererRevision: number;
 }>;
+export type PAConversationSubmissionInput = Readonly<{
+    userMessageId: string;
+    requestId: PARequestId;
+    clientScopeId: PAClientScopeId;
+    conversationScopeId: PAConversationScopeId;
+    viewId: PAViewId;
+    rendererRevision: number;
+    content: string;
+    attachments: readonly PAAttachmentSource[];
+    context: PAJsonObject;
+    invocation: PAInvocation;
+    entrySurface: PAEntrySurface;
+    submittedAt: number;
+}>;
+export type PAOwnedSubmission = PAConversationSubmissionInput & Readonly<{
+    contextPreparation?: Readonly<{
+        pageContent: string;
+        sessionTabs: readonly PAJsonObject[];
+    }> | null;
+    requestedModel: PAProductAgentModel | null;
+    sessionId: PASessionId | null;
+    delivery: "staged" | "sending" | "uncertain" | "accepted" | "failed";
+    cancelled: boolean;
+    executionVersion: number | null;
+    error: PATransportedError | null;
+}>;
+export type PAConversationSnapshotLane = "current" | "history";
+export type PAConversationSnapshotRequest = PADirectoryAuthority & Readonly<{
+    retryPreparation?: boolean;
+    sessionId: PASessionId;
+    requestId: PARequestId;
+    lane: PAConversationSnapshotLane;
+    before: string | null;
+    refreshItemIds: readonly string[];
+}>;
+export type PAConversationInteractionHandoff = PADirectoryAuthority & Readonly<{
+    sessionId: PASessionId;
+    sources: readonly PAConversationInteractionSource[];
+}>;
+export type PAConversationEffects = PAConversationDeliveryEffects & {
+    "conversation.interactions": {
+        input: PAConversationInteractionHandoff;
+        output: null;
+    };
+    "conversation.snapshot": {
+        input: PAConversationSnapshotRequest;
+        output: Readonly<{
+            snapshot: PADisplaySnapshot;
+            updatedAt: number;
+        }>;
+    };
+};
+export type PAConversationPorts = PAEffectHandlers<PAConversationEffects>;
+export type PAConversationRecord = Readonly<{
+    preparation?: "pending" | "busy" | null;
+    sessionId: PASessionId;
+    items: Readonly<Record<string, PADisplayItem>>;
+    streams: Readonly<Record<string, PAStreamLifecycle>>;
+    removedItems: Readonly<Record<string, string>>;
+    execution: PAExecutionState | null;
+    executionByUserMessage: Readonly<Record<string, Pick<PAExecutionState, "version" | "phase">>>;
+    followUps: readonly PAConversationFollowUp[];
+    followUpsVersion: number;
+    queries: Readonly<Record<PAConversationSnapshotLane, PAQueryState<string, readonly string[]>>>;
+}>;
+export type PAConversationStopReason = "user_requested" | "new_chat" | "session_switch" | "task_tab_closed" | "flow_reset" | "delegated_task_cancelled" | "sdk_session_reset" | "security_policy_changed";
+export type PAConversationStop = Readonly<{
+    requestId: PARequestId;
+    userMessageIds: readonly string[];
+    executionVersion: number;
+    reason?: PAConversationStopReason;
+}>;
+export type PAConversationState = PADirectoryAuthority & Readonly<{
+    sessions: Readonly<Record<string, PAConversationRecord>>;
+    proactiveQuestions: Readonly<Record<string, Readonly<{
+        id: string;
+        content: string;
+    }>>>;
+    submissions: Readonly<Record<string, PAOwnedSubmission>>;
+    submissionOrder: readonly string[];
+    stops: Readonly<Record<string, PAConversationStop>>;
+    requests: Readonly<Record<string, PAConversationSnapshotRequest & Readonly<{
+        acceptedUserMessageIds: readonly string[];
+    }>>>;
+    requestSequence: number;
+    deliveries: Readonly<Record<string, PAConversationDelivery>>;
+    effectsEnabled: boolean;
+    checkpointEffectId: PAEffectId | null;
+    checkpointError: PATransportedError | null;
+    operations: Readonly<Record<string, PAConversationOperation>>;
+}>;
+export type PAConversationCommand = PAConversationDeliveryCommand | PADirectoryAuthority & ((PAConversationSubmissionInput & Readonly<{
+    type: "conversation.submission_stage";
+    prepareContext?: boolean;
+}>) | Readonly<{
+    type: "conversation.context_prepared";
+    userMessageId: string;
+    pageContent: string;
+    sessionTabs: readonly PAJsonObject[];
+}> | Readonly<{
+    type: "conversation.proactive_edit";
+    conversationScopeId: PAConversationScopeId;
+    id: string;
+    content: string;
+}> | Readonly<{
+    type: "conversation.stop";
+    clientScopeId: PAClientScopeId;
+    conversationScopeId: PAConversationScopeId;
+    requestId: PARequestId;
+    reason?: PAConversationStopReason;
+    userMessageIds?: readonly string[];
+}> | Readonly<{
+    type: "conversation.observation_released";
+    sessionId: PASessionId;
+}> | Readonly<{
+    type: "conversation.snapshot";
+    sessionId: PASessionId;
+    requestId: PARequestId;
+    lane: PAConversationSnapshotLane;
+}>);
+export type PAConversationEvent = PADirectoryAuthority & (Readonly<{
+    type: "conversation.submission_accepted";
+    userMessageId: string;
+    sessionId: PASessionId;
+}> | Readonly<{
+    type: "conversation.submission_delivery";
+    userMessageId: string;
+    requestId: PARequestId;
+    delivery: "sending" | "uncertain" | "failed";
+    error: PATransportedError | null;
+}> | Readonly<{
+    type: "conversation.display_received";
+    event: PAConversationDisplayEvent;
+}>);
+export type PAConversationSegment = Readonly<{
+    id: string;
+    userMessageId: string | null;
+    activityIds: readonly string[];
+    outcomeIds: readonly string[];
+    collapsed: boolean;
+}>;
+export type PAConversationProjection = Readonly<{
+    preparation?: "pending" | "busy" | null;
+    selectionKey?: string;
+    isDraftSession: boolean;
+    proactiveQuestion: Readonly<{
+        id: string;
+        content: string;
+    }> | null;
+    followUps: readonly PAConversationFollowUp[];
+    sessionId: PASessionId | null;
+    submissions: readonly PAOwnedSubmission[];
+    deliveries: Readonly<Record<string, PAConversationDelivery>>;
+    items: readonly PADisplayItem[];
+    optimistic: readonly PAOwnedSubmission[];
+    removedItems: Readonly<Record<string, string>>;
+    streamStates: Readonly<Record<string, PAStreamLifecycle["state"] | "awaiting_content">>;
+    stop: (PAConversationStop & Readonly<{
+        pending: boolean;
+    }>) | null;
+    segments: readonly PAConversationSegment[];
+    activity: Readonly<{
+        phase: PAExecutionState["phase"] | "submitting" | "awaiting_execution";
+        activeItemId: string | null;
+        userMessageId?: string | null;
+    }>;
+    receipts: readonly Readonly<{
+        viewId: PAViewId;
+        userMessageId: string;
+        acceptedRendererRevision: number;
+    }>[];
+}>;

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

@@ -0,0 +1,22 @@
+import type { PAEffect, PAEffectResultEvent } from "../kernel/effects";
+import type { PAModelSelectionState } from "../model-selection/state";
+import type { PADirectoryState } from "../session-directory/contracts";
+import type { PAConversationCommand, PAConversationEffects, PAConversationEvent, PAConversationState } from "./contracts";
+import type { PAConversationDeliveryCheckpoint, PAConversationOperation } from "./deliveryContracts";
+type Input = PAConversationCommand | PAConversationEvent | PAEffectResultEvent<PAConversationEffects>;
+export declare function conversationDeliveryCheckpoint(state: PAConversationState, directory: PADirectoryState): PAConversationDeliveryCheckpoint;
+export declare function canAutomaticallyReplayOperation(op: PAConversationOperation): boolean;
+export declare function needsConversationDeliveryRecovery(state: PAConversationState, id: string): boolean;
+export declare function checkpointConversationChange(previous: PAConversationState, state: PAConversationState, directory: PADirectoryState, retry?: boolean): {
+    state: PAConversationState;
+    effects: PAEffect<PAConversationEffects>[];
+};
+export declare function scheduleConversationDelivery(state: PAConversationState): {
+    state: PAConversationState;
+    effects: PAEffect<PAConversationEffects>[];
+};
+export declare function reduceConversationWithDelivery(state: PAConversationState, input: Input, directory: PADirectoryState, models: PAModelSelectionState): {
+    state: PAConversationState;
+    effects: PAEffect<PAConversationEffects>[];
+};
+export {};

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

@@ -0,0 +1,100 @@
+import type { PAConversationScopeId, PAEffectId, PARequestId, PASessionId } from "../kernel/state";
+import type { PAJsonObject, PAJsonValue } from "../protocol/json";
+import type { PATransportedError } from "../protocol/errors";
+import type { PADirectoryAuthority } from "../session-directory/contracts";
+import type { PAAttachmentSource, PAOwnedSubmission, PAConversationState } from "./contracts";
+export type PAUploadedAttachment = Readonly<{
+    id: string | null;
+    name: string;
+    mime_type: string;
+    size_bytes: number;
+    storage_key?: string | null;
+    sandbox_path?: string | null;
+    file_url?: string | null;
+}>;
+export type PAConversationWireCommand = Readonly<{
+    request_id: string;
+    type: "chat.user_message" | "chat.retry_last_user_message" | "run.stop" | "attachment.upload_completed" | "runtime.warmup" | "session.reset";
+    payload: PAJsonObject;
+}>;
+export type PAConversationDelivery = Readonly<{
+    phase: "waiting" | "running" | "uncertain" | "paused" | "failed" | "done";
+    recoveryDeadline: number | null;
+    step: "upload" | "complete" | "send" | "receipt" | null;
+    effectId: PAEffectId | null;
+    uploads: readonly PAUploadedAttachment[];
+    completedUploads: number;
+    command: PAConversationWireCommand | null;
+}>;
+export type PAConversationOperationCommand = PAConversationWireCommand | Readonly<{
+    request_id: string;
+    type: "attachment.prepare";
+    payload: PAJsonObject;
+}>;
+export type PAConversationOperation = Readonly<{
+    conversationScopeId: PAConversationScopeId | null;
+    command: PAConversationOperationCommand;
+    phase: "waiting" | "running" | "uncertain" | "failed" | "done";
+    effectId: PAEffectId | null;
+    result: PAJsonValue;
+    error: PATransportedError | null;
+}>;
+export type PAConversationDeliveryEffects = {
+    "conversation.checkpoint": {
+        input: PADirectoryAuthority & Readonly<{
+            checkpoint: PAConversationDeliveryCheckpoint;
+        }>;
+        output: null;
+    };
+    "conversation.receipt": {
+        input: PADirectoryAuthority & Readonly<{
+            userMessageId: string;
+            sessionId: PASessionId | null;
+        }>;
+        output: Readonly<{
+            sessionId: PASessionId;
+            clientMessageId: string;
+        }> | null;
+    };
+    "conversation.upload": {
+        input: PADirectoryAuthority & Readonly<{
+            submission: Pick<PAOwnedSubmission, "userMessageId" | "conversationScopeId" | "sessionId" | "context" | "requestedModel" | "entrySurface">;
+            source: PAAttachmentSource;
+            preparationId?: string;
+        }>;
+        output: Readonly<{
+            sessionId: PASessionId;
+            attachment: PAUploadedAttachment;
+        }>;
+    };
+    "conversation.command": {
+        input: PADirectoryAuthority & Readonly<{
+            command: PAConversationWireCommand;
+        }>;
+        output: PAJsonValue;
+    };
+};
+export type PAConversationDeliveryCommand = PADirectoryAuthority & (Readonly<{
+    type: "conversation.enable_effects";
+}> | Readonly<{
+    type: "conversation.recover";
+    now: number;
+}> | Readonly<{
+    type: "conversation.restore_delivery";
+    checkpoint: PAConversationDeliveryCheckpoint;
+}> | Readonly<{
+    type: "conversation.submit";
+    userMessageId: string;
+    now: number;
+    manualRetry?: true;
+}> | Readonly<{
+    type: "conversation.operation";
+    command: PAConversationOperationCommand;
+    conversationScopeId?: PAConversationScopeId;
+}> | Readonly<{
+    type: "conversation.retry_operation";
+    requestId: PARequestId;
+}>);
+export type PAConversationDeliveryCheckpoint = Readonly<{
+    schema: 1;
+}> & Pick<PAConversationState, "authorityId" | "submissions" | "submissionOrder" | "deliveries" | "operations" | "stops" | "requestSequence">;

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

@@ -0,0 +1,134 @@
+export type PAInvocation = "user" | "automation" | "scheduled_continuation" | "private_continuation";
+export type PAEntrySurface = "extension_sidepanel" | "extension_widget" | "main_web_chat" | "whatsapp" | "automation" | "mcp" | "embedded_widget" | "embedded_custom_ui";
+export type PADisplayAttachment = Readonly<{
+    id: string | null;
+    name: string;
+    mime_type: string;
+    size_bytes: number;
+    file_url: string | null;
+}>;
+type PAItemShell = Readonly<{
+    id: string;
+    conversation_id: string;
+    created_at: string;
+    updated_at: string;
+}>;
+type PAStreamContent = Readonly<{
+    content: string;
+    revision: number;
+}>;
+export type PADisplayItem = PAItemShell & (Readonly<{
+    type: "user_message";
+    data: Readonly<{
+        content: string;
+        attachments: readonly PADisplayAttachment[];
+        invocation: PAInvocation;
+        entry_surface: PAEntrySurface;
+    }>;
+}> | Readonly<{
+    type: "commentary" | "tool_summary";
+    data: PAStreamContent;
+}> | Readonly<{
+    type: "final_response";
+    data: PAStreamContent & Readonly<{
+        attachments: readonly PADisplayAttachment[];
+    }>;
+}> | Readonly<{
+    type: "error";
+    data: Readonly<{
+        code: string;
+        message: string;
+        security_settings_url?: string | null;
+    }>;
+}> | Readonly<{
+    type: "stopped";
+    data: Readonly<{
+        message: string;
+    }>;
+}>);
+export type PAStreamLifecycle = Readonly<{
+    item_id: string;
+    revision: number;
+    state: "open" | "finished" | "stopped" | "failed";
+}>;
+export type PAItemRemoval = Readonly<{
+    type: "conversation.item.removed";
+    conversation_id: string;
+    item_id: string;
+    replacement_item_id: string;
+}>;
+export type PAExecutionState = Readonly<{
+    conversation_id: string;
+    version: number;
+    phase: "idle" | "queued" | "thinking" | "steering" | "stopping" | "completed" | "stopped" | "failed";
+    user_message_ids: readonly string[];
+    execution_message_ids?: readonly string[];
+}>;
+export declare function executionMessageIds(execution: PAExecutionState | null | undefined): readonly string[];
+export type PAConversationInteractionSource = Readonly<{
+    id: string;
+    conversation_id: string;
+    version: number;
+    lifecycle: "pending" | "completed" | "cancelled" | "expired";
+    user_message_id: string | null;
+    scope: "conversation";
+    invocation: PAInvocation | null;
+    entry_surface: PAEntrySurface | null;
+    payload: Readonly<{
+        kind: "sharing";
+        eligible: boolean;
+        variant: "social" | "referral";
+        wait_for_terminal: boolean;
+        decision_scope: "client";
+    }> | Readonly<{
+        kind: "integration_auth";
+        request_id: string;
+        app_slug: string;
+        app_name: string;
+        app_logo: string | null;
+        expires_at: string;
+    }> | Readonly<{
+        kind: "personal_channel";
+        request_id: string;
+        channel: "whatsapp";
+        management_url: string;
+    }>;
+}>;
+export type PAConversationFollowUp = Readonly<{
+    task_id: string;
+    due_at: string;
+}>;
+export type PADisplaySnapshot = Readonly<{
+    conversation_id: string;
+    items: readonly PADisplayItem[];
+    removed_items: readonly PAItemRemoval[];
+    streams: readonly PAStreamLifecycle[];
+    execution: PAExecutionState;
+    interactions: readonly PAConversationInteractionSource[];
+    follow_ups: readonly PAConversationFollowUp[];
+    follow_ups_version: number;
+    next_cursor: string | null;
+    projection_ready: boolean;
+    preparation?: "pending" | "busy" | "failed" | "disabled" | null;
+}>;
+export type PAConversationDisplayEvent = Readonly<{
+    type: "conversation.interaction.updated";
+    interaction: PAConversationInteractionSource;
+}> | Readonly<{
+    type: "conversation.follow_ups.updated";
+    conversation_id: string;
+    version: number;
+    follow_ups: readonly PAConversationFollowUp[];
+}> | Readonly<{
+    type: "conversation.item.updated";
+    item: PADisplayItem;
+}> | PAItemRemoval | (PAStreamLifecycle & Readonly<{
+    type: "conversation.item.stream_finished";
+    conversation_id: string;
+}>) | Readonly<{
+    type: "conversation.execution.updated";
+    execution: PAExecutionState;
+}>;
+export declare function displayTimestampKey(value: string): string;
+export declare function displayRevision(item: PADisplayItem): number | null;
+export {};

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

@@ -0,0 +1,8 @@
+import type { PAEffectResultEvent } from "../kernel/effects";
+import type { PAReduction } from "../kernel/reducer";
+import type { PAModelSelectionState } from "../model-selection/state";
+import type { PADirectoryState } from "../session-directory/contracts";
+import type { PAConversationCommand, PAConversationEffects, PAConversationEvent, PAConversationState, PAOwnedSubmission } from "./contracts";
+export declare function submissionHasLocalPresence(submission: PAOwnedSubmission, directory: PADirectoryState): boolean;
+export declare function synchronizeConversationDirectory(state: PAConversationState, directory: PADirectoryState): PAConversationState;
+export declare function reduceConversation(state: PAConversationState, input: PAConversationCommand | PAConversationEvent | PAEffectResultEvent<PAConversationEffects>, directory: PADirectoryState, models: PAModelSelectionState): PAReduction<PAConversationState, PAConversationEffects>;