@toolplex/client 0.1.45 → 0.1.47

package/dist/mcp-server/toolHandlers/callToolHandler.js

@@ -35,7 +35,8 @@ export async function handleCallTool(params) {
             const isPreApproved = automationContext.preApprovedToolCall?.server_id === params.server_id &&
                 automationContext.preApprovedToolCall?.tool_name === params.tool_name;
             // Check if tool requires HITL approval (skip if pre-approved)
-            if (!isPreApproved && automationContext.toolsRequiringApproval.includes(toolKey)) {
+            if (!isPreApproved &&
+                automationContext.toolsRequiringApproval.includes(toolKey)) {
                 await logger.info(`Tool ${toolKey} requires HITL approval`);
                 // Return HITL signal for cloud-agent to handle
                 return {
@@ -49,7 +50,7 @@ export async function handleCallTool(params) {
                                 server_id: params.server_id,
                                 tool_name: params.tool_name,
                                 args: params.arguments,
-                                context: `Requesting approval to run "${params.tool_name}" on "${params.server_id}"`,
+                                context: `Requesting approval to run "${params.tool_name}"`,
                             }),
                         },
                     ],

package/dist/mcp-server/toolHandlers/lookupEntityHandler.js

@@ -85,12 +85,17 @@ export async function handleLookupEntityTool(params) {
                 text: `Found ${params.entity_type}: ${lookupResponse.server_name || lookupResponse.description || params.entity_id}`,
             },
         ];
