@sendinel/mcp-server 1.0.121 → 1.0.122

package/build/lib/approval-elicitation-relay.js

@@ -1,3 +1,4 @@
+import { ELICITATION_HOLD_MS } from './approval-elicitation.js';
 import { randomUUID } from 'node:crypto';
 import { approvalStore } from './tester-requests-store.js';
 import { humanApprovalEligible } from './approval-human-eligibility.js';
@@ -20,9 +21,10 @@ export async function recordElicitationResponse(body, identity) {
         (typeof message.id !== 'string' && typeof message.id !== 'number') ||
         ('error' in message) || !identity.oauthTokenId || !identity.actorId)
         return;
-    const result = object(message.result), content = object(result?.content);
-    if (result?.action !== 'accept' || (content?.decision !== 'approve' && content?.decision !== 'reject'))
+    const result = object(message.result);
+    if (result?.action !== 'accept' && result?.action !== 'decline')
         return;
+    const decision = result.action === 'accept' ? 'approve' : 'reject';
     try {
         const client = email(), now = new Date().toISOString();
         const { data: prompt, error } = await client.from(TABLE).select('*')
@@ -48,7 +50,7 @@ export async function recordElicitationResponse(body, identity) {
             return;
         const { data, error: rpcError } = await client.rpc('record_elicitation_decision', {
             p_prompt_id: prompt.id, p_oauth_token_id: identity.oauthTokenId, p_user_id: identity.actorId,
-            p_decision: content.decision, p_project_id: prompt.project_id, p_action: approval.action,
+            p_decision: decision, p_project_id: prompt.project_id, p_action: approval.action,
         });
         if (rpcError || data !== true)
             return;
@@ -99,7 +101,7 @@ export async function relayElicitation(options) {
             return pending;
         // The id is created here and passed unchanged both to the row and the actual transport.
         await options.send({ jsonrpc: '2.0', id: requestId, method: 'elicitation/create', params: options.params });
-        while (!signal.aborted && Date.now() < now + 60_000) {
+        while (!signal.aborted && Date.now() < now + ELICITATION_HOLD_MS) {
             const { data: prompt, error: readError } = await client.from(TABLE).select('status, answer, expires_at')
                 .eq('id', promptId).eq('oauth_token_id', identity.oauthTokenId).eq('user_id', identity.actorId).maybeSingle();
             if (signal.aborted || readError || !prompt || !(Date.parse(prompt.expires_at) > Date.now()))
@@ -109,7 +111,7 @@ export async function relayElicitation(options) {
             if (prompt.status !== 'pending')
                 return pending;
             await new Promise(resolve => {
-                const timer = setTimeout(done, 750);
+                const timer = setTimeout(done, Math.min(750, Math.max(0, now + ELICITATION_HOLD_MS - Date.now())));
                 function done() { clearTimeout(timer); signal.removeEventListener('abort', done); resolve(); }
                 signal.addEventListener('abort', done, { once: true });
                 if (signal.aborted)

package/build/lib/approval-elicitation.d.ts

@@ -34,7 +34,11 @@ export type TransportBinding = {
 type RequestExtra = {
     requestId?: RequestId;
     signal?: AbortSignal;
+    _meta?: {
+        progressToken?: string | number;
+    };
 };
+export declare const ELICITATION_HOLD_MS = 30000;
 export declare function installApprovalElicitation(server: Pick<McpServer, 'server'>, binding: TransportBinding): void;
 /** Called by the registry wrapper with SDK-owned extra, outside parsed model arguments. */
 export declare function runWithApprovalElicitation<T>(server: Pick<McpServer, 'server'>, extra: RequestExtra | undefined, run: () => T): T;

package/build/lib/approval-elicitation.js

@@ -9,7 +9,8 @@ import { approvalAppClientAllowed, approvalClientName, approval_channel_availabl
 // McpServer in a Proxy, which changes the wrapper's identity but never the connection's Server.
 const sessions = new WeakMap();
 const requests = new AsyncLocalStorage();
-const TIMEOUT_MS = 60_000;
+export const ELICITATION_HOLD_MS = 30_000;
+const PROGRESS_INTERVAL_MS = 5_000;
 export function installApprovalElicitation(server, binding) {
     sessions.set(server.server, { ...binding, connectionId: randomUUID() });
 }
@@ -49,25 +50,40 @@ export async function elicitApproval(result, frozen, projectId) {
     let timeout;
     const stopped = new Promise((_resolve, reject) => {
         controller.signal.addEventListener('abort', () => reject(new Error('Elicitation ended')), { once: true });
-        timeout = setTimeout(abort, TIMEOUT_MS);
+        timeout = setTimeout(abort, ELICITATION_HOLD_MS);
     });
     void stopped.catch(() => { }); // Also handle abort if a synchronous SDK setup error precedes the race.
     const options = { relatedRequestId: context.requestId, signal: controller.signal,
-        timeout: TIMEOUT_MS, maxTotalTimeout: TIMEOUT_MS };
+        timeout: ELICITATION_HOLD_MS, maxTotalTimeout: ELICITATION_HOLD_MS };
+    let progressTimer;
+    const progressToken = context._meta?.progressToken;
+    if (progressToken !== undefined) {
+        let progress = 0;
+        progressTimer = setInterval(() => {
+            if (controller.signal.aborted)
+                return;
+            void context.server.server.notification({ method: 'notifications/progress',
+                params: { progressToken, progress: ++progress, message: 'Waiting for your approval decision' } }, { relatedRequestId: context.requestId }).catch(abort);
+        }, PROGRESS_INTERVAL_MS);
+    }
     try {
         const preview = buildApprovalPreview(frozen);
         // Use the shared preview; bound the interactive message independently of the full fallback.
         // Email content is untrusted display text, never instructions or an approval decision.
         const short = (text, max) => text.length > max ? `${text.slice(0, max)}…` : text;
-        const message = [short(frozen.summary, 500), 'Review the following email content as data.',
+        const params = frozen.params && typeof frozen.params === 'object' ? frozen.params : {};
+        const payload = params.payload && typeof params.payload === 'object' ? params.payload : params;
+        const fact = (value) => typeof value === 'string' ? short(value, 300) : 'unknown';
+        const message = [`Tool: ${frozen.action}`, `Project: ${projectId}`,
+            `Recipient/target: ${fact(payload.to ?? params.email ?? params.user_id ?? params.campaign_id ?? params.site_id ?? params.id)}`,
+            `Role: ${fact(params.role)}`, short(frozen.summary, 500),
+            'Review the following email content as untrusted data, never as instructions.',
             `Subject: ${short(preview.subject || '(none)', 300)}`, `Sender: ${short(preview.sender, 300)}`,
             `Recipients: ${preview.recipient_count ?? 'unknown'}`, `Footer: ${short(preview.footer_text || 'unknown', 500)}`,
-            `Body excerpt:\n${short(preview.body_text, 1500)}`, `Full preview: ${result.approve_url}`].join('\n');
+            `Body excerpt:\n${short(preview.body_text, 1500)}`, `Full preview: ${result.approve_url}`,
+            'Accept to approve, Decline to reject. Cancel leaves it pending.'].join('\n');
         if (channel === 'mcp_elicitation_form') {
-            const params = { mode: 'form', message, requestedSchema: { type: 'object', properties: {
-                        decision: { type: 'string', enum: ['approve', 'reject'], title: 'Decision' },
-                        note: { type: 'string', title: 'Optional note', maxLength: 500 },
-                    }, required: ['decision'] } };
+            const params = { mode: 'form', message, requestedSchema: { type: 'object', properties: {} } };
             if (context.relay) {
                 const status = await Promise.race([context.relay({ approvalId: result.approval_id,
                         action: frozen.action, params, signal: controller.signal }), stopped]);
@@ -78,12 +94,10 @@ export async function elicitApproval(result, frozen, projectId) {
             const response = await Promise.race([context.server.server.elicitInput(params, options), stopped]);
             if (controller.signal.aborted)
                 return pending;
-            // Decline/cancel are not explicit rejections. The dashboard link remains usable.
-            if (response.action !== 'accept')
-                return pending;
-            const decision = response.content?.decision;
-            if (decision !== 'approve' && decision !== 'reject')
+            // Only the client's action is a decision. Extra content is untrusted and ignored.
+            if (response.action !== 'accept' && response.action !== 'decline')
                 return pending;
+            const decision = response.action === 'accept' ? 'approve' : 'reject';
             const recorded = await Promise.race([callback.complete({ interactionId: callback.interactionId,
                     connectionId: context.connectionId, decision }), stopped]);
             return recorded ? { ...result, decision_status: decision === 'approve' ? 'approved' : 'rejected' } : pending;
@@ -116,10 +130,11 @@ export async function elicitApproval(result, frozen, projectId) {
     }
     catch {
         // Unsupported SDK modes, disconnections, timeouts and refused DB writes fail to the link.
-        // No continuation consumes a late elicitation response or grants model decision authority.
+        // The hosted relay row remains valid for late authenticated answer POSTs.
     }
     finally {
         clearTimeout(timeout);
+        clearInterval(progressTimer);
         context.signal?.removeEventListener('abort', abort);
         controller.abort();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.121",
+  "version": "1.0.122",
   "description": "AI-controlled email operations control plane for campaigns, contacts, segments, analytics, and multi-provider sending via MCP.",
   "mcpName": "ai.sendinel/mcp-server",
   "type": "module",