@customer-agent/sdk 0.5.6-test.g260612164307

package/types/messages/en.json.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+  "add_emoji": "Add emoji",
+  "assistant_author_ai": "Agent",
+  "assistant_author_human": "Support",
+  "attachment_label": "Attach image, PDF, or MP4",
+  "close_chat": "Close chat",
+  "collapse_window": "Collapse window",
+  "download_transcript": "Download transcript",
+  "expand_window": "Expand window",
+  "input_placeholder": "Ask a question...",
+  "interview_input_placeholder": "Your answer...",
+  "interview_session_description": "Insights start here. We’re listening.",
+  "launcher_close": "Close {title}",
+  "launcher_open": "Open {title}",
+  "message_aria_label": "Message",
+  "more_options": "More options",
+  "relative_time_today": "Today",
+  "relative_time_yesterday": "Yesterday",
+  "relative_time_day": "{count} days ago",
+  "relative_time_hour": "{count}h ago",
+  "relative_time_minute": "{count}m ago",
+  "relative_time_now": "now",
+  "remove_attachment": "Remove {name}",
+  "send_message": "Send message",
+  "status_reply_time": "Agent is here. Our team is nearby.",
+  "support_chat_label": "{title} support chat",
+  "welcome_message": "Hi, I’m your support assistant. How can I help?"
+}
+;
+
+export default _default;

package/types/messages/index.d.ts

@@ -0,0 +1,53 @@
+import { ResolvedWidgetLocale } from '../sdk/i18n';
+import { CustomerAgentMemoryRoute } from '../sdk/navigationState';
+import { CustomerAgentInterviewState, CustomerAgentSupportState, CustomerAgentTarget } from '../sdk/public-types';
+import { WidgetOptions, WidgetViewport } from '../types';
+export declare const WIDGET_FRAME_ACTION_TYPE: Readonly<{
+    readonly EXPAND_CHANGE: "expand-change";
+    readonly MEMORY_ROUTE_CHANGE: "memory-route-change";
+    readonly OPEN_CHANGE: "open-change";
+}>;
+export declare const WIDGET_FRAME_MESSAGE_TYPE: Readonly<{
+    readonly ACTION: "customer-agent:frame-action";
+    readonly STATE: "customer-agent:frame-state";
+}>;
+export type WidgetSurface = "launcher" | "panel";
+export type WidgetFrameState = {
+    activeTarget?: CustomerAgentTarget;
+    bootOptions: Partial<WidgetOptions>;
+    isExpanded: boolean;
+    memoryRoute?: CustomerAgentMemoryRoute;
+    runtimeState?: {
+        interview: CustomerAgentInterviewState;
+        support: CustomerAgentSupportState;
+    };
+    locale: ResolvedWidgetLocale;
+    isOpen: boolean;
+    viewport: WidgetViewport;
+};
+export type WidgetFrameAction = {
+    open: boolean;
+    type: typeof WIDGET_FRAME_ACTION_TYPE.OPEN_CHANGE;
+} | {
+    expanded: boolean;
+    type: typeof WIDGET_FRAME_ACTION_TYPE.EXPAND_CHANGE;
+} | {
+    route: CustomerAgentMemoryRoute;
+    type: typeof WIDGET_FRAME_ACTION_TYPE.MEMORY_ROUTE_CHANGE;
+};
+export type WidgetFrameStateMessage = {
+    state: WidgetFrameState;
+    surface: WidgetSurface;
+    type: typeof WIDGET_FRAME_MESSAGE_TYPE.STATE;
+    widgetId: string;
+};
+export type WidgetFrameActionMessage = {
+    action: WidgetFrameAction;
+    surface: WidgetSurface;
+    type: typeof WIDGET_FRAME_MESSAGE_TYPE.ACTION;
+    widgetId: string;
+};
+export declare function createFrameStateMessage(widgetId: string, surface: WidgetSurface, state: WidgetFrameState): WidgetFrameStateMessage;
+export declare function createFrameActionMessage(widgetId: string, surface: WidgetSurface, action: WidgetFrameAction): WidgetFrameActionMessage;
+export declare function isFrameStateMessage(value: unknown): value is WidgetFrameStateMessage;
+export declare function isFrameActionMessage(value: unknown): value is WidgetFrameActionMessage;

