guideai-app 0.5.4-2 → 0.5.4-3

package/dist/devtools/useDraggableDialog.d.ts

@@ -7,14 +7,21 @@ interface UseDraggableDialogParams {
     initialPosition: () => DraggableDialogPosition;
     minVisibleWidth: number;
     minVisibleHeight: number;
+    /** When set, used during drag instead of minVisibleWidth/Height (e.g. measured panel size). */
+    clampSize?: () => {
+        width: number;
+        height: number;
+    };
     ignoreSelector?: string;
+    /** Called when the user finishes a drag (pointer up) with the settled position. */
+    onPositionSettled?: (position: DraggableDialogPosition) => void;
     /**
      * Host dialog handles drag/position; keep hook API stable with a fixed `{0,0}` position
      * and inert drag handlers (e.g. panels nested in {@link DeveloperToolsShell}).
      */
     embedded?: boolean;
 }
-export declare function useDraggableDialog(React: typeof import('react'), { initialPosition, minVisibleWidth, minVisibleHeight, ignoreSelector, embedded, }: UseDraggableDialogParams): {
+export declare function useDraggableDialog(React: typeof import('react'), { initialPosition, minVisibleWidth, minVisibleHeight, clampSize, ignoreSelector, onPositionSettled, embedded, }: UseDraggableDialogParams): {
     position: DraggableDialogPosition;
     setPosition: import("react").Dispatch<import("react").SetStateAction<DraggableDialogPosition>>;
     dialogRef: import("react").MutableRefObject<HTMLDivElement | null>;

package/dist/devtools/useGuideDeveloperTools.d.ts

@@ -13,17 +13,16 @@ import type { AudioConfig, StoredAudioConfig } from '../types/audioConfig.types'
 import type { StubWorkflowItem } from '../stubs/workspaces';
 import type { UseVisualContextReturn } from '../visualContext/useVisualContext';
 import type { InterruptLockOverlayConfig } from '../hooks/useProtectedPlayback';
-export type GuideDeveloperToolsTranscriptMenu = {
-    shellOpen: boolean;
-    onToggleShell: () => void;
-} | null;
+import type { LearnModePanelProps } from './learn/LearnModePanel';
+import { type DeveloperToolPanelId } from './developerToolPanelId';
+import type { DeveloperToolsShellControl } from './transcriptDevtoolsMenuProps';
 export interface UseGuideDeveloperToolsParams {
     hooks: ReactHooks;
     React: typeof import('react');
     ReactDOM?: {
         createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
     };
-    debugMoreMenu: boolean;
+    developerToolsSectionVisible: boolean;
     visualContextEnabled: boolean;
     visualContext: UseVisualContextReturn;
     getDataChannelManager: () => DataChannelManager | null;
@@ -47,9 +46,19 @@ export interface UseGuideDeveloperToolsParams {
     conversationIdRef: MutableRefObject<string | null>;
     getConversationManager: () => ConversationManager | null;
     queueWorkflowSteerTitle?: (title: string) => void;
+    isDataChannelReady?: () => boolean;
+    ensureRealtimeSession?: () => Promise<boolean>;
+    syncTranscriptFromStorage?: () => void;
+    learn: LearnModePanelProps;
+    /** First time the Learn tab is selected (lazy-load Learn orchestration). */
+    onLearnTabActivate?: () => void;
 }
 export interface UseGuideDeveloperToolsResult {
-    transcriptDeveloperToolsMenu: GuideDeveloperToolsTranscriptMenu;
+    developerToolsShellControl: DeveloperToolsShellControl;
     developerToolsPanel: React.ReactNode;
+    /** Open the devtools shell and switch to the given tab (e.g. Learn after clarifying). */
+    openShellOnTab: (tab: DeveloperToolPanelId) => void;
+    /** Close the floating developer-tools shell (e.g. when entering learn focus mode). */
+    closeShell: () => void;
 }
-export declare function useGuideDeveloperTools({ hooks, React, ReactDOM, debugMoreMenu, visualContextEnabled, visualContext, getDataChannelManager, propToolNames, zIndexDevTools, micPreset, protectedPlaybackActive, overlayConfig, playbackInterruptDebug, hasRespondedWithAudio, defaultMicLabel, handleApplyAudioConfig, logMicPresetToServer, handleTextSubmit, isConversationActive, isDataChannelOpen, isResponseActive, allMessages, workspaceWorkflows, sessionWorkflowIdForInitRef, conversationIdRef, getConversationManager, queueWorkflowSteerTitle, }: UseGuideDeveloperToolsParams): UseGuideDeveloperToolsResult;
+export declare function useGuideDeveloperTools({ hooks, React, ReactDOM, developerToolsSectionVisible, visualContextEnabled, visualContext, getDataChannelManager, propToolNames, zIndexDevTools, micPreset, protectedPlaybackActive, overlayConfig, playbackInterruptDebug, hasRespondedWithAudio, defaultMicLabel, handleApplyAudioConfig, logMicPresetToServer, handleTextSubmit, isConversationActive, isDataChannelOpen, isResponseActive, allMessages, workspaceWorkflows, sessionWorkflowIdForInitRef, conversationIdRef, getConversationManager, queueWorkflowSteerTitle, isDataChannelReady, ensureRealtimeSession, syncTranscriptFromStorage, learn, onLearnTabActivate, }: UseGuideDeveloperToolsParams): UseGuideDeveloperToolsResult;

package/dist/devtools/useGuideDevtoolsIntegration.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import type { MutableRefObject } from 'react';
+import type { ZIndexConfig } from '../styles/GuideAI.styles.types';
+import type { ReactHooks } from '../utils/reactHooks';
+import type { GuideAIEnvironment } from '../types/GuideAI.types';
+import { type UseGuideDeveloperToolsParams } from './useGuideDeveloperTools';
+import type { ExtensionPortalAuthProp } from './devtoolsAuth/types';
+import type { TranscriptDevtoolsMenuProps } from './transcriptDevtoolsMenuProps';
+import type { RecordingStatus } from '../types/GuideAI.types';
+import type { StubWorkspaceOption } from '../stubs/workspaces';
+export type GuideDevtoolsShellParams = Omit<UseGuideDeveloperToolsParams, 'hooks' | 'React' | 'ReactDOM' | 'developerToolsSectionVisible' | 'zIndexDevTools' | 'learn'> & {
+    conversationKey: string;
+    /** Same path as transcript ⋯ → Reset chat (no confirm). */
+    performResetChat: () => void | Promise<void>;
+    transcriptSessionMode: string;
+    workspaceOptions: StubWorkspaceOption[];
+    widgetAuthWorkspace?: string;
+    hasInitializedRef: MutableRefObject<boolean>;
+    startConversationSession: () => Promise<boolean>;
+    setStatus: (status: RecordingStatus) => void;
+    setIsConversationActive: (active: boolean) => void;
+    onLearnFocusEnter?: () => void;
+    onLearnFocusExit?: () => void;
+};
+export type UseGuideDevtoolsIntegrationParams = {
+    hooks: ReactHooks;
+    React: typeof import('react');
+    ReactDOM?: UseGuideDeveloperToolsParams['ReactDOM'];
+    environment?: GuideAIEnvironment;
+    extensionPortalAuth?: ExtensionPortalAuthProp;
+    zIndexConfig: ZIndexConfig;
+    shell: GuideDevtoolsShellParams;
+    cleanupWebRTC: () => void;
+    handleToggleMute: () => void;
+    applyMicMuted: (muted: boolean) => void;
+    isMuted: boolean;
+    isAssistantPlaybackMuted: boolean;
+    handleToggleAssistantPlaybackMute: () => void;
+    recordingStatus: RecordingStatus;
+    isConnecting: boolean;
+    connectionMessage?: string | null;
+    hasMic: boolean;
+    /** Mic + transcript; hidden during learn focus. Receives transcript ⋯ menu props from integration. */
+    renderStandardEmbed: (transcriptDevtools: TranscriptDevtoolsMenuProps) => React.ReactNode;
+};
+export type UseGuideDevtoolsIntegrationResult = {
+    transcriptDevtools: TranscriptDevtoolsMenuProps;
+    embedChrome: React.ReactNode;
+};
+/** GuideAI entry: auth gate, developer tools shell, login modal, and transcript ⋯ menu wiring. */
+export declare function useGuideDevtoolsIntegration({ hooks, React, ReactDOM, environment, extensionPortalAuth, zIndexConfig, shell, cleanupWebRTC, handleToggleMute, applyMicMuted, isMuted, isAssistantPlaybackMuted, handleToggleAssistantPlaybackMute, recordingStatus, isConnecting, connectionMessage, hasMic, renderStandardEmbed, }: UseGuideDevtoolsIntegrationParams): UseGuideDevtoolsIntegrationResult;

package/dist/devtools/workflowTester/WorkflowTesterPanel.d.ts

@@ -5,32 +5,8 @@
  *
  * Visual structure matches {@link AdminToolDiagnosticsPanel} (`guideai-atd-*` classes).
  */
-import React, { type MutableRefObject } from 'react';
-import type { StubWorkflowItem } from '../../stubs/workspaces';
-import type { StoredMessage } from '../../utils/messageStorage';
-import type { WorkflowTesterSessionLogdata } from '../../utils/conversationManager';
-export interface WorkflowTesterPanelProps {
-    zIndex: number;
-    visible: boolean;
-    onClose: () => void;
-    /** Same callback the transcript text input uses; gates on `isConversationActive` internally. */
-    handleTextSubmit: (text: string) => void | Promise<void>;
-    isConversationActive: boolean;
-    isDataChannelOpen: boolean;
-    isResponseActive: boolean;
-    allMessages: StoredMessage[];
-    ReactDOM?: {
-        createPortal?: (children: React.ReactNode, c: Element) => React.ReactNode;
-    };
-    /** Workflows for the active transcript workspace (used to pick the steer label for the session workflow id). */
-    workspaceWorkflows: StubWorkflowItem[];
-    /** Same ref as transcript chrome: focused workflow id for `/initialize`. */
-    sessionWorkflowIdForInitRef: MutableRefObject<string | null>;
-    getServerConversationId?: () => string | null;
-    /** Admin messages API markers (not transcript storage) when a server conversation exists. */
-    logWorkflowTesterSessionMarker?: (logdata: WorkflowTesterSessionLogdata) => void | Promise<void>;
-    /** Nested in {@link DeveloperToolsShell}: no portal, no floating title bar. */
-    embedded?: boolean;
-}
-declare const WorkflowTesterPanel: ({ zIndex, visible, onClose, handleTextSubmit, isConversationActive, isDataChannelOpen, isResponseActive, allMessages, ReactDOM, workspaceWorkflows, sessionWorkflowIdForInitRef, getServerConversationId, logWorkflowTesterSessionMarker, embedded, }: WorkflowTesterPanelProps) => string | number | boolean | React.JSX.Element | Iterable<React.ReactNode> | null | undefined;
+import React from 'react';
+import type { WorkflowTesterPanelProps } from './workflowTesterPanel.types';
+export type { WorkflowTesterPanelProps } from './workflowTesterPanel.types';
+declare const WorkflowTesterPanel: ({ zIndex, visible, onClose, handleTextSubmit, isConversationActive, isDataChannelOpen, isResponseActive, allMessages, ReactDOM, workspaceWorkflows, sessionWorkflowIdForInitRef, getServerConversationId, logWorkflowTesterSessionMarker, isDataChannelReady, ensureRealtimeSession, syncTranscriptFromStorage, embedded, }: WorkflowTesterPanelProps) => string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
 export default WorkflowTesterPanel;

package/dist/devtools/workflowTester/WorkflowTesterPanel.stub.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowTesterPanelProps } from './workflowTesterPanel.types';
+/** Production strip build: workflow tester UI omitted from the bundle. */
+export default function WorkflowTesterPanelStub(_props: WorkflowTesterPanelProps): null;

package/dist/devtools/workflowTester/index.d.ts

@@ -3,5 +3,4 @@
  * Colocated under `devtools/` so a production-only build can drop this folder,
  * the `WorkflowTesterPanel` import in `DeveloperTools.tsx`, and related props from `GuideAI.tsx`.
  */
-export { default } from './WorkflowTesterPanel';
-export type { WorkflowTesterPanelProps } from './WorkflowTesterPanel';
+export type { WorkflowTesterPanelProps } from './workflowTesterPanel.types';

package/dist/devtools/workflowTester/useWorkflowSimulationController.d.ts

@@ -0,0 +1,12 @@
+import type { ReactHooks } from '../../utils/reactHooks';
+import { type WorkflowSimulationControllerHost } from './workflowSimulationController';
+export type UseWorkflowSimulationControllerParams = WorkflowSimulationControllerHost & {
+    hooks: ReactHooks;
+};
+export type UseWorkflowSimulationControllerResult = {
+    isDataChannelReady: () => boolean;
+    ensureRealtimeSession: () => Promise<boolean>;
+    shouldSkipConversationAutoRestore: () => boolean;
+    shouldKeepTranscriptOnInitFailure: () => boolean;
+};
+export declare function useWorkflowSimulationController({ hooks, ...host }: UseWorkflowSimulationControllerParams): UseWorkflowSimulationControllerResult;

package/dist/devtools/workflowTester/useWorkflowSimulationRun.d.ts

@@ -0,0 +1,47 @@
+import type { MutableRefObject } from 'react';
+import type { StoredMessage } from '../../utils/messageStorage';
+import type { WorkflowTesterSessionLogdata } from '../../utils/conversationManager';
+import type { StubWorkflowItem } from '../../stubs/workspaces';
+import { type PendingWorkflowTesterRun } from './workflowTesterRunSessionStorage';
+import { type TesterStatus, type WorkflowSimulationType } from './workflowSimulationTypes';
+export type UseWorkflowSimulationRunParams = {
+    visible: boolean;
+    portalToken: string | null;
+    answersText: string;
+    simulationType: WorkflowSimulationType;
+    maxRounds: number | null;
+    selectedSimulationId: string | null;
+    targetWorkflowId: string | null;
+    workspaceWorkflows: StubWorkflowItem[];
+    sessionWorkflowIdForInitRef: MutableRefObject<string | null>;
+    allMessages: StoredMessage[];
+    isConversationActive: boolean;
+    isDataChannelOpen: boolean;
+    isResponseActive: boolean;
+    handleTextSubmit: (text: string) => void | Promise<void>;
+    isDataChannelReady?: () => boolean;
+    ensureRealtimeSession?: () => Promise<boolean>;
+    syncTranscriptFromStorage?: () => void;
+    getServerConversationId?: () => string | null;
+    logWorkflowTesterSessionMarker?: (logdata: WorkflowTesterSessionLogdata) => void | Promise<void>;
+};
+export declare function useWorkflowSimulationRun({ visible, portalToken, answersText, simulationType, maxRounds, selectedSimulationId, targetWorkflowId, workspaceWorkflows, sessionWorkflowIdForInitRef, allMessages, isConversationActive, isDataChannelOpen, isResponseActive, handleTextSubmit, isDataChannelReady, ensureRealtimeSession, syncTranscriptFromStorage, getServerConversationId, logWorkflowTesterSessionMarker, }: UseWorkflowSimulationRunParams): {
+    status: TesterStatus;
+    statusLabel: Record<TesterStatus, string>;
+    errorMessage: string | null;
+    setErrorMessage: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    queueIndex: number;
+    queueTotal: number;
+    lastRunOutcome: string | null;
+    isRunning: boolean;
+    isAiPaused: boolean;
+    onWorkflowTesterStartStop: () => void;
+    stopWorkflowTester: () => void;
+    endWorkflowTester: () => Promise<void>;
+    resetRunFeedback: () => void;
+    prepareResumeFromPending: (pending: PendingWorkflowTesterRun) => void;
+    runWorkflowTester: (resume?: PendingWorkflowTesterRun) => Promise<void>;
+    stopRequestedRef: MutableRefObject<boolean>;
+    lastResumedRunIdRef: MutableRefObject<string | null>;
+    clearPendingOnPanelClose: () => void;
+};

package/dist/devtools/workflowTester/workflowSimulationController.d.ts

@@ -0,0 +1,31 @@
+import type { MutableRefObject } from 'react';
+import type { DataChannelManager } from '../../utils/dataChannel';
+export type WorkflowSimulationControllerHost = {
+    conversationKey: string;
+    hasInitializedRef: MutableRefObject<boolean>;
+    isConversationActiveRef: MutableRefObject<boolean>;
+    hasAttemptedAutoStartRef: MutableRefObject<boolean>;
+    dataChannelManagerRef: MutableRefObject<DataChannelManager | null>;
+    toggleConversation: (force?: boolean) => Promise<void>;
+    syncMessagesFromStorage: () => void;
+    setShowTranscript: (show: boolean) => void;
+    setShowTextInput: (show: boolean) => void;
+    setIsResponseActive: (active: boolean) => void;
+    transcriptUiEnabled: boolean;
+    textInputUiEnabled: boolean;
+};
+/** Owns simulation session restore, deduping, and hot-path active checks for GuideAI. */
+export declare class WorkflowSimulationController {
+    private getHost;
+    private sessionRestoreInFlight;
+    private pendingRestoreAttempted;
+    constructor(getHost: () => WorkflowSimulationControllerHost);
+    private host;
+    shouldSkipConversationAutoRestore(): boolean;
+    shouldKeepTranscriptOnInitFailure(): boolean;
+    isDataChannelReady(): boolean;
+    resetPendingRestoreForConversationKey(): void;
+    /** Call once after widget init when a pending simulation run exists in sessionStorage. */
+    maybeRestoreSessionOnMount(): void;
+    ensureRealtimeSession(): Promise<boolean>;
+}

package/dist/devtools/workflowTester/workflowSimulationDevtoolsApi.d.ts

@@ -0,0 +1,51 @@
+import type { GuideAIEnvironment } from '../../types/GuideAI.types';
+import type { WorkflowSimulationType } from './workflowSimulationTypes';
+export type WorkflowSimulationListItem = {
+    id: string;
+    title: string;
+    simulationType: WorkflowSimulationType;
+    body: string;
+    passCriteria: string;
+    maxRounds: number | null;
+    sortOrder: number;
+};
+export declare function fetchWorkflowSimulationsForDevtools(workflowId: string, token: string, environment?: GuideAIEnvironment): Promise<WorkflowSimulationListItem[]>;
+export type GenerateWorkflowSimulationBodyForDevtoolsOptions = {
+    /** Optional scenario override (default: customer completes the RAW workflow). */
+    instructions?: string;
+    simulationType?: WorkflowSimulationType;
+    environment?: GuideAIEnvironment;
+};
+/** Generate simulation body for one RAW workflow from its prompt (server / Gemini). */
+export declare function generateWorkflowSimulationBodyForDevtools(workflowId: string, token: string, options?: GenerateWorkflowSimulationBodyForDevtoolsOptions): Promise<string>;
+export declare function generateWorkflowSimulationTurnForDevtools(workflowId: string, token: string, payload: {
+    instructions: string;
+    messages: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>;
+}, environment?: GuideAIEnvironment): Promise<{
+    message: string;
+    shouldStop: boolean;
+}>;
+export declare function saveWorkflowSimulationForDevtools(workflowId: string, token: string, payload: {
+    id?: string;
+    title: string;
+    simulationType?: WorkflowSimulationType;
+    body: string;
+    passCriteria: string;
+    maxRounds?: number | null;
+}, environment?: GuideAIEnvironment): Promise<WorkflowSimulationListItem>;
+export type FinishSimulationRunResult = {
+    workflowId: string;
+    assessedOutcome: 'pass' | 'fail';
+    judgeSummary: string | null;
+    mechanicalStatus: string;
+};
+export declare function finishWorkflowSimulationRunForDevtools(workflowId: string, token: string, payload: {
+    simulationId: string;
+    conversationId: string;
+    runId: string;
+    mechanicalStatus: 'finished' | 'stopped' | 'error';
+    failureReason?: string | null;
+}, environment?: GuideAIEnvironment): Promise<FinishSimulationRunResult>;

package/dist/devtools/workflowTester/workflowSimulationRunner.d.ts

@@ -0,0 +1,46 @@
+import type { MutableRefObject } from 'react';
+import type { WorkflowTesterSessionLogdata } from '../../utils/conversationManager';
+import type { StubWorkflowItem } from '../../stubs/workspaces';
+import { type PendingWorkflowTesterRun } from './workflowTesterRunSessionStorage';
+import { type TesterStatus, type WorkflowSimulationType } from './workflowSimulationTypes';
+import type { WorkflowSimulationWaits } from './workflowSimulationWaits';
+export type WorkflowSimulationRunnerCallbacks = {
+    onStatus: (status: TesterStatus) => void;
+    onError: (message: string | null) => void;
+    onQueueProgress: (index: number, total: number) => void;
+    onLastRunOutcome: (message: string | null) => void;
+};
+export type WorkflowSimulationRunnerParams = {
+    resume?: PendingWorkflowTesterRun;
+    simulationType?: WorkflowSimulationType;
+    answersText: string;
+    /** AI simulations: customer actor instructions (body field). */
+    instructionsText?: string;
+    maxRounds?: number | null;
+    selectedSimulationId: string | null;
+    targetWorkflowId: string | null;
+    workspaceWorkflows: StubWorkflowItem[];
+    sessionWorkflowIdForInitRef: MutableRefObject<string | null>;
+    portalToken: string | null;
+    stopRequested: () => boolean;
+    runningRef: {
+        current: boolean;
+    };
+    lastResumedRunIdRef: {
+        current: string | null;
+    };
+    getMessages: () => import('../../utils/messageStorage').StoredMessage[];
+    isResponseActive: () => boolean;
+    isConversationActive: () => boolean;
+    isDataChannelOpen: () => boolean;
+    isDataChannelReady?: () => boolean;
+    handleTextSubmit: (text: string) => void | Promise<void>;
+    ensureRealtimeSession?: () => Promise<boolean>;
+    syncTranscriptFromStorage?: () => void;
+    getServerConversationId?: () => string | null;
+    enqueueWorkflowSteer: (label: string) => void;
+    logWorkflowTesterSessionMarker?: (logdata: WorkflowTesterSessionLogdata) => void | Promise<void>;
+    callbacks: WorkflowSimulationRunnerCallbacks;
+    waits: WorkflowSimulationWaits;
+};
+export declare function runWorkflowSimulation(params: WorkflowSimulationRunnerParams): Promise<void>;

package/dist/devtools/workflowTester/workflowSimulationRunnerAi.d.ts

@@ -0,0 +1,20 @@
+import type { WorkflowSimulationRunnerParams } from './workflowSimulationRunner';
+import { type PendingWorkflowTesterRun } from './workflowTesterRunSessionStorage';
+import type { WorkflowSimulationRunnerCallbacks } from './workflowSimulationRunner';
+export type EndAiWorkflowSimulationRunParams = {
+    pending: PendingWorkflowTesterRun;
+    portalToken: string;
+    getServerConversationId?: () => string | null;
+    logWorkflowTesterSessionMarker?: WorkflowSimulationRunnerParams['logWorkflowTesterSessionMarker'];
+    callbacks: Pick<WorkflowSimulationRunnerCallbacks, 'onStatus' | 'onLastRunOutcome' | 'onError'>;
+    lastResumedRunIdRef?: {
+        current: string | null;
+    };
+};
+/** Finalize a paused AI run: audit/judge when possible, then clear resumable pending state. */
+export declare function endAiWorkflowSimulationRun(params: EndAiWorkflowSimulationRunParams): Promise<void>;
+export type AiWorkflowSimulationRunnerParams = WorkflowSimulationRunnerParams & {
+    instructionsText: string;
+    maxRounds: number | null;
+};
+export declare function runAiWorkflowSimulation(params: AiWorkflowSimulationRunnerParams): Promise<void>;

package/dist/devtools/workflowTester/workflowSimulationSessionRestore.d.ts

@@ -0,0 +1,21 @@
+export type RestoreWidgetRealtimeSessionParams = {
+    conversationKey: string;
+    hasInitialized: () => boolean;
+    isConversationActive: () => boolean;
+    isDataChannelOpen: () => boolean;
+    transcriptUiEnabled: boolean;
+    textInputUiEnabled: boolean;
+    hasAttemptedAutoStart: {
+        current: boolean;
+    };
+    syncMessagesFromStorage: () => void;
+    toggleConversation: (force?: boolean) => Promise<void>;
+    setShowTranscript: (show: boolean) => void;
+    setShowTextInput: (show: boolean) => void;
+    setIsResponseActive: (active: boolean) => void;
+};
+/**
+ * Reconnect WebRTC after a mid-simulation page refresh (admin workflow tester only).
+ * Dedupes concurrent callers via {@link WorkflowSimulationController}.
+ */
+export declare function restoreWidgetRealtimeSession(params: RestoreWidgetRealtimeSessionParams): Promise<boolean>;

package/dist/devtools/workflowTester/workflowSimulationTurnState.d.ts

@@ -0,0 +1,20 @@
+import type { StoredMessage } from '../../utils/messageStorage';
+import type { StubWorkflowItem } from '../../stubs/workspaces';
+export declare function parseSimulationAnswers(raw: string): string[];
+export declare function newWorkflowSimulationRunId(): string;
+export declare function resolveWorkflowStepLabelForSteer(workflows: StubWorkflowItem[], sessionWorkflowId: string | null): string | null;
+export type AnswerTurnState = {
+    status: 'not_started';
+} | {
+    status: 'awaiting_assistant';
+    humanTimestamp: number;
+} | {
+    status: 'complete';
+};
+export declare function getAnswerTurnState(messages: StoredMessage[], answer: string, startedAt: number): AnswerTurnState;
+export declare function findHumanAnswerMessage(messages: StoredMessage[], answer: string, startedAt: number): StoredMessage | null;
+export declare function formatMessagesForAiCustomerTurn(messages: StoredMessage[], startedAt: number): Array<{
+    role: 'user' | 'assistant';
+    content: string;
+}>;
+export declare function lastVisibleTranscriptMessage(messages: StoredMessage[] | undefined): StoredMessage | null;

package/dist/devtools/workflowTester/workflowSimulationTypes.d.ts

@@ -0,0 +1,26 @@
+export type WorkflowSimulationType = 'SCRIPTED' | 'AI';
+/** Default pass criteria for new AI simulations (custom tester + save draft). */
+export declare const DEFAULT_WORKFLOW_SIMULATION_PASS_CRITERIA = "Evaluate the outcome of the interaction to determine whether the simulation succeeded or failed.";
+/** Default scripted body: one cooperative customer line per assistant turn. */
+export declare const DEFAULT_SCRIPTED_SIMULATION_BODY: string;
+/** Default AI customer-actor instructions for custom/new simulations. */
+export declare const DEFAULT_AI_SIMULATION_INSTRUCTIONS: string;
+/** Placeholder hint for scripted body fields (not pre-filled). */
+export declare const SCRIPTED_SIMULATION_BODY_PLACEHOLDER = "Hi \u2014 I'd like help with this.\nYes, please walk me through the steps.\nHere is the info you asked for.";
+/** Placeholder hint for AI instruction fields (not pre-filled). */
+export declare const AI_SIMULATION_INSTRUCTIONS_PLACEHOLDER = "Cooperative customer who completes the workflow. Use a frustrated tone on step 2 but still finish.";
+export declare function defaultSimulationBodyForType(simulationType: WorkflowSimulationType): string;
+/** Short label for the workflow tester Type column. */
+export declare function workflowSimulationTypeDisplayLabel(simulationType: WorkflowSimulationType): string;
+/** Short labels for the custom-mode Type dropdown. */
+export declare function workflowSimulationTypePickerLabel(simulationType: WorkflowSimulationType): string;
+/** Saved simulation option label in the picker (`(ai)` suffix for AI sims). */
+export declare function workflowSimulationPickerOptionLabel(title: string, simulationType: WorkflowSimulationType): string;
+export type TesterStatus = 'idle' | 'starting-workflow' | 'waiting-for-conversation' | 'sending' | 'awaiting-response' | 'generating-customer' | 'finished' | 'error' | 'stopped';
+export declare const TESTER_STATUS_LABEL: Record<TesterStatus, string>;
+export declare const ASSISTANT_RESPONSE_TIMEOUT_MS = 60000;
+export declare const POST_RESPONSE_PAUSE_MS = 400;
+export declare const STEER_QUEUE_YIELD_MS = 50;
+export declare const DATA_CHANNEL_POLL_MS = 100;
+export declare const CONDITION_POLL_MS = 200;
+export declare const TESTER_WAIT_FAILSAFE_MS = 120000;

package/dist/devtools/workflowTester/workflowSimulationWaits.d.ts

@@ -0,0 +1,55 @@
+import type { StoredMessage } from '../../utils/messageStorage';
+import { type TesterStatus } from './workflowSimulationTypes';
+export type WorkflowSimulationWaitsDeps = {
+    stopRequested: () => boolean;
+    getMessages: () => StoredMessage[];
+    isResponseActive: () => boolean;
+    isDataChannelOpen: () => boolean;
+    isDataChannelReady?: () => boolean;
+    syncTranscriptFromStorage?: () => void;
+    onStatus: (status: TesterStatus) => void;
+};
+export type WorkflowSimulationWaits = ReturnType<typeof createWorkflowSimulationWaits>;
+export declare function createWorkflowSimulationWaits(deps: WorkflowSimulationWaitsDeps): {
+    waitForCondition: (predicate: () => boolean, timeoutMs: number, pollMs?: number) => Promise<boolean>;
+    channelIsReady: () => boolean;
+    waitForSteerResponseCycle: () => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+    waitForTranscriptRestored: () => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+    waitForTesterChannelReady: (options?: {
+        skipResponseIdle?: boolean;
+    }) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+    waitForAssistantAfterHuman: (humanTimestamp: number) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+    waitForAssistantSettled: (humanTimestamp: number) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+    waitForUserAnswerInTranscript: (answer: string, startedAt: number) => Promise<{
+        ok: true;
+        human: StoredMessage;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+};

package/dist/devtools/workflowTester/workflowTesterPanel.types.d.ts

@@ -0,0 +1,25 @@
+import type { MutableRefObject } from 'react';
+import type { StoredMessage } from '../../utils/messageStorage';
+import type { WorkflowTesterSessionLogdata } from '../../utils/conversationManager';
+import type { StubWorkflowItem } from '../../stubs/workspaces';
+export interface WorkflowTesterPanelProps {
+    zIndex: number;
+    visible: boolean;
+    onClose: () => void;
+    handleTextSubmit: (text: string) => void | Promise<void>;
+    isConversationActive: boolean;
+    isDataChannelOpen: boolean;
+    isResponseActive: boolean;
+    allMessages: StoredMessage[];
+    ReactDOM?: {
+        createPortal?: (children: React.ReactNode, c: Element) => React.ReactNode;
+    };
+    workspaceWorkflows: StubWorkflowItem[];
+    sessionWorkflowIdForInitRef: MutableRefObject<string | null>;
+    getServerConversationId?: () => string | null;
+    logWorkflowTesterSessionMarker?: (logdata: WorkflowTesterSessionLogdata) => void | Promise<void>;
+    isDataChannelReady?: () => boolean;
+    ensureRealtimeSession?: () => Promise<boolean>;
+    syncTranscriptFromStorage?: () => void;
+    embedded?: boolean;
+}

package/dist/devtools/workflowTester/workflowTesterRunSessionStorage.d.ts

@@ -0,0 +1,43 @@
+import type { DeveloperToolPanelId } from '../developerToolPanelId';
+import type { WorkflowSimulationType } from './workflowSimulationTypes';
+export type PendingWorkflowTesterRun = {
+    runId: string;
+    workflowId: string;
+    simulationId: string | null;
+    simulationType?: WorkflowSimulationType;
+    /** SCRIPTED: full answer queue (parsed lines). */
+    answersQueue?: string[];
+    /** SCRIPTED: index of the next line to send (0-based). */
+    queueIndex?: number;
+    /** AI: customer actor instructions. */
+    instructions?: string;
+    /** AI: completed user+assistant rounds. */
+    roundIndex?: number;
+    /** AI: optional cap (null/undefined = indefinite). */
+    maxRounds?: number | null;
+    /** Initial hidden workflow steer completed. */
+    steerDone: boolean;
+    /** Server conversation id when known (for audit finish-run). */
+    conversationId: string | null;
+    /** Ms since epoch — used to detect duplicate sends after reload. */
+    startedAt: number;
+    /** In-memory only: same-tab resume after Stop (not persisted to sessionStorage). */
+    resumeMode?: 'page' | 'pause';
+};
+export type DevtoolsShellSession = {
+    open: boolean;
+    activeTab: DeveloperToolPanelId;
+};
+export declare function getPendingWorkflowTesterRun(): PendingWorkflowTesterRun | null;
+export declare function refreshSimulationActiveFlag(): void;
+export declare function setSimulationActiveFlag(active: boolean): void;
+export declare function isSimulationActive(): boolean;
+/** True when sessionStorage has a resumable pending run (no side effects). */
+export declare function hasPendingWorkflowTesterRun(): boolean;
+export declare function setPendingWorkflowTesterRun(run: PendingWorkflowTesterRun): void;
+export declare function clearPendingWorkflowTesterRun(): void;
+export declare function getDevtoolsShellSession(): DevtoolsShellSession | null;
+export declare function setDevtoolsShellSession(session: DevtoolsShellSession): void;
+export declare function clearDevtoolsShellSession(): void;
+/** User dismissed the workflow tester — do not auto-open or resume on the next page load. */
+export declare function dismissWorkflowTesterAutoResume(): void;

package/dist/devtools/workflowTester/workflowTesterWorkspaceBridge.d.ts

@@ -2,11 +2,13 @@ import type { StubWorkspaceOption } from '../../stubs/workspaces';
 export type WorkflowTesterWorkspaceBridgeSnapshot = {
     transcriptSessionMode: string;
     workspaceOptions: StubWorkspaceOption[];
+    /** Workflow row the user activated in the transcript drawer (null = none selected yet). */
+    focusedWorkflowId: string | null;
 };
 type Listener = () => void;
 /**
- * Transcript chrome keeps this in sync so {@link WorkflowTesterPanel} can read workspace slug +
- * catalog rows without extra props from `GuideAI`.
+ * Transcript chrome keeps this in sync so {@link WorkflowTesterPanel} can read workspace slug,
+ * drawer-focused workflow id, and catalog rows without extra props from `GuideAI`.
  */
 export declare function setWorkflowTesterWorkspaceBridge(next: WorkflowTesterWorkspaceBridgeSnapshot | null): void;
 export declare function getWorkflowTesterWorkspaceBridge(): WorkflowTesterWorkspaceBridgeSnapshot | null;

package/dist/hooks/useConversationSession.d.ts

@@ -6,12 +6,22 @@ import type { DataChannelManager } from '../utils/dataChannel';
 import type { UseVisualContextReturn } from '../visualContext/useVisualContext';
 import type { StoredMessage } from '../utils/messageStorage';
 import type { InitializeWebRTCCallOptions } from './useWebRTC';
+export type EndConversationSessionOptions = {
+    /** When false, skip the post-session rating prompt (e.g. chat reset). Default true. */
+    promptRating?: boolean;
+};
+export type ConversationSessionEndedPayload = {
+    conversationId: string | null;
+    promptRating: boolean;
+    /** Wall-clock ms the mic session was active (mic on → mic off). */
+    sessionDurationMs: number;
+};
 export type UseConversationSessionParams = {
     hooks: ReactHooks;
     conversationKey: string;
     keyTrim: string;
     hasPortalAuth: boolean;
-    workspaceDataSource: 'api' | 'stub';
+    catalogFromApi: boolean;
     widgetAuthWorkspace: string | undefined;
     transcriptOptions: GuideAIProps['transcript'];
     inputOptions: GuideAIProps['input'];
@@ -57,11 +67,13 @@ export type UseConversationSessionParams = {
     resetNoisySuggestForChatReset: () => void;
     /** Runs at the start of `endConversationSession` (toolbar X, errors, reset chat, etc.). */
     onBeforeEndConversationSession?: () => void;
+    conversationIdRef: MutableRefObject<string | null>;
+    onConversationSessionEnded?: (payload: ConversationSessionEndedPayload) => void;
 };
 export declare function useConversationSession(params: UseConversationSessionParams): {
     startConversationSession: () => Promise<boolean>;
     reestablishActiveRealtimeSession: (callOptions?: InitializeWebRTCCallOptions) => Promise<boolean>;
-    endConversationSession: () => void;
+    endConversationSession: (options?: EndConversationSessionOptions) => void;
     toggleConversation: (force?: boolean) => Promise<void>;
     handleToggleConversation: () => Promise<void>;
     handleResetChat: () => Promise<void>;