@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/server/tools/MarketplaceTools.js

@@ -0,0 +1,92 @@
+/**
+ * Marketplace-related tool definitions and handlers
+ */
+export function getMarketplaceTools(server) {
+    return [
+        {
+            tool: {
+                name: "browse_marketplace",
+                description: "Browse personas from the DollhouseMCP marketplace by category",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        category: {
+                            type: "string",
+                            description: "Category to browse (creative, professional, educational, gaming, personal)",
+                        },
+                    },
+                },
+            },
+            handler: (args) => server.browseMarketplace(args?.category)
+        },
+        {
+            tool: {
+                name: "search_marketplace",
+                description: "Search for personas in the marketplace by keywords",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search query for finding personas",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            handler: (args) => server.searchMarketplace(args.query)
+        },
+        {
+            tool: {
+                name: "get_marketplace_persona",
+                description: "Get detailed information about a persona from the marketplace",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "The marketplace path to the persona (e.g., 'creative/storyteller_20250701_alice.md')",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: (args) => server.getMarketplacePersona(args.path)
+        },
+        {
+            tool: {
+                name: "install_persona",
+                description: "Install a persona from the marketplace to your local collection",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "The marketplace path to the persona (e.g., 'creative/storyteller_20250701_alice.md')",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            handler: (args) => server.installPersona(args.path)
+        },
+        {
+            tool: {
+                name: "submit_persona",
+                description: "Submit a local persona to the marketplace for community review",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to submit",
+                        },
+                    },
+                    required: ["persona"],
+                },
+            },
+            handler: (args) => server.submitPersona(args.persona)
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/server/tools/PersonaTools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Persona-related tool definitions and handlers
+ */
+import { ToolDefinition } from './ToolRegistry.js';
+import { IToolHandler } from '../types.js';
+export declare function getPersonaTools(server: IToolHandler): Array<{
+    tool: ToolDefinition;
+    handler: any;
+}>;
+//# sourceMappingURL=PersonaTools.d.ts.map

package/dist/test/src/server/tools/PersonaTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaTools.d.ts","sourceRoot":"","sources":["../../../../../src/server/tools/PersonaTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAkQnG"}

package/dist/test/src/server/tools/PersonaTools.js

@@ -0,0 +1,257 @@
+/**
+ * Persona-related tool definitions and handlers
+ */
+export function getPersonaTools(server) {
+    return [
+        {
+            tool: {
+                name: "list_personas",
+                description: "List all available personas",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.listPersonas()
+        },
+        {
+            tool: {
+                name: "activate_persona",
+                description: "Activate a specific persona by name or filename",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to activate",
+                        },
+                    },
+                    required: ["persona"],
+                },
+            },
+            handler: (args) => server.activatePersona(args.persona)
+        },
+        {
+            tool: {
+                name: "get_active_persona",
+                description: "Get information about the currently active persona",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.getActivePersona()
+        },
+        {
+            tool: {
+                name: "deactivate_persona",
+                description: "Deactivate the current persona",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.deactivatePersona()
+        },
+        {
+            tool: {
+                name: "get_persona_details",
+                description: "Get detailed information about a specific persona",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to get details for",
+                        },
+                    },
+                    required: ["persona"],
+                },
+            },
+            handler: (args) => server.getPersonaDetails(args.persona)
+        },
+        {
+            tool: {
+                name: "reload_personas",
+                description: "Reload all personas from the personas directory",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.reloadPersonas()
+        },
+        {
+            tool: {
+                name: "create_persona",
+                description: "Create a new persona with guided assistance",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "The display name for the persona",
+                        },
+                        description: {
+                            type: "string",
+                            description: "A brief description of the persona",
+                        },
+                        category: {
+                            type: "string",
+                            description: "Category: creative, professional, educational, gaming, or personal",
+                        },
+                        instructions: {
+                            type: "string",
+                            description: "The main instructions/prompt for the persona",
+                        },
+                        triggers: {
+                            type: "string",
+                            description: "Comma-separated list of trigger words (optional)",
+                        },
+                    },
+                    required: ["name", "description", "category", "instructions"],
+                },
+            },
+            handler: (args) => server.createPersona(args.name, args.description, args.category, args.instructions, args.triggers)
+        },
+        {
+            tool: {
+                name: "edit_persona",
+                description: "Edit an existing persona's properties",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to edit",
+                        },
+                        field: {
+                            type: "string",
+                            description: "Field to edit: name, description, instructions, triggers, category, version, or metadata fields",
+                        },
+                        value: {
+                            type: "string",
+                            description: "The new value for the field",
+                        },
+                    },
+                    required: ["persona", "field", "value"],
+                },
+            },
+            handler: (args) => server.editPersona(args.persona, args.field, args.value)
+        },
+        {
+            tool: {
+                name: "validate_persona",
+                description: "Validate a persona's format and provide quality feedback",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to validate",
+                        },
+                    },
+                    required: ["persona"],
+                },
+            },
+            handler: (args) => server.validatePersona(args.persona)
+        },
+        {
+            tool: {
+                name: "export_persona",
+                description: "Export a single persona to a JSON format",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to export",
+                        },
+                    },
+                    required: ["persona"],
+                },
+            },
+            handler: (args) => server.exportPersona(args.persona)
+        },
+        {
+            tool: {
+                name: "export_all_personas",
+                description: "Export all personas to a JSON bundle",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        includeDefaults: {
+                            type: "boolean",
+                            description: "Include default personas in export (default: true)",
+                        },
+                    },
+                },
+            },
+            handler: (args) => server.exportAllPersonas(args.includeDefaults)
+        },
+        {
+            tool: {
+                name: "import_persona",
+                description: "Import a persona from a file path or JSON string",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        source: {
+                            type: "string",
+                            description: "File path to a .md or .json file, or a JSON string of the persona",
+                        },
+                        overwrite: {
+                            type: "boolean",
+                            description: "Overwrite if persona already exists (default: false)",
+                        },
+                    },
+                    required: ["source"],
+                },
+            },
+            handler: (args) => server.importPersona(args.source, args.overwrite)
+        },
+        {
+            tool: {
+                name: "share_persona",
+                description: "Generate a shareable URL for a persona",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona: {
+                            type: "string",
+                            description: "The persona name or filename to share",
+                        },
+                        expiryDays: {
+                            type: "number",
+                            description: "Number of days the share link is valid (default: 7)",
+                        },
+                    },
+                    required: ["persona"],
+                },
+            },
+            handler: (args) => server.sharePersona(args.persona, args.expiryDays)
+        },
+        {
+            tool: {
+                name: "import_from_url",
+                description: "Import a persona from a shared URL",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: {
+                            type: "string",
+                            description: "The shared URL to import from",
+                        },
+                        overwrite: {
+                            type: "boolean",
+                            description: "Overwrite if persona already exists (default: false)",
+                        },
+                    },
+                    required: ["url"],
+                },
+            },
+            handler: (args) => server.importFromUrl(args.url, args.overwrite)
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaTools.js","sourceRoot":"","sources":["../../../../../src/server/tools/PersonaTools.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persona-related tool definitions and handlers\n */\n\nimport { ToolDefinition } from './ToolRegistry.js';\nimport { IToolHandler } from '../types.js';\n\nexport function getPersonaTools(server: IToolHandler): Array<{ tool: ToolDefinition; handler: any }> {\n  return [\n    {\n      tool: {\n        name: \"list_personas\",\n        description: \"List all available personas\",\n        inputSchema: {\n          type: \"object\",\n          properties: {},\n        },\n      },\n      handler: () => server.listPersonas()\n    },\n    {\n      tool: {\n        name: \"activate_persona\",\n        description: \"Activate a specific persona by name or filename\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            persona: {\n              type: \"string\",\n              description: \"The persona name or filename to activate\",\n            },\n          },\n          required: [\"persona\"],\n        },\n      },\n      handler: (args: any) => server.activatePersona(args.persona)\n    },\n    {\n      tool: {\n        name: \"get_active_persona\",\n        description: \"Get information about the currently active persona\",\n        inputSchema: {\n          type: \"object\",\n          properties: {},\n        },\n      },\n      handler: () => server.getActivePersona()\n    },\n    {\n      tool: {\n        name: \"deactivate_persona\",\n        description: \"Deactivate the current persona\",\n        inputSchema: {\n          type: \"object\",\n          properties: {},\n        },\n      },\n      handler: () => server.deactivatePersona()\n    },\n    {\n      tool: {\n        name: \"get_persona_details\",\n        description: \"Get detailed information about a specific persona\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            persona: {\n              type: \"string\",\n              description: \"The persona name or filename to get details for\",\n            },\n          },\n          required: [\"persona\"],\n        },\n      },\n      handler: (args: any) => server.getPersonaDetails(args.persona)\n    },\n    {\n      tool: {\n        name: \"reload_personas\",\n        description: \"Reload all personas from the personas directory\",\n        inputSchema: {\n          type: \"object\",\n          properties: {},\n        },\n      },\n      handler: () => server.reloadPersonas()\n    },\n    {\n      tool: {\n        name: \"create_persona\",\n        description: \"Create a new persona with guided assistance\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            name: {\n              type: \"string\",\n              description: \"The display name for the persona\",\n            },\n            description: {\n              type: \"string\",\n              description: \"A brief description of the persona\",\n            },\n            category: {\n              type: \"string\",\n              description: \"Category: creative, professional, educational, gaming, or personal\",\n            },\n            instructions: {\n              type: \"string\",\n              description: \"The main instructions/prompt for the persona\",\n            },\n            triggers: {\n              type: \"string\",\n              description: \"Comma-separated list of trigger words (optional)\",\n            },\n          },\n          required: [\"name\", \"description\", \"category\", \"instructions\"],\n        },\n      },\n      handler: (args: any) => server.createPersona(\n        args.name,\n        args.description,\n        args.category,\n        args.instructions,\n        args.triggers\n      )\n    },\n    {\n      tool: {\n        name: \"edit_persona\",\n        description: \"Edit an existing persona's properties\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            persona: {\n              type: \"string\",\n              description: \"The persona name or filename to edit\",\n            },\n            field: {\n              type: \"string\",\n              description: \"Field to edit: name, description, instructions, triggers, category, version, or metadata fields\",\n            },\n            value: {\n              type: \"string\",\n              description: \"The new value for the field\",\n            },\n          },\n          required: [\"persona\", \"field\", \"value\"],\n        },\n      },\n      handler: (args: any) => server.editPersona(args.persona, args.field, args.value)\n    },\n    {\n      tool: {\n        name: \"validate_persona\",\n        description: \"Validate a persona's format and provide quality feedback\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            persona: {\n              type: \"string\",\n              description: \"The persona name or filename to validate\",\n            },\n          },\n          required: [\"persona\"],\n        },\n      },\n      handler: (args: any) => server.validatePersona(args.persona)\n    },\n    {\n      tool: {\n        name: \"export_persona\",\n        description: \"Export a single persona to a JSON format\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            persona: {\n              type: \"string\",\n              description: \"The persona name or filename to export\",\n            },\n          },\n          required: [\"persona\"],\n        },\n      },\n      handler: (args: any) => server.exportPersona(args.persona)\n    },\n    {\n      tool: {\n        name: \"export_all_personas\",\n        description: \"Export all personas to a JSON bundle\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            includeDefaults: {\n              type: \"boolean\",\n              description: \"Include default personas in export (default: true)\",\n            },\n          },\n        },\n      },\n      handler: (args: any) => server.exportAllPersonas(args.includeDefaults)\n    },\n    {\n      tool: {\n        name: \"import_persona\",\n        description: \"Import a persona from a file path or JSON string\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            source: {\n              type: \"string\",\n              description: \"File path to a .md or .json file, or a JSON string of the persona\",\n            },\n            overwrite: {\n              type: \"boolean\",\n              description: \"Overwrite if persona already exists (default: false)\",\n            },\n          },\n          required: [\"source\"],\n        },\n      },\n      handler: (args: any) => server.importPersona(args.source, args.overwrite)\n    },\n    {\n      tool: {\n        name: \"share_persona\",\n        description: \"Generate a shareable URL for a persona\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            persona: {\n              type: \"string\",\n              description: \"The persona name or filename to share\",\n            },\n            expiryDays: {\n              type: \"number\",\n              description: \"Number of days the share link is valid (default: 7)\",\n            },\n          },\n          required: [\"persona\"],\n        },\n      },\n      handler: (args: any) => server.sharePersona(args.persona, args.expiryDays)\n    },\n    {\n      tool: {\n        name: \"import_from_url\",\n        description: \"Import a persona from a shared URL\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            url: {\n              type: \"string\",\n              description: \"The shared URL to import from\",\n            },\n            overwrite: {\n              type: \"boolean\",\n              description: \"Overwrite if persona already exists (default: false)\",\n            },\n          },\n          required: [\"url\"],\n        },\n      },\n      handler: (args: any) => server.importFromUrl(args.url, args.overwrite)\n    }\n  ];\n}"]}

package/dist/test/src/server/tools/ToolRegistry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tool Registry for managing MCP tool definitions and handlers
+ */
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export interface ToolHandler {
+    (args: any): Promise<any>;
+}
+export interface ToolDefinition extends Tool {
+    handler?: ToolHandler;
+}
+export declare class ToolRegistry {
+    private tools;
+    /**
+     * Register a tool with its definition and handler
+     */
+    register(tool: ToolDefinition, handler?: ToolHandler): void;
+    /**
+     * Register multiple tools at once
+     */
+    registerMany(tools: Array<{
+        tool: ToolDefinition;
+        handler?: ToolHandler;
+    }>): void;
+    /**
+     * Get all registered tools (for ListToolsRequest)
+     */
+    getAllTools(): Tool[];
+    /**
+     * Get a specific tool handler
+     */
+    getHandler(name: string): ToolHandler | undefined;
+    /**
+     * Check if a tool exists
+     */
+    has(name: string): boolean;
+}
+//# sourceMappingURL=ToolRegistry.d.ts.map

package/dist/test/src/server/tools/ToolRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/server/tools/ToolRegistry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAE1D,MAAM,WAAW,WAAW;IAC1B,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,cAAe,SAAQ,IAAI;IAC1C,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAA0C;IAEvD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI;IAO3D;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,OAAO,CAAC,EAAE,WAAW,CAAA;KAAE,CAAC,GAAG,IAAI;IAIjF;;OAEG;IACH,WAAW,IAAI,IAAI,EAAE;IAIrB;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIjD;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAG3B"}

package/dist/test/src/server/tools/ToolRegistry.js

@@ -0,0 +1,40 @@
+/**
+ * Tool Registry for managing MCP tool definitions and handlers
+ */
+export class ToolRegistry {
+    tools = new Map();
+    /**
+     * Register a tool with its definition and handler
+     */
+    register(tool, handler) {
+        if (handler) {
+            tool.handler = handler;
+        }
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Register multiple tools at once
+     */
+    registerMany(tools) {
+        tools.forEach(({ tool, handler }) => this.register(tool, handler));
+    }
+    /**
+     * Get all registered tools (for ListToolsRequest)
+     */
+    getAllTools() {
+        return Array.from(this.tools.values()).map(({ handler, ...tool }) => tool);
+    }
+    /**
+     * Get a specific tool handler
+     */
+    getHandler(name) {
+        return this.tools.get(name)?.handler;
+    }
+    /**
+     * Check if a tool exists
+     */
+    has(name) {
+        return this.tools.has(name);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/server/tools/UpdateTools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Update/maintenance-related tool definitions and handlers
+ */
+import { ToolDefinition } from './ToolRegistry.js';
+import { IToolHandler } from '../types.js';
+export declare function getUpdateTools(server: IToolHandler): Array<{
+    tool: ToolDefinition;
+    handler: any;
+}>;
+//# sourceMappingURL=UpdateTools.d.ts.map

package/dist/test/src/server/tools/UpdateTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateTools.d.ts","sourceRoot":"","sources":["../../../../../src/server/tools/UpdateTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CA2DlG"}

package/dist/test/src/server/tools/UpdateTools.js

@@ -0,0 +1,64 @@
+/**
+ * Update/maintenance-related tool definitions and handlers
+ */
+export function getUpdateTools(server) {
+    return [
+        {
+            tool: {
+                name: "check_for_updates",
+                description: "Check if a newer version of DollhouseMCP is available",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.checkForUpdates()
+        },
+        {
+            tool: {
+                name: "update_server",
+                description: "Update DollhouseMCP to the latest version from GitHub",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        confirm: {
+                            type: "boolean",
+                            description: "Confirm the update (true to proceed, false for preview)",
+                        },
+                    },
+                    required: ["confirm"],
+                },
+            },
+            handler: (args) => server.updateServer(args.confirm)
+        },
+        {
+            tool: {
+                name: "rollback_update",
+                description: "Rollback to the previous version from backup",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        confirm: {
+                            type: "boolean",
+                            description: "Confirm the rollback (true to proceed, false for info)",
+                        },
+                    },
+                    required: ["confirm"],
+                },
+            },
+            handler: (args) => server.rollbackUpdate(args.confirm)
+        },
+        {
+            tool: {
+                name: "get_server_status",
+                description: "Get current server status, version, and system information",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.getServerStatus()
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/server/tools/UserTools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * User identity-related tool definitions and handlers
+ */
+import { ToolDefinition } from './ToolRegistry.js';
+import { IToolHandler } from '../types.js';
+export declare function getUserTools(server: IToolHandler): Array<{
+    tool: ToolDefinition;
+    handler: any;
+}>;
+//# sourceMappingURL=UserTools.d.ts.map

package/dist/test/src/server/tools/UserTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserTools.d.ts","sourceRoot":"","sources":["../../../../../src/server/tools/UserTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CA8ChG"}

package/dist/test/src/server/tools/UserTools.js

@@ -0,0 +1,51 @@
+/**
+ * User identity-related tool definitions and handlers
+ */
+export function getUserTools(server) {
+    return [
+        {
+            tool: {
+                name: "set_user_identity",
+                description: "Set your username for persona attribution and collection participation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        username: {
+                            type: "string",
+                            description: "Your username (alphanumeric, hyphens, underscores, dots)",
+                        },
+                        email: {
+                            type: "string",
+                            description: "Your email address (optional)",
+                        },
+                    },
+                    required: ["username"],
+                },
+            },
+            handler: (args) => server.setUserIdentity(args.username, args?.email)
+        },
+        {
+            tool: {
+                name: "get_user_identity",
+                description: "Get current user identity information",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.getUserIdentity()
+        },
+        {
+            tool: {
+                name: "clear_user_identity",
+                description: "Clear user identity and return to anonymous mode",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            handler: () => server.clearUserIdentity()
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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