@sqaitech/visualizer 0.5.0

package/dist/types/component/env-config/index.d.ts

@@ -0,0 +1,6 @@
+export declare function EnvConfig({ showTooltipWhenEmpty, showModelName, tooltipPlacement, mode, }: {
+    showTooltipWhenEmpty?: boolean;
+    showModelName?: boolean;
+    tooltipPlacement?: 'bottom' | 'top';
+    mode?: 'icon' | 'text';
+}): import("react").JSX.Element;

package/dist/types/component/env-config-reminder/index.d.ts

@@ -0,0 +1,6 @@
+import './index.less';
+interface EnvConfigReminderProps {
+    className?: string;
+}
+export declare const EnvConfigReminder: React.FC<EnvConfigReminderProps>;
+export {};

package/dist/types/component/form-field/index.d.ts

@@ -0,0 +1,17 @@
+import type { z } from '@sqaitech/core';
+import type React from 'react';
+interface FormFieldProps {
+    name: string;
+    label: string;
+    fieldSchema: z.ZodTypeAny;
+    isRequired: boolean;
+    isLocateField: boolean;
+    marginBottom: number;
+    placeholder?: string;
+}
+export declare const TextField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const LocateField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const EnumField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const NumberField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const BooleanField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export {};

package/dist/types/component/history-selector/index.d.ts

@@ -0,0 +1,10 @@
+import type React from 'react';
+import type { HistoryItem } from '../../store/history';
+import './index.less';
+interface HistorySelectorProps {
+    onSelect: (history: HistoryItem) => void;
+    history: HistoryItem[];
+    currentType: string;
+}
+export declare const HistorySelector: React.FC<HistorySelectorProps>;
+export {};

package/dist/types/component/index.d.ts

@@ -0,0 +1 @@
+export * from '../types';

package/dist/types/component/logo/index.d.ts

@@ -0,0 +1,5 @@
+import './index.less';
+export declare const LogoUrl: any;
+export declare const Logo: ({ hideLogo }: {
+    hideLogo?: boolean;
+}) => import("react").JSX.Element | null;

package/dist/types/component/misc/index.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+export declare function timeCostStrElement(timeCost?: number): React.JSX.Element;
+export declare const iconForStatus: (status: string) => React.JSX.Element;
+export declare const errorMessageServerNotReady: React.JSX.Element;
+export declare const serverLaunchTip: (notReadyMessage?: React.ReactNode | string) => React.JSX.Element;
+export declare const emptyResultTip: React.JSX.Element;

package/dist/types/component/nav-actions/index.d.ts

@@ -0,0 +1,10 @@
+import './style.less';
+export interface NavActionsProps {
+    showEnvConfig?: boolean;
+    showTooltipWhenEmpty?: boolean;
+    showModelName?: boolean;
+    githubUrl?: string;
+    helpUrl?: string;
+    className?: string;
+}
+export declare function NavActions({ showEnvConfig, showTooltipWhenEmpty, showModelName, githubUrl, helpUrl, className, }: NavActionsProps): import("react").JSX.Element;

package/dist/types/component/player/index.d.ts

@@ -0,0 +1,13 @@
+import 'pixi.js/unsafe-eval';
+import './index.less';
+import type { AnimationScript } from '../../utils/replay-scripts';
+export declare function Player(props?: {
+    replayScripts?: AnimationScript[];
+    imageWidth?: number;
+    imageHeight?: number;
+    reportFileContent?: string | null;
+    key?: string | number;
+    fitMode?: 'width' | 'height';
+    autoZoom?: boolean;
+    elementsVisible?: boolean;
+}): import("react").JSX.Element;

package/dist/types/component/playground/index.d.ts

@@ -0,0 +1,7 @@
+export { ContextPreview } from '../context-preview';
+export { PlaygroundResultView } from '../playground-result';
+export { PromptInput } from '../prompt-input';
+export { useServerValid } from '../../hooks/useServerValid';
+export { ServiceModeControl } from '../service-mode-control';
+export * from '../../types';
+export { useEnvConfig } from '../../store/store';

