@parhelia/core 0.1.12782 → 0.1.12784

package/dist/client-components/api.js

@@ -1,4 +1,4 @@
 export function selectComponents(componentIds) {
-    window.top?.window.postMessage({ componentIds, type: "componentsSelected" }, "*");
+    window.top?.window.postMessage({ componentIds, type: "componentsSelected" }, window.location.origin);
 }
 //# sourceMappingURL=api.js.map

package/dist/client-components/api.js.map

@@ -1 +1 @@
-{"version":3,"file":"api.js","sourceRoot":"","sources":["../../src/client-components/api.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,gBAAgB,CAAC,YAAsB;IACrD,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,WAAW,CAC5B,EAAE,YAAY,EAAE,IAAI,EAAE,oBAAoB,EAAE,EAC5C,GAAG,CACJ,CAAC;AACJ,CAAC"}
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../src/client-components/api.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,gBAAgB,CAAC,YAAsB;IACrD,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,WAAW,CAC5B,EAAE,YAAY,EAAE,IAAI,EAAE,oBAAoB,EAAE,EAC5C,MAAM,CAAC,QAAQ,CAAC,MAAM,CACvB,CAAC;AACJ,CAAC"}

package/dist/editor/ai/AgentTerminal.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import React, { useEffect, useState, useRef, useCallback, useLayoutEffect, useMemo, } from "react";
 import { flushSync } from "react-dom";
 import { Send, AlertCircle, Loader2, Wand2, Square, Mic, MicOff, ChevronDown, ChevronUp, ArrowLeft, DollarSign, ExternalLink, Settings2, Target, X, Plus, Lock, } from "lucide-react";
-import { getAgent, startAgent, claimAgentBrowser, cancelAgentDialog, assignAgentSkill, persistDraftAgent, updateAgentSettings, updateAgentCostLimit, updateAgentContext, getAgentSkillCatalog, getAgentAvailableTools, getAgentOperationAllowances, getAgentTriggerSubscriptions, cancelAgent, canonicalizeAgentMetadata, getPendingPrompts, getAgentDiagnostics, releaseAgentBrowser, rejectToolCall, revokeAgentSkill, isAgentReadOnly, } from "../services/agentService";
+import { getAgent, startAgent, claimAgentBrowser, cancelAgentDialog, acceptAgentDialog, replayAgentDialog, assignAgentSkill, persistDraftAgent, updateAgentSettings, updateAgentCostLimit, updateAgentContext, getAgentSkillCatalog, getAgentAvailableTools, getAgentOperationAllowances, getAgentTriggerSubscriptions, cancelAgent, canonicalizeAgentMetadata, getPendingPrompts, getAgentDiagnostics, releaseAgentBrowser, rejectToolCall, revokeAgentSkill, isAgentReadOnly, } from "../services/agentService";
 import { parseAgentRunStatusData, parseAgentStatus, } from "../services/agentStatus";
 import { useEditContext, useFieldsEditContext } from "../client/editContext";
 import { localStorageService } from "../services/localStorageService";
@@ -47,7 +47,7 @@ import { forceEditorSocketReconnect } from "../client/hooks/useEditorWebSocket";
 import { SimpleTabs } from "../ui/SimpleTabs";
 import { Splitter } from "../ui/Splitter";
 import { ScrollingContentTree } from "../ScrollingContentTree";
-import { requestAgentSubscriptionReplay, subscribeAgent, } from "../services/agentSubscriptionRegistry";
+import { subscribeAgent } from "../services/agentSubscriptionRegistry";
 import { registerMountedInstance, unregisterMountedInstance, setVisibleDialogEntry, clearVisibleDialogEntriesForInstance, updateInstanceFocus, isElectedDialogReceiver, } from "./agentDialogRegistry";
 const RECENT_RUN_EVENTS_LIMIT = 50;
 const STOP_STALE_RUNNING_LOAD_SUPPRESSION_MS = 5000;
@@ -79,6 +79,10 @@ function hasStaleRunningLoadSuppression(agentId) {
     }
     return true;
 }