-        if (params.entity_type === "server") {
-            content.push({
-                type: "text",
-                text: promptsCache.getPrompt("lookup_entity_install_guidance"),
-                _meta: { role: "system" },
-            });
+        // Add installation guidance for server lookups, but not for org users
+        // (org users don't have install tools - they use pre-approved tools only)
+        if (params.entity_type === "server" && !clientContext.isOrgUser) {
+            const installGuidance = promptsCache.getPrompt("lookup_entity_install_guidance");
+            if (installGuidance) {
+                content.push({
+                    type: "text",
+                    text: installGuidance,
+                    _meta: { role: "system" },
+                });
+            }
         }
         return {
             content,

package/dist/mcp-server/toolHandlers/notifyHandler.d.ts

@@ -3,6 +3,6 @@ import { NotifyParams } from "../../shared/mcpServerTypes.js";
 /**
  * Handler for the notify tool.
  * Only available in automation mode.
- * Returns an HITL signal for the cloud-agent to process.
+ * Creates a notification via the API and optionally pauses the automation.
  */
 export declare function handleNotify(params: NotifyParams): Promise<CallToolResult>;

package/dist/mcp-server/toolHandlers/notifyHandler.js

@@ -4,13 +4,14 @@ const logger = FileLogger;
 /**
  * Handler for the notify tool.
  * Only available in automation mode.
- * Returns an HITL signal for the cloud-agent to process.
+ * Creates a notification via the API and optionally pauses the automation.
  */
 export async function handleNotify(params) {
     const startTime = Date.now();
     await logger.debug(`Handling notify request with params: ${JSON.stringify(params)}`);
     const telemetryLogger = Registry.getTelemetryLogger();
     const clientContext = Registry.getClientContext();
+    const apiService = Registry.getToolplexApiService();
     try {
         // Verify we're in automation mode
         if (clientContext.clientMode !== "automation") {
@@ -32,34 +33,42 @@ export async function handleNotify(params) {
             }
         }
         await logger.info(`Sending HITL notification: ${params.title} (pause: ${params.pause_until_response})`);
+        // Call the API to create the notification (and pause if needed)
+        const result = await apiService.createAutomationNotification({
+            automationId: automationContext.automationId,
+            runId: automationContext.runId,
+            sessionId: clientContext.sessionId,
+            title: params.title,
+            content: params.content,
+            context: params.context,
+            responseType: params.response_type,
+            responseOptions: params.response_options,
+            pauseUntilResponse: params.pause_until_response,
+            notificationRecipients: [{ email: automationContext.notificationEmail }],
+            expirationHours: automationContext.expirationHours,
+        });
         await telemetryLogger.log("client_notify", {
             success: true,
             log_context: {
                 response_type: params.response_type,
                 pause_until_response: params.pause_until_response,
                 has_context: !!params.context,
+                notification_id: result.notificationId,
             },
             latency_ms: Date.now() - startTime,
         });
-        // Return HITL signal for cloud-agent to handle
-        // The cloud-agent will parse this and create the notification
+        // Return simple result - cloud-agent checks for 'paused' flag
         return {
             content: [
                 {
                     type: "text",
                     text: JSON.stringify({
-                        _hitl_required: true,
-                        _hitl_type: "agent_notify",
-                        title: params.title,
-                        content: params.content,
-                        context: params.context,
-                        response_type: params.response_type,
-                        response_options: params.response_options,
-                        pause_until_response: params.pause_until_response,
-                        automation_id: automationContext.automationId,
-                        run_id: automationContext.runId,
-                        notification_email: automationContext.notificationEmail,
-                        expiration_hours: automationContext.expirationHours,
+                        success: true,
+                        notificationId: result.notificationId,
+                        paused: result.paused,
+                        message: result.paused
+                            ? "Notification sent. Automation paused awaiting response."
+                            : "Notification sent. Automation continues.",
                     }),
                 },
             ],

package/dist/mcp-server/toolplexApi/service.d.ts

@@ -1,4 +1,4 @@
-import { CreatePlaybookResponse, LogPlaybookUsageResponse, SubmitFeedbackResponse, SecurityAssessment, FeedbackSummaryResponse, LogTelemetryRequest, LogTelemetryBatchResponse, InitResponse, SearchResponse } from "./types.js";
+import { CreatePlaybookResponse, LogPlaybookUsageResponse, SubmitFeedbackResponse, SecurityAssessment, FeedbackSummaryResponse, LogTelemetryRequest, LogTelemetryBatchResponse, InitResponse, SearchResponse, NotificationRecipient } from "./types.js";
 import { ClientContext } from "../clientContext.js";
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
 import { PlaybookAction } from "../../shared/mcpServerTypes.js";
@@ -26,4 +26,26 @@ export declare class ToolplexApiService {
     logPlaybookUsage(playbookId: string, success: boolean, errorMessage?: string): Promise<LogPlaybookUsageResponse>;
     submitFeedback(targetType: "server" | "playbook", targetId: string, vote: "up" | "down", message?: string, securityAssessment?: SecurityAssessment): Promise<SubmitFeedbackResponse>;
     getFeedbackSummary(): Promise<FeedbackSummaryResponse>;
+    /**
+     * Create an automation notification (HITL)
+     * Optionally pauses the automation run if pauseUntilResponse is true
+     *
+     * @returns Object with notificationId and paused status
+     */
+    createAutomationNotification(params: {
+        automationId: string;
+        runId: string;
+        sessionId?: string;
+        title: string;
+        content: string;
+        context?: string;
+        responseType: "boolean" | "multi_choice" | "freeform";
+        responseOptions?: string[];
+        pauseUntilResponse: boolean;
+        notificationRecipients: NotificationRecipient[];
+        expirationHours: number;
+    }): Promise<{
+        notificationId: string;
+        paused: boolean;
+    }>;
 }

package/dist/mcp-server/toolplexApi/service.js

@@ -227,4 +227,66 @@ export class ToolplexApiService {
             throw err;
         }
     }
+    /**
+     * Create an automation notification (HITL)
+     * Optionally pauses the automation run if pauseUntilResponse is true
+     *
+     * @returns Object with notificationId and paused status
+     */
+    async createAutomationNotification(params) {
+        const { automationId, runId, sessionId, title, content, context, responseType, responseOptions, pauseUntilResponse, notificationRecipients, expirationHours, } = params;
+        try {
+            // Create the notification
+            const notificationRequest = {
+                automation_id: automationId,
+                run_id: runId,
+                session_id: sessionId,
+                notification_type: "agent_notify",
+                title,
+                content,
+                context,
+                response_type: responseType,
+                response_options: responseOptions,
+                requires_response: pauseUntilResponse,
+                notification_recipients: notificationRecipients,
+                expiration_hours: expirationHours,
+            };
+            const response = await fetch(`${this.baseUrl}/cloud/automation-notifications`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(notificationRequest),
+            });
+            const notificationResult = await this.handleFetchResponse(response);
+            await logger.info(`Created automation notification: ${notificationResult.id}`);
+            // If pause is requested, update the run status
+            if (pauseUntilResponse) {
+                const pauseResponse = await fetch(`${this.baseUrl}/cloud/automation-runs/${runId}/pause`, {
+                    method: "POST",
+                    headers: this.getHeadersWithSession(),
+                    body: JSON.stringify({
+                        status: "awaiting_response",
+                        resume_context: {
+                            pending_notification_id: notificationResult.id,
+                            paused_at: new Date().toISOString(),
+                        },
+                    }),
+                });
+                if (!pauseResponse.ok) {
+                    const errorText = await pauseResponse.text();
+                    await logger.warn(`Failed to pause automation run ${runId}: ${errorText}`);
+                }
+                else {
+                    await logger.info(`Automation run ${runId} paused awaiting response`);
+                }
+            }
+            return {
+                notificationId: notificationResult.id,
+                paused: pauseUntilResponse,
+            };
+        }
+        catch (err) {
+            await logger.error(`Error creating automation notification: ${err}`);
+            throw err;
+        }
+    }
 }

package/dist/mcp-server/toolplexApi/types.d.ts

@@ -148,3 +148,33 @@ export interface SearchResponse {
     mcp_servers?: any[];
     playbooks?: any[];
 }
+export interface NotificationRecipient {
+    email: string;
+    name?: string;
+    role?: string;
+}
+export interface CreateAutomationNotificationRequest {
+    automation_id: string;
+    run_id: string;
+    session_id?: string;
+    notification_type: "agent_notify" | "tool_approval";
+    title: string;
+    content: string;
+    context?: string;
+    response_type: "boolean" | "multi_choice" | "freeform";
+    response_options?: string[];
+    requires_response: boolean;
+    notification_recipients: NotificationRecipient[];
+    expiration_hours: number;
+}
+export interface CreateAutomationNotificationResponse {
+    id: string;
+    decision_token: string;
+}
+export interface PauseAutomationRunRequest {
+    status: "awaiting_response";
+    resume_context: {
+        pending_notification_id: string;
+        paused_at: string;
+    };
+}

package/dist/src/mcp-server/toolplexApi/service.js

@@ -227,4 +227,66 @@ export class ToolplexApiService {
             throw err;
         }
     }
+    /**
+     * Create an automation notification (HITL)
+     * Optionally pauses the automation run if pauseUntilResponse is true
+     *
+     * @returns Object with notificationId and paused status
+     */
+    async createAutomationNotification(params) {
+        const { automationId, runId, sessionId, title, content, context, responseType, responseOptions, pauseUntilResponse, notificationRecipients, expirationHours, } = params;
+        try {
+            // Create the notification
+            const notificationRequest = {
+                automation_id: automationId,
+                run_id: runId,
+                session_id: sessionId,
+                notification_type: "agent_notify",
+                title,
+                content,
+                context,
+                response_type: responseType,
+                response_options: responseOptions,
+                requires_response: pauseUntilResponse,
+                notification_recipients: notificationRecipients,
+                expiration_hours: expirationHours,
+            };
+            const response = await fetch(`${this.baseUrl}/cloud/automation-notifications`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(notificationRequest),
+            });
+            const notificationResult = await this.handleFetchResponse(response);
+            await logger.info(`Created automation notification: ${notificationResult.id}`);
+            // If pause is requested, update the run status
+            if (pauseUntilResponse) {
+                const pauseResponse = await fetch(`${this.baseUrl}/cloud/automation-runs/${runId}/pause`, {
+                    method: "POST",
+                    headers: this.getHeadersWithSession(),
+                    body: JSON.stringify({
+                        status: "awaiting_response",
+                        resume_context: {
+                            pending_notification_id: notificationResult.id,
+                            paused_at: new Date().toISOString(),
+                        },
+                    }),
+                });
+                if (!pauseResponse.ok) {
+                    const errorText = await pauseResponse.text();
+                    await logger.warn(`Failed to pause automation run ${runId}: ${errorText}`);
+                }
+                else {
+                    await logger.info(`Automation run ${runId} paused awaiting response`);
+                }
+            }
+            return {
+                notificationId: notificationResult.id,
+                paused: pauseUntilResponse,
+            };
+        }
+        catch (err) {
+            await logger.error(`Error creating automation notification: ${err}`);
+            throw err;
+        }
+    }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.1.45";
+export declare const version = "0.1.47";

package/dist/version.js

@@ -1 +1 @@
-export const version = '0.1.45';
+export const version = '0.1.47';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolplex/client",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "author": "ToolPlex LLC",
   "license": "SEE LICENSE IN LICENSE",
   "description": "The official ToolPlex client for AI agent tool discovery and execution",