@wildo-ai/saas-backend-lib 1.1.2 → 1.1.4

package/dist/esm/requests/service/websocket.service.js

@@ -20,7 +20,7 @@ import { AppConfigurationService } from '../../config/services/app-configuration
 import { RedisService } from '../../databases/services/redis.service.js';
 import { ErrorBuilderBackendService } from '../../errors/services/error-builder.backend.service.js';
 import { runInFreshRequestContextIfAbsent } from '../../runtime/models/request-context.als.backend.js';
-import { ErrorCustomMessageReference, ErrorType, ExecutionContext_ExecutionType, ResourcePrimaryScope, CoreResourceOperation, CoreResourceType, ARRAY_RESPONSE_OPERATIONS, DataMode, ResourcesConfigOperationsDtosBuilderUtils, ResourcesConfig_OperationPathUtils, ResourceOperationsUtils, WildoHeaderKeys, ResourceOperationVariantType, isWildoBackendError, } from '@wildo-ai/saas-models';
+import { ErrorCustomMessageReference, ErrorType, ExecutionContext_ExecutionType, ResourcePrimaryScope, isSupportedNotificationBadgeScope, CoreResourceOperation, CoreResourceType, ARRAY_RESPONSE_OPERATIONS, DataMode, ResourcesConfigOperationsDtosBuilderUtils, ResourcesConfig_OperationPathUtils, ResourceOperationsUtils, WildoHeaderKeys, ResourceOperationVariantType, isWildoBackendError, } from '@wildo-ai/saas-models';
 import { ExecutionContextCreatorBackendService, } from '../../runtime/services/execution-context-creator.backend.service.js';
 import { AuthorizationsBackendService } from '../../security/authorizations/services/authorizations.backend.service.js';
 import { ResourcesRegistryBackendService } from '../../resources/services/resources-registry.backend.service.js';
@@ -2085,12 +2085,44 @@ let WebSocketService = class WebSocketService {
             const initiator = auth?.initiatorIds;
             if (!initiator?.userId)
                 return;
+            const approverUserId = initiator.userId;
             await this.getConversationalExecutionService().respondToApproval({
                 systemRef: parsed.data.systemRef,
                 executionId: parsed.data.executionId,
                 approvalId: parsed.data.approvalId,
                 approved: parsed.data.approved,
-                scopeContext: { userId: initiator.userId },
+                scopeContext: { userId: approverUserId },
+                /*
+                 * The channel back to the approver — and until now this handler passed NONE.
+                 *
+                 * `resumeAfterApproval` streams the resumed reply and its final message through
+                 * `params.emitter?.(…)`, and its own comments say so ("the agent's reply was emitted to the
+                 * live socket"). At the only production call site there was no emitter, so every one of
+                 * those calls was a no-op: a person approved a tool call and their screen showed nothing
+                 * until they reloaded, which read as a resume that had not happened.
+                 *
+                 * It became load-bearing rather than merely missing with approve-with-modifications (#566):
+                 * an edit the server REFUSES has to reach the human who made it, or the surface has
+                 * collected a change and dropped it — the exact outcome #537 refused to ship.
+                 *
+                 * Same construction as the START handler above: the initiating user's own room, bound to
+                 * the SERVER-VALIDATED id, never anything from the payload.
+                 */
+                emitter: (event, payload) => {
+                    if (!this.io)
+                        return;
+                    this.io.to(buildUserRoomName(approverUserId)).emit(event, payload);
+                },
+                /*
+                 * The arguments the approver AUTHORED, when they edited the proposed call (#566).
+                 *
+                 * Forwarded rather than interpreted: this handler cannot know the tool's `inputSchema`, and
+                 * the browser's validation is a convenience. The server re-validates against the tool's own
+                 * schema, re-signs the approval over the modified input, and refuses back through the
+                 * emitter above with the pause left standing — so a rejected edit costs an error message
+                 * rather than the turn.
+                 */
+                modifiedToolArgs: parsed.data.modifiedToolArgs,
                 // The APPROVER's verified auth. The resumed turn executes the gated tool, and it must do so
                 // with a real identity — without this the agent resolves no tools at all and the approval
                 // completes having done nothing. Passing the socket's own auth (never anything from the
@@ -2100,6 +2132,22 @@ let WebSocketService = class WebSocketService {
                 // unresumable: the resume filtered on the DEFAULT sentinel while the paused execution had
                 // been written with the named ref, so the read matched nothing and returned silently.
                 resourceServerInstanceRef: parsed.data.resourceServerInstanceRef,
+                /*
+                 * The approver's own words, forwarded to the model — and until 2026-09-09 they were not.
+                 *
+                 * `comment` is offered by the approval surface, sent by the browser and validated by the
+                 * payload schema; this handler parsed it and passed everything EXCEPT it, so `reason` was
+                 * always `undefined` and the text a person typed to explain their decision reached nothing.
+                 * The UI collected it, the wire carried it, and it was dropped one function short of the
+                 * `tool-approval-response` that would have shown it to the agent.
+                 *
+                 * That is the same defect #537 refused to ship for a MODIFIED ARGUMENT — a surface that
+                 * collects a change and silently discards it — already live for the field beside it. It
+                 * matters most on a DENIAL: denying resumes the turn so the model can respond, and "no,
+                 * send it to finance instead" is the difference between the agent re-proposing something
+                 * useful and answering that it cannot proceed.
+                 */
+                reason: parsed.data.comment,
             });
         });
     }