+function normalizeInitialPrompt(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
 // interface AgentTerminalProps {
 //   agentStub: Agent;
 // }
@@ -90,6 +94,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
     const effectiveIsVisible = isVisible ?? isActive ?? true;
     const effectiveIsFocused = isFocused ?? isActive ?? true;
     const editContext = useEditContext();
+    const editContextRef = useRef(editContext);
+    useEffect(() => {
+        editContextRef.current = editContext;
+    }, [editContext]);
     const fieldsContext = useFieldsEditContext();
     const [agent, setAgent] = useState(() => buildPlaceholderAgentDetails(agentStub));
     const [messages, setMessages] = useState([]);
@@ -373,19 +381,79 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             if (activeCallbackId === normalizedCallbackId) {
                 return;
             }
-            const replayRequested = requestAgentSubscriptionReplay(agentId);
-            appendToolUiEvent(replayRequested
-                ? "ui:pending-dialog-replay-requested"
-                : "ui:pending-dialog-replay-skipped", `${dialogType || "dialog"} callbackId=${normalizedCallbackId} agentId=${agentId}`);
+            if (!editContext?.sessionId) {
+                appendToolUiEvent("ui:pending-dialog-replay-skipped", `${dialogType || "dialog"} callbackId=${normalizedCallbackId} agentId=${agentId} reason=no-session`);
+                return;
+            }
+            void replayAgentDialog({
+                callbackId: normalizedCallbackId,
+                agentId,
+                reason: "frontend-recover",
+                terminalInstanceId: dialogTerminalInstanceIdRef.current,
+                sessionId: editContext.sessionId,
+            })
+                .then((result) => {
+                appendToolUiEvent("ui:pending-dialog-replay-requested", `${dialogType || "dialog"} callbackId=${normalizedCallbackId} agentId=${agentId} replayed=${result.replayed ?? 0}`);
+            })
+                .catch((error) => {
+                appendToolUiEvent("ui:pending-dialog-replay-failed", `${dialogType || "dialog"} callbackId=${normalizedCallbackId} agentId=${agentId} error=${error instanceof Error ? error.message : String(error)}`);
+            });
         }, 750);
         pendingDialogReplayTimeoutsRef.current.add(timeout);
-    }, [appendToolUiEvent]);
+    }, [appendToolUiEvent, editContext?.sessionId]);
     useEffect(() => {
         return () => {
             pendingDialogReplayTimeoutsRef.current.forEach((timeout) => clearTimeout(timeout));
             pendingDialogReplayTimeoutsRef.current.clear();
         };
     }, []);