package/types/runtime/interview/interviewApiClient.d.ts

@@ -0,0 +1,2 @@
+import { InterviewClient } from './interviewTypes';
+export declare function createInterviewRuntimeClient(): InterviewClient;

package/types/runtime/interview/interviewSessionCache.d.ts

@@ -0,0 +1,5 @@
+import { WidgetOptions } from '../../types';
+import { InterviewSessionCache } from './interviewTypes';
+export declare function getInterviewIdentityKey(options: WidgetOptions): string | null;
+export declare function getInterviewDiscoveryKey(options: WidgetOptions): string | null;
+export declare function createLocalStorageInterviewSessionCache(): InterviewSessionCache;

package/types/runtime/interview/interviewSessionService.d.ts

@@ -0,0 +1,93 @@
+import { ConversationContextPayload } from '../../sdk/conversation';
+import { WidgetOptions } from '../../types';
+import { CUSTOMER_AGENT_INTERVIEW_STATUS, INTERVIEW_SESSION_STATUS, CustomerAgentInterviewState, InterviewClient, InterviewInvitationChoice, InterviewSessionCache, InterviewSessionResponse } from './interviewTypes';
+export type InterviewAvailablePayload = Extract<CustomerAgentInterviewState, {
+    status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE;
+}>;
+export type InterviewSessionServiceDeps = {
+    api: InterviewClient;
+    buildContextPayload?: (options: WidgetOptions) => ConversationContextPayload;
+    cache: InterviewSessionCache;
+    emitAvailable(payload: InterviewAvailablePayload): void;
+    emitConversationCreated?(payload: InterviewConversationMeta): void;
+    emitSessionStarted?(payload: InterviewConversationMeta): void;
+    emitStateChanged(state: CustomerAgentInterviewState): void;
+    getOptions(): WidgetOptions;
+};
+export type InterviewConversationMeta = {
+    conversationId: string;
+    conversationType: "interview";
+    entryId: `interview/session/${string}`;
+    interviewSessionId: string;
+};
+export type InterviewSessionService = ReturnType<typeof createInterviewSessionService>;
+export declare function createInterviewSessionService({ api, buildContextPayload: buildPayload, cache, emitAvailable, emitConversationCreated, emitSessionStarted, emitStateChanged, getOptions }: InterviewSessionServiceDeps): {
+    chooseInvitation(id: string, choice: InterviewInvitationChoice): Promise<void>;
+    ensureInvitation(): Promise<string>;
+    getState(): {
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.CHECKING | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.ERROR | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.IDLE | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.UNAVAILABLE;
+        error?: {
+            message: string;
+        };
+    } | {
+        body: string;
+        campaignId: string;
+        laterCta: string;
+        startCta: string;
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE;
+        title: string;
+    } | {
+        sessionId: string;
+        sessionStatus: Exclude<import('./interviewTypes').InterviewStatus, typeof INTERVIEW_SESSION_STATUS.ACTIVE>;
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.TERMINAL;
+    } | {
+        title: string;
+        entryId: `interview/session/${string}`;
+        sessionId: string;
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.ACTIVE;
+    };
+    getActiveSession(): InterviewSessionResponse | null;
+    loadReward(sessionId?: string | undefined): Promise<unknown>;
+    syncAvailability: () => Promise<void>;
+    startInvitation(id: string): Promise<{
+        entryId: string;
+        session: InterviewSessionResponse;
+        sessionId: string;
+    }>;
+    sendMessage(content: string): Promise<void>;
+};
+export declare function createDefaultInterviewSessionService(deps: Omit<InterviewSessionServiceDeps, "buildContextPayload" | "cache">): {
+    chooseInvitation(id: string, choice: InterviewInvitationChoice): Promise<void>;
+    ensureInvitation(): Promise<string>;
+    getState(): {
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.CHECKING | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.ERROR | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.IDLE | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.UNAVAILABLE;
+        error?: {
+            message: string;
+        };
+    } | {
+        body: string;
+        campaignId: string;
+        laterCta: string;
+        startCta: string;
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE;
+        title: string;
+    } | {
+        sessionId: string;
+        sessionStatus: Exclude<import('./interviewTypes').InterviewStatus, typeof INTERVIEW_SESSION_STATUS.ACTIVE>;
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.TERMINAL;
+    } | {
+        title: string;
+        entryId: `interview/session/${string}`;
+        sessionId: string;
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.ACTIVE;
+    };
+    getActiveSession(): InterviewSessionResponse | null;
+    loadReward(sessionId?: string | undefined): Promise<unknown>;
+    syncAvailability: () => Promise<void>;
+    startInvitation(id: string): Promise<{
+        entryId: string;
+        session: InterviewSessionResponse;
+        sessionId: string;
+    }>;
+    sendMessage(content: string): Promise<void>;
+};

