@pluno/product-agent-web 0.1.260 → 0.1.262

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

@@ -0,0 +1,492 @@
+import type { UiFlightEvidence } from './uiFlightEvidence';
+import type { PAAccountData, PAAccountState, PAFeatureAuthority, PAFeaturePreferences } from '../account/contracts';
+import type { PAEffectHandlers, PAEffectResultEvent } from '../kernel/effects';
+import type { PAQueryState, PARequestId } from '../kernel/state';
+import type { PATransportedError } from '../protocol/errors';
+import type { PAInteractionState, PAFeatureName, PAPreferencePrompt, PAPreferencePrompts, PAUserDecision, PAUserDecisionInput, PAInteractionProjection, PADeviceFact } from '../interactions/contracts';
+export type PAFeaturePage = Readonly<{
+    clientScopeId: string;
+    origin: string;
+    pageUrl: string;
+}>;
+export type PAContextStatus = Readonly<{
+    origin?: string;
+    latestRun?: Readonly<{
+        id: string;
+        status: string;
+        createdAt: string;
+        completedAt: string | null;
+        error: string | null;
+    }> | null;
+    status: string;
+    runId: string | null;
+    updatedAt: string | null;
+    hasContext: boolean | null;
+}>;
+export type PAProactiveEventMatcher = Readonly<{
+    eventTypeRegex: string;
+    urlRegex: string;
+    targetRoleRegex?: string;
+    targetNameRegex?: string;
+    targetAncestorRegex?: string;
+}>;
+export type PAProactivePageMatcher = Readonly<{
+    urlRegex: string;
+    textRegex?: string;
+    roleRegex?: string;
+    nameRegex?: string;
+}>;
+export type PAProactiveSuggestion = Readonly<{
+    id: string;
+    suggestedQuery: string;
+    condition: Readonly<{
+        template: 'page_visit';
+        urlRegex: string;
+    }> | Readonly<{
+        template: 'semantic_interaction';
+        event: PAProactiveEventMatcher;
+    }> | Readonly<{
+        template: 'event_sequence';
+        steps: readonly PAProactiveEventMatcher[];
+        withinSeconds: number;
+    }> | Readonly<{
+        template: 'page_state_after_event';
+        event: PAProactiveEventMatcher;
+        state: PAProactivePageMatcher;
+        withinSeconds: number;
+    }>;
+}>;
+export type PAOriginAppearance = Readonly<{
+    accent: string;
+    colorScheme: 'light' | 'dark';
+    fontFamily: string;
+    scribbleStyle: boolean;
+}>;
+export type PADeepFlowStep = Readonly<{
+    index: number;
+    kind: string;
+    title: string;
+    detail?: string | null;
+    status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+    linkedSessionId?: string | null;
+    linkedContextRefreshRunId?: string | null;
+}>;
+export type PADeepFlow = Readonly<{
+    id: string;
+    type: 'deep_exploration';
+    origin: string;
+    status: 'idle' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+    currentStepIndex: number;
+    startedAt: string;
+    completedAt?: string | null;
+    error?: string | null;
+    detail?: string | null;
+    steps: readonly PADeepFlowStep[];
+}>;
+export type PAFeedbackContext = Readonly<{
+    communityId: string | null;
+    sessionId: string | null;
+    page: Readonly<{
+        url: string;
+        title: string;
+        origin: string;
+        tabId: number | null;
+        windowId: number | null;
+        plunoProductAgentUi: Readonly<{
+            surface: string;
+            description: string;
+            selectors: readonly Readonly<{
+                name: string;
+                selector: string;
+                description: string;
+            }>[];
+        }> | null;
+    }> | null;
+    extensionVersion: string | null;
+    extensionVersionStatus: string | null;
+    browserMode: string | null;
+    bridgeStatus: string | null;
+    sdkPreviewOpen: boolean | null;
+}>;
+export type PAFeatureQuery = Readonly<{
+    kind: 'account' | 'preferences' | 'preferencePrompts' | 'decisions' | 'userContext' | 'hostedEligibility' | 'userSuggestedTasks';
+}> | (PAFeaturePage & Readonly<{
+    kind: 'starterPrompts';
+    includeUserSuggestions: boolean;
+}>) | (PAFeaturePage & Readonly<{
+    kind: 'originContext';
+    trigger?: 'auth' | 'page' | 'manual' | 'poll';
+}>) | (PAFeaturePage & Readonly<{
+    kind: 'appearance';
+}>) | Readonly<{
+    kind: 'contextRun';
+    runId: string;
+}>;
+export type PAFeatureResult = Readonly<{
+    kind: 'account';
+    value: PAAccountData;
+}> | Readonly<{
+    kind: 'preferences';
+    value: PAFeaturePreferences;
+}> | Readonly<{
+    kind: 'preferencePrompts';
+    value: PAPreferencePrompts;
+}> | Readonly<{
+    kind: 'preferencePrompt';
+    feature: PAFeatureName;
+    value: PAPreferencePrompt;
+}> | Readonly<{
+    kind: 'decisions';
+    decisions: readonly PAUserDecision[];
+}> | Readonly<{
+    kind: 'decision';
+    value: PAUserDecision;
+}> | Readonly<{
+    kind: 'starterPrompts';
+    origin: string;
+    prompts: readonly string[];
+    runtimeHelpersJavascript?: string | null;
+}> | Readonly<{
+    kind: 'userSuggestedTasks';
+    prompts: readonly string[];
+    morningReportOpening: string | null;
+    signupAt: string;
+    proactiveSuggestions: readonly PAProactiveSuggestion[];
+}> | Readonly<{
+    kind: 'originContext' | 'userContext' | 'contextRun';
+    value: PAContextStatus;
+}> | Readonly<{
+    kind: 'appearance';
+    origin: string;
+    value: PAOriginAppearance | null;
+    stored?: Readonly<{
+        createdAt: string;
+        updatedAt: string;
+        metadata: import('../protocol/json').PAJsonValue;
+    }>;
+}> | Readonly<{
+    kind: 'hostedEligibility';
+    eligible: boolean;
+}> | Readonly<{
+    kind: 'ack';
+    success: boolean;
+}>;
+export type PAFeatureMutation = Readonly<{
+    kind: 'preference';
+    feature: PAFeatureName;
+    enabled: boolean;
+}> | Readonly<{
+    kind: 'preferenceAcknowledge';
+    feature: PAFeatureName;
+    action: 'enable' | 'allow' | 'not_now' | 'dont_enable';
+    expectedRevision: number;
+}> | Readonly<{
+    kind: 'preferenceSnooze';
+    feature: PAFeatureName;
+    expectedRevision: number;
+}> | (Readonly<{
+    kind: 'decision';
+}> & PAUserDecisionInput) | Readonly<{
+    kind: 'feedback';
+    message: string;
+    context: PAFeedbackContext;
+}> | Readonly<{
+    kind: 'proactiveFeedback';
+    suggestionId: string;
+    suggestedQuery: string;
+    message: string;
+    context: PAFeedbackContext;
+}> | Readonly<{
+    kind: 'targetFeedback';
+    targetId: string;
+    rating: 'positive' | 'negative';
+    comment?: string;
+}> | Readonly<{
+    kind: 'report';
+    sessionId: string | null;
+    message: string;
+    context: PAFeedbackContext;
+    uiEvidence: readonly UiFlightEvidence[];
+    widgetEvidenceAvailable: boolean;
+}> | Readonly<{
+    kind: 'generatePrompts';
+    page: PAFeaturePage;
+    includeUserSuggestions?: boolean;
+    htmlContent: string;
+    pageTitle: string;
+}> | Readonly<{
+    kind: 'refreshContext';
+    origin: string;
+    communityId: string | null;
+}> | Readonly<{
+    kind: 'refreshUserContext';
+    communityId: string | null;
+}> | Readonly<{
+    kind: 'stopContext';
+    runId: string;
+}> | Readonly<{
+    kind: 'sampleStyle';
+    origin: string;
+    page: PAFeaturePage;
+}> | Readonly<{
+    kind: 'saveStyle';
+    origin: string;
+    value: PAOriginAppearance;
+}> | Readonly<{
+    kind: 'deleteStyle';
+    origin: string;
+}> | Readonly<{
+    kind: 'scribble';
+    origin: string;
+    enabled: boolean;
+}> | Readonly<{
+    kind: 'scribblePreference';
+    enabled: boolean;
+}> | Readonly<{
+    kind: 'personalInstructions';
+    value: string;
+}> | Readonly<{
+    kind: 'blockedOrigins';
+    origins: readonly string[];
+    expectedSecurityVersion: number;
+}>;
+export type PAFeaturePending = Readonly<{
+    requestId: string;
+    effectId: string;
+    fingerprint: string;
+    key: string;
+    generation: number;
+    startedAt?: number;
+    operation: PAFeatureQuery | PAFeatureMutation;
+    mode: 'query' | 'mutation';
+    result: PAFeatureResult | null;
+    status: 'queued' | 'pending' | 'done' | 'error';
+    error: PATransportedError | null;
+}>;
+export type PAFeatureState = Readonly<{
+    localScribbleStyle: boolean | null;
+    appearanceEpochs: Readonly<Record<string, number>>;
+    appearanceQueries: Readonly<Record<string, PAFeaturePage & Readonly<{
+        kind: 'appearance';
+    }>>>;
+    originContextQueries: Readonly<Record<string, PAFeaturePage>>;
+    contextObservers: Readonly<Record<string, string>>;
+    contextReads: Readonly<Record<string, Readonly<{
+        settledAt: number;
+        failures: number;
+    }>>>;
+    contextRunOrigins: Readonly<Record<string, string>>;
+    polls: Readonly<Record<string, Readonly<{
+        query: PAFeatureQuery;
+        deadline: number;
+    }>>>;
+    queries: Readonly<Record<string, PAQueryState<string, PAFeatureResult>>>;
+    pending: Readonly<Record<string, PAFeaturePending>>;
+    queuedPreferences: Readonly<Partial<Record<PAFeatureName, Readonly<{
+        requestId: string;
+        enabled: boolean;
+    }>>>>;
+    desiredPreferences: Readonly<Partial<Record<PAFeatureName, boolean>>>;
+    refreshBatch: Readonly<{
+        pending: readonly string[];
+        failed: boolean;
+    }> | null;
+    refreshAt: number | null;
+    failures: number;
+    now: number;
+    timerId: string | null;
+    timerDeadline: number | null;
+    timerRevision: number;
+    refreshQueuedRequestId: string | null;
+    refreshRequired: boolean;
+    schedulerError: PATransportedError | null;
+    deepFlows: Readonly<Record<string, PADeepFlow>>;
+}>;
+export type PAStage7Slices = Readonly<{
+    account: PAAccountState;
+    features: PAFeatureState;
+    interactions: PAInteractionState;
+}>;
+type Scope = Readonly<{
+    authority: PAFeatureAuthority;
+    now: number;
+}>;
+export type PAStage7Command = (Scope & Readonly<{
+    type: 'stage7.initialize' | 'stage7.retire';
+}>) | (Scope & Readonly<{
+    type: 'stage7.account_refusal';
+    code: string;
+}>) | (Scope & Readonly<{
+    type: 'stage7.account_fallback';
+    sessionId: string;
+    enabled: boolean;
+}>) | (Scope & Readonly<{
+    type: 'stage7.query';
+    requestId: string;
+    query: PAFeatureQuery;
+    force?: boolean;
+}>) | (Scope & Readonly<{
+    type: 'stage7.context_observe';
+    clientScopeId: string;
+    origin: string | null;
+}>) | (Scope & Readonly<{
+    type: 'stage7.mutate';
+    requestId: string;
+    mutation: PAFeatureMutation;
+}>) | (Scope & Readonly<{
+    type: 'stage7.retry';
+    requestId: string;
+}>) | (Scope & Readonly<{
+    type: 'stage7.reconcile';
+    requestId: string;
+    reason: 'startup' | 'wake' | 'reconnect' | 'settings' | 'periodic';
+}>) | (Scope & Readonly<{
+    type: 'stage7.observe_work';
+}>) | (Scope & Readonly<{
+    type: 'stage7.local_style';
+    enabled: boolean | null;
+}>) | (Scope & Readonly<{
+    type: 'stage7.restore_prompt_openings';
+    checkpoint: Pick<PAInteractionState, 'openings' | 'openingGeneration' | 'closedScopes' | 'crossTabTurns' | 'promptActions'>;
+}>) | (Scope & Readonly<{
+    type: 'stage7.prompt_view';
+    clientScopeId: string;
+    open: boolean;
+}>) | (Scope & Readonly<{
+    type: 'stage7.prompt_shown';
+    clientScopeId: string;
+    feature: PAFeatureName;
+    openingGeneration: number;
+}>) | (Scope & Readonly<{
+    type: 'stage7.bridge_ready';
+    ready: boolean;
+    error?: string | null;
+}>) | (Scope & Readonly<{
+    type: 'stage7.cross_tab';
+    sessionId: string;
+    userMessageId: string;
+}>) | (Scope & Readonly<{
+    type: 'stage7.permission';
+    requestId: string;
+    feature: PAFeatureName;
+    action: 'allow' | 'not_now';
+    settings: boolean;
+}>) | (Scope & Readonly<{
+    type: 'stage7.device_fact';
+    feature: PAFeatureName;
+    fact: PADeviceFact;
+}>) | (Scope & Readonly<{
+    type: 'stage7.act';
+    requestId: string;
+    clientScopeId: string;
+    interactionId: string;
+    action: 'copy' | 'share' | 'dismiss' | 'connect' | 'pair' | 'run' | 'edit' | 'feedback' | 'not_now' | 'never' | 'snooze' | 'enable' | 'dont_enable' | 'allow';
+    expectedRevision: number;
+    sourceVersion: number | null;
+    origin?: string | null;
+    feedback?: Readonly<{
+        message: string;
+        context: PAFeedbackContext;
+    }>;
+    taskIndex?: number;
+    sharePlatform?: 'linkedin' | 'x' | 'instagram';
+}>) | (Scope & Readonly<{
+    type: 'stage7.retry_action';
+    requestId: string;
+}>) | (Scope & Readonly<{
+    type: 'stage7.import_legacy_decisions';
+    decisions: readonly PAUserDecision[];
+}>) | (Scope & Readonly<{
+    type: 'stage7.device_hints';
+    hints: Readonly<Record<string, boolean>>;
+}>) | (Scope & Readonly<{
+    type: 'stage7.local_sharing';
+    decisions: PAInteractionState['localSharing'];
+}>) | (Scope & Readonly<{
+    type: 'stage7.sources';
+    sources: readonly import('../conversation/display').PAConversationInteractionSource[];
+}>) | (Scope & Readonly<{
+    type: 'stage7.welcome';
+    card: PAInteractionState['welcome'][string] & Readonly<{
+        category: 'proactive_suggestion';
+    }>;
+}>) | (Scope & Readonly<{
+    type: 'stage7.morning';
+    retained?: boolean;
+    id: string;
+    text: string | null;
+    tasks: readonly string[];
+    signupAgeDays: number;
+    localHour: number;
+    localDate: string;
+    lastShownDate: string | null;
+}>) | (Scope & Readonly<{
+    type: 'stage7.deep_flow';
+    clientScopeId: string;
+    expectedId: string | null;
+    flow: PADeepFlow | null;
+}>);
+export type PAStage7Effects = {
+    'stage7.platform': {
+        input: Readonly<{
+            authority: PAFeatureAuthority;
+            requestId: string;
+            operation: import('../interactions/contracts').PAInteractionPlatformOperation;
+        }>;
+        output: Readonly<{
+            revision: number;
+            completedAt: number;
+        }>;
+    };
+    'stage7.query': {
+        input: Readonly<{
+            authority: PAFeatureAuthority;
+            requestId: string;
+            query: PAFeatureQuery;
+        }>;
+        output: Readonly<{
+            data: PAFeatureResult;
+            completedAt: number;
+        }>;
+    };
+    'stage7.mutate': {
+        input: Readonly<{
+            authority: PAFeatureAuthority;
+            requestId: string;
+            mutation: PAFeatureMutation;
+        }>;
+        output: Readonly<{
+            data: PAFeatureResult;
+            completedAt: number;
+        }>;
+    };
+    'stage7.device': {
+        input: Readonly<{
+            authority: PAFeatureAuthority;
+            requestId: string;
+            feature: PAFeatureName;
+            action: 'check' | 'allow' | 'not_now';
+            now: number;
+        }>;
+        output: Readonly<{
+            fact: PADeviceFact;
+            completedAt: number;
+        }>;
+    };
+    'stage7.wait': {
+        input: Readonly<{
+            authority: PAFeatureAuthority;
+            deadline: number;
+        }>;
+        output: Readonly<{
+            now: number;
+        }>;
+    };
+};
+export type PAStage7Ports = PAEffectHandlers<PAStage7Effects>;
+export type PAStage7Input = PAStage7Command | PAEffectResultEvent<PAStage7Effects>;
+export type PAStage7Projection = PAStage7Slices & Readonly<{
+    cards: readonly PAInteractionProjection[];
+}>;
+export declare const asFeatureRequestId: (value: string) => PARequestId;
+export {};

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

