@pluno/product-agent-web 0.1.191 → 0.1.196

package/dist/runRecovery.d.ts

@@ -0,0 +1,18 @@
+type RunRecoveryItem = {
+    id: string;
+    data: unknown;
+};
+type RunRecoveryIdentity = {
+    type?: unknown;
+    status?: unknown;
+    reason?: unknown;
+    role?: unknown;
+    clientMessageId?: unknown;
+    respondsToUserMessageId?: unknown;
+    runId?: unknown;
+};
+export declare function filterSupersededTaskTabClosedStops<T extends RunRecoveryItem>(items: T[], activeRetryClientMessageId: string | null): T[];
+export declare function isTaskTabClosedStopForClientMessage(items: RunRecoveryItem[], item: RunRecoveryItem, clientMessageId: string): boolean;
+export declare function isTaskTabClosedStop(data: Record<string, unknown>): boolean;
+export declare function isRecoveredTaskTabClosedTurnProgress(stoppedData: RunRecoveryIdentity, candidateData: RunRecoveryIdentity): boolean;
+export {};

package/dist/runtime.d.ts

@@ -0,0 +1,10 @@
+export { createProductAgentQueryState, mergeProductAgentEntityPages, normalizeProductAgentEntityPage, ProductAgentQueryController, reconcileProductAgentSubmissionGate, resolveProductAgentComposerAction, resolveProductAgentBillingPresentation, resolveProductAgentWidgetPresentation, hasProductAgentPaidCreditFallback, selectProductAgentQueryEntities, } from "./runtimeState";
+export type { ProductAgentAuthProjection, ProductAgentComposerAction, ProductAgentEntity, ProductAgentEntityPage, ProductAgentEntityQueryData, ProductAgentInteraction, ProductAgentInteractionAction, ProductAgentInteractionPresentation, ProductAgentInteractionScope, ProductAgentInteractionStatus, ProductAgentPromptAction, ProductAgentPromptDecision, ProductAgentPromptDecisionScope, ProductAgentQueryLoadMode, ProductAgentQueryState, ProductAgentQueryStatus, ProductAgentSafeUser, ProductAgentSafeWorkspace, ProductAgentSubmissionGate, ProductAgentWidgetPresentation, } from "./runtimeState";
+export { ProductAgentSessionHistoryManager } from "./sessionHistoryState";
+export type { ProductAgentSessionHistoryEntity, ProductAgentSessionHistoryLoader, ProductAgentSessionHistoryPage, } from "./sessionHistoryState";
+export { createLocalStorageInteractionDecisionStorage, ProductAgentInteractionManager, readLocalStorageInteractionDecisions, } from "./interactionManager";
+export type { ProductAgentInteractionDecisionStorage, ProductAgentInteractionDefinition, } from "./interactionManager";
+export { createProductAgentTaskPageTitleDocument, formatProductAgentTaskPageTitle, ProductAgentTaskPageTitleController, } from "./taskPageTitle";
+export { isProductAgentRuntimeCommand, ProductAgentRemoteRuntimeClient } from "./runtimeClient";
+export type { ProductAgentRuntimeClient, ProductAgentRuntimeClientAdapter, ProductAgentRuntimeCommand, ProductAgentRuntimeCommandResult, ProductAgentRuntimeEventName, } from "./runtimeClient";
+export type { ProductAgentTaskPageTitleDocument, ProductAgentTaskStatus, } from "./taskPageTitle";

package/dist/runtimeClient.d.ts

