@pluno/product-agent-web 0.1.260 → 0.1.263

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

@@ -0,0 +1,4 @@
+import type { PAAccountData, PAAccountState } from '../../core/account/contracts';
+import type { ProductAgentAccountProjection } from '../../core/account/presentation';
+export declare function accountData(presentation: ProductAgentAccountProjection, user: PAAccountData['user'], communityId: string | null): PAAccountData;
+export declare function projectAccount(state: PAAccountState, sessionId?: string | null): ProductAgentAccountProjection | null;

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

@@ -0,0 +1 @@
+export declare function contextHttpError(response: Response): Promise<Error>;

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

@@ -1,3 +1,4 @@
+import type { PAJsonObject } from '../../core/protocol/json';
 import type { ConversationCancellationState } from "./conversationCancellation";
 import { type OperationTiming } from "../../operationTiming";
 import type { ProductAgentPrepareAttachmentUploadInput, ProductAgentAttachmentUpload } from "../../index";
@@ -32,8 +33,9 @@ export declare function createConversationPorts(options: Boundary & {
     now: () => number;
     onUploaded?: (sourceId: string, sessionId: string, attachment: PAUploadedAttachment) => Promise<void>;
     prepareUpload?: (input: ProductAgentPrepareAttachmentUploadInput) => Promise<ProductAgentAttachmentUpload>;
+    snapshotContext?: (sessionId: string) => PAJsonObject;
     persistUpload?: (input: ProductAgentPrepareAttachmentUploadInput, bytes: File) => Promise<Pick<ProductAgentAttachmentUpload, "sessionId" | "attachment">>;
-}): Omit<PAConversationPorts, "conversation.interactions">;
+}): PAConversationPorts;
 export declare class ProductAgentConversationObservationAdapter {
     private readonly options;
     private readonly observations;

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

@@ -0,0 +1,2 @@
+export declare function readDeviceHints(storage: Storage): Record<string, boolean>;
+export declare function dismissDeviceHint(storage: Storage, id: string): void;

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

@@ -0,0 +1,30 @@
+import type { ProductAgentHttpTransport } from './backendHttp';
+import type { PAAccountData, PAFeatureAuthority, PAFeaturePreferences } from '../../core/account/contracts';
+import type { PAFeatureResult, PAStage7Ports, PAFeatureQuery } from '../../core/features/contracts';
+import type { PAPreferencePrompt, PAPreferencePrompts, PAUserDecision } from '../../core/interactions/contracts';
+export declare function decodeFeaturePreferences(value: unknown): PAFeaturePreferences;
+export declare function decodePreferencePrompt(value: unknown): PAPreferencePrompt;
+export declare function decodePreferencePrompts(value: unknown): PAPreferencePrompts;
+export declare function decodeUserDecision(value: unknown): PAUserDecision;
+export type PAFeatureHttpOptions = Readonly<{
+    http: Pick<ProductAgentHttpTransport, 'request'>;
+    now: () => number;
+    authority: () => PAFeatureAuthority | null;
+    onContextStatusRead?: (event: Readonly<{
+        requestId: string;
+        origin: string;
+        trigger: string;
+        phase: 'started' | 'ready' | 'failed';
+        code?: string;
+        retryable?: boolean;
+    }>) => void;
+    sampleStyle?: (page: import('../../core/features/contracts').PAFeaturePage) => Promise<import('../../core/features/contracts').PAOriginAppearance>;
+    readAccount: (authority: PAFeatureAuthority) => Promise<PAAccountData>;
+    embedded: Readonly<{
+        appearance: (query: Extract<PAFeatureQuery, {
+            kind: 'originContext' | 'appearance';
+        }>) => Promise<PAFeatureResult>;
+        feedback: (message: string) => Promise<boolean>;
+    }>;
+}>;
+export declare function createFeatureHttpPorts(options: PAFeatureHttpOptions): Pick<PAStage7Ports, 'stage7.query' | 'stage7.mutate'>;

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

@@ -0,0 +1,18 @@
+import type { PAClientRuntime } from '../../runtime/composition';
+import type { PAFeatureAuthority } from '../../core/account/contracts';
+import type { PAStage7Ports } from '../../core/features/contracts';
+import type { PAFeatureName, PADeviceFact } from '../../core/interactions/contracts';
+export declare function createFeatureScheduler(now: () => number): Readonly<{
+    wait: PAStage7Ports['stage7.wait'];
+    dispose: () => void;
+}>;
+export type PAFeatureDeviceAdapter = Readonly<{
+    authority: () => PAFeatureAuthority | null;
+    enabled: (feature: PAFeatureName) => boolean;
+    now: () => number;
+    check: (authority: PAFeatureAuthority, feature: PAFeatureName) => Promise<PADeviceFact>;
+    allow: (authority: PAFeatureAuthority, feature: PAFeatureName, requestId: string) => Promise<PADeviceFact>;
+    postpone: (authority: PAFeatureAuthority, feature: PAFeatureName, requestId: string) => Promise<PADeviceFact>;
+}>;
+export declare function createFeatureDevicePort(adapter: PAFeatureDeviceAdapter): PAStage7Ports['stage7.device'];
+export declare function observeFeatureWork(runtime: PAClientRuntime, now: () => number): () => void;

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

@@ -0,0 +1,15 @@
+import type { PAClientRuntime } from '../../runtime/composition';
+import type { PAFeatureAuthority } from '../../core/account/contracts';
+import type { PAFeatureMutation, PAFeatureQuery, PAFeatureResult, PAStage7Command } from '../../core/features/contracts';
+export declare function initializeFeatureOwner(runtime: PAClientRuntime, authority: PAFeatureAuthority, now: number): Promise<void>;
+export declare function featureQuery(runtime: PAClientRuntime, query: PAFeatureQuery, options?: {
+    force?: boolean;
+}): Promise<PAFeatureResult>;
+export declare function featureMutation(runtime: PAClientRuntime, mutation: PAFeatureMutation, requestId?: string): Promise<PAFeatureResult>;
+export declare function observeContextRun(runtime: PAClientRuntime, runId: string, signal: AbortSignal, timeoutMs: number): Promise<import('../../core/features/contracts').PAContextStatus | null>;
+export type FeatureAction = Omit<Extract<PAStage7Command, {
+    type: 'stage7.act';
+}>, 'type' | 'authority' | 'now' | 'requestId' | 'sourceVersion'> & {
+    expectedSourceVersion?: number | null;
+};
+export declare function featureAction(runtime: PAClientRuntime, action: FeatureAction, newRequestId?: string): Promise<void>;

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

@@ -0,0 +1,5 @@
+import type { PAStage7Slices } from '../../core/features/contracts';
+import type { PAConversationState } from '../../core/conversation/contracts';
+import type { PADirectoryState } from '../../core/session-directory/contracts';
+import type { ProductAgentInteraction } from '../../runtimeState';
+export declare function projectFeatureInteractions(state: PAStage7Slices, conversation: PAConversationState, directory: PADirectoryState, clientScopeId: string): readonly ProductAgentInteraction[];

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

@@ -0,0 +1,56 @@
+import type { ProductAgentAccountProjection, ProductAgentSubmissionGate } from './presentation';
+import type { PAClientCapabilityProfile, PAOperation } from '../kernel/capabilities';
+import type { PAQueryState } from '../kernel/state';
+export type PAFeatureAuthority = Readonly<{
+    authorityId: string;
+    generation: number;
+    userId: string;
+    communityId: string | null;
+    installationId: string | null;
+    profile: PAClientCapabilityProfile;
+    interactionAdapters?: Readonly<{
+        integrationAuth: boolean;
+        personalChannel: boolean;
+    }>;
+}>;
+export type PAFeaturePreferences = Readonly<{
+    taskNotificationsEnabled: boolean | null;
+    tabGroupingEnabled: boolean | null;
+    preferencesVersion: number;
+    scribbleStyleEnabled: boolean | null;
+    blockedOrigins: readonly string[];
+    personalInstructions: string | null;
+    securityPolicyVersion?: number;
+}>;
+export type PAAccountData = Readonly<{
+    presentation?: ProductAgentAccountProjection;
+    referralLink?: string;
+    plan?: string | null;
+    loadedAt?: string;
+    user: Readonly<{
+        id: string;
+        email: string | null;
+        name: string | null;
+        isSuperuser: boolean;
+    }> | null;
+    communityId: string | null;
+    workspaceName: string | null;
+    credits: number | null;
+    usage: number | null;
+    billing: 'available' | 'required' | 'exhausted' | 'unknown';
+    submissionAllowed: boolean;
+    hostedBrowserEligible: boolean | null;
+}>;
+export type PAAccountState = Readonly<{
+    authority: PAFeatureAuthority | null;
+    refusal: ProductAgentSubmissionGate | null;
+    paidFallbackBySession: Readonly<Record<string, boolean>>;
+    query: PAQueryState<string, PAAccountData>;
+    preferences: PAFeaturePreferences | null;
+}>;
+export type PAAccessDecision = Readonly<{
+    operation: PAOperation;
+    allowed: boolean;
+    reason: 'allowed' | 'capability' | 'authentication' | 'workspace' | 'billing' | 'unavailable' | 'blocked_origin' | 'device';
+    recovery: 'none' | 'login' | 'select_workspace' | 'billing' | 'refresh' | 'settings';
+}>;

package/dist/core/account/presentation.d.ts

@@ -0,0 +1,49 @@
+export type ProductAgentSafeUser = {
+    id: string;
+    email: string | null;
+    name: string | null;
+};
+export type ProductAgentSafeWorkspace = {
+    id: string;
+    name: string | null;
+};
+export type ProductAgentAuthProjection = {
+    status: "anonymous" | "checking";
+    user: null;
+    workspace: null;
+} | {
+    status: "refreshing";
+    user: ProductAgentSafeUser;
+    workspace: ProductAgentSafeWorkspace | null;
+} | {
+    status: "authenticated";
+    user: ProductAgentSafeUser;
+    workspace: ProductAgentSafeWorkspace | null;
+} | {
+    status: "error";
+    user: null;
+    workspace: null;
+    errorCode: string;
+    message: string;
+};
+export type ProductAgentSubmissionGate = {
+    allowed: boolean;
+    reason: "allowed" | "authentication_required" | "workspace_required" | "connection_required" | "onboarding_required" | "credits_exhausted" | "payment_issue" | "update_required";
+    actions: readonly ("login" | "create_workspace" | "complete_onboarding" | "earn_credits" | "upgrade" | "update")[];
+};
+export type ProductAgentAccountProjection = {
+    auth?: ProductAgentAuthProjection;
+    actionUrls?: Partial<Record<ProductAgentSubmissionGate["actions"][number], string>>;
+    creditsUsed: number | null;
+    creditLimit: number | null;
+    creditsRemaining: number | null;
+    limitExceeded: boolean;
+    paymentIssue: string | null;
+    pricingUrl: string;
+    earnCreditsUrl: string;
+    onboardingIncomplete?: boolean;
+    onboardingUrl?: string;
+    usingPaidCreditFallback?: boolean;
+    submissionGate?: ProductAgentSubmissionGate;
+};
+export declare function reconcileProductAgentSubmissionGate(gate: ProductAgentSubmissionGate | undefined, errorCode: string | null | undefined): ProductAgentSubmissionGate;

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

@@ -0,0 +1,2 @@
+import type { PAAccountState, PAFeaturePreferences } from './contracts';
+export declare function mergeFeaturePreferences(state: PAAccountState, value: PAFeaturePreferences): PAAccountState;

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

@@ -0,0 +1,3 @@
+import { type PAOperation } from '../kernel/capabilities';
+import type { PAAccessDecision, PAAccountState } from './contracts';
+export declare function selectAccountAccess(state: PAAccountState, operation: PAOperation, origin?: string | null, deviceAvailable?: boolean): PAAccessDecision;

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

@@ -0,0 +1,2 @@
+import type { PAAccountState, PAFeatureAuthority } from './contracts';
+export declare function createAccountState(authority?: PAFeatureAuthority | null): PAAccountState;

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

@@ -64,15 +64,11 @@ export type PAConversationSnapshotRequest = PADirectoryAuthority & Readonly<{
     before: string | null;
     refreshItemIds: readonly string[];
 }>;
-export type PAConversationInteractionHandoff = PADirectoryAuthority & Readonly<{
+export type PAConversationInteractionSources = PADirectoryAuthority & Readonly<{
     sessionId: PASessionId;
     sources: readonly PAConversationInteractionSource[];
 }>;
 export type PAConversationEffects = PAConversationDeliveryEffects & {
-    "conversation.interactions": {
-        input: PAConversationInteractionHandoff;
-        output: null;
-    };
     "conversation.snapshot": {
         input: PAConversationSnapshotRequest;
         output: Readonly<{
@@ -127,6 +123,7 @@ export type PAConversationState = PADirectoryAuthority & Readonly<{
 export type PAConversationCommand = PAConversationDeliveryCommand | PADirectoryAuthority & ((PAConversationSubmissionInput & Readonly<{
     type: "conversation.submission_stage";
     prepareContext?: boolean;
+    waitForAuthentication?: "unauthorized" | "auth_reconnecting";
 }>) | Readonly<{
     type: "conversation.context_prepared";
     userMessageId: string;

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

@@ -18,5 +18,6 @@ export declare function scheduleConversationDelivery(state: PAConversationState)
 export declare function reduceConversationWithDelivery(state: PAConversationState, input: Input, directory: PADirectoryState, models: PAModelSelectionState): {
     state: PAConversationState;
     effects: PAEffect<PAConversationEffects>[];
+    interactionSources: import("./contracts").PAConversationInteractionSources | undefined;
 };
 export {};

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

@@ -93,6 +93,8 @@ export type PAConversationDeliveryEffects = {
 };
 export type PAConversationDeliveryCommand = PADirectoryAuthority & (Readonly<{
     type: "conversation.enable_effects";
+}> | Readonly<{
+    type: "conversation.authentication_restored";
 }> | Readonly<{
     type: "conversation.recover";
     now: number;

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

@@ -2,7 +2,9 @@ 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";
+import type { PAConversationInteractionSources, 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>;
+export declare function synchronizeConversationDirectory(state: PAConversationState, directory: PADirectoryState, adoptLocalSubmissions?: boolean): PAConversationState;
+export declare function reduceConversation(state: PAConversationState, input: PAConversationCommand | PAConversationEvent | PAEffectResultEvent<PAConversationEffects>, directory: PADirectoryState, models: PAModelSelectionState): PAReduction<PAConversationState, PAConversationEffects> & {
+    interactionSources?: PAConversationInteractionSources;
+};

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

@@ -0,0 +1,10 @@
+import type { PAFeatureAuthority } from '../account/contracts';
+import type { PAEffect } from '../kernel/effects';
+import { type PAFeatureQuery, type PAFeatureState, type PAStage7Effects, type PAStage7Input } from './contracts';
+export declare function isAppearanceOperation(operation: {
+    kind: string;
+}): boolean;
+export declare function reduceAppearance(initial: PAFeatureState, authority: PAFeatureAuthority, input: PAStage7Input, queryKey: (query: PAFeatureQuery) => string): {
+    state: PAFeatureState;
+    effects: readonly PAEffect<PAStage7Effects>[];
+};