@@ -0,0 +1,16 @@
+import type { PAConversationState } from '../conversation/contracts';
+import type { PADirectoryState } from '../session-directory/contracts';
+import type { PAEffect } from '../kernel/effects';
+import type { PAFeatureName } from '../interactions/contracts';
+import { type PAFeatureQuery, type PAFeatureMutation, type PAStage7Slices, type PAStage7Input, type PAStage7Effects } from './contracts';
+import type { PAFeatureAuthority } from '../account/contracts';
+export declare function featureQueryKey(authority: PAFeatureAuthority, query: PAFeatureQuery): string;
+export declare function featurePreference(state: PAStage7Slices, feature: PAFeatureName): boolean | null;
+export declare function assertFeatureOperation(authority: PAFeatureAuthority, operation: PAFeatureQuery | PAFeatureMutation): void;
+export declare function reduceStage7(initial: PAStage7Slices, input: PAStage7Input, context: Readonly<{
+    conversation: PAConversationState;
+    directory: PADirectoryState;
+}>): {
+    state: PAStage7Slices;
+    effects: readonly PAEffect<PAStage7Effects>[];
+};

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

@@ -0,0 +1,15 @@
+import type { PAFeatureQuery, PAStage7Slices } from './contracts';
+export declare function selectFeatureQuery(state: PAStage7Slices, query: PAFeatureQuery): Readonly<{
+    key: string;
+    status: import("..").PAQueryStatus;
+    data: import("./contracts").PAFeatureResult | null;
+    cursor: string | null;
+    error: Readonly<{
+        code: import("..").PATransportedErrorCode;
+        message: string;
+        retryable: boolean;
+        details?: import("..").PAJsonObject;
+    }> | null;
+    requestId: import("..").PARequestId | null;
+    updatedAt: number | null;
+}> | null;

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

