@pagelines/sdk 1.0.758 → 1.0.759

package/dist/agent/AgentController.d.ts

@@ -1,25 +1,10 @@
 import { ComputedRef, Ref } from 'vue';
-import { AgentConfig, ChatToolActivityData, SettingsObject } from '@pagelines/core';
+import { AgentConfig, ChatStreamError, ChatToolActivityData, SettingsObject } from '@pagelines/core';
 import { PageLinesSDK } from '../sdkClient';
 import { AgentMode, ChatAttachment, ChatMessage, TextConnectionState, Agent } from './schema';
+import { VoiceClientHandlers, VoiceSessionClient } from './voice/voice-session-client';
 import { LiveTurnBlock, WorkJournalModel, WorkJournalOutcome } from './work-journal';
 import { VoiceRecorderController } from './VoiceRecorderController';
-/**
- * Structured error payload surfaced by the chat stream. Matches the
- * ApiResponse contract in plans/architecture/architecture-api.md — consumers switch on
- * `code` (stable identifier), render `error` (user-facing copy). When
- * the server emits a ChatIssueWireFrame (chat-gate.ts), the bucket +
- * actionLabel + actionUrl triad lets the UI render a CTA inside the
- * error bubble.
- */
-export interface ChatStreamError {
-    code: string;
-    error: string;
-    bucket?: 'account' | 'error';
-    actionLabel?: string;
-    actionUrl?: string;
-    help?: string;
-}
 export type ChatStreamErrorPresentation = {
     surface: 'transcript';
     issue: NonNullable<ChatMessage['issue']>;
@@ -66,7 +51,7 @@ export type AgentChatComposerState = {
     pendingAttachments: ChatAttachment[];
     isUploading: boolean;
 };
-type AgentChatControllerSettings = {
+export type AgentChatControllerSettings = {
     sdk?: PageLinesSDK;
     agent: Agent | AgentConfig;
     context?: string;
@@ -82,14 +67,59 @@ type AgentChatControllerSettings = {
      * surfaces omit it — a visitor can't wake someone else's assistant.
      */
     manageUrl?: string;
+    /**
+     * Voice-mode seam — voice exists only where the surface provides it.
+     *
+     * There is deliberately no built-in default: the controller ships in the
+     * embeddable widget, and a static edge to the LiveKit transport put a full
+     * WebRTC stack (~500KB) on every host page for a capability the widget
+     * cannot use (a voice mint needs a signed-in user). Surfaces that can do
+     * voice construct `VoiceSessionClient` and pass it here; everywhere else
+     * `canStartVoice` stays false and the seat never renders.
+     */
+    createVoiceClientFn?: (args: {
+        /** Validated by the controller's gate — the surface does not re-check. */
+        agentId: string;
+        orgId: string;
+        conversationId?: string;
+        handlers: VoiceClientHandlers;
+    }) => VoiceSessionClient;
+    /** Reload the bound transcript after an out-of-band voice session writes turns. */
+    refreshMessagesFn?: () => Promise<void>;
 };
-/** @deprecated Use AgentChatControllerSettings */
-export type AgentControllerSettings = AgentChatControllerSettings;
 export declare class AgentChatController extends SettingsObject<AgentChatControllerSettings> {
     private isTextMode;
     private lastMessage;
     private isConnecting;
-    private activeTurnGeneration;
+    /**
+     * Turn ownership across concurrent send streams.
+     *
+     * A send that lands mid-turn is accepted and held by the server, so two
+     * streams can be open at once: the one rendering the running turn and the
+     * one waiting for the queued turn the server will dispatch next. Each
+     * stream carries a token; `runningStreamToken` names the one that owns the
+     * live chrome, and Stop suppresses that token alone. `turnEpoch` is the
+     * wholesale invalidation (reset / conversation switch) — bumping it orphans
+     * every open stream at once.
+     */
+    private turnEpoch;
+    private nextStreamToken;
+    private runningStreamToken;
+    private readonly suppressedStreamTokens;
+    /**
+     * Client ids of messages accepted while a turn was running. Rendered dimmed
+     * until the turn that answers them starts producing output.
+     */
+    private readonly queuedMessageIdSet;
+    readonly queuedMessageIds: ComputedRef<ReadonlySet<string>>;
+    isQueuedMessage(messageId: string): boolean;
+    /**
+     * Undim the queued message answered by a starting turn, plus every queued
+     * message before it — a burst of held sends becomes one follow-up turn
+     * keyed to the latest prompt, so the whole chronological prefix resolves
+     * together. Mirrors iOS `consumeQueuedMessages(through:)`.
+     */
+    private consumeQueuedThrough;
     private boundaryTimer?;
     private readonly nowMs;
     private readonly toolActivityTiming;
@@ -120,7 +150,28 @@ export declare class AgentChatController extends SettingsObject<AgentChatControl
     readonly voiceRecorder: VoiceRecorderController;
     readonly canSend: ComputedRef<boolean>;
     readonly canStop: ComputedRef<boolean>;
+    /**
+     * Which control owns the composer's primary slot (mockup 28d, iOS
+     * `ComposeState.derive`). Send outranks Stop the moment a draft exists —
+     * even mid-turn, because that send queues rather than cancelling. Stop
+     * borrows the primary slot only while the draft is empty, and otherwise
+     * steps aside to the secondary slot.
+     */
     readonly composerAction: ComputedRef<'idle' | 'send' | 'stop'>;
+    /** Quiet Stop beside the primary Send while a turn runs against a draft. */
+    readonly composerShowsSecondaryStop: ComputedRef<boolean>;
+    /**
+     * The empty-draft send seat offers voice (mockup composer contract). Gated
+     * on a buildable client plus browser capture support — a surface that
+     * can't open a session never shows the seat. Deliberately NOT gated on
+     * connection state, same reasoning as canUseComposer.
+     */
+    readonly canStartVoice: ComputedRef<boolean>;
+    /** The thread the controller is bound to — the voice mint is conversation-scoped. */
+    get activeConversationId(): string | undefined;
+    /** Build the live-conversation client for the voice surface. Undefined when this surface can't do voice. */
+    createVoiceClient(handlers: VoiceClientHandlers): VoiceSessionClient | undefined;
+    refreshMessages(): Promise<void>;
     private _agent;
     constructor(settings: AgentChatControllerSettings);
     get chatEnabled(): boolean;
@@ -136,6 +187,14 @@ export declare class AgentChatController extends SettingsObject<AgentChatControl
     private isTransientError;
     private isDuplicateMessage;
     private addMessage;
+    /**
+     * Optimistic client id. Timestamp-ordered but counter-suffixed: two messages
+     * created in the same millisecond (a mid-turn send landing on the tick that
+     * added the previous bubble) must not share an id, or they collide as Vue
+     * keys and as queued-set entries.
+     */
+    private localMessageSeq;
+    private nextLocalMessageId;
     /**
      * Surface a one-shot system bubble in the chat transcript.
      *
@@ -229,4 +288,3 @@ export declare class AgentChatController extends SettingsObject<AgentChatControl
     }): void;
     destroy(): Promise<void>;
 }
-export {};

package/dist/agent/index.d.ts

@@ -1,12 +1,14 @@
 import { default as AgentChat } from './ui/AgentChat.vue';
-import { default as AgentModal } from './ui/AgentModal.vue';
 import { default as AgentProvider } from './ui/AgentProvider.vue';
 import { default as AgentWidget } from './ui/AgentWidget.vue';
 import { default as AgentWrap } from './ui/AgentWrap.vue';
 import { default as ElAgentChat } from './ui/ElAgentChat.vue';
 import { default as ElAgentChatPreview } from './ui/ElAgentChatPreview.vue';
+import { default as VoiceMode } from './ui/VoiceMode.vue';
 export { AgentChatController, AgentChatController as AgentController } from './AgentController';
 export type { AgentChatComposerState, ChatStreamFn, ChatUploadFn } from './AgentController';
+export { VoiceSessionClient } from './voice/voice-session-client';
+export type { VoiceClientHandlers, VoiceLevelEvent, VoiceSessionClientState, VoiceSessionError, } from './voice/voice-session-client';
 export type { WorkJournalModel, WorkJournalOutcome, WorkJournalRow, WorkJournalTone } from './work-journal';
 export * from './schema';
-export { AgentChat, AgentModal, AgentProvider, AgentWidget, AgentWrap, ElAgentChat, ElAgentChatPreview };
+export { AgentChat, AgentProvider, AgentWidget, AgentWrap, ElAgentChat, ElAgentChatPreview, VoiceMode };

package/dist/agent/schema.d.ts

@@ -1,21 +1,6 @@
-import { ChatToolActivityData } from '@pagelines/core';
+import { ChatAttachment, ChatToolActivityData } from '@pagelines/core';
 export { Agent } from '@pagelines/core';
-export type { AgentConfig, ChatToolActivityData as ChatToolActivity } from '@pagelines/core';
-export interface ChatAttachment {
-    type: 'image' | 'audio' | 'video' | 'document';
-    src: string;
-    filename: string;
-    mimeType: string;
-    mediaId?: string;
-    size?: number;
-    width?: number;
-    height?: number;
-    duration?: number;
-    placement?: {
-        kind: 'inline';
-        offset: number;
-    };
-}
+export type { AgentConfig, ChatAttachment, ChatToolActivityData as ChatToolActivity } from '@pagelines/core';
 export interface ChatMessageIssue {
     code: string;
     bucket: 'account' | 'error';

package/dist/agent/ui/AgentAvatar.vue.d.ts

@@ -19,6 +19,8 @@ import { Agent } from '@pagelines/core';
 type __VLS_Props = {
     agent: Agent;
     showStatus?: boolean;
+    /** Voice mode opts out: the owner is the one present and speaking, so the "whose assistant is this" question is already answered. */
+    showOwnerMark?: boolean;
     /** Ring color follows the surface so the mark reads as framed, not cut out. */
     isLight?: boolean;
 };

package/dist/agent/ui/AgentChat.vue.d.ts

@@ -1,3 +1,4 @@
+import { AgentChatControllerSettings } from '../AgentController';
 import { PageLinesSDK } from '../../sdkClient';
 import { ButtonIconPreset } from '../../widget/PLWidget';
 import { ColorName, SuggestedPrompt } from '@pagelines/core';
@@ -19,6 +20,8 @@ type __VLS_Props = {
     bare?: boolean;
     emptyStateMessage?: string;
     suggestedPrompts?: SuggestedPrompt[];
+    /** Voice transport, supplied by hosts that ship it. See the note in createChatController. */
+    createVoiceClientFn?: AgentChatControllerSettings['createVoiceClientFn'];
 };
 type __VLS_Slots = {
     'empty-heading': (props: {

package/dist/agent/ui/ElCreateAgent.vue.d.ts

@@ -68,6 +68,7 @@ declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {
             handle: string;
         }[] | null | undefined;
         model?: string | null | undefined;
+        voice?: "woman" | "man" | null | undefined;
         billingTier?: "essential" | "professional" | "business" | undefined;
         lastActiveAt?: string | null | undefined;
         lastMessageAt?: string | null | undefined;
@@ -201,6 +202,7 @@ declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {
             handle: string;
         }[] | null | undefined;
         model?: string | null | undefined;
+        voice?: "woman" | "man" | null | undefined;
         billingTier?: "essential" | "professional" | "business" | undefined;
         lastActiveAt?: string | null | undefined;
         lastMessageAt?: string | null | undefined;

package/dist/agent/ui/{AgentModal.vue.d.ts → VoiceMode.vue.d.ts}

@@ -1,17 +1,14 @@
-import { PageLinesSDK } from '../../sdkClient';
-import { AgentConfig } from '../schema';
+import { Agent } from '@pagelines/core';
+import { AgentChatController } from '../AgentController';
 type __VLS_Props = {
-    vis?: boolean;
-    sdk?: PageLinesSDK;
-    agent?: AgentConfig;
-    handle?: string;
-    context?: string;
-    firstMessage?: string;
+    agent: Agent;
+    chatController?: AgentChatController;
+    isLight?: boolean;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:vis": (value: boolean) => any;
+    end: () => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:vis"?: ((value: boolean) => any) | undefined;
+    onEnd?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/agent/utils.d.ts

@@ -13,10 +13,6 @@ export declare function parseVoiceMessage(args: {
     text: string;
     sender: 'user' | 'agent';
 } | null;
-export declare function generateFirstMessage(args: {
-    name: string;
-    context?: string;
-}): string;
 /**
  * Parse button template string with self data variables
  * Supports: {name}, {title}, {handle}, {orgName}

package/dist/agent/voice/provider.d.ts

@@ -0,0 +1,28 @@
+import { VoiceSessionMint } from '@pagelines/core';
+export interface VoiceLevelEvent {
+    source: 'mic' | 'playback';
+    /** Normalized 0..1 signal level. */
+    level: number;
+    /** Speech-spectrum energies, low pitch first. */
+    bands?: readonly number[];
+}
+export interface VoiceSessionError {
+    code: string;
+    message: string;
+}
+export interface VoiceProviderClient {
+    connect: (handlers: {
+        onDisconnected: () => void;
+        onError: (error: VoiceSessionError) => void;
+    }) => Promise<void>;
+    disconnect: () => Promise<void>;
+    sampleLevel: () => VoiceLevelEvent | undefined;
+}
+export type CreateVoiceProviderClient = (mint: VoiceSessionMint) => Promise<VoiceProviderClient>;
+/** Provider selection is a closed union; each SDK remains in its lazy chunk. */
+export declare const createVoiceProviderClient: CreateVoiceProviderClient;
+export declare const VOICE_SPECTRUM_BANDS = 9;
+/** Log-spaced speech spectrum for transports that expose FFT bins. */
+export declare function voiceSpectrum(frequencies: Uint8Array, sampleRate: number, fftSize: number, bandCount?: number): readonly number[];
+/** Equal-width bands for SDKs that already expose voice-range FFT bins. */
+export declare function voiceRangeSpectrum(frequencies: Uint8Array, bandCount?: number): readonly number[];

package/dist/agent/voice/providers/elevenlabs/provider.d.ts

@@ -0,0 +1,30 @@
+import { VoiceSessionMint } from '@pagelines/core';
+import { VoiceProviderClient } from '../../provider';
+type ElevenLabsMint = Extract<VoiceSessionMint, {
+    provider: 'elevenlabs';
+}>;
+interface ElevenLabsConversation {
+    endSession: () => Promise<void>;
+    getInputVolume: () => number;
+    getOutputVolume: () => number;
+    getInputByteFrequencyData: () => Uint8Array;
+    getOutputByteFrequencyData: () => Uint8Array;
+}
+type StartSession = (options: {
+    conversationToken: string;
+    connectionType: 'webrtc';
+    onDisconnect: () => void;
+    onError: (message: string) => void;
+}) => Promise<ElevenLabsConversation>;
+export declare class ElevenLabsVoiceProvider implements VoiceProviderClient {
+    private readonly mint;
+    private readonly startSession;
+    private conversation?;
+    private closing;
+    private handlers?;
+    constructor(mint: ElevenLabsMint, startSession?: StartSession);
+    connect(handlers: Parameters<VoiceProviderClient['connect']>[0]): Promise<void>;
+    disconnect(): Promise<void>;
+    sampleLevel(): ReturnType<VoiceProviderClient['sampleLevel']>;
+}
+export {};

package/dist/agent/voice/providers/livekit/provider.d.ts

@@ -0,0 +1,55 @@
+import { VoiceSessionMint } from '@pagelines/core';
+import { VoiceProviderClient } from '../../provider';
+type LiveKitMint = Extract<VoiceSessionMint, {
+    provider: 'livekit';
+}>;
+export interface VoiceLevelAnalyser {
+    calculateVolume: () => number;
+    calculateBands?: () => readonly number[];
+    cleanup: () => Promise<void>;
+}
+export interface VoiceRoom {
+    connect: (url: string, token: string) => Promise<void>;
+    disconnect: () => Promise<void>;
+    startAudio: () => Promise<void>;
+    on: (event: string, handler: (...args: any[]) => void) => unknown;
+    off: (event: string, handler: (...args: any[]) => void) => unknown;
+    remoteParticipants: ReadonlyMap<string, {
+        isAgent: boolean;
+        attributes: Readonly<Record<string, string>>;
+    }>;
+    localParticipant: {
+        setMicrophoneEnabled: (enabled: boolean, options?: {
+            echoCancellation?: boolean;
+            noiseSuppression?: boolean;
+        }) => Promise<{
+            track?: unknown;
+        } | undefined>;
+        getTrackPublication?: (source: string) => {
+            track?: unknown;
+        } | undefined;
+    };
+}
+export declare class LiveKitVoiceProvider implements VoiceProviderClient {
+    private readonly mint;
+    private readonly room;
+    private readonly createAnalyser?;
+    private handlers?;
+    private cancelReadyWait?;
+    private analysers;
+    private levelSources;
+    private attachedElements;
+    private closing;
+    constructor(mint: LiveKitMint, deps?: {
+        createRoom?: () => VoiceRoom;
+        createAnalyser?: (track: unknown) => VoiceLevelAnalyser;
+    });
+    connect(handlers: Parameters<VoiceProviderClient['connect']>[0]): Promise<void>;
+    disconnect(): Promise<void>;
+    sampleLevel(): ReturnType<VoiceProviderClient['sampleLevel']>;
+    private waitForAgentReady;
+    private analyserFor;
+    private watchMicLevel;
+    private attachRemoteAudio;
+}
+export {};

package/dist/agent/voice/voice-session-client.d.ts

@@ -0,0 +1,44 @@
+import { Ref } from 'vue';
+import { CreateVoiceProviderClient, VoiceLevelEvent, VoiceSessionError } from './provider';
+import { SettingsObject } from '@pagelines/core';
+export type { VoiceLevelEvent, VoiceSessionError } from './provider';
+export { VOICE_SPECTRUM_BANDS, voiceSpectrum } from './provider';
+export type VoiceSessionClientState = 'idle' | 'minting' | 'connecting' | 'live' | 'ended';
+export type VoiceChimeKind = 'start' | 'end';
+export interface VoiceClientHandlers {
+    onStateChange?: (state: VoiceSessionClientState) => void;
+    onLevel?: (event: VoiceLevelEvent) => void;
+    onError?: (error: VoiceSessionError) => void;
+}
+export interface VoiceSessionClientSettings extends VoiceClientHandlers, Record<string, unknown> {
+    agentId: string;
+    orgId: string;
+    conversationId?: string;
+    apiBase?: string;
+    isDev?: boolean;
+    token?: string;
+    fetchFn?: typeof fetch;
+    /** Provider composition seam; the default dynamically loads the minted provider. */
+    createProvider?: CreateVoiceProviderClient;
+    playChime?: (kind: VoiceChimeKind) => void;
+}
+export declare function createBrowserVoiceChimePlayer(): (kind: VoiceChimeKind) => void;
+export declare class VoiceSessionClient extends SettingsObject<VoiceSessionClientSettings> {
+    readonly state: Ref<VoiceSessionClientState>;
+    private provider?;
+    private readonly chime;
+    private generation;
+    private levelTimer;
+    constructor(settings: VoiceSessionClientSettings);
+    start(): Promise<void>;
+    end(): void;
+    private connect;
+    private setState;
+    private fail;
+    private teardown;
+    private startLevelTimer;
+    private authHeaders;
+    private post;
+    private mintSession;
+    private toSessionError;
+}