@godscene/visualizer 1.7.11

package/dist/lib/hooks/useMinimalTypeGate.js

@@ -0,0 +1,81 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useMinimalTypeGate: ()=>useMinimalTypeGate
+});
+const external_react_namespaceObject = require("react");
+function useMinimalTypeGate(options) {
+    const { enabled, form, selectedType, onAfterReset, defaultType = 'aiAct' } = options;
+    const [hasExplicitSelection, setHasExplicitSelection] = (0, external_react_namespaceObject.useState)(false);
+    const skipNextRestoreRef = (0, external_react_namespaceObject.useRef)(false);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled || hasExplicitSelection || !selectedType || selectedType === defaultType) return;
+        skipNextRestoreRef.current = false;
+        form.setFieldsValue({
+            type: defaultType,
+            prompt: '',
+            params: {}
+        });
+        null == onAfterReset || onAfterReset();
+    }, [
+        enabled,
+        hasExplicitSelection,
+        selectedType,
+        defaultType,
+        form,
+        onAfterReset
+    ]);
+    const markExplicitSelection = (0, external_react_namespaceObject.useCallback)(()=>{
+        if (!enabled) return;
+        setHasExplicitSelection(true);
+    }, [
+        enabled
+    ]);
+    const skipNextRestore = (0, external_react_namespaceObject.useCallback)(()=>{
+        skipNextRestoreRef.current = true;
+    }, []);
+    const shouldSkipRestoreOnce = (0, external_react_namespaceObject.useCallback)(()=>{
+        if (!skipNextRestoreRef.current) return false;
+        skipNextRestoreRef.current = false;
+        return true;
+    }, []);
+    return (0, external_react_namespaceObject.useMemo)(()=>({
+            markExplicitSelection,
+            skipNextRestore,
+            shouldSkipRestoreOnce
+        }), [
+        markExplicitSelection,
+        skipNextRestore,
+        shouldSkipRestoreOnce
+    ]);
+}
+exports.useMinimalTypeGate = __webpack_exports__.useMinimalTypeGate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useMinimalTypeGate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/hooks/usePlaygroundExecution.js