package/types/runtime/interview/interviewTypes.d.ts

@@ -0,0 +1,115 @@
+import { ConversationContextPayload } from '../../sdk/conversation';
+import { WidgetOptions } from '../../types';
+export declare const INTERVIEW_SESSION_STATUS: Readonly<{
+    ABANDONED: "abandoned";
+    ABORTED: "aborted";
+    ACTIVE: "active";
+    COMPLETED: "completed";
+    DISMISSED: "dismissed";
+}>;
+export type InterviewStatus = (typeof INTERVIEW_SESSION_STATUS)[keyof typeof INTERVIEW_SESSION_STATUS];
+export declare const CUSTOMER_AGENT_INTERVIEW_STATUS: Readonly<{
+    ACTIVE: "active";
+    AVAILABLE: "available";
+    CHECKING: "checking";
+    ERROR: "error";
+    IDLE: "idle";
+    TERMINAL: "terminal";
+    UNAVAILABLE: "unavailable";
+}>;
+export type CustomerAgentInterviewStatus = (typeof CUSTOMER_AGENT_INTERVIEW_STATUS)[keyof typeof CUSTOMER_AGENT_INTERVIEW_STATUS];
+export declare const INTERVIEW_INVITATION_ACTION: Readonly<{
+    CLOSE: "close";
+    LATER: "later";
+    START: "start";
+}>;
+export type InterviewInvitationAction = (typeof INTERVIEW_INVITATION_ACTION)[keyof typeof INTERVIEW_INVITATION_ACTION];
+export type InterviewInvitationChoice = Exclude<InterviewInvitationAction, typeof INTERVIEW_INVITATION_ACTION.START>;
+export type InterviewMessage = {
+    content: string;
+    createdAt: string;
+    id: string;
+    role: "assistant" | "user";
+};
+export type InterviewSessionResponse = {
+    messages: InterviewMessage[];
+    sessionId: string;
+    status: InterviewStatus;
+};
+export type InterviewInvitationCard = {
+    body: string;
+    laterCta: string;
+    startCta: string;
+    title: string;
+};
+export type InterviewEligibilityResponse = {
+    eligible: false;
+    status?: string;
+} | {
+    campaignId: string;
+    eligible: true;
+    invitation: InterviewInvitationCard;
+    showRequestId: string;
+    status?: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE | string;
+    variantKey?: string | null;
+};
+export type CustomerAgentInterviewState = {
+    status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.CHECKING | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.ERROR | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.IDLE | typeof CUSTOMER_AGENT_INTERVIEW_STATUS.UNAVAILABLE;
+    error?: {
+        message: string;
+    };
+} | {
+    body: string;
+    campaignId: string;
+    laterCta: string;
+    startCta: string;
+    status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE;
+    title: string;
+} | {
+    entryId: `interview/session/${string}`;
+    sessionId: string;
+    status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.ACTIVE;
+    title?: string;
+} | {
+    sessionId: string;
+    sessionStatus: Exclude<InterviewStatus, typeof INTERVIEW_SESSION_STATUS.ACTIVE>;
+    status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.TERMINAL;
+};
+export type CachedInterviewSession = {
+    entryId: string;
+    priority: number;
+    sessionId: string;
+    title: string;
+};
+export type InterviewSessionCache = {
+    clear(options: WidgetOptions): void;
+    read(options: WidgetOptions): CachedInterviewSession | null;
+    write(options: WidgetOptions, session: CachedInterviewSession): void;
+};
+export type InterviewRequestOptions = {
+    signal?: AbortSignal;
+};
+export type InterviewClient = {
+    checkEligibility(payload: Record<string, unknown>, options?: InterviewRequestOptions): Promise<InterviewEligibilityResponse>;
+    chooseInvitation(id: string, payload: {
+        choice: InterviewInvitationChoice;
+    }): Promise<void>;
+    createInvitation(payload: Record<string, unknown>): Promise<{
+        invitationId: string;
+    }>;
+    getReward(sessionId: string): Promise<unknown>;
+    getSession(sessionId: string, options?: InterviewRequestOptions): Promise<InterviewSessionResponse>;
+    sendMessage(sessionId: string, payload: {
+        clientMessageId: string;
+        content: string;
+        locale?: string;
+    }): Promise<{
+        assistantMessage: string;
+        completion?: {
+            reason: string;
+        };
+        duplicate?: true;
+        sessionStatus: InterviewStatus;
+    }>;
+    startInvitation(id: string, payload: ConversationContextPayload): Promise<InterviewSessionResponse>;
+};