@@ -0,0 +1,189 @@
+import type { ProductAgentAttachment, ProductAgentEventMap, ProductAgentInvocation, ProductAgentModel, ProductAgentSessionHistoryPage, ProductAgentSessionHistoryEntry, ProductAgentState, ProductAgentWidgetLifecycleAction, ProductAgentWidgetLifecycleTrigger } from "./index";
+import type { ProductAgentAccountProjection, ProductAgentInteraction, ProductAgentInteractionAction } from "./runtimeState";
+import { type ProductAgentEntityQueryData, type ProductAgentQueryState } from "./runtimeState";
+export type ProductAgentRuntimeEventName = keyof ProductAgentEventMap;
+export type ProductAgentRuntimeCommand = {
+    type: "runtime.connect";
+} | {
+    type: "runtime.warmup";
+    reason: "panel_open" | "extension_install" | "composer_input";
+} | {
+    type: "runtime.widget_lifecycle";
+    action: ProductAgentWidgetLifecycleAction;
+    trigger: ProductAgentWidgetLifecycleTrigger;
+} | {
+    type: "session.new";
+} | {
+    type: "session.load";
+    sessionId: string;
+} | {
+    type: "session.list";
+    cursor?: string | null;
+    limit?: number;
+    pinned?: boolean;
+} | {
+    type: "session.set_model";
+    model: ProductAgentModel;
+} | {
+    type: "session.pin";
+    sessionId: string;
+    pinned: boolean;
+} | {
+    type: "session.rename";
+    sessionId: string;
+    title: string;
+} | {
+    type: "run.stop";
+} | {
+    type: "run.retry";
+} | {
+    type: "interaction.act";
+    interactionId: string;
+    action: ProductAgentInteractionAction;
+    expectedRevision: number;
+    snoozeUntil?: string;
+    feedback?: string;
+} | {
+    type: "conversation.stage_proactive_suggestion";
+    question: string;
+    clientMessageId: string;
+} | {
+    type: "conversation.stage";
+    content: string;
+    clientMessageId: string;
+    proactiveSuggestionQuestion?: string;
+    attachments?: ProductAgentAttachment[];
+} | {
+    type: "conversation.fail_staged";
+    clientMessageId: string;
+    message: string;
+} | {
+    type: "conversation.send";
+    content: string;
+    clientMessageId: string;
+    initiatedBy?: "pluno";
+    invocation?: ProductAgentInvocation | "pluno";
+    proactiveSuggestionQuestion?: string;
+    attachments?: ProductAgentAttachment[];
+};
+export type ProductAgentRuntimeCommandResult = {
+    clientMessageId?: string | null;
+};
+export type ProductAgentRuntimeClientAdapter = {
+    dispatch(command: ProductAgentRuntimeCommand): Promise<ProductAgentRuntimeCommandResult | void>;
+    uploadAttachment?: (file: File, attachment: ProductAgentAttachment, context: {
+        clientMessageId: string;
+    }) => Promise<ProductAgentAttachment>;
+    onDisconnect?: () => void;
+};
+export declare function isProductAgentRuntimeCommand(value: unknown): value is ProductAgentRuntimeCommand;
+export type ProductAgentRuntimeClient = {
+    on<T extends ProductAgentRuntimeEventName>(eventName: T, listener: (payload: ProductAgentEventMap[T]) => void): () => void;
+    getState(): ProductAgentState;
+    connect(): Promise<void>;
+    destroy(): void;
+    warmup(reason?: "panel_open" | "extension_install" | "composer_input"): void;
+    recordWidgetLifecycle(action: ProductAgentWidgetLifecycleAction, trigger: ProductAgentWidgetLifecycleTrigger): void;
+    sendMessage(content: string, options?: {
+        attachments?: ProductAgentAttachment[];
+        clientMessageId?: string;
+        initiatedBy?: "pluno";
+        invocation?: ProductAgentInvocation | "pluno";
+        proactiveSuggestionQuestion?: string;
+    }): Promise<string | null>;
+    getModel(): ProductAgentModel | undefined;
+    setModel(model: ProductAgentModel): void;
+    retryLastMessage(): boolean;
+    createLocalAttachment(file: File): ProductAgentAttachment;
+    stop(): void;
+    startNewSession(options?: {
+        notifyTransport?: boolean;
+    }): void;
+    listSessions(options?: {
+        cursor?: string | null;
+        limit?: number;
+        pinned?: boolean;
+    }): Promise<ProductAgentSessionHistoryPage>;
+    getSessionHistoryState(): ProductAgentQueryState<ProductAgentEntityQueryData<ProductAgentSessionHistoryEntry>>;
+    subscribeSessionHistory(listener: (state: ProductAgentQueryState<ProductAgentEntityQueryData<ProductAgentSessionHistoryEntry>>) => void): () => void;
+    refreshSessionHistory(): Promise<void>;
+    loadMoreSessionHistory(): Promise<void>;
+    setSessionPinned(sessionId: string, pinned: boolean): Promise<void>;
+    renameSession(sessionId: string, title: string): Promise<void>;
+    getInteractions(): readonly ProductAgentInteraction[];
+    subscribeInteractions(listener: (interactions: readonly ProductAgentInteraction[]) => void): () => void;
+    actOnInteraction(interactionId: string, action: ProductAgentInteractionAction, expectedRevision: number, input?: {
+        feedback?: string;
+        snoozeUntil?: string;
+    }): Promise<void>;
+    getAccount(): ProductAgentAccountProjection | null;
+    subscribeAccount(listener: (account: ProductAgentAccountProjection | null) => void): () => void;
+    refreshAccount(): Promise<void>;
+    loadSession(sessionId: string): void;
+    stageProactiveSuggestionQuestion(question: string): void;
+};
+export declare class ProductAgentRemoteRuntimeClient implements ProductAgentRuntimeClient {
+    private readonly adapter;
+    private readonly listeners;
+    private readonly attachmentFiles;
+    private readonly sessionHistoryListeners;
+    private readonly interactionListeners;
+    private readonly accountListeners;
+    private state;
+    private sessionHistoryState;
+    private model;
+    private interactions;
+    private account;
+    private stagedProactiveSuggestionClientMessageId;
+    private operationQueue;
+    private destroyed;
+    constructor(initialState: ProductAgentState, adapter: ProductAgentRuntimeClientAdapter, model?: ProductAgentModel);
+    on<T extends ProductAgentRuntimeEventName>(eventName: T, listener: (payload: ProductAgentEventMap[T]) => void): () => void;
+    getState(): ProductAgentState;
+    updateProjection(state: ProductAgentState, model?: ProductAgentModel, sessionHistoryState?: ProductAgentQueryState<ProductAgentEntityQueryData<ProductAgentSessionHistoryEntry>>, interactions?: readonly ProductAgentInteraction[], account?: ProductAgentAccountProjection | null): void;
+    connect(): Promise<void>;
+    destroy(): void;
+    warmup(reason?: "panel_open" | "extension_install" | "composer_input"): Promise<void>;
+    recordWidgetLifecycle(action: ProductAgentWidgetLifecycleAction, trigger: ProductAgentWidgetLifecycleTrigger): void;
+    sendMessage(content: string, options?: {
+        attachments?: ProductAgentAttachment[];
+        clientMessageId?: string;
+        initiatedBy?: "pluno";
+        invocation?: ProductAgentInvocation | "pluno";
+        proactiveSuggestionQuestion?: string;
+    }): Promise<string | null>;
+    private sendMessageNow;
+    getModel(): ProductAgentModel | undefined;
+    setModel(model: ProductAgentModel): Promise<void>;
+    retryLastMessage(): boolean;
+    createLocalAttachment(file: File): ProductAgentAttachment;
+    stop(): Promise<void>;
+    startNewSession(options?: {
+        notifyTransport?: boolean;
+    }): Promise<void>;
+    listSessions(options?: {
+        cursor?: string | null;
+        limit?: number;
+        pinned?: boolean;
+    }): Promise<ProductAgentSessionHistoryPage>;
+    getSessionHistoryState(): ProductAgentQueryState<ProductAgentEntityQueryData<ProductAgentSessionHistoryEntry>>;
+    subscribeSessionHistory(listener: (state: ProductAgentQueryState<ProductAgentEntityQueryData<ProductAgentSessionHistoryEntry>>) => void): () => void;
+    refreshSessionHistory(): Promise<void>;
+    loadMoreSessionHistory(): Promise<void>;
+    setSessionPinned(sessionId: string, pinned: boolean): Promise<void>;
+    renameSession(sessionId: string, title: string): Promise<void>;
+    getInteractions(): readonly ProductAgentInteraction[];
+    subscribeInteractions(listener: (interactions: readonly ProductAgentInteraction[]) => void): () => void;
+    actOnInteraction(interactionId: string, action: ProductAgentInteractionAction, expectedRevision: number, input?: {
+        feedback?: string;
+        snoozeUntil?: string;
+    }): Promise<void>;
+    getAccount(): ProductAgentAccountProjection | null;
+    subscribeAccount(listener: (account: ProductAgentAccountProjection | null) => void): () => void;
+    refreshAccount(): Promise<void>;
+    loadSession(sessionId: string): Promise<void>;
+    stageProactiveSuggestionQuestion(question: string): Promise<void>;
+    private dispatch;
+    private enqueueOperation;
+    private emit;
+}