@@ -0,0 +1,478 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildProgressContent: ()=>buildProgressContent,
+    formatError: ()=>formatError,
+    usePlaygroundExecution: ()=>usePlaygroundExecution,
+    wrapExecutionDumpForReplay: ()=>wrapExecutionDumpForReplay
+});
+const agent_namespaceObject = require("@godscene/core/agent");
+const external_react_namespaceObject = require("react");
+const store_js_namespaceObject = require("../store/store.js");
+const constants_js_namespaceObject = require("../utils/constants.js");
+const replay_scripts_js_namespaceObject = require("../utils/replay-scripts.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function usePlaygroundExecution_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else usePlaygroundExecution_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+function formatError(error) {
+    var _error_dump;
+    if (!error) return '';
+    if ('string' == typeof error) return error;
+    if (null == error ? void 0 : null == (_error_dump = error.dump) ? void 0 : _error_dump.error) return error.dump.error;
+    if (error.message) return String(error.message);
+    try {
+        return JSON.stringify(error);
+    } catch (unused) {
+        return String(error);
+    }
+}
+function buildProgressContent(task) {
+    const action = (0, agent_namespaceObject.typeStr)(task);
+    const description = (0, agent_namespaceObject.paramStr)(task);
+    return description ? `${action} - ${description}` : action;
+}
+function wrapExecutionDumpForReplay(dump, deviceType) {
+    return {
+        sdkVersion: '',
+        groupName: 'Playground Execution',
+        modelBriefs: [],
+        executions: [
+            dump
+        ],
+        deviceType
+    };
+}
+function usePlaygroundExecution(options) {
+    const { playgroundSDK, storage, actionSpace, loading, setLoading, setInfoList, replayCounter, setReplayCounter, verticalMode, currentRunningIdRef, interruptedFlagRef, deviceType } = options;
+    const { deepLocate, deepThink, screenshotIncluded, domIncluded, imeStrategy, autoDismissKeyboard, keyboardDismissStrategy, alwaysRefreshScreenInfo } = (0, store_js_namespaceObject.useEnvConfig)();
+    const handleRun = (0, external_react_namespaceObject.useCallback)((value)=>_async_to_generator(function*() {
+            if (!playgroundSDK) return void console.warn('PlaygroundSDK is not available');
+            const thisRunningId = Date.now();
+            const actionType = value.type;
+            const displayContent = `${value.type}: ${value.prompt || JSON.stringify(value.params)}`;
+            const userItem = {
+                id: `user-${Date.now()}`,
+                type: 'user',
+                content: displayContent,
+                timestamp: new Date()
+            };
+            setInfoList((prev)=>[
+                    ...prev,
+                    userItem
+                ]);
+            setLoading(true);
+            const result = _object_spread({}, constants_js_namespaceObject.BLANK_RESULT);
+            const systemItem = {
+                id: `system-${thisRunningId}`,
+                type: 'system',
+                content: '',
+                timestamp: new Date(),
+                loading: true,
+                loadingProgressText: ''
+            };
+            setInfoList((prev)=>[
+                    ...prev,
+                    systemItem
+                ]);
+            try {
+                currentRunningIdRef.current = thisRunningId;
+                interruptedFlagRef.current[thisRunningId] = false;
+                if (playgroundSDK.onDumpUpdate) playgroundSDK.onDumpUpdate((_, executionDump)=>{
+                    var _executionDump_tasks;
+                    if (interruptedFlagRef.current[thisRunningId] || !(null == executionDump ? void 0 : null == (_executionDump_tasks = executionDump.tasks) ? void 0 : _executionDump_tasks.length)) return;
+                    const progressItems = executionDump.tasks.map((task, index)=>{
+                        var _task_timing;
+                        return {
+                            id: `progress-${thisRunningId}-task-${index}`,
+                            type: 'progress',
+                            content: buildProgressContent(task),
+                            actionKind: (0, agent_namespaceObject.typeStr)(task),
+                            timestamp: new Date((null == (_task_timing = task.timing) ? void 0 : _task_timing.start) || Date.now()),
+                            result: task.error ? {
+                                error: formatError(task.error),
+                                result: null
+                            } : void 0
+                        };
+                    });
+                    setInfoList((prev)=>{
+                        const systemItemIndex = prev.findIndex((item)=>item.id === `system-${thisRunningId}`);
+                        if (-1 === systemItemIndex) return prev;
+                        const listWithoutCurrentProgress = prev.filter((item)=>!('progress' === item.type && item.id.startsWith(`progress-${thisRunningId}-`)));
+                        return [
+                            ...listWithoutCurrentProgress.slice(0, systemItemIndex + 1),
+                            ...progressItems,
+                            ...listWithoutCurrentProgress.slice(systemItemIndex + 1)
+                        ];
+                    });
+                });
+                if ('aiAct' !== actionType && true === deepThink) console.warn('[Playground] Non-aiAct action will be executed without deepThink. deepThink is only forwarded for aiAct.', {
+                    actionType,
+                    requestId: thisRunningId.toString()
+                });
+                const resolvedDeepThink = 'unset' === deepThink ? void 0 : deepThink;
+                const executionOptions = _object_spread_props(_object_spread({
+                    requestId: thisRunningId.toString(),
+                    deepLocate
+                }, 'aiAct' === actionType && void 0 !== resolvedDeepThink ? {
+                    deepThink: resolvedDeepThink
+                } : {}), {
+                    screenshotIncluded,
+                    domIncluded,
+                    deviceOptions: {
+                        imeStrategy,
+                        autoDismissKeyboard,
+                        keyboardDismissStrategy,
+                        alwaysRefreshScreenInfo
+                    }
+                });
+                result.result = yield playgroundSDK.executeAction(actionType, value, executionOptions);
+                if ('object' == typeof result.result && null !== result.result) {
+                    const resultObj = result.result;
+                    if (resultObj.dump) result.dump = resultObj.dump;
+                    if (resultObj.reportHTML) result.reportHTML = resultObj.reportHTML;
+                    if (resultObj.error) result.error = formatError(resultObj.error);
+                    if ('result' in resultObj) result.result = resultObj.result;
+                }
+            } catch (e) {
+                result.error = formatError(e);
+                console.error('Playground execution error:', e);
+                if ('object' == typeof e && null !== e) {
+                    if (e.dump) result.dump = e.dump;
+                    if (e.reportHTML) result.reportHTML = e.reportHTML;
+                }
+            }
+            if (interruptedFlagRef.current[thisRunningId]) return;
+            setLoading(false);
+            currentRunningIdRef.current = null;
+            let replayInfo = null;
+            let counter = replayCounter;
+            if (null == result ? void 0 : result.dump) {
+                if (result.dump.tasks && Array.isArray(result.dump.tasks)) {
+                    const groupedDump = wrapExecutionDumpForReplay(result.dump, deviceType);
+                    const info = (0, replay_scripts_js_namespaceObject.allScriptsFromDump)(groupedDump);
+                    setReplayCounter((c)=>c + 1);
+                    replayInfo = info;
+                    counter = replayCounter + 1;
+                }
+            }
+            setInfoList((prev)=>prev.map((item)=>item.id === `system-${thisRunningId}` ? _object_spread_props(_object_spread({}, item), {
+                        content: '',
+                        loading: false,
+                        loadingProgressText: ''
+                    }) : item));
+            const resultItem = {
+                id: `result-${thisRunningId}`,
+                type: 'result',
+                content: 'Execution result',
+                timestamp: new Date(),
+                result: result,
+                loading: false,
+                replayScriptsInfo: replayInfo,
+                replayCounter: counter,
+                loadingProgressText: '',
+                verticalMode: verticalMode,
+                actionType: actionType
+            };
+            setInfoList((prev)=>[
+                    ...prev,
+                    resultItem
+                ]);
+            if (null == storage ? void 0 : storage.saveResult) try {
+                yield storage.saveResult(resultItem.id, resultItem);
+            } catch (error) {
+                console.error('Failed to save result:', error);
+            }
+            try {
+                console.log('result----', result);
+                const { tasks, logTime } = result.dump;
+                const end = tasks.at(-1).timing.end;
+                const totalTime = end - logTime;
+                const list = tasks.map((item)=>({
+                        type: item.type,
+                        subType: item.subType,
+                        cost: item.timing.cost
+                    }));
+                console.log('总耗时：', totalTime);
+                console.table(list);
+            } catch (error) {
+                console.error(error);
+            }
+            if (result && result.dump && result.dump.tasks) {
+                const thisRunningId = Date.now();
+                const tasks = result.dump.tasks || [];
+                const actionTasks = tasks.map((item, index)=>{
+                    if ('Action Space' === item.type) {
+                        var _tasks__param, _tasks_;
+                        if ('DragAndDrop' === item.subType) {
+                            var _tasks__param1, _tasks_1, _tasks__param2, _tasks_2;
+                            const from = (null == (_tasks_1 = tasks[index - 2]) ? void 0 : null == (_tasks__param1 = _tasks_1.param) ? void 0 : _tasks__param1.prompt) || '';
+                            const to = (null == (_tasks_2 = tasks[index - 1]) ? void 0 : null == (_tasks__param2 = _tasks_2.param) ? void 0 : _tasks__param2.prompt) || '';
+                            return _object_spread_props(_object_spread({}, item), {
+                                param: _object_spread_props(_object_spread({}, item.param), {
+                                    from: _object_spread_props(_object_spread({}, item.param.from), {
+                                        locateDescription: from
+                                    }),
+                                    to: _object_spread_props(_object_spread({}, item.param.to), {
+                                        locateDescription: to
+                                    })
+                                }),
+                                output: _object_spread_props(_object_spread({}, item.output), {
+                                    param: _object_spread_props(_object_spread({}, item.output.param), {
+                                        from: _object_spread_props(_object_spread({}, item.output.param.from), {
+                                            locateDescription: from
+                                        }),
+                                        to: _object_spread_props(_object_spread({}, item.output.param.to), {
+                                            locateDescription: to
+                                        })
+                                    })
+                                })
+                            });
+                        }
+                        return _object_spread_props(_object_spread({}, item), {
+                            locateDescription: (null == (_tasks_ = tasks[index - 1]) ? void 0 : null == (_tasks__param = _tasks_.param) ? void 0 : _tasks__param.prompt) || ''
+                        });
+                    }
+                    return null;
+                }).filter(Boolean);
+                const systemItem = {
+                    id: `system-${thisRunningId}`,
+                    type: 'system',
+                    content: '',
+                    timestamp: new Date(),
+                    loading: false,
+                    loadingProgressText: '',
+                    actionTasks
+                };
+                setInfoList((prev)=>[
+                        ...prev,
+                        systemItem
+                    ]);
+            }
+            const separatorItem = {
+                id: `separator-${thisRunningId}`,
+                type: 'separator',
+                content: 'New Session',
+                timestamp: new Date()
+            };
+            setInfoList((prev)=>[
+                    ...prev,
+                    separatorItem
+                ]);
+            return _object_spread_props(_object_spread({}, result), {
+                reportHTML: null
+            });
+        })(), [
+        playgroundSDK,
+        storage,
+        actionSpace,
+        setLoading,
+        setInfoList,
+        replayCounter,
+        setReplayCounter,
+        verticalMode,
+        currentRunningIdRef,
+        interruptedFlagRef,
+        deepLocate,
+        deepThink,
+        screenshotIncluded,
+        domIncluded,
+        deviceType,
+        imeStrategy,
+        autoDismissKeyboard,
+        keyboardDismissStrategy,
+        alwaysRefreshScreenInfo
+    ]);
+    const handleStop = (0, external_react_namespaceObject.useCallback)(()=>_async_to_generator(function*() {
+            const thisRunningId = currentRunningIdRef.current;
+            if (thisRunningId && playgroundSDK && playgroundSDK.cancelExecution) try {
+                const cancelResult = yield playgroundSDK.cancelExecution(thisRunningId.toString());
+                let executionData = null;
+                if (cancelResult) executionData = cancelResult;
+                else if (playgroundSDK.getCurrentExecutionData) try {
+                    executionData = yield playgroundSDK.getCurrentExecutionData();
+                } catch (error) {
+                    console.error('Failed to get execution data before stop:', error);
+                }
+                interruptedFlagRef.current[thisRunningId] = true;
+                setLoading(false);
+                if (playgroundSDK.onProgressUpdate) playgroundSDK.onProgressUpdate(()=>{});
+                if (playgroundSDK.onDumpUpdate) playgroundSDK.onDumpUpdate(()=>{});
+                setInfoList((prev)=>prev.map((item)=>item.id === `system-${thisRunningId}` ? _object_spread_props(_object_spread({}, item), {
+                            content: '',
+                            loading: false,
+                            loadingProgressText: ''
+                        }) : item));
+                if (executionData && (executionData.dump || executionData.reportHTML)) {
+                    var _executionData_dump;
+                    let replayInfo = null;
+                    let counter = replayCounter;
+                    if ((null == (_executionData_dump = executionData.dump) ? void 0 : _executionData_dump.tasks) && Array.isArray(executionData.dump.tasks)) {
+                        const groupedDump = wrapExecutionDumpForReplay(executionData.dump, deviceType);
+                        replayInfo = (0, replay_scripts_js_namespaceObject.allScriptsFromDump)(groupedDump);
+                        setReplayCounter((c)=>c + 1);
+                        counter = replayCounter + 1;
+                    }
+                    const resultItem = {
+                        id: `stop-result-${thisRunningId}`,
+                        type: 'result',
+                        content: 'Execution stopped by user',
+                        timestamp: new Date(),
+                        result: {
+                            result: null,
+                            dump: executionData.dump,
+                            reportHTML: executionData.reportHTML,
+                            error: null
+                        },
+                        loading: false,
+                        verticalMode,
+                        replayScriptsInfo: replayInfo,
+                        replayCounter: counter
+                    };
+                    setInfoList((prev)=>[
+                            ...prev,
+                            resultItem
+                        ]);
+                } else {
+                    const stopItem = {
+                        id: `stop-${thisRunningId}`,
+                        type: 'system',
+                        content: 'Operation stopped',
+                        timestamp: new Date(),
+                        loading: false
+                    };
+                    setInfoList((prev)=>[
+                            ...prev,
+                            stopItem
+                        ]);
+                }
+                const separatorItem = {
+                    id: `separator-${thisRunningId}`,
+                    type: 'separator',
+                    content: 'New Session',
+                    timestamp: new Date()
+                };
+                setInfoList((prev)=>[
+                        ...prev,
+                        separatorItem
+                    ]);
+            } catch (error) {
+                console.error('Failed to stop execution:', error);
+            }
+        })(), [
+        playgroundSDK,
+        currentRunningIdRef,
+        interruptedFlagRef,
+        setLoading,
+        setInfoList,
+        verticalMode,
+        replayCounter,
+        deviceType
+    ]);
+    const canStop = loading && !!currentRunningIdRef.current && !!playgroundSDK && !!playgroundSDK.cancelExecution;
+    return {
+        handleRun,
+        handleStop,
+        canStop
+    };
+}
+exports.buildProgressContent = __webpack_exports__.buildProgressContent;
+exports.formatError = __webpack_exports__.formatError;
+exports.usePlaygroundExecution = __webpack_exports__.usePlaygroundExecution;
+exports.wrapExecutionDumpForReplay = __webpack_exports__.wrapExecutionDumpForReplay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildProgressContent",
+    "formatError",
+    "usePlaygroundExecution",
+    "wrapExecutionDumpForReplay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});