@@ -2154,8 +2202,20 @@ let WebSocketService = class WebSocketService {
                 return;
             try {
                 const auth = this.getSocketAuth(socket);
+                /**
+                 * `payload.scope` is CLIENT-supplied. It used to be cast (`as ResourcePrimaryScope`) and
+                 * handed straight to the access check and the badge service, so a scope no resource type
+                 * backs — `application`, dropped by the polymorphism refactor — reached both and was
+                 * answered with a silent zero. Parse it instead: an unsupported scope is refused here, and
+                 * what continues is a value the badge service's own two-scope contract can accept.
+                 */
+                if (!isSupportedNotificationBadgeScope(payload.scope)) {
+                    callback({ count: 0 });
+                    return;
+                }
+                const badgeScope = payload.scope;
                 // Verify user has access to this scope
-                if (!this.verifyBadgeScopeAccess(auth, payload.scope, payload.scopeId)) {
+                if (!this.verifyBadgeScopeAccess(auth, badgeScope, payload.scopeId)) {
                     callback({ count: 0 });
                     return;
                 }
@@ -2166,7 +2226,7 @@ let WebSocketService = class WebSocketService {
                     return;
                 }
                 const executionContext = await this.executionContextCreator.buildContextFromSocketAuth(auth, appReadOp, {});
-                const count = await this.getBadgeService().getBadgeCount(executionContext, payload.scope, payload.scopeId, payload.identifier);
+                const count = await this.getBadgeService().getBadgeCount(executionContext, badgeScope, payload.scopeId, payload.identifier);
                 callback({ count });
             }
             catch (error) {
@@ -2182,8 +2242,14 @@ let WebSocketService = class WebSocketService {
                 return;
             try {
                 const auth = this.getSocketAuth(socket);
+                // Same parse-don't-cast as `badge:get` above — see the comment there.
+                if (!isSupportedNotificationBadgeScope(payload.scope)) {
+                    callback([]);
+                    return;
+                }
+                const badgeScope = payload.scope;
                 // Verify user has access to this scope
-                if (!this.verifyBadgeScopeAccess(auth, payload.scope, payload.scopeId)) {
+                if (!this.verifyBadgeScopeAccess(auth, badgeScope, payload.scopeId)) {
                     callback([]);
                     return;
                 }
@@ -2194,7 +2260,7 @@ let WebSocketService = class WebSocketService {
                     return;
                 }
                 const executionContext = await this.executionContextCreator.buildContextFromSocketAuth(auth, appReadOp, {});
-                const badges = await this.getBadgeService().getAllBadges(executionContext, payload.scope, payload.scopeId);
+                const badges = await this.getBadgeService().getAllBadges(executionContext, badgeScope, payload.scopeId);
                 callback(badges);
             }
             catch (error) {
@@ -2208,6 +2274,15 @@ let WebSocketService = class WebSocketService {
     /**
      * Verify user has access to a badge scope
      */
+    /**
+     * May this socket read badges at `(scope, scopeId)`?
+     *
+     * Typed `NotificationScope` rather than `ResourcePrimaryScope` because only two scopes have a
+     * badge resource behind them. The removed third arm granted access to "application-level badges"
+     * on the strength of holding any application role — a survivor of the polymorphism refactor that
+     * dropped the APPLICATION variant, so it authorized reads of badges that cannot exist. Callers
+     * now refuse an unsupported scope before they get here.
+     */
     verifyBadgeScopeAccess(auth, scope, scopeId) {
         // Public users cannot access badges
         if (auth.executionType === ExecutionContext_ExecutionType.PUBLIC_EXECUTION) {
@@ -2221,9 +2296,6 @@ let WebSocketService = class WebSocketService {
                 // User must be member of the organization
                 return auth.initiatorRoles.some(r => r.relatedPrimaryScope === ResourcePrimaryScope.ORGANIZATIONS &&
                     r.relatedResourceId === scopeId);
-            case ResourcePrimaryScope.APPLICATION:
-                // Application-level badges - check if user has any app roles
-                return auth.initiatorRoles.some(r => r.relatedPrimaryScope === ResourcePrimaryScope.APPLICATION);
             default:
                 return false;
         }