package/dist/types/component/playground-result/index.d.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+import type { PlaygroundResult as PlaygroundResultType } from '../../types';
+import type { ServiceModeType } from '../../types';
+import type { ReplayScriptsInfo } from '../../utils/replay-scripts';
+import './index.less';
+interface PlaygroundResultProps {
+    result: PlaygroundResultType | null;
+    loading: boolean;
+    serverValid?: boolean;
+    serviceMode: ServiceModeType;
+    replayScriptsInfo: ReplayScriptsInfo | null;
+    replayCounter: number;
+    loadingProgressText: string;
+    verticalMode?: boolean;
+    notReadyMessage?: React.ReactNode | string;
+    fitMode?: 'width' | 'height';
+    autoZoom?: boolean;
+}
+export declare const PlaygroundResultView: React.FC<PlaygroundResultProps>;
+export {};

package/dist/types/component/prompt-input/index.d.ts

@@ -0,0 +1,22 @@
+import './index.less';
+import React from 'react';
+import type { RunType } from '../../types';
+import type { ServiceModeType } from '../../types';
+import './index.less';
+import type { DeviceAction } from '@sqaitech/core';
+interface PromptInputProps {
+    runButtonEnabled: boolean;
+    form: any;
+    serviceMode: ServiceModeType;
+    selectedType: RunType;
+    dryMode: boolean;
+    stoppable: boolean;
+    loading: boolean;
+    onRun: () => void;
+    onStop: () => void;
+    clearPromptAfterRun?: boolean;
+    hideDomAndScreenshotOptions?: boolean;
+    actionSpace: DeviceAction<any>[];
+}
+export declare const PromptInput: React.FC<PromptInputProps>;
+export {};

package/dist/types/component/service-mode-control/index.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+interface ServiceModeControlProps {
+    serviceMode: 'Server' | 'In-Browser';
+}
+export declare const ServiceModeControl: React.FC<ServiceModeControlProps>;
+export {};

package/dist/types/component/shiny-text/index.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+import './index.less';
+type ColorTheme = 'blue' | 'purple' | 'green' | 'rainbow';
+interface ShinyTextProps {
+    text: string;
+    disabled?: boolean;
+    speed?: number;
+    className?: string;
+    colorTheme?: ColorTheme;
+}
+declare const ShinyText: React.FC<ShinyTextProps>;
+export default ShinyText;

package/dist/types/component/universal-playground/index.d.ts

@@ -0,0 +1,4 @@
+import type { UniversalPlaygroundProps } from '../../types';
+import './index.less';
+export declare function UniversalPlayground({ playgroundSDK, storage, contextProvider, config: componentConfig, branding, className, dryMode, showContextPreview, }: UniversalPlaygroundProps): import("react").JSX.Element;
+export default UniversalPlayground;

package/dist/types/component/universal-playground/providers/context-provider.d.ts

@@ -0,0 +1,37 @@
+import type { UIContext } from '@sqaitech/core';
+import type { ContextProvider } from '../../../types';
+/**
+ * Base context provider implementation
+ */
+export declare abstract class BaseContextProvider implements ContextProvider {
+    protected cachedContext?: UIContext;
+    abstract getUIContext(): Promise<UIContext>;
+    refreshContext(): Promise<UIContext>;
+}
+/**
+ * Agent-based context provider for local execution modes
+ */
+export declare class AgentContextProvider extends BaseContextProvider {
+    private getAgent;
+    private options?;
+    constructor(getAgent: () => any, options?: {
+        forceSameTabNavigation?: boolean;
+    } | undefined);
+    getUIContext(): Promise<UIContext>;
+}
+/**
+ * Static context provider for pre-determined UI contexts
+ */
+export declare class StaticContextProvider extends BaseContextProvider {
+    private context;
+    constructor(context: UIContext);
+    getUIContext(): Promise<UIContext>;
+    refreshContext(): Promise<UIContext>;
+}
+/**
+ * No-op context provider for cases where context preview is disabled
+ */
+export declare class NoOpContextProvider implements ContextProvider {
+    getUIContext(): Promise<UIContext>;
+    refreshContext(): Promise<UIContext>;
+}