package/dist/runtimeState.d.ts

@@ -0,0 +1,174 @@
+export type ProductAgentQueryStatus = "not_requested" | "loading" | "ready" | "refreshing" | "loading_more" | "error";
+export type ProductAgentQueryState<T> = {
+    key: string;
+    status: ProductAgentQueryStatus;
+    data: T | null;
+    error: string | null;
+    requestId: number;
+    updatedAt: number | null;
+};
+export type ProductAgentEntity = {
+    id: string;
+};
+export type ProductAgentEntityPage<T extends ProductAgentEntity> = {
+    entities: T[];
+    nextCursor: string | null;
+};
+export type ProductAgentEntityQueryData<T extends ProductAgentEntity> = {
+    entitiesById: Readonly<Record<string, T>>;
+    ids: readonly string[];
+    nextCursor: string | null;
+};
+export type ProductAgentQueryLoadMode = "replace" | "append";
+export type ProductAgentQueryLoader<T> = (input: {
+    key: string;
+    cursor: string | null;
+}) => Promise<T>;
+type ProductAgentQueryListener<T> = (state: ProductAgentQueryState<T>) => void;
+export declare function createProductAgentQueryState<T>(key: string): ProductAgentQueryState<T>;
+export declare class ProductAgentQueryController<T> {
+    private readonly loader;
+    private readonly merge;
+    private state;
+    private readonly listeners;
+    private inFlight;
+    private trailingLoad;
+    constructor(key: string, loader: ProductAgentQueryLoader<T>, merge?: (current: T | null, next: T, mode: ProductAgentQueryLoadMode) => T);
+    getState(): ProductAgentQueryState<T>;
+    subscribe(listener: ProductAgentQueryListener<T>): () => void;
+    setKey(key: string): void;
+    reset(): void;
+    invalidate(): void;
+    load(mode?: ProductAgentQueryLoadMode, cursor?: string | null): Promise<void>;
+    update(updater: (data: T | null) => T | null): void;
+    private runLoads;
+    private publish;
+}
+export declare function normalizeProductAgentEntityPage<T extends ProductAgentEntity>(page: ProductAgentEntityPage<T>): ProductAgentEntityQueryData<T>;
+export declare function mergeProductAgentEntityPages<T extends ProductAgentEntity>(current: ProductAgentEntityQueryData<T> | null, next: ProductAgentEntityQueryData<T>, mode: ProductAgentQueryLoadMode): ProductAgentEntityQueryData<T>;
+export declare function selectProductAgentQueryEntities<T extends ProductAgentEntity>(data: ProductAgentEntityQueryData<T> | null): T[];
+export type ProductAgentPromptAction = "dismiss" | "later" | "snooze" | "never" | "dont_show_again";
+export type ProductAgentPromptDecisionScope = ProductAgentInteractionScope;
+export type ProductAgentPromptDecision = {
+    promptKey: string;
+    category: string;
+    action: ProductAgentPromptAction;
+    scope: ProductAgentPromptDecisionScope;
+    decidedAt: string;
+    nextEligibleAt: string | null;
+};
+export type ProductAgentInteractionScope = {
+    level: "device" | "user" | "workspace" | "origin" | "tab" | "session" | "turn";
+    key: string;
+};
+export type ProductAgentInteractionStatus = "scheduled" | "presentable" | "pending" | "snoozed" | "resolved" | "suppressed" | "expired" | "error";
+export type ProductAgentInteractionAction = ProductAgentPromptAction | "enable" | "run" | "edit" | "connect" | "submit_feedback";
+export type ProductAgentInteractionPresentation = {
+    title: string | null;
+    body: string;
+    actionLabels: Partial<Record<ProductAgentInteractionAction, string>>;
+};
+export type ProductAgentInteraction<TKind extends string = string, TPayload = unknown> = {
+    id: string;
+    kind: TKind;
+    category: string;
+    scope: ProductAgentInteractionScope;
+    payload: TPayload;
+    presentation: ProductAgentInteractionPresentation;
+    eligible: boolean;
+    status: ProductAgentInteractionStatus;
+    allowedActions: readonly ProductAgentInteractionAction[];
+    decision: ProductAgentPromptDecision | null;
+    eligibleAt: string | null;
+    expiresAt: string | null;
+    revision: number;
+};
+export type ProductAgentWidgetPresentation = {
+    state: "hidden";
+} | {
+    state: "minimized";
+} | {
+    state: "visible_closed";
+} | {
+    state: "visible_open";
+};
+export declare function resolveProductAgentWidgetPresentation(input: {
+    visible: boolean;
+    minimized: boolean;
+    open: boolean;
+}): ProductAgentWidgetPresentation;
+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;
+export declare function hasProductAgentPaidCreditFallback(metadata: unknown): boolean;
+export type ProductAgentBillingPresentation = {
+    state: "hidden";
+} | {
+    state: "action_required";
+    reason: ProductAgentSubmissionGate["reason"];
+} | {
+    state: "paid_credit_fallback";
+} | {
+    state: "low_credits";
+} | {
+    state: "usage";
+};
+export declare function resolveProductAgentBillingPresentation(account: ProductAgentAccountProjection | null | undefined): ProductAgentBillingPresentation;
+export type ProductAgentComposerAction = {
+    action: "send" | "stop";
+    disabled: boolean;
+};
+export declare function resolveProductAgentComposerAction(input: {
+    hasRunningAssistantTurn: boolean;
+    hasDraftMessage: boolean;
+    hasPreSubmittedAttachment: boolean;
+    canStopRunningTurn: boolean;
+    canSubmitMessage: boolean;
+}): ProductAgentComposerAction;
+export {};