package/types/runtime/support/supportApiClient.d.ts

@@ -0,0 +1,2 @@
+import { SupportApiClient } from './supportTypes';
+export declare function createSupportApiClient(apiOrigin: string): SupportApiClient;

package/types/runtime/support/supportSessionCache.d.ts

@@ -0,0 +1,4 @@
+import { WidgetOptions } from '../../types';
+import { SupportSessionCache } from './supportTypes';
+export declare function getSupportSessionKey(options: WidgetOptions): string;
+export declare function createLocalStorageSupportSessionCache(): SupportSessionCache;

package/types/runtime/support/supportSessionService.d.ts

@@ -0,0 +1,43 @@
+import { CustomerAgentApiMessage } from '../../sdk/apiClient';
+import { ConversationContextPayload } from '../../sdk/conversation';
+import { WidgetOptions } from '../../types';
+import { CustomerAgentSupportState, SupportApiClient, SupportSessionCache } from './supportTypes';
+export type SupportSessionServiceDeps = {
+    api: SupportApiClient;
+    buildContextPayload?: (options: WidgetOptions) => ConversationContextPayload;
+    cache: SupportSessionCache;
+    emitConversationCreated(conversationId: string): void;
+    emitStateChanged(state: CustomerAgentSupportState): void;
+    getOptions(): WidgetOptions;
+    onSessionReady?(options: WidgetOptions, session: {
+        conversationId: string;
+        messages: CustomerAgentApiMessage[];
+    }): void;
+};
+export type SupportSessionService = ReturnType<typeof createSupportSessionService>;
+export declare function createSupportSessionService({ api, buildContextPayload: buildPayload, cache, emitConversationCreated, emitStateChanged, getOptions, onSessionReady }: SupportSessionServiceDeps): {
+    ensureSession(): Promise<{
+        conversationId: string;
+        messages: CustomerAgentApiMessage[];
+    }>;
+    getState(): CustomerAgentSupportState;
+    getSessionSnapshot(): {
+        conversationId: string;
+        messages: CustomerAgentApiMessage[];
+    } | null;
+    invalidateSession(): void;
+    syncCachedSession(): Promise<void>;
+};
+export declare function createDefaultSupportSessionService(deps: Omit<SupportSessionServiceDeps, "buildContextPayload" | "cache">): {
+    ensureSession(): Promise<{
+        conversationId: string;
+        messages: CustomerAgentApiMessage[];
+    }>;
+    getState(): CustomerAgentSupportState;
+    getSessionSnapshot(): {
+        conversationId: string;
+        messages: CustomerAgentApiMessage[];
+    } | null;
+    invalidateSession(): void;
+    syncCachedSession(): Promise<void>;
+};