+    useEffect(() => {
+        const currentStatus = parseAgentStatus(agent?.status);
+        if (currentStatus !== "waitingForInput" ||
+            activeInlineDialog ||
+            !editContext?.sessionId) {
+            return;
+        }
+        let cancelled = false;
+        appendToolUiEvent("ui:pending-dialog-recovery-check-started", `agentId=${agentStub.id} status=${currentStatus} activeDialog=false`);
+        void getAgentDiagnostics(agentStub.id, editContext.sessionId)
+            .then((diagnostics) => {
+            if (cancelled || activeInlineDialogRef.current)
+                return;
+            const pendingDialogs = diagnostics.pendingDialogs ?? [];
+            const pendingDialog = pendingDialogs.find((dialog) => dialog.replayableToCurrentSession &&
+                dialog.callbackId &&
+                dialog.dialogType !== DIALOG_TYPES.CAPTURE_PAGE_DOM &&
+                dialog.dialogType !== DIALOG_TYPES.CAPTURE_PAGE_SCREENSHOT);
+            if (!pendingDialog) {
+                appendToolUiEvent("ui:pending-dialog-recovery-check-not-required", `agentId=${agentStub.id} pendingDialogCount=${diagnostics.pendingDialogCount ?? pendingDialogs.length} replayableDialogs=${pendingDialogs.length}`);
+                return;
+            }
+            appendToolUiEvent("ui:pending-dialog-recovery-check-required", `${pendingDialog.dialogType} callbackId=${pendingDialog.callbackId} agentId=${agentStub.id}`);
+            window.dispatchEvent(new CustomEvent("agent:dialog:recover", {
+                detail: {
+                    agentId: agentStub.id,
+                    callbackId: pendingDialog.callbackId,
+                    dialogType: pendingDialog.dialogType,
+                    terminalInstanceId: dialogTerminalInstanceIdRef.current,
+                },
+            }));
+            schedulePendingDialogReplay(agentStub.id, pendingDialog.callbackId, pendingDialog.dialogType);
+        })
+            .catch((error) => {
+            appendToolUiEvent("ui:pending-dialog-recovery-lookup-failed", error instanceof Error ? error.message : String(error));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        agent?.status,
+        agentStub.id,
+        activeInlineDialog,
+        appendToolUiEvent,
+        editContext?.sessionId,
+        schedulePendingDialogReplay,
+    ]);
     // Collect all pending tool calls for batch approval functionality.
     // Returns a stable reference when the content is equivalent so consumers
     // (memoized children) don't re-render on every streaming token.
@@ -1301,6 +1369,19 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
     const pendingSettingsRef = useRef(null);
     // Track whether textarea should maintain focus during re-renders
     const shouldMaintainFocusRef = useRef(false);
+    // The splash screen clears initialPrompt after first render; keep a local
+    // copy until the terminal is ready to submit it.
+    const pendingInitialPromptRef = useRef(normalizeInitialPrompt(initialPrompt));
+    const submittedInitialPromptKeyRef = useRef(null);
+    useEffect(() => {
+        const normalizedPrompt = normalizeInitialPrompt(initialPrompt);
+        if (!normalizedPrompt)
+            return;
+        const promptKey = `${agentStub.id}:${normalizedPrompt}`;
+        if (submittedInitialPromptKeyRef.current === promptKey)
+            return;
+        pendingInitialPromptRef.current = normalizedPrompt;
+    }, [agentStub.id, initialPrompt]);
     // Auto-scroll to bottom when new messages arrive
     const scrollToBottom = useCallback(() => {
         const container = messagesContainerRef.current;
@@ -3858,6 +3939,18 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 window.dispatchEvent(new CustomEvent("agent:dialog:accepted", {
                     detail: { callbackId: request.callbackId },
                 }));
+                const currentEditContext = editContextRef.current;
+                if (currentEditContext?.sessionId) {
+                    void acceptAgentDialog({
+                        callbackId: request.callbackId,
+                        agentId: request.agentId,
+                        dialogType: request.dialogType,
+                        terminalInstanceId,
+                        sessionId: currentEditContext.sessionId,
+                    }).catch((error) => {
+                        console.warn("[AgentTerminal] Failed to acknowledge dialog:", error);
+                    });
+                }
             }
             setTimeout(() => {
                 if (request.dialogType === "questionnaire") {
@@ -4410,6 +4503,45 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             setIsSubmitting(false);
         }
     };
+    useEffect(() => {
+        const promptToSubmit = pendingInitialPromptRef.current;
+        if (!promptToSubmit)
+            return;
+        const promptKey = `${agentStub.id}:${promptToSubmit}`;
+        if (submittedInitialPromptKeyRef.current === promptKey) {
+            pendingInitialPromptRef.current = null;
+            return;
+        }
+        if (!effectiveIsFocused ||
+            isLoading ||
+            isSubmitting ||
+            readOnly ||
+            !editContext ||
+            !agent?.id ||
+            !activeProfile) {
+            return;
+        }
+        if ((activeProfile.models?.length ?? 0) > 0 && !selectedModelId)
+            return;
+        if (initialMetadata && !agentMetadata)
+            return;
+        submittedInitialPromptKeyRef.current = promptKey;
+        pendingInitialPromptRef.current = null;
+        void handleSubmit(promptToSubmit);
+    }, [
+        activeProfile,
+        agent?.id,
+        agentMetadata,
+        agentStub.id,
+        editContext,
+        effectiveIsFocused,
+        handleSubmit,
+        initialMetadata,
+        isLoading,
+        isSubmitting,
+        readOnly,
+        selectedModelId,
+    ]);
     const handlePaste = (e) => {
         if (!activeProfile?.enableDocumentUpload || !documentListRef.current)
             return;