package/dist/types/component/universal-playground/providers/indexeddb-storage-provider.d.ts

@@ -0,0 +1,71 @@
+import type { InfoListItem, StorageProvider } from '../../../types';
+/**
+ * IndexedDB Storage implementation for playground message persistence
+ * Provides much larger storage capacity compared to localStorage
+ */
+export declare class IndexedDBStorageProvider implements StorageProvider {
+    private dbManager;
+    private namespace;
+    private messagesCleanup;
+    private resultsCleanup;
+    constructor(namespace?: string);
+    /**
+     * Save messages to IndexedDB
+     */
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    /**
+     * Load messages from IndexedDB
+     */
+    loadMessages(): Promise<InfoListItem[]>;
+    /**
+     * Clear all messages from IndexedDB
+     */
+    clearMessages(): Promise<void>;
+    /**
+     * Save a single result to IndexedDB with compression
+     */
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+    /**
+     * Load a single result from IndexedDB
+     */
+    loadResult(id: string): Promise<InfoListItem | null>;
+    /**
+     * Compress result data for storage while preserving playback functionality
+     */
+    private compressResultForStorage;
+    /**
+     * Compress screenshot if it exceeds size threshold
+     */
+    private compressScreenshotIfNeeded;
+    /**
+     * Get storage statistics
+     */
+    getStorageStats(): Promise<{
+        messageCount: number;
+        resultCount: number;
+    }>;
+    /**
+     * Manually trigger cleanup
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Memory-based storage provider for IndexedDB fallback
+ */
+export declare class MemoryStorageProvider implements StorageProvider {
+    private messages;
+    private results;
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+}
+/**
+ * No-op storage provider for disabled storage
+ */
+export declare class NoOpStorageProvider implements StorageProvider {
+    saveMessages(_messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(_id: string, _result: InfoListItem): Promise<void>;
+}

package/dist/types/component/universal-playground/providers/storage-provider.d.ts

@@ -0,0 +1,58 @@
+import type { InfoListItem, StorageProvider } from '../../../types';
+import { MemoryStorageProvider as IndexedDBMemoryStorageProvider, NoOpStorageProvider as IndexedDBNoOpStorageProvider, IndexedDBStorageProvider } from './indexeddb-storage-provider';
+/**
+ * Local Storage implementation for playground message persistence
+ */
+export declare class LocalStorageProvider implements StorageProvider {
+    private readonly messagesKey;
+    private readonly resultsKey;
+    private readonly maxStorageItems;
+    constructor(namespace?: string);
+    /**
+     * Check available storage space
+     */
+    private checkStorageSpace;
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+    /**
+     * Handle quota exceeded by clearing old data
+     */
+    private handleQuotaExceeded;
+}
+/**
+ * Memory-only storage implementation for non-persistent scenarios
+ */
+export declare class MemoryStorageProvider implements StorageProvider {
+    private messages;
+    private results;
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+}
+/**
+ * No-op storage implementation for cases where persistence is disabled
+ */
+export declare class NoOpStorageProvider implements StorageProvider {
+    saveMessages(_messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(_id: string, _result: InfoListItem): Promise<void>;
+}
+/**
+ * Storage type enumeration
+ */
+export declare enum StorageType {
+    INDEXEDDB = "indexeddb",
+    LOCALSTORAGE = "localStorage",
+    MEMORY = "memory",
+    NONE = "none"
+}
+/**
+ * Factory function to create the appropriate storage provider
+ */
+export declare function createStorageProvider(type?: StorageType, namespace?: string): StorageProvider;
+export declare function detectBestStorageType(): StorageType;
+export { IndexedDBStorageProvider, IndexedDBMemoryStorageProvider, IndexedDBNoOpStorageProvider, };

package/dist/types/hooks/usePlaygroundExecution.d.ts

@@ -0,0 +1,10 @@
+import type { DeviceAction } from '@sqaitech/core';
+import type { FormValue, InfoListItem, PlaygroundSDKLike, StorageProvider } from '../types';
+/**
+ * Hook for handling playground execution logic
+ */
+export declare function usePlaygroundExecution(playgroundSDK: PlaygroundSDKLike | null, storage: StorageProvider | undefined | null, actionSpace: DeviceAction<unknown>[], loading: boolean, setLoading: (loading: boolean) => void, infoList: InfoListItem[], setInfoList: React.Dispatch<React.SetStateAction<InfoListItem[]>>, replayCounter: number, setReplayCounter: React.Dispatch<React.SetStateAction<number>>, verticalMode: boolean, currentRunningIdRef: React.MutableRefObject<number | null>, interruptedFlagRef: React.MutableRefObject<Record<number, boolean>>): {
+    handleRun: (value: FormValue) => Promise<void>;
+    handleStop: () => Promise<void>;
+    canStop: boolean;
+};

package/dist/types/hooks/usePlaygroundState.d.ts

@@ -0,0 +1,26 @@
+import type { DeviceAction, UIContext } from '@sqaitech/core';
+import type { ContextProvider, InfoListItem, PlaygroundSDKLike, StorageProvider } from '../types';
+/**
+ * Hook for managing playground state
+ */
+export declare function usePlaygroundState(playgroundSDK: PlaygroundSDKLike | null, storage?: StorageProvider | null, contextProvider?: ContextProvider): {
+    loading: boolean;
+    setLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    infoList: InfoListItem[];
+    setInfoList: import("react").Dispatch<import("react").SetStateAction<InfoListItem[]>>;
+    actionSpace: DeviceAction<unknown>[];
+    actionSpaceLoading: boolean;
+    uiContextPreview: UIContext<import("@sqaitech/core").BaseElement> | undefined;
+    setUiContextPreview: import("react").Dispatch<import("react").SetStateAction<UIContext<import("@sqaitech/core").BaseElement> | undefined>>;
+    showScrollToBottomButton: boolean;
+    verticalMode: boolean;
+    replayCounter: number;
+    setReplayCounter: import("react").Dispatch<import("react").SetStateAction<number>>;
+    infoListRef: import("react").RefObject<HTMLDivElement>;
+    currentRunningIdRef: import("react").MutableRefObject<number | null>;
+    interruptedFlagRef: import("react").MutableRefObject<Record<number, boolean>>;
+    clearInfoList: () => Promise<void>;
+    refreshContext: () => Promise<void>;
+    handleScrollToBottom: () => void;
+    scrollToBottom: () => void;
+};

package/dist/types/hooks/useSafeOverrideAIConfig.d.ts

@@ -0,0 +1,16 @@
+import type { GLOBAL_ENV_KEYS, MODEL_ENV_KEYS } from '@sqaitech/shared/env';
+/**
+ * Safely override AI configuration with built-in error handling
+ * @param newConfig - The configuration to override
+ * @param extendMode - Whether to extend or replace the config (default: false)
+ * @param showErrorMessage - Whether to show error message in UI (default: true)
+ * @returns boolean indicating success
+ */
+export declare function safeOverrideAIConfig(newConfig: Partial<Record<(typeof GLOBAL_ENV_KEYS)[number] | (typeof MODEL_ENV_KEYS)[number], string>>, extendMode?: boolean, showErrorMessage?: boolean): boolean;
+/**
+ * React Hook for safely overriding AI config with error handling
+ * Useful for components that need to handle config changes
+ */
+export declare function useSafeOverrideAIConfig(): {
+    applyConfig: (newConfig: Partial<Record<(typeof GLOBAL_ENV_KEYS)[number] | (typeof MODEL_ENV_KEYS)[number], string>>, extendMode?: boolean, showErrorMessage?: boolean) => boolean;
+};

package/dist/types/hooks/useServerValid.d.ts

@@ -0,0 +1 @@
+export declare const useServerValid: (shouldRun?: boolean) => boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,27 @@
+import './component/playground/index.less';
+import './component/universal-playground/index.less';
+export { type AnimationScript, type ReplayScriptsInfo, allScriptsFromDump, generateAnimationScripts, } from './utils/replay-scripts';
+export { useEnvConfig } from './store/store';
+export { colorForName, highlightColorForType, globalThemeConfig, } from './utils/color';
+export { EnvConfig } from './component/env-config';
+export { EnvConfigReminder } from './component/env-config-reminder';
+export { NavActions } from './component/nav-actions';
+export type { NavActionsProps } from './component/nav-actions';
+export { Logo } from './component/logo';
+export { iconForStatus, timeCostStrElement } from './component/misc';
+export { useServerValid } from './hooks/useServerValid';
+export { useSafeOverrideAIConfig, safeOverrideAIConfig, } from './hooks/useSafeOverrideAIConfig';
+export { PlaygroundResultView } from './component/playground-result';
+export type { PlaygroundResult } from './types';
+export { ServiceModeControl } from './component/service-mode-control';
+export { ContextPreview } from './component/context-preview';
+export { PromptInput } from './component/prompt-input';
+export { Player } from './component/player';
+export { Blackboard } from './component/blackboard';
+export { actionNameForType, staticAgentFromContext, getPlaceholderForType, } from './utils/playground-utils';
+export { timeStr, filterBase64Value } from './utils';
+export { default as ShinyText } from './component/shiny-text';
+export { UniversalPlayground, default as UniversalPlaygroundDefault, } from './component/universal-playground';
+export type { UniversalPlaygroundProps, PlaygroundSDKLike, StorageProvider, ContextProvider, UniversalPlaygroundConfig, PlaygroundBranding, InfoListItem, FormValue, ExecutionOptions, ProgressCallback, } from './types';
+export { LocalStorageProvider, MemoryStorageProvider, NoOpStorageProvider, IndexedDBStorageProvider, createStorageProvider, detectBestStorageType, StorageType, } from './component/universal-playground/providers/storage-provider';
+export { BaseContextProvider, AgentContextProvider, StaticContextProvider, NoOpContextProvider, } from './component/universal-playground/providers/context-provider';

package/dist/types/store/history.d.ts

@@ -0,0 +1,16 @@
+import * as Z from 'zustand';
+export interface HistoryItem {
+    type: string;
+    prompt: string;
+    params?: Record<string, any>;
+    timestamp: number;
+}
+export type HistoryState = Record<string, HistoryItem[]>;
+export declare const useHistoryStore: Z.UseBoundStore<Z.StoreApi<{
+    history: HistoryState;
+    lastSelectedType: string;
+    clearHistory: (type: string) => void;
+    addHistory: (historyItem: HistoryItem) => void;
+    getHistoryForType: (type: string) => HistoryItem[];
+    setLastSelectedType: (type: string) => void;
+}>>;

package/dist/types/store/store.d.ts

@@ -0,0 +1,36 @@
+import * as Z from 'zustand';
+export declare const useBlackboardPreference: Z.UseBoundStore<Z.StoreApi<{
+    backgroundVisible: boolean;
+    elementsVisible: boolean;
+    autoZoom: boolean;
+    setBackgroundVisible: (visible: boolean) => void;
+    setElementsVisible: (visible: boolean) => void;
+    setAutoZoom: (enabled: boolean) => void;
+}>>;
+/**
+ * Service Mode
+ *
+ * - Server: use a node server to run the code
+ * - In-Browser: use browser's fetch API to run the code
+ * - In-Browser-Extension: use browser's fetch API to run the code, but the page is running in the extension context
+ */
+export type ServiceModeType = 'Server' | 'In-Browser' | 'In-Browser-Extension';
+export declare const useEnvConfig: Z.UseBoundStore<Z.StoreApi<{
+    serviceMode: ServiceModeType;
+    setServiceMode: (serviceMode: ServiceModeType) => void;
+    config: Record<string, string>;
+    configString: string;
+    setConfig: (config: Record<string, string>) => void;
+    loadConfig: (configString: string) => void;
+    syncFromStorage: () => void;
+    forceSameTabNavigation: boolean;
+    setForceSameTabNavigation: (forceSameTabNavigation: boolean) => void;
+    deepThink: boolean;
+    setDeepThink: (deepThink: boolean) => void;
+    screenshotIncluded: boolean;
+    setScreenshotIncluded: (screenshotIncluded: boolean) => void;
+    domIncluded: boolean | "visible-only";
+    setDomIncluded: (domIncluded: boolean | "visible-only") => void;
+    popupTab: "playground" | "bridge" | "recorder";
+    setPopupTab: (tab: "playground" | "bridge" | "recorder") => void;
+}>>;

package/dist/types/types.d.ts

@@ -0,0 +1,161 @@
+import type { DeviceAction, UIContext } from '@sqaitech/core';
+import type { ComponentType } from 'react';
+export interface ZodType {
+    _def?: {
+        typeName: 'ZodOptional' | 'ZodDefault' | 'ZodNullable' | 'ZodObject' | 'ZodEnum' | 'ZodNumber' | 'ZodString' | 'ZodBoolean';
+        innerType?: ZodType;
+        defaultValue?: () => unknown;
+        shape?: () => Record<string, ZodType>;
+        values?: string[];
+        description?: string;
+    };
+    description?: string;
+}
+export interface ZodObjectSchema extends ZodType {
+    shape: Record<string, ZodType>;
+    parse: (data: unknown) => unknown;
+}
+export interface ZodEnumSchema extends ZodType {
+    _def: {
+        typeName: 'ZodEnum';
+        values: string[];
+    };
+}
+export interface ZodNumberSchema extends ZodType {
+    _def: {
+        typeName: 'ZodNumber';
+    };
+}
+export interface ZodBooleanSchema extends ZodType {
+    _def: {
+        typeName: 'ZodBoolean';
+    };
+}
+export interface ZodRuntimeAccess extends ZodType {
+    shape?: Record<string, ZodType>;
+    description?: string;
+    typeName?: string;
+    type?: string;
+}
+export interface ActionSpaceItem extends Omit<DeviceAction<any>, 'paramSchema'> {
+    paramSchema?: ZodObjectSchema;
+}
+export interface FormParams {
+    [key: string]: string | number | boolean | null | undefined;
+}
+export declare const VALIDATION_CONSTANTS: {
+    readonly ZOD_TYPES: {
+        readonly OPTIONAL: "ZodOptional";
+        readonly DEFAULT: "ZodDefault";
+        readonly NULLABLE: "ZodNullable";
+        readonly OBJECT: "ZodObject";
+        readonly ENUM: "ZodEnum";
+        readonly NUMBER: "ZodNumber";
+        readonly STRING: "ZodString";
+        readonly BOOLEAN: "ZodBoolean";
+    };
+    readonly FIELD_FLAGS: {
+        readonly LOCATION: "midscene_location_field_flag";
+    };
+    readonly DEFAULT_VALUES: {
+        readonly ACTION_TYPE: "aiAction";
+        readonly TIMEOUT_MS: 15000;
+        readonly CHECK_INTERVAL_MS: 3000;
+    };
+};
+export declare const isZodObjectSchema: (schema: unknown) => schema is ZodObjectSchema;
+export declare const isLocateField: (field: ZodType) => boolean;
+export declare const unwrapZodType: (field: ZodType) => {
+    actualField: ZodType;
+    isOptional: boolean;
+    hasDefault: boolean;
+};
+export declare const extractDefaultValue: (field: ZodType) => unknown;
+import type { GroupedActionDump, WebUIContext } from '@sqaitech/core';
+import type { ExecutionOptions, PlaygroundAgent } from '@sqaitech/playground';
+export interface PlaygroundResult {
+    result: any;
+    dump?: GroupedActionDump | null;
+    reportHTML?: string | null;
+    error: string | null;
+}
+export interface PlaygroundProps {
+    getAgent: (forceSameTabNavigation?: boolean) => PlaygroundAgent | null;
+    hideLogo?: boolean;
+    showContextPreview?: boolean;
+    dryMode?: boolean;
+}
+export interface StaticPlaygroundProps {
+    context: WebUIContext | null;
+}
+export type ServiceModeType = 'Server' | 'In-Browser' | 'In-Browser-Extension';
+export type RunType = 'aiAction' | 'aiQuery' | 'aiAssert' | 'aiTap' | 'aiDoubleClick' | 'aiHover' | 'aiInput' | 'aiRightClick' | 'aiKeyboardPress' | 'aiScroll' | 'aiLocate' | 'aiBoolean' | 'aiNumber' | 'aiString' | 'aiAsk' | 'aiWaitFor';
+export interface ReplayScriptsInfo {
+    scripts: any[];
+    width?: number;
+    height?: number;
+    sdkVersion?: string;
+    modelBriefs: string[];
+}
+export interface FormValue {
+    type: string;
+    prompt?: string;
+    params?: Record<string, unknown>;
+}
+export type { ExecutionOptions };
+export type ProgressCallback = (step: string, status?: 'loading' | 'completed' | 'error') => void;
+export interface PlaygroundSDKLike {
+    executeAction(actionType: string, value: FormValue, options: ExecutionOptions): Promise<unknown>;
+    getActionSpace(context?: any): Promise<DeviceAction<unknown>[]>;
+    onProgressUpdate?: (callback: ProgressCallback) => void;
+    cancelExecution?(requestId: string): Promise<void>;
+    overrideConfig?(config: any): Promise<void>;
+    checkStatus?(): Promise<boolean>;
+    id?: string;
+}
+export interface StorageProvider {
+    saveMessages?(messages: InfoListItem[]): Promise<void>;
+    loadMessages?(): Promise<InfoListItem[]>;
+    clearMessages?(): Promise<void>;
+    saveResult?(id: string, result: InfoListItem): Promise<void>;
+}
+export interface ContextProvider {
+    getUIContext?(): Promise<UIContext>;
+    refreshContext?(): Promise<UIContext>;
+}
+export interface InfoListItem {
+    id: string;
+    type: 'user' | 'system' | 'result' | 'progress' | 'separator';
+    content: string;
+    timestamp: Date;
+    result?: PlaygroundResult | null;
+    loading?: boolean;
+    replayScriptsInfo?: ReplayScriptsInfo | null;
+    replayCounter?: number;
+    loadingProgressText?: string;
+    verticalMode?: boolean;
+}
+export interface UniversalPlaygroundConfig {
+    showContextPreview?: boolean;
+    storageNamespace?: string;
+    layout?: 'vertical' | 'horizontal';
+    showVersionInfo?: boolean;
+    enableScrollToBottom?: boolean;
+    serverMode?: boolean;
+    showEnvConfigReminder?: boolean;
+}
+export interface PlaygroundBranding {
+    title?: string;
+    icon?: ComponentType<any>;
+    version?: string;
+}
+export interface UniversalPlaygroundProps {
+    playgroundSDK: PlaygroundSDKLike | null;
+    storage?: StorageProvider;
+    contextProvider?: ContextProvider;
+    config?: UniversalPlaygroundConfig;
+    branding?: PlaygroundBranding;
+    className?: string;
+    dryMode?: boolean;
+    showContextPreview?: boolean;
+}

package/dist/types/utils/color.d.ts

@@ -0,0 +1,4 @@
+import type { ThemeConfig } from 'antd';
+export declare function colorForName(name: string): string;
+export declare function highlightColorForType(type: 'searchArea' | 'element'): string;
+export declare function globalThemeConfig(): ThemeConfig;