@@ -0,0 +1,2 @@
+import type { PAFeatureState } from './contracts';
+export declare function createFeatureState(now?: number): PAFeatureState;

package/dist/core/features/uiFlightEvidence.d.ts

@@ -0,0 +1,29 @@
+export type UiFlightRecord = {
+    sequence: number;
+    occurred_at: string;
+    monotonic_ms: number;
+    kind: "runtime" | "paint" | "click" | "submit" | "focus";
+    action: "new_chat" | "send" | "stop" | "retry" | null;
+    session_id: string | null;
+    run_id: string | null;
+    item_keys: string[];
+    item_count: number;
+    items_truncated: boolean;
+    thinking: boolean;
+    loading: boolean;
+    welcome: boolean;
+    error: boolean;
+    connected: boolean;
+    visible: boolean;
+    output_length: number;
+    active_count: number;
+    terminal_count: number;
+};
+export type UiFlightEvidence = {
+    schema_version: 1;
+    surface: "extension_sidepanel" | "extension_widget" | "main_web_chat" | "embedded_widget";
+    recorder_id: string;
+    sdk_version: string;
+    dropped_records: number;
+    records: UiFlightRecord[];
+};

package/dist/core/index.d.ts

@@ -23,3 +23,14 @@ export * from "./session-directory/state";
 export * from "./session-directory/reducer";
 export * from "./session-directory/selectors";
 export * from "./session-directory/membership";
+export * from './account/contracts';
+export * from './account/state';
+export * from './account/reducer';
+export * from './account/selectors';
+export * from './features/contracts';
+export * from './features/state';
+export * from './features/reducer';
+export * from './features/selectors';
+export * from './interactions/state';
+export * from './interactions/reducer';
+export * from './interactions/selectors';

package/dist/core/interactions/actions.d.ts

@@ -0,0 +1,12 @@
+import type { PAStage7Slices, PAStage7Command, PAStage7Effects } from '../features/contracts';
+import type { PAConversationState } from '../conversation/contracts';
+import type { PADirectoryState } from '../session-directory/contracts';
+import type { PAEffect, PAEffectResultEvent } from '../kernel/effects';
+export type PAInteractionActionEvent = Extract<PAStage7Command, {
+    type: 'stage7.act' | 'stage7.retry_action';
+}> | PAEffectResultEvent<Pick<PAStage7Effects, 'stage7.platform'>>;
+export declare function reduceInteractionAction(initial: PAStage7Slices, input: PAInteractionActionEvent, conversation: PAConversationState, directory: PADirectoryState): {
+    state: PAStage7Slices;
+    effects: readonly PAEffect<PAStage7Effects>[];
+    command: PAStage7Command | null;
+};