package/types/runtime/support/supportTypes.d.ts

@@ -0,0 +1,35 @@
+import { CustomerAgentApiMessage } from '../../sdk/apiClient';
+import { ConversationContextPayload } from '../../sdk/conversation';
+import { WidgetOptions } from '../../types';
+export declare const CUSTOMER_AGENT_SUPPORT_STATUS: Readonly<{
+    ERROR: "error";
+    IDLE: "idle";
+    READY: "ready";
+    REFRESHING: "refreshing";
+    STARTING: "starting";
+}>;
+export type CustomerAgentSupportStatus = (typeof CUSTOMER_AGENT_SUPPORT_STATUS)[keyof typeof CUSTOMER_AGENT_SUPPORT_STATUS];
+export type CustomerAgentSupportState = {
+    status: typeof CUSTOMER_AGENT_SUPPORT_STATUS.ERROR | typeof CUSTOMER_AGENT_SUPPORT_STATUS.IDLE | typeof CUSTOMER_AGENT_SUPPORT_STATUS.REFRESHING | typeof CUSTOMER_AGENT_SUPPORT_STATUS.STARTING;
+    error?: {
+        message: string;
+    };
+} | {
+    status: typeof CUSTOMER_AGENT_SUPPORT_STATUS.READY;
+    conversationId: string;
+};
+export type SupportSession = {
+    conversationId: string;
+    messages: CustomerAgentApiMessage[];
+};
+export type SupportApiClient = {
+    startSession(payload: ConversationContextPayload, conversationId: string | null): Promise<SupportSession>;
+    updateContext?(payload: ConversationContextPayload & {
+        conversationId: string;
+    }, conversationId: string): Promise<unknown>;
+};
+export type SupportSessionCache = {
+    clear(options: WidgetOptions): void;
+    read(options: WidgetOptions): string | null;
+    write(options: WidgetOptions, conversationId: string): void;
+};

package/types/sdk/apiClient.d.ts

@@ -0,0 +1,103 @@
+export type ApiSuccess<TData> = {
+    ok: true;
+    data: TData;
+    meta: {
+        requestId: string;
+        serverTime: string;
+        version: string;
+    };
+};
+export type ApiFailure = {
+    ok: false;
+    error: {
+        code: string;
+        details?: unknown;
+        message: string;
+    };
+    meta?: {
+        requestId: string;
+        serverTime: string;
+        version: string;
+    };
+};
+export type CustomerAgentApiMessage = {
+    id: string;
+    attachments?: CustomerAgentApiAttachment[];
+    assistantAuthor: "llm" | "human" | null;
+    role: "user" | "assistant";
+    content: string;
+    createdAt: string;
+};
+export type CustomerAgentApiAttachment = {
+    expiresAt?: string;
+    filename: string;
+    id: string;
+    mimeType: string;
+    sizeBytes: number;
+    url: string;
+};
+export type UploadAttachmentResponse = {
+    attachmentId: string;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    url: string;
+};
+export type StartSessionResponse = {
+    conversationId: string;
+    context: {
+        customerOrigin: string | null;
+        locale: string | null;
+        pagePath: string | null;
+        pageUrl: string | null;
+        visitorId: string | null;
+    };
+    messages: CustomerAgentApiMessage[];
+};
+export type SendMessageResponse = {
+    conversationId: string;
+    userMessage: CustomerAgentApiMessage;
+    assistantMessage: CustomerAgentApiMessage;
+    handoff: {
+        needed: boolean;
+        reason: string | null;
+        eventId: string | null;
+    };
+};
+export type UpdateContextResponse = {
+    conversationId: string;
+};
+export type PublicAppConfigResponse = {
+    appId: string;
+    branding: Record<string, unknown>;
+    businessHours: Record<string, unknown>;
+    supportEmail: string;
+    welcomeMessage: Record<string, string>;
+};
+type RequestOptions = {
+    body?: Record<string, unknown>;
+    conversationId?: string | null;
+    method?: "GET" | "PATCH" | "POST";
+    signal?: AbortSignal;
+};
+export declare class CustomerAgentApiError extends Error {
+    code: string;
+    requestId: string | null;
+    status: number;
+    constructor(message: string, options: {
+        code: string;
+        requestId?: string | null;
+        status: number;
+    });
+}
+export declare function createWidgetApiClient(apiBaseUrl: string): {
+    request: <TData>(path: string, options?: RequestOptions) => Promise<{
+        data: TData;
+        response: Response;
+    }>;
+    upload: <TData>(path: string, formData: FormData, options?: Pick<RequestOptions, "conversationId" | "signal">) => Promise<{
+        data: TData;
+        response: Response;
+    }>;
+};
+export {};

