@toolplex/client 0.1.3 → 0.1.4

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/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),
@@ -99,6 +101,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.4";

package/dist/version.js

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

package/package.json

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