package/dist/sessionHistoryState.d.ts

@@ -0,0 +1,57 @@
+import { type ProductAgentEntity, type ProductAgentEntityQueryData, type ProductAgentQueryState } from "./runtimeState";
+export type ProductAgentSessionHistoryEntity = ProductAgentEntity & {
+    isActive?: boolean;
+    isPinned?: boolean;
+    customTitle?: string | null;
+};
+export type ProductAgentSessionHistoryPage<T extends ProductAgentSessionHistoryEntity> = {
+    sessions: T[];
+    nextCursor: string | null;
+};
+export type ProductAgentSessionHistoryLoader<T extends ProductAgentSessionHistoryEntity> = (input: {
+    cursor: string | null;
+    limit: number;
+    pinned: boolean;
+}) => Promise<ProductAgentSessionHistoryPage<T>>;
+type PinnedOverride = {
+    pinned: boolean;
+    confirmAfterRefresh: number;
+};
+export declare class ProductAgentSessionHistoryManager<T extends ProductAgentSessionHistoryEntity> {
+    private readonly loadPage;
+    private readonly limit;
+    private readonly recentQuery;
+    private readonly pinnedQuery;
+    private readonly listeners;
+    private readonly optimisticEntities;
+    private readonly activityOverrides;
+    private readonly pinnedOverrides;
+    private readonly titleOverrides;
+    private refreshSequence;
+    private completedRefreshSequence;
+    private activityReconciliationScheduled;
+    constructor(key: string, loadPage: ProductAgentSessionHistoryLoader<T>, limit?: number);
+    getState(): ProductAgentQueryState<ProductAgentEntityQueryData<T>>;
+    subscribe(listener: (state: ProductAgentQueryState<ProductAgentEntityQueryData<T>>) => void): () => void;
+    getEntity(sessionId: string): T | null;
+    setKey(key: string): void;
+    refresh(): Promise<void>;
+    loadMore(cursor: string): Promise<void>;
+    addOptimistic(entity: T): void;
+    removeOptimistic(sessionId: string): void;
+    acknowledgeOptimistic(optimisticId: string, entity: T): void;
+    setActivity(sessionId: string, isActive: boolean): void;
+    setPinned(sessionId: string, pinned: boolean): PinnedOverride;
+    confirmPinned(sessionId: string, override: PinnedOverride): void;
+    rollbackPinned(sessionId: string, override: PinnedOverride, pinned: boolean): void;
+    setTitle(sessionId: string, title: string | null): void;
+    confirmTitle(sessionId: string): void;
+    private reconcileDurableEntities;
+    private loadAllPinned;
+    private applyOverrides;
+    private updateProjection;
+    private updateEntity;
+    private hasUnconfirmedActivityOverride;
+    private publish;
+}
+export {};

