@wildo-ai/saas-frontend-lib 1.1.4 → 1.1.6

package/dist/esm/core/flows-actors/FlowsActorsContext.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useState, useMemo, useEffect, useCallback, useRef } from 'react';
-import { MAIN_API_BASE_PATH, MANUAL_CONTROLLER_ROUTES_URLS, ManualControllerRouteKey, CoreWebSocketEvent, WS_FlowsActorsApprovalAnnouncementDataSchema, } from '@wildo-ai/saas-models';
+import { MAIN_API_BASE_PATH, MANUAL_CONTROLLER_ROUTES_URLS, ManualControllerRouteKey, CoreWebSocketEvent, WS_FlowsActorsApprovalAnnouncementDataSchema, FlowsActors_ExecutionErrorCode, canonicalizeFlowsActorsContextRef, } from '@wildo-ai/saas-models';
 import { LoggerFrontendService } from '../../core/monitoring/logger.frontend.service.js';
 import { errorManagement } from '../../core/errors/error-management.frontend.service.js';
 import { useApplication } from '../../core/runtime/useApplication.js';
@@ -57,6 +57,31 @@ export var FlowsActorsExecutionStatus;
     FlowsActorsExecutionStatus["COMPLETED"] = "completed";
     FlowsActorsExecutionStatus["ERROR"] = "error";
 })(FlowsActorsExecutionStatus || (FlowsActorsExecutionStatus = {}));
+/**
+ * The one mapping from a server approval announcement to the client's pending decision — shared by the
+ * live socket handler and the history seeding (#1601), so a decision reached either way renders and
+ * answers identically.
+ *
+ * `actionDescription` is the SERVER's sentence (the PROGRESS text, or the history's `description`),
+ * never composed here from `toolName`: that would invent display text no i18n tree owns.
+ */
+function pendingApprovalFromAnnouncement(announcement, actionDescription) {
+    const { approvalId, decisionRef, routeKind, toolName, toolArgs, toolInputSchema, requestedAt, expiresAt, reasonCodes } = announcement;
+    return {
+        approvalId,
+        actionDescription,
+        toolName,
+        toolArgs,
+        // A descriptor the transport does not re-validate (#587) — typed here for the editor, which falls
+        // back to raw JSON for any shape it cannot render as fields.
+        toolInputSchema: toolInputSchema,
+        requestedAt: new Date(requestedAt),
+        expiresAt: expiresAt ? new Date(expiresAt) : undefined,
+        decisionRef,
+        routeKind,
+        ...(reasonCodes && reasonCodes.length > 0 ? { reasonCodes } : {}),
+    };
+}
 /**
  * FlowsActors Context
  * @internal - Use useFlowsActors() hook instead of accessing this directly
@@ -78,6 +103,7 @@ export const FlowsActorsProvider = ({ children }) => {
     const hasInitializedRef = useRef(false);
     const hasConfiguredFlowsActorsViews = (frontendConfiguration?.flowsActorsViews?.length ?? 0) > 0;
     const [systems, setSystems] = useState([]);
+    const [autonomousAgents, setAutonomousAgents] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [executions, setExecutions] = useState(new Map());
@@ -124,6 +150,7 @@ export const FlowsActorsProvider = ({ children }) => {
             // registers with) so both sides stay in lockstep under MAIN_API_BASE_PATH.
             const data = await httpClient.get(`${MAIN_API_BASE_PATH}${MANUAL_CONTROLLER_ROUTES_URLS[ManualControllerRouteKey.FLOWS_ACTORS_FRONTEND_INFO]}`);
             setSystems(data.systems);
+            setAutonomousAgents(data.autonomousAgents);
             setHasCompletedFetch(true);
             logDebug('Systems refreshed', { count: data.systems.length });
         }
@@ -131,6 +158,7 @@ export const FlowsActorsProvider = ({ children }) => {
             if (errorManagement.isNotFoundError(err)) {
                 logDebug('FlowsActors backend support not available - skipping systems bootstrap');
                 setSystems([]);
+                setAutonomousAgents([]);
                 setError(null);
                 setHasCompletedFetch(true);
                 return;
@@ -149,15 +177,51 @@ export const FlowsActorsProvider = ({ children }) => {
      * owner filter restricts rows to the caller's threads. A missing backend
      * surface (feature absent) resolves to `[]`, never an error.
      */
