@toolplex/client 0.1.3 → 0.1.5

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

@@ -100,6 +100,12 @@ export async function handleInitialize(params) {
                 .join("\n") +
             "\n\nMore playbooks are available through the search tool.",
     });
+    if (toolplexApiInitResponse.announcement) {
+        result.content.push({
+            type: "text",
+            text: `\nToolPlex Platform Announcements: ${toolplexApiInitResponse.announcement}`,
+        });
+    }
     await telemetryLogger.log("client_initialize_toolplex", {
         session_id: toolplexApiInitResponse.session_id,
         success: Object.keys(allFailures).length === 0,

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

@@ -11,7 +11,6 @@ export async function handleListServers() {
     const policyEnforcer = Registry.getPolicyEnforcer();
     try {
         await logger.debug("Listing all installed servers");
-        let response = "Currently installed MCP servers:\n\n";
         // Collect all servers for updating the cache
         const allServers = [];
         for (const [runtime, client] of Object.entries(serverManagerClients)) {
@@ -28,10 +27,7 @@ export async function handleListServers() {
                 // Filter out blocked servers
                 const filteredServers = policyEnforcer.filterBlockedMcpServers(parsed.data.servers, (server) => server.server_id);
                 filteredServers.forEach((server) => {
-                    response += `- Server ID: ${server.server_id}\n`;
-                    response += `  Name: ${server.server_name}\n`;
-                    response += `  Description: ${server.description}\n\n`;
-                    // Add to allServers for cache update
+                    // Add to allServers for cache update and structured response
                     allServers.push({
                         server_id: server.server_id,
                         server_name: server.server_name,
@@ -42,20 +38,36 @@ export async function handleListServers() {
         }
         // Update the servers cache with the fresh list
         serversCache.updateServers(allServers);
-        if (response === "Currently installed MCP servers:\n\n") {
-            response = promptsCache.getPrompt("list_servers_empty");
-        }
         await logger.debug("Successfully retrieved servers list");
         await telemetryLogger.log("client_list_servers", {
             success: true,
             latency_ms: Date.now() - startTime,
         });
+        // Build response content
+        if (allServers.length === 0) {
+            return {
+                role: "system",
+                content: [
+                    {
+                        type: "text",
+                        text: promptsCache.getPrompt("list_servers_empty"),
+                    },
+                ],
+            };
+        }
         return {
             role: "system",
             content: [
                 {
                     type: "text",
-                    text: response,
+                    text: JSON.stringify({
+                        servers: allServers,
+                        count: allServers.length,
+                    }),
+                },
+                {
+                    type: "text",
+                    text: `Found ${allServers.length} installed MCP server${allServers.length !== 1 ? "s" : ""}`,
                 },
             ],
         };

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

@@ -11,7 +11,7 @@ export async function handleListTools(params) {
     const policyEnforcer = Registry.getPolicyEnforcer();
     try {
         const server_id = params.server_id;
-        let response = "";
+        const content = [];
         if (server_id) {
             // Check if server is blocked using policy enforcer
             policyEnforcer.enforceUseServerPolicy(server_id);
@@ -27,23 +27,34 @@ export async function handleListTools(params) {
             if (!parsed.success) {
                 throw new Error(`Invalid response from server manager: ${parsed.error}`);
             }
-            response = promptsCache
-                .getPrompt("list_tools_server_header")
-                .replace("{SERVER_ID}", parsed.data.server_id)
-                .replace("{SERVER_NAME}", parsed.data.server_name);
-            if (!parsed.data.tools || parsed.data.tools.length === 0) {
-                response += promptsCache.getPrompt("list_tools_empty");
+            const tools = parsed.data.tools || [];
+            if (tools.length > 0) {
+                // First: Structured JSON for easy parsing
+                content.push({
+                    type: "text",
+                    text: JSON.stringify({
+                        server_id: parsed.data.server_id,
+                        server_name: parsed.data.server_name,
+                        tools: tools,
+                        tool_count: tools.length,
+                    }),
+                });
+                // Second: Human-readable summary
+                content.push({
+                    type: "text",
+                    text: `Available tools from server '${parsed.data.server_name}' (${parsed.data.server_id}): ${tools.length} tool${tools.length !== 1 ? "s" : ""}`,
+                });
             }
             else {
-                parsed.data.tools.forEach((tool) => {
-                    response += `- ${tool.name}: ${tool.description}\n`;
-                    response += `  Input Schema: ${JSON.stringify(tool.inputSchema, null, 2)}\n\n`;
+                content.push({
+                    type: "text",
+                    text: promptsCache.getPrompt("list_tools_empty"),
                 });
             }
         }
         else {
             await logger.debug("Listing tools from all installed servers");
-            response = promptsCache.getPrompt("list_tools_all_header");
+            const allServerTools = [];
             for (const [runtime, client] of Object.entries(serverManagerClients)) {
                 const response_data = await client.sendRequest("list_all_tools", {});
                 if (response_data.error) {
@@ -59,17 +70,35 @@ export async function handleListTools(params) {
                 const filteredEntries = policyEnforcer.filterBlockedMcpServers(serverEntries, ([serverId]) => serverId);
                 for (const [serverId, serverTools] of filteredEntries) {
                     if (serverTools && serverTools.length > 0) {
-                        response += `Server: ${serverId}\n`;
-                        serverTools.forEach((tool) => {
-                            response += `- ${tool.name}: ${tool.description}\n`;
-                            response += `  Input Schema: ${JSON.stringify(tool.inputSchema, null, 2)}\n\n`;
+                        allServerTools.push({
+                            server_id: serverId,
+                            tools: serverTools,
                         });
-                        response += "\n";
                     }
                 }
             }
-            if (response === promptsCache.getPrompt("list_tools_all_header")) {
-                response += promptsCache.getPrompt("list_tools_empty");
+            if (allServerTools.length > 0) {
+                const totalTools = allServerTools.reduce((sum, server) => sum + server.tools.length, 0);
+                // First: Structured JSON for easy parsing
+                content.push({
+                    type: "text",
+                    text: JSON.stringify({
+                        server_tools: allServerTools,
+                        server_count: allServerTools.length,
+                        total_tools: totalTools,
+                    }),
+                });
+                // Second: Human-readable summary
+                content.push({
+                    type: "text",
+                    text: `Found ${totalTools} tools across ${allServerTools.length} server${allServerTools.length !== 1 ? "s" : ""}`,
+                });
+            }
+            else {
+                content.push({
+                    type: "text",
+                    text: promptsCache.getPrompt("list_tools_empty"),
+                });
             }
         }
         await logger.debug("Successfully retrieved tools list");
@@ -82,12 +111,7 @@ export async function handleListTools(params) {
         });
         return {
             role: "system",
-            content: [
-                {
-                    type: "text",
-                    text: response,
-                },
-            ],
+            content,
         };
     }
     catch (error) {

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

@@ -57,9 +57,6 @@ export async function handleLookupEntityTool(params) {
             }
         }
         await logger.debug(`Found entity: ${JSON.stringify(lookupResponse)}`);
-        let response = `Found ${params.entity_type}:\n`;
-        response += JSON.stringify(lookupResponse, null, 2);
-        response += "\n";
         await logger.debug("Lookup completed successfully");
         await telemetryLogger.log("client_lookup_entity", {
             success: true,
@@ -69,10 +66,21 @@ export async function handleLookupEntityTool(params) {
             },
             latency_ms: Date.now() - startTime,
         });
+        // Return structured data first for easy frontend parsing, then instructions
         const content = [
+            // First: Structured JSON for easy parsing
             {
                 type: "text",
-                text: response,
+                text: JSON.stringify({
+                    entity_type: params.entity_type,
+                    entity_id: params.entity_id,
+                    result: lookupResponse,
+                }),
+            },
+            // Second: Human-readable summary
+            {
+                type: "text",
+                text: `Found ${params.entity_type}: ${lookupResponse.server_name || lookupResponse.description || params.entity_id}`,
             },
         ];
         if (params.entity_type === "server") {

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

@@ -21,8 +21,8 @@ export async function handleSavePlaybook(params) {
         }
         // Enforce playbook policy before saving
         policyEnforcer.enforceSavePlaybookPolicy(params);
-        const { description, actions, domain, keywords, requirements, source_playbook_id, fork_reason, } = params;
-        const response = await apiService.createPlaybook(description, actions, domain, keywords, requirements, source_playbook_id, fork_reason);
+        const { description, actions, domain, keywords, requirements, privacy, source_playbook_id, fork_reason, } = params;
+        const response = await apiService.createPlaybook(description, actions, domain, keywords, requirements, privacy, source_playbook_id, fork_reason);
         await logger.info(`Playbook created successfully with ID: ${response.id}`);
         await telemetryLogger.log("client_save_playbook", {
             success: true,

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

@@ -15,18 +15,20 @@ export async function handleSearchTool(params) {
     const expandedKeywords = params.expanded_keywords || [];
     const filter = params.filter || "all";
     const size = params.size || 10;
+    const scope = params.scope || "all";
     try {
         // Check if the client is in restricted mode
         if (clientContext.clientMode === "restricted") {
             throw new Error("Search functionality is disabled in restricted mode.");
         }
-        const results = await apiService.search(query, expandedKeywords, filter, size);
+        const results = await apiService.search(query, expandedKeywords, filter, size, scope);
         // Log telemetry event
         await telemetryLogger.log("client_search", {
             success: true,
             log_context: {
                 filter,
                 size,
+                scope,
                 num_expanded_keywords: expandedKeywords.length,
                 num_results: (results.mcp_servers?.length ?? -1) +
                     (results.playbooks?.length ?? -1),
@@ -63,32 +65,34 @@ export async function handleSearchTool(params) {
             };
         }
         await logger.debug(`Found ${totalResults} results`);
-        let response = promptsCache.getPrompt("search_results_header");
-        if ((annotatedServers.length ?? 0) > 0) {
-            response += "\n=== Servers ===\n";
-            response += JSON.stringify(annotatedServers, null, 2);
-            response += "\n";
-        }
-        else {
-            response += "\n(No servers found)\n";
-        }
-        if (playbooks.length > 0) {
-            response += "\n=== Playbooks ===\n";
-            response += JSON.stringify(playbooks, null, 2);
-            response += "\n";
-        }
-        else {
-            response += "\n(No playbooks found)\n";
-        }
+        // Build structured response content
+        const content = [
+            // First: Structured JSON for easy parsing
+            {
+                type: "text",
+                text: JSON.stringify({
+                    query,
+                    expanded_keywords: expandedKeywords,
+                    filter,
+                    scope,
+                    size,
+                    servers: annotatedServers,
+                    playbooks,
+                    server_count: annotatedServers.length,
+                    playbook_count: playbooks.length,
+                    total_results: totalResults,
+                }),
+            },
+            // Second: Human-readable summary
+            {
+                type: "text",
+                text: `Found ${totalResults} results for "${query}": ${annotatedServers.length} servers, ${playbooks.length} playbooks`,
+            },
+        ];
         await logger.info("Search completed successfully");
         return {
             role: "system",
-            content: [
-                {
-                    type: "text",
-                    text: response,
-                },
-            ],
+            content,
         };
     }
     catch (error) {
@@ -99,6 +103,7 @@ export async function handleSearchTool(params) {
             log_context: {
                 filter,
                 size,
+                scope,
                 num_expanded_keywords: expandedKeywords.length,
             },
             pii_sanitized_error_message: errorMessage,

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

@@ -21,11 +21,11 @@ export declare class ToolplexApiService {
         data: Partial<Omit<LogTelemetryRequest, "event_type">>;
     }>): Promise<LogTelemetryBatchResponse>;
     lookupEntity(entityType: "server" | "playbook" | "feedback", entityId: string): Promise<any>;
-    search(query: string, expandedKeywords?: string[], filter?: string, size?: number): Promise<{
+    search(query: string, expandedKeywords?: string[], filter?: string, size?: number, scope?: string): Promise<{
         mcp_servers?: any[];
         playbooks?: any[];
     }>;
-    createPlaybook(description: string, actions: Array<PlaybookAction>, domain?: string, keywords?: string[], requirements?: string[], sourcePlaybookId?: string, forkReason?: string): Promise<CreatePlaybookResponse>;
+    createPlaybook(description: string, actions: Array<PlaybookAction>, domain?: string, keywords?: string[], requirements?: string[], privacy?: "public" | "private", sourcePlaybookId?: string, forkReason?: string): Promise<CreatePlaybookResponse>;
     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>;

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

@@ -110,12 +110,13 @@ export class ToolplexApiService {
             throw err;
         }
     }
-    async search(query, expandedKeywords = [], filter = "all", size = 10) {
+    async search(query, expandedKeywords = [], filter = "all", size = 10, scope = "all") {
         const requestBody = {
             query,
             expanded_keywords: expandedKeywords,
             filter,
             size,
+            scope,
         };
         await logger.debug(`Searching API at ${this.baseUrl} with query: ${query}`);
         try {
@@ -135,7 +136,7 @@ export class ToolplexApiService {
             throw err;
         }
     }
-    async createPlaybook(description, actions, domain, keywords, requirements, sourcePlaybookId, forkReason) {
+    async createPlaybook(description, actions, domain, keywords, requirements, privacy, sourcePlaybookId, forkReason) {
         const requestBody = {
             description,
             actions,
@@ -143,6 +144,7 @@ export class ToolplexApiService {
             domain,
             keywords,
             requirements,
+            privacy,
             source_playbook_id: sourcePlaybookId,
             fork_reason: forkReason,
         };

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

@@ -23,6 +23,7 @@ export interface InitResponse {
     is_org_user: boolean;
     prompts: Record<string, string>;
     permissions: ClientPermissions;
+    announcement?: string;
     flags: ClientFlags;
 }
 export type SecurityFlag = string;
@@ -51,6 +52,7 @@ export interface CreatePlaybookRequest {
     domain?: string;
     keywords?: string[];
     requirements?: string[];
+    privacy?: "public" | "private";
     source_playbook_id?: string;
     fork_reason?: string;
 }

package/dist/shared/mcpServerTypes.d.ts

@@ -96,16 +96,19 @@ export declare const SearchParamsSchema: z.ZodObject<{
     expanded_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     filter: z.ZodOptional<z.ZodEnum<["all", "servers_only", "playbooks_only"]>>;
     size: z.ZodOptional<z.ZodNumber>;
+    scope: z.ZodOptional<z.ZodEnum<["all", "public_only", "private_only"]>>;
 }, "strip", z.ZodTypeAny, {
     query: string;
     filter?: "all" | "servers_only" | "playbooks_only" | undefined;
     expanded_keywords?: string[] | undefined;
     size?: number | undefined;
+    scope?: "all" | "public_only" | "private_only" | undefined;
 }, {
     query: string;
     filter?: "all" | "servers_only" | "playbooks_only" | undefined;
     expanded_keywords?: string[] | undefined;
     size?: number | undefined;
+    scope?: "all" | "public_only" | "private_only" | undefined;
 }>;
 export type SearchParams = z.infer<typeof SearchParamsSchema>;
 export declare const LookupEntityParamsSchema: z.ZodObject<{
@@ -295,6 +298,7 @@ export declare const SavePlaybookParamsSchema: z.ZodObject<{
     domain: z.ZodOptional<z.ZodString>;
     keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     requirements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    privacy: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
     source_playbook_id: z.ZodOptional<z.ZodString>;
     fork_reason: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -310,6 +314,7 @@ export declare const SavePlaybookParamsSchema: z.ZodObject<{
     domain?: string | undefined;
     keywords?: string[] | undefined;
     requirements?: string[] | undefined;
+    privacy?: "public" | "private" | undefined;
     source_playbook_id?: string | undefined;
     fork_reason?: string | undefined;
 }, {
@@ -325,6 +330,7 @@ export declare const SavePlaybookParamsSchema: z.ZodObject<{
     domain?: string | undefined;
     keywords?: string[] | undefined;
     requirements?: string[] | undefined;
+    privacy?: "public" | "private" | undefined;
     source_playbook_id?: string | undefined;
     fork_reason?: string | undefined;
 }>;

package/dist/shared/mcpServerTypes.js

@@ -43,6 +43,7 @@ export const SearchParamsSchema = z.object({
     expanded_keywords: z.array(z.string()).optional(),
     filter: z.enum(["all", "servers_only", "playbooks_only"]).optional(),
     size: z.number().int().min(1).max(25).optional(),
+    scope: z.enum(["all", "public_only", "private_only"]).optional(),
 });
 // --------------------
 // LookupEntityParams
@@ -121,6 +122,7 @@ export const SavePlaybookParamsSchema = z.object({
     domain: z.string().optional(),
     keywords: z.array(z.string()).optional(),
     requirements: z.array(z.string()).optional(),
+    privacy: z.enum(["public", "private"]).optional(),
     source_playbook_id: z.string().optional(),
     fork_reason: z.string().optional(),
 });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.1.2";
+export declare const version = "0.1.5";

package/dist/version.js

@@ -1 +1 @@
-export const version = '0.1.2';
+export const version = '0.1.5';

package/package.json

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