package/dist/sessionRecoveryPolling.d.ts

@@ -0,0 +1,25 @@
+export type ProductAgentSessionRecoveryPollContext = {
+    sessionId: string;
+    identityScope: string;
+};
+type ProductAgentSessionRecoveryPollerOptions<Result> = {
+    poll: (context: ProductAgentSessionRecoveryPollContext) => Promise<Result>;
+    apply?: (result: Result, context: ProductAgentSessionRecoveryPollContext) => void | Promise<void>;
+    isActiveTurn: () => boolean;
+    activeIntervalMs: number;
+    idleIntervalMs: number;
+    maxFailureIntervalMs: number;
+};
+export declare class ProductAgentSessionRecoveryPoller<Result = void> {
+    private readonly options;
+    private timer;
+    private context;
+    private generation;
+    private failureCount;
+    constructor(options: ProductAgentSessionRecoveryPollerOptions<Result>);
+    start(sessionId: string, identityScope: string): void;
+    stop(): void;
+    private schedule;
+    private run;
+}
+export {};

package/dist/taskPageTitle.d.ts

@@ -4,6 +4,7 @@ export type ProductAgentTaskPageTitleDocument = {
     setTitle: (title: string) => void;
     observeTitle: (onTitleChanged: () => void) => () => void;
 };