-    const fetchConversationHistory = useCallback(async (systemRef) => {
+    const fetchConversationHistory = useCallback(async (systemRef, contextResourceIdentifiers) => {
         if (!httpClient) {
             logDebug('Cannot fetch conversation history - httpClient not available');
             return [];
         }
         try {
             const basePath = `${MAIN_API_BASE_PATH}${MANUAL_CONTROLLER_ROUTES_URLS[ManualControllerRouteKey.FLOWS_ACTORS_HISTORY]}`;
-            const data = await httpClient.get(`${basePath}?systemRef=${encodeURIComponent(systemRef)}`);
+            const contextRef = contextResourceIdentifiers === undefined
+                ? undefined
+                : canonicalizeFlowsActorsContextRef({
+                    ...(appScope?.currentOrganizationId ? { organizationId: appScope.currentOrganizationId } : {}),
+                    ...contextResourceIdentifiers,
+                });
+            const query = `?systemRef=${encodeURIComponent(systemRef)}${contextRef === undefined ? '' : `&contextRef=${encodeURIComponent(contextRef)}`}`;
+            const data = await httpClient.get(`${basePath}${query}`);
             logDebug('Conversation history fetched', { systemRef, count: data.executions.length });
+            /*
+             * A thread whose turn is paused on a decision becomes an execution here, carrying that
+             * decision (#1601). The pause is announced only over the live socket, so a page that loaded
+             * after it — a reload, a second tab, a restart — had a thread waiting on an answer and nothing
+             * to answer it with: the creator saw their message sit unanswered. The history route now
+             * returns the same announcement the socket carried, and it is folded through the same mapping.
+             *
+             * A live entry is never replaced: the socket is the fresher source for a turn this page is
+             * watching, and a seeded copy could revive a decision this client just answered.
+             */
+            const paused = data.executions.filter((row) => row.pendingApproval !== undefined);
+            if (paused.length > 0) {
+                setExecutions((prev) => {
+                    let next;
+                    for (const row of paused) {
+                        if (prev.has(row.executionId) || row.pendingApproval === undefined)
+                            continue;
+                        next ??= new Map(prev);
+                        next.set(row.executionId, {
+                            executionId: row.executionId,
+                            systemRef: row.systemRef,
+                            status: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
+                            messages: [],
+                            pendingApproval: pendingApprovalFromAnnouncement(row.pendingApproval, row.pendingApproval.description),
+                        });
+                    }
+                    return next ?? prev;
+                });
+            }
             return data.executions;
         }
         catch (err) {
@@ -168,7 +232,7 @@ export const FlowsActorsProvider = ({ children }) => {
             logDebug('Failed to fetch conversation history', { systemRef, error: err instanceof Error ? err.message : 'unknown' });
             return [];
         }
-    }, [httpClient]);
+    }, [httpClient, appScope?.currentOrganizationId]);
     /**
      * Delete one of the caller's persisted conversations. Owner-scoped server-side
      * (USER_SELF), so a user can only delete their own discussion.
@@ -186,7 +250,7 @@ export const FlowsActorsProvider = ({ children }) => {
      * Start a new execution via WebSocket (fire-and-forget).
      * Errors are delivered asynchronously via FLOWS_ACTORS_STARTED / FLOWS_ACTORS_ERROR events.
      */
-    const startExecution = useCallback((systemRef, initialInput, existingExecutionId) => {
+    const startExecution = useCallback((systemRef, initialInput, existingExecutionId, extraContextResourceIdentifiers, options) => {
         if (!isConnected) {
             logDebug('Cannot start execution — WebSocket not connected', { systemRef });
             return null;
@@ -195,10 +259,17 @@ export const FlowsActorsProvider = ({ children }) => {
         // new one to start a fresh discussion.
         const executionId = existingExecutionId ?? crypto.randomUUID();
         logDebug('Starting execution', { systemRef, executionId, hasInput: !!initialInput, isContinuation: !!existingExecutionId });
+        /*
+         * The scope's own identifiers first, the caller's on top: a surface that hosts one system for
+         * several subjects (a tool pointed at one application at a time) names the subject here, and
+         * the backend folds the whole set into the thread's `contextRef`, which `fetchConversationHistory`
+         * lists by when handed the same identifiers.
+         */
         const contextResourceIdentifiers = {};
         if (appScope?.currentOrganizationId) {
             contextResourceIdentifiers.organizationId = appScope.currentOrganizationId;
         }
+        Object.assign(contextResourceIdentifiers, extraContextResourceIdentifiers ?? {});
         setExecutions(prev => {
             const next = new Map(prev);
             // Reset messages every turn: the live execution holds ONLY the current
@@ -218,6 +289,7 @@ export const FlowsActorsProvider = ({ children }) => {
             executionId,
             contextResourceIdentifiers,
             initialInput,
+            ...(options?.caseRef ? { caseRef: options.caseRef } : {}),
         });
         return executionId;
     }, [isConnected, emit, appScope?.currentOrganizationId]);
@@ -225,7 +297,7 @@ export const FlowsActorsProvider = ({ children }) => {
      * Respond to an approval request via WebSocket (fire-and-forget).
      * Backend confirms via FLOWS_ACTORS_STATUS_UPDATE / FLOWS_ACTORS_ERROR events.
      */
-    const respondToApproval = useCallback((executionId, approvalId, approved, comment, modifiedToolArgs) => {
+    const respondToApproval = useCallback((executionId, approvalId, approved, comment, modifiedToolArgs, reasonCode) => {
         const execution = executionsRef.current.get(executionId);
         if (!execution) {
             logDebug('Cannot respond to approval — execution not found', { executionId, approvalId });
@@ -243,13 +315,11 @@ export const FlowsActorsProvider = ({ children }) => {
             approved,
             comment,
             /*
-             * Echoed, never omitted. The resume filters on owner FK + machine credential + AGENT
-             * INSTANCE; without this axis the read is filtered against the default-instance sentinel, so
-             * a decision on an approval raised by a NAMED agent matches no row and is dropped silently —
-             * logged as "no pending approval matches", with the turn paused forever. The server sends it
-             * unconditionally for exactly this reason.
+             * The decision's id, echoed (#1594). The server addresses the answer by it and reads the owner,
+             * credential and agent instance off the row — so nothing here can point the answer at a different
+             * conversation, and a reviewer answering someone else's decision reaches it.
              */
-            resourceServerInstanceRef: execution.pendingApproval?.resourceServerInstanceRef,
+            ...(execution.pendingApproval?.decisionRef ? { decisionRef: execution.pendingApproval.decisionRef } : {}),
             /*
              * The arguments the approver AUTHORED (#566), when they edited the proposed call.
              *
@@ -258,11 +328,19 @@ export const FlowsActorsProvider = ({ children }) => {
              * refusal — the mirror of the defect that made this field necessary.
              */
             ...(modifiedToolArgs ? { modifiedToolArgs } : {}),
+            // Why the approver changed or rejected the call (#1921), one of the application's declared codes. The server
+            // checks it against the same vocabulary and refuses an undeclared one, leaving the pause standing.
+            ...(reasonCode ? { reasonCode } : {}),
         });
         updateExecution(executionId, exec => ({
             ...exec,
             status: approved ? FlowsActorsExecutionStatus.RUNNING : exec.status,
             pendingApproval: undefined,
+            // Kept until the server reacts: a REFUSED modification leaves the pause standing, and this is
+            // what the error handler restores — with the arguments the approver submitted (#587).
+            answeredApproval: exec.pendingApproval
+                ? { approval: exec.pendingApproval, ...(modifiedToolArgs ? { submittedToolArgs: modifiedToolArgs } : {}) }
+                : undefined,
         }));
     }, [isConnected, emit, updateExecution]);
     /**
@@ -295,9 +373,20 @@ export const FlowsActorsProvider = ({ children }) => {
         }
         hasInitializedRef.current = false;
         setSystems([]);
+        setAutonomousAgents([]);
         setError(null);
         setExecutions(new Map());
     }, [userOrgs]);
+    const requestAutonomousAgents = useCallback(() => {
+        if (hasInitializedRef.current
+            || !appConfig?.runtime?.endPoints?.main_backend_api
+            || !httpClient
+            || !userOrgs.isAuthenticated()) {
+            return;
+        }
+        hasInitializedRef.current = true;
+        void refreshSystems();
+    }, [appConfig?.runtime?.endPoints?.main_backend_api, httpClient, userOrgs, refreshSystems]);
     useEffect(() => {
         if (!hasInitializedRef.current
             && hasConfiguredFlowsActorsViews
@@ -314,6 +403,44 @@ export const FlowsActorsProvider = ({ children }) => {
         userOrgs,
         refreshSystems,
     ]);
+    /**
+     * A dropped socket ENDS every turn still in flight on it.
+     *
+     * The server emits a turn's events to the socket that started it (`conversational-execution`'s
+     * emitter is bound to that socket), so once it drops, no `STARTED`, `MESSAGE`, `COMPLETED` or
+     * `ERROR` for that turn can ever arrive — not after a reconnect either, which opens a different
+     * socket. Before this, a turn sent into a companion that restarted a second later stayed `STARTING`
+     * for good: the page showed neither the question nor an error, and the composer sat on its stop
+     * button (measured for eight minutes on the creation workbench, 2026-09-24, #1464).
+     *
+     * Only `STARTING` and `RUNNING` end. A turn `AWAITING_APPROVAL` is a persisted suspension the person
+     * answers later, over whatever socket is live then, so a drop does not end it. The error is
+     * RECOVERABLE and names its cause with a CLIENT-DETECTED code, carrying no text of its own: every
+     * surface already words an errored turn, and a surviving server still completes and persists the
+     * turn, which the thread's history then shows.
+     */
+    const wasConnectedRef = useRef(isConnected);
+    useEffect(() => {
+        const dropped = wasConnectedRef.current && !isConnected;
+        wasConnectedRef.current = isConnected;
+        if (!dropped)
+            return;
+        setExecutions(prev => {
+            let next = null;
+            for (const [executionId, execution] of prev) {
+                if (execution.status !== FlowsActorsExecutionStatus.STARTING && execution.status !== FlowsActorsExecutionStatus.RUNNING)
+                    continue;
+                next ??= new Map(prev);
+                next.set(executionId, {
+                    ...execution,
+                    status: FlowsActorsExecutionStatus.ERROR,
+                    recoverable: true,
+                    errorCode: FlowsActors_ExecutionErrorCode.CONNECTION_LOST,
+                });
+            }
+            return next ?? prev;
+        });
+    }, [isConnected]);
     /**
      * WebSocket event listeners for FlowsActors inbound events.
      * Follows the WebSocketEventBridge pattern: subscribe on connect, cleanup on disconnect.
@@ -352,23 +479,16 @@ export const FlowsActorsProvider = ({ children }) => {
              */
             const announcement = WS_FlowsActorsApprovalAnnouncementDataSchema.safeParse(payload.data);
             if (announcement.success) {
-                const { approvalId, toolName, toolArgs, requestedAt, expiresAt, resourceServerInstanceRef } = announcement.data;
+                const { approvalId, toolName } = announcement.data;
                 logDebug('Approval requested', { executionId: payload.executionId, approvalId, toolName });
                 updateExecution(payload.executionId, exec => ({
                     ...exec,
                     status: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
-                    pendingApproval: {
-                        approvalId,
-                        // The server's own PROGRESS text, reused rather than composed here: manufacturing
-                        // display text from `toolName` in the browser would invent wording that no i18n
-                        // tree owns.
-                        actionDescription: payload.content,
-                        toolName,
-                        toolArgs,
-                        requestedAt: new Date(requestedAt),
-                        expiresAt: expiresAt ? new Date(expiresAt) : undefined,
-                        resourceServerInstanceRef,
-                    },
+                    // A new pause supersedes whatever this client answered before it.
+                    answeredApproval: undefined,
+                    // The server's own PROGRESS text, reused rather than composed here: manufacturing
+                    // display text from `toolName` in the browser would invent wording that no i18n tree owns.
+                    pendingApproval: pendingApprovalFromAnnouncement(announcement.data, payload.content),
                 }));
             }
             updateExecution(payload.executionId, exec => ({
@@ -392,9 +512,8 @@ export const FlowsActorsProvider = ({ children }) => {
          * withdrawn is a decision recorded on #528, not something to settle by deleting the listener:
          * if it is ever emitted, an approval must still be observable here.
          *
-         * Note it cannot supply `resourceServerInstanceRef` — its payload has no such field — so a
-         * decision answered from this path alone would still be unresumable on a named agent instance.
-         * That is another reason the payload's fate needs deciding rather than assuming.
+         * Note it carries no `decisionRef`, so a decision answered from this path is resolved by the
+         * server from `executionId` + `approvalId`.
          */
         const unsubApproval = on(CoreWebSocketEvent.FLOWS_ACTORS_APPROVAL_REQUEST, (payload) => {
             logDebug('Approval requested', { executionId: payload.executionId, approvalId: payload.approvalId, riskLevel: payload.riskLevel });
@@ -439,18 +558,97 @@ export const FlowsActorsProvider = ({ children }) => {
         });
         const unsubError = on(CoreWebSocketEvent.FLOWS_ACTORS_ERROR, (payload) => {
             logDebug('Execution error', { executionId: payload.executionId, errorCode: payload.errorCode, recoverable: payload.recoverable });
-            updateExecution(payload.executionId, exec => ({
-                ...exec,
-                status: FlowsActorsExecutionStatus.ERROR,
-                recoverable: payload.recoverable,
-                errorCode: payload.errorCode,
-                pendingApproval: undefined,
-                messages: appendMessages(exec.messages, {
-                    type: 'text',
-                    content: payload.errorMessage,
-                    timestamp: new Date(),
-                }),
-            }));
+            updateExecution(payload.executionId, exec => {
+                /*
+                 * A refused MODIFICATION is not a failed turn (#587). The server leaves the pause standing and
+                 * says so with `recoverable: true`, so the decision goes back on screen — with the reason, and
+                 * with the arguments the approver submitted — instead of vanishing while the server still
+                 * waits for it. Treating it as ERROR is what made the approval disappear on every refusal.
+                 */
+                if (payload.recoverable
+                    && payload.errorCode === FlowsActors_ExecutionErrorCode.APPROVAL_MODIFICATION_REJECTED
+                    && exec.answeredApproval) {
+                    return {
+                        ...exec,
+                        status: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
+                        recoverable: payload.recoverable,
+                        errorCode: payload.errorCode,
+                        pendingApproval: {
+                            ...exec.answeredApproval.approval,
+                            modificationRefusal: payload.approvalModificationRefusal ?? { reason: '' },
+                            rejectedToolArgs: exec.answeredApproval.submittedToolArgs,
+                            // A refusal of THIS answer, not the reason code of an earlier one (#1921).
+                            reasonCodeRefused: undefined,
+                        },
+                        answeredApproval: undefined,
+                    };
+                }
+                /*
+                 * A reason code the application does not declare is refused while the pause stands (#1921). The approval goes
+                 * back on screen as it was asked, and the card says why in its own labels — the server's English sentence is
+                 * not appended to the conversation, because words a reader sees come from the label tree.
+                 */
+                if (payload.recoverable
+                    && payload.errorCode === FlowsActors_ExecutionErrorCode.APPROVAL_REASON_CODE_REJECTED
+                    && exec.answeredApproval) {
+                    return {
+                        ...exec,
+                        status: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
+                        recoverable: payload.recoverable,
+                        errorCode: payload.errorCode,
+                        pendingApproval: {
+                            ...exec.answeredApproval.approval,
+                            modificationRefusal: undefined,
+                            rejectedToolArgs: undefined,
+                            reasonCodeRefused: true,
+                        },
+                        answeredApproval: undefined,
+                    };
+                }
+                /*
+                 * A decision refused by the application's consent requirement is not a failed turn either (#534). The
+                 * server checks the requirement BEFORE it releases the pause, so the approval still stands and can be
+                 * answered once the person has recorded their consent: it goes back on screen, and the reason joins the
+                 * conversation rather than masquerading as an argument-edit error.
+                 */
+                if (payload.recoverable
+                    && payload.errorCode === FlowsActors_ExecutionErrorCode.SERVICE_CONSENT_REQUIRED
+                    && exec.answeredApproval) {
+                    return {
+                        ...exec,
+                        status: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
+                        recoverable: payload.recoverable,
+                        errorCode: payload.errorCode,
+                        // Restored as it was ASKED, not as it was last refused: an earlier refused edit's error must not
+                        // reappear, and the arguments just submitted reopen the editor (#534 fourth review F5).
+                        pendingApproval: {
+                            ...exec.answeredApproval.approval,
+                            modificationRefusal: undefined,
+                            rejectedToolArgs: exec.answeredApproval.submittedToolArgs,
+                            reasonCodeRefused: undefined,
+                        },
+                        answeredApproval: undefined,
+                        messages: appendMessages(exec.messages, {
+                            type: 'text',
+                            content: payload.errorMessage,
+                            timestamp: new Date(),
+                        }),
+                    };
+                }
+                return {
+                    ...exec,
+                    status: FlowsActorsExecutionStatus.ERROR,
+                    recoverable: payload.recoverable,
+                    errorCode: payload.errorCode,
+                    pendingApproval: undefined,
+                    answeredApproval: undefined,
+                    messages: appendMessages(exec.messages, {
+                        type: 'text',
+                        content: payload.errorMessage,
+                        timestamp: new Date(),
+                    }),
+                };
+            });
         });
         return () => {
             unsubStarted();
@@ -463,6 +661,8 @@ export const FlowsActorsProvider = ({ children }) => {
     }, [isConnected, on, updateExecution]);
     const contextValue = useMemo(() => ({
         systems,
+        autonomousAgents,
+        requestAutonomousAgents,
         isLoading,
         error,
         executions,
@@ -474,7 +674,7 @@ export const FlowsActorsProvider = ({ children }) => {
         refreshSystems,
         fetchConversationHistory,
         deleteConversation,
-    }), [systems, isLoading, error, executions, startExecution, respondToApproval, clearExecution, getExecution, getSystem, refreshSystems, fetchConversationHistory, deleteConversation]);
+    }), [systems, autonomousAgents, requestAutonomousAgents, isLoading, error, executions, startExecution, respondToApproval, clearExecution, getExecution, getSystem, refreshSystems, fetchConversationHistory, deleteConversation]);
     return (_jsx(FlowsActorsContext.Provider, { value: contextValue, children: children }));
 };
 //# sourceMappingURL=FlowsActorsContext.js.map