package/types/sdk/config.d.ts

@@ -0,0 +1,4 @@
+import { CustomerAgentOptions } from './public-types';
+export declare function createWidgetId(): string;
+export declare function resolveApiOrigin(): string;
+export declare function normalizeOptions(options: CustomerAgentOptions, widgetId: string): CurrentCustomerAgentOptions;

package/types/sdk/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const CUSTOMER_AGENT_EVENTS: Readonly<{
+    readonly BUG_REPORTED: "support.bug_reported";
+    readonly CONVERSATION_CREATED: "conversation.created";
+    readonly ERROR: "error";
+    readonly FEEDBACK_SUBMITTED: "support.feedback_submitted";
+    readonly HANDOFF_REQUESTED: "support.handoff_requested";
+    readonly INTERVIEW_INVITATION_CLOSED: "interview.invitation_closed";
+    readonly INTERVIEW_INVITATION_LATER: "interview.invitation_later";
+    readonly INTERVIEW_INVITATION_SHOWN: "interview.invitation_shown";
+    readonly INTERVIEW_AVAILABLE: "interview.available";
+    readonly INTERVIEW_REWARD_UPDATED: "interview.reward_updated";
+    readonly INTERVIEW_STATE_CHANGED: "interview.state_changed";
+    readonly INTERVIEW_SESSION_COMPLETED: "interview.session_completed";
+    readonly INTERVIEW_SESSION_STARTED: "interview.session_started";
+    readonly MESSAGE_COMPLETED: "message.completed";
+    readonly MESSAGE_FAILED: "message.failed";
+    readonly MESSAGE_RETRY: "message.retry";
+    readonly MESSAGE_SEND_FAILED: "message.send_failed";
+    readonly MESSAGE_SENT: "message.sent";
+    readonly MESSAGE_STARTED: "message.started";
+    readonly SUPPORT_STATE_CHANGED: "support.state_changed";
+    readonly TRANSCRIPT_DOWNLOADED: "transcript.downloaded";
+    readonly WIDGET_CLOSED: "widget.closed";
+    readonly WIDGET_COLLAPSED: "widget.collapsed";
+    readonly WIDGET_EXPANDED: "widget.expanded";
+    readonly WIDGET_OPENED: "widget.opened";
+    readonly WIDGET_READY: "widget.ready";
+}>;

package/types/sdk/controller.d.ts

@@ -0,0 +1,36 @@
+import { WidgetContextJson, WidgetUser } from '../types';
+import { CustomerAgentEventMap, CustomerAgentEventName } from './events';
+import { CustomerAgentGlobal, CustomerAgentInterviewInvitationChoice, CustomerAgentOptions, CustomerAgentTarget, CustomerAgentWidget, SetContextOptions } from './public-types';
+declare function boot(options: CustomerAgentOptions): CustomerAgentWidget;
+declare function ensureInvitation(): Promise<{
+    invitationId: string;
+} | null>;
+declare function startInvitation(invitationId: string): Promise<{
+    entryId: string;
+    sessionId: string;
+} | null>;
+declare function startInterview(): Promise<{
+    entryId: string;
+    sessionId: string;
+} | null>;
+declare function chooseInvitation(invitationId: string, choice: CustomerAgentInterviewInvitationChoice): Promise<void>;
+declare function sendInterviewMessage(content: string): Promise<void>;
+declare function loadInterviewReward(sessionId?: string): Promise<unknown>;
+declare function update(options: Partial<CustomerAgentOptions>): void;
+declare function show(target?: CustomerAgentTarget): void;
+declare function hide(): void;
+declare function toggle(target?: CustomerAgentTarget): void;
+declare function openEntry(entryId: string): void;
+declare function shutdown(): void;
+declare function identify(user: WidgetUser): void;
+declare function setContext(context: WidgetContextJson, options?: SetContextOptions): void;
+declare function getSession(): Promise<{
+    conversationId: string;
+} | null>;
+declare function getSupportState(): import('./public-types').CustomerAgentSupportState | null;
+declare function getInterviewState(): import('./public-types').CustomerAgentInterviewState | null;
+declare function getInterviewSession(): import('./public-types').CustomerAgentInterviewSession | null;
+declare function getState(): import('./public-types').CustomerAgentState | null;
+declare function on<TEventName extends CustomerAgentEventName>(eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void): () => void;
+export declare const CustomerAgent: CustomerAgentGlobal;
+export { boot, chooseInvitation, ensureInvitation, getInterviewState, getInterviewSession, getSession, getState, getSupportState, hide, identify, on, openEntry, loadInterviewReward, sendInterviewMessage, setContext, show, shutdown, startInterview, startInvitation, toggle, update };

package/types/sdk/conversation.d.ts

@@ -0,0 +1,56 @@
+import { ThreadMessageLike } from '@assistant-ui/react';
+import { WidgetOptions } from '../types';
+import { CustomerAgentApiAttachment, CustomerAgentApiMessage, SendMessageResponse, UpdateContextResponse } from './apiClient';
+export type ConversationContextPayload = {
+    appId: string;
+    customerOrigin?: string;
+    deviceInfo?: Record<string, unknown>;
+    locale?: string;
+    pagePath?: string;
+    pageUrl?: string;
+    userContext?: Record<string, unknown>;
+    visitorId?: string;
+    widgetId?: string;
+};
+export type CustomerAgentConversationSession = {
+    cacheKey: string;
+    conversationId: string;
+    messages: CustomerAgentApiMessage[];
+};
+type EnsureSessionOptions = {
+    onConversationCreated?(conversationId: string): void;
+    onSessionInvalidated?(conversationId: string): void;
+};
+export type UploadedWidgetAttachment = CustomerAgentApiAttachment;
+export declare class CustomerAgentSessionInvalidatedError extends Error {
+    readonly conversationId: string;
+    constructor(conversationId: string);
+}
+export declare function buildContextPayload(options: WidgetOptions): ConversationContextPayload;
+export declare function toThreadMessages(messages: readonly CustomerAgentApiMessage[]): ThreadMessageLike[];
+export declare function getLatestUserMessageText(messages: readonly {
+    content: readonly unknown[];
+    role: string;
+}[]): string;
+export declare class WidgetConversation {
+    private apiOrigin;
+    private client;
+    private lastContextFingerprint;
+    private session;
+    private sessionPromise;
+    private getClient;
+    clear(options: WidgetOptions): void;
+    hydrateSession(options: WidgetOptions, session: Pick<CustomerAgentConversationSession, "conversationId" | "messages">): void;
+    ensureSession(options: WidgetOptions, sessionOptions?: EnsureSessionOptions): Promise<CustomerAgentConversationSession>;
+    sendMessage(options: WidgetOptions, message: string, attachments: readonly {
+        id: string;
+    }[], signal: AbortSignal, sessionOptions?: EnsureSessionOptions): Promise<SendMessageResponse>;
+    refreshSession(options: WidgetOptions, signal?: AbortSignal): Promise<CustomerAgentConversationSession | null>;
+    updateContext(options: WidgetOptions): Promise<UpdateContextResponse | null>;
+    uploadAttachment(options: WidgetOptions, file: File, sessionOptions?: EnsureSessionOptions): Promise<UploadedWidgetAttachment>;
+    private startSession;
+    private postMessage;
+    private getHydratedSession;
+}
+export declare const widgetConversation: WidgetConversation;
+export {};