+export declare function formatProductAgentTaskPageTitle(title: string, status: ProductAgentTaskStatus | null): string;
 export declare class ProductAgentTaskPageTitleController {
     private readonly titleDocument;
     private status;

package/dist/widget.d.ts

@@ -1,7 +1,10 @@
-import { PlunoProductAgent, type ProductAgentAttachment, type ProductAgentIntegrationAuthRequest, type ProductAgentPersonalChannelConnectionRequest, type ProductAgentInitOptions, type ProductAgentModel, type ProductAgentWidgetLifecycleTrigger } from "./index";
+import { type ProductAgentAttachment, type ProductAgentIntegrationAuthRequest, type ProductAgentPersonalChannelConnectionRequest, type ProductAgentInitOptions, type ProductAgentModel, type ProductAgentRuntimeAdapters, type ProductAgentRuntimeClient, type ProductAgentWidgetLifecycleTrigger } from "./index";
 import { type PersonalProductAgentModel } from "./modelSelection";
+import { type ProductAgentShareCandidate } from "./shareCard";
 import { type ActiveUsersCounterValue } from "./activeUsersCounter";
+import { type ProductAgentInteraction, type ProductAgentAccountProjection } from "./runtimeState";
 export type ProductAgentWidgetOptions = {
+    runtimeClient?: ProductAgentRuntimeClient;
     layout?: "floating" | "page";
     mountTarget?: HTMLElement;
     token?: string;
@@ -46,29 +49,17 @@ export type ProductAgentWidgetOptions = {
     referralLinkLoader?: () => Promise<string>;
     billingStatus?: ProductAgentWidgetBillingStatus | null;
     billingStatusLoader?: () => Promise<ProductAgentWidgetBillingStatus | null>;
+    runtimeAdapters?: ProductAgentRuntimeAdapters;
     activeUsersLoader?: () => Promise<ActiveUsersCounterValue>;
     socialPostRewardsUrl?: string;
-    loadSharePromptsDisabled?: () => boolean | Promise<boolean>;
-    persistSharePromptsDisabled?: (disabled: boolean) => void | Promise<void>;
-    sdkPreviewChannelId?: string;
+    extensionRuntime?: {
+        ownerId: string;
+        markHostOwner?: (host: HTMLElement) => void;
+    };
     initialDisplayState?: "shown" | "minimized";
     onDisplayStateChange?: (state: "shown" | "minimized", trigger: ProductAgentWidgetLifecycleTrigger) => void;
     onPanelOpenChange?: (open: boolean, trigger: ProductAgentWidgetLifecycleTrigger) => void;
     showLauncherMinimizeButton?: boolean;
-    morningReport?: ProductAgentWidgetMorningReport | null;
-    onMorningReportSnooze?: () => void;
-    onMorningReportTaskStart?: () => void;
-    proactiveSuggestion?: ProductAgentWidgetProactiveSuggestion | null;
-    proactiveSuggestionPreparing?: boolean;
-    onProactiveSuggestionDismiss?: (suggestionId: string, reason: "dismiss") => void;
-    onProactiveSuggestionEdit?: (suggestionId: string) => void;
-    onProactiveSuggestionNeverShow?: (suggestionId: string) => void;
-    onProactiveSuggestionFeedbackSubmit?: (interactionId: string, suggestionId: string, genericQuestion: string, question: string, feedback: string) => void | Promise<void>;
-    taskNotifications?: WidgetTaskNotificationsBridge;
-    tabGroups?: WidgetTabGroupsBridge;
-    integrationAuthStatusLoader?: (request: ProductAgentIntegrationAuthRequest) => Promise<ProductAgentIntegrationAuthStatus>;
-    integrationAuthHandler?: (request: ProductAgentIntegrationAuthRequest) => Promise<void>;
-    personalChannelConnectionHandler?: (request: ProductAgentPersonalChannelConnectionRequest) => Promise<void>;
 };
 export type ProductAgentIntegrationAuthStatus = "pending" | "completed" | "cancelled" | "expired";
 export type ProductAgentWidgetMorningReport = {
@@ -81,54 +72,36 @@ export type ProductAgentWidgetProactiveSuggestion = {
     genericQuestion: string;
     question: string;
 };
-type WidgetTaskNotificationsBridge = {
-    getState: () => Promise<{
-        enabled: boolean;
-        neverSuggest: boolean;
-    }>;
-    enable: () => Promise<boolean>;
-    dismissForever: () => Promise<void>;
-};
-type WidgetTabGroupsBridge = {
-    getState: () => Promise<{
-        permissionNeeded: boolean;
-    }>;
-    enable: () => Promise<void>;
-    dismiss: () => Promise<void>;
-};
-export type ProductAgentWidgetBillingStatus = {
-    creditsUsed: number | null;
-    creditLimit: number | null;
-    creditsRemaining: number | null;
-    limitExceeded: boolean;
-    paymentIssue: string | null;
-    pricingUrl: string;
-    earnCreditsUrl: string;
-    onboardingIncomplete?: boolean;
-    onboardingUrl?: string;
-    usingPaidCreditFallback?: boolean;
-};
+export type ProductAgentWidgetRuntimeInteraction = ProductAgentInteraction<"social_share", {
+    candidate: ProductAgentShareCandidate;
+}> | ProductAgentInteraction<"task_notifications", {
+    enabled: boolean;
+}> | ProductAgentInteraction<"tab_group_permission", {
+    permissionNeeded: boolean;
+}> | ProductAgentInteraction<"proactive_suggestion", {
+    suggestion: ProductAgentWidgetProactiveSuggestion;
+}> | ProductAgentInteraction<"morning_report", ProductAgentWidgetMorningReport> | ProductAgentInteraction<"integration_connection", {
+    request: ProductAgentIntegrationAuthRequest;
+    status: ProductAgentIntegrationAuthStatus | "checking" | "error";
+    error?: string | null;
+}> | ProductAgentInteraction<"personal_channel_connection", {
+    request: ProductAgentPersonalChannelConnectionRequest;
+}>;
+export type ProductAgentWidgetBillingStatus = ProductAgentAccountProjection;
 export type ProductAgentWidgetHandle = {
-    agent: PlunoProductAgent;
+    agent: ProductAgentRuntimeClient;
     host: HTMLElement;
     startNewChat: (options?: {
         notifyTransport?: boolean;
     }) => void;
     updateAppearance: (appearance: Pick<ProductAgentWidgetOptions, "accentColor" | "colorScheme" | "fontFamily" | "scribbleStyle">) => void;
-    updateBillingStatus: (billingStatus: ProductAgentWidgetBillingStatus | null | undefined) => void;
-    updateModel: (model: PersonalProductAgentModel) => void;
-    updateAuthGate: (options: Pick<ProductAgentWidgetOptions, "loginRequired" | "loginButtonLabel" | "loginUrl" | "signupRequired" | "signupButtonLabel" | "signupUrl">) => void;
     openPanel: (initialValueOrOptions?: string | {
         focusComposer?: boolean;
         trigger?: ProductAgentWidgetLifecycleTrigger;
     }) => void;
     closePanel: (trigger?: ProductAgentWidgetLifecycleTrigger) => void;
     updateDisplayState: (displayState: "shown" | "minimized") => void;
-    updateMorningReport: (morningReport: ProductAgentWidgetMorningReport | null | undefined) => void;
-    updateProactiveSuggestion: (suggestion: ProductAgentWidgetProactiveSuggestion | null | undefined) => void;
-    updateProactiveSuggestionPreparing: (preparing: boolean) => void;
     destroy: () => void;
 };
 export declare function createProductAgentPreviewBridgeWebSocketFactory(channelId: string): ProductAgentInitOptions["webSocketFactory"];
 export declare function mountPlunoProductAgentWidget(options?: ProductAgentWidgetOptions): Promise<ProductAgentWidgetHandle>;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluno/product-agent-web",
-  "version": "0.1.191",
+  "version": "0.1.196",
   "description": "Browser SDK and default widget for embedding Pluno Product Agent into customer web apps.",
   "license": "Apache-2.0",
   "type": "module",
@@ -24,9 +24,11 @@
     "INTEGRATION.md"
   ],
   "scripts": {
-    "build": "vite build --mode sdk && vite build --mode widget && tsc --emitDeclarationOnly",
+    "build": "vite build --mode sdk && vite build --mode widget && vite build --mode runtime && tsc --emitDeclarationOnly",
     "check": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "verify:package": "node scripts/verify-package-contents.mjs",
+    "prepack": "npm run verify:package"
   },
   "publishConfig": {
     "access": "public"
@@ -39,12 +41,17 @@
     "./widget": {
       "types": "./dist/widget.d.ts",
       "import": "./dist/product-agent-widget.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/product-agent-runtime.js",
+      "require": "./dist/product-agent-runtime.cjs"
     }
   },
   "devDependencies": {
     "jsdom": "^26.1.0",
     "typescript": "^5.9.2",
-    "vite": "^7.1.3",
-    "vitest": "3.2.4"
+    "vite": "^7.3.6",
+    "vitest": "^3.2.7"
   }
 }