@hapticpaper/mcp-server 1.0.26 → 1.0.29

package/dist/client/hapticPaperClient.js

@@ -126,4 +126,65 @@ export class HapticPaperClient {
         const response = await this.client.post(`/gpt/qualification/${sessionId}/complete`, {});
         return response.data;
     }
+    // Message Methods
+    async sendMessage(data, accessToken) {
+        const response = await this.client.post('/gpt/messages', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async getTaskMessages(taskId, accessToken) {
+        const response = await this.client.get(`/gpt/messages/task/${taskId}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    // Extended Task Methods
+    async assignTask(taskId, workerId, accessToken) {
+        const response = await this.client.post(`/gpt/tasks/${taskId}/assign`, { workerId }, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async submitDeliverable(taskId, data, accessToken) {
+        const response = await this.client.post(`/gpt/tasks/${taskId}/deliverables`, data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async updateTaskTags(taskId, tags, accessToken) {
+        const response = await this.client.patch(`/gpt/tasks/${taskId}/tags`, { tags }, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    // Extended Worker Methods
+    async updateWorkerProfile(data, accessToken) {
+        const response = await this.client.put('/gpt/workers/profile', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async addSkill(data, accessToken) {
+        const response = await this.client.post('/gpt/workers/skills', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async deleteSkill(id, accessToken) {
+        const response = await this.client.delete(`/gpt/workers/skills/${id}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async addCertification(data, accessToken) {
+        const response = await this.client.post('/gpt/workers/certifications', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async deleteCertification(id, accessToken) {
+        const response = await this.client.delete(`/gpt/workers/certifications/${id}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    // Extended Account/Billing Methods
+    async purchaseCredits(entityId, amountCents, paymentMethodId, accessToken) {
+        const response = await this.client.post(`/gpt/billing/${entityId}/purchase`, { amountCents, paymentMethodId }, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async getTransactions(entityId, accessToken) {
+        const response = await this.client.get(`/gpt/billing/${entityId}/transactions`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async getPaymentMethods(entityId, accessToken) {
+        const response = await this.client.get(`/gpt/payment-methods/${entityId}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    // Reviews
+    async leaveReview(data, accessToken) {
+        const response = await this.client.post('/gpt/reviews', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
 }

package/dist/tools/account.js

@@ -23,8 +23,12 @@ function toolInvocationMeta(invoking, invoked, widgetSessionId) {
     };
 }
 const AccountToolSchema = z.object({
-    action: z.enum(['get_my_profile', 'get_balance', 'transaction_history']).describe("Action to perform on the account resource"),
-}).describe("Manage user account and credits. Actions: get_my_profile, get_balance.");
+    action: z.enum(['get_my_profile', 'get_balance', 'transaction_history', 'purchase_credits', 'list_payment_methods']).describe("Action to perform on the account resource"),
+    // Purchase/Payment params
+    amountCents: z.number().min(100).optional().describe("Amount to purchase in cents (min 100)"),
+    paymentMethodId: z.string().optional().describe("Stripe Payment Method ID"),
+    entityId: z.string().uuid().optional().describe("Entity ID context (for billing and transactions)"),
+}).describe("Manage user account and credits. Actions: get_my_profile (no params), get_balance (no params), transaction_history (requires entityId), list_payment_methods (requires entityId), purchase_credits (requires entityId, amountCents, optional paymentMethodId).");
 export function registerAccountTools(server, client) {
     const accountHandler = async (args, extra) => {
         try {
@@ -63,12 +67,40 @@ export function registerAccountTools(server, client) {
                     };
                 }
                 case 'transaction_history': {
-                    // Placeholder for future implementation
+                    if (!args.entityId)
+                        throw new Error("Missing entityId for transaction_history");
+                    const history = await client.getTransactions(args.entityId, auth?.token);
+                    const summary = history.data?.length
+                        ? history.data.map((t) => `- ${t.date}: ${t.description} (${t.amount} credits)`).join('\n')
+                        : "No transactions found.";
                     return {
-                        content: [{ type: 'text', text: "Transaction history is not yet available via MCP." }],
+                        structuredContent: { transactions: history.data },
+                        content: [{ type: 'text', text: `Transaction History:\n${summary}` }],
                         isError: false
                     };
                 }
+                case 'list_payment_methods': {
+                    if (!args.entityId)
+                        throw new Error("Missing entityId for list_payment_methods");
+                    const methods = await client.getPaymentMethods(args.entityId, auth?.token);
+                    const summary = methods.data?.length
+                        ? methods.data.map((m) => `- [${m.brand} *${m.last4}] Exp: ${m.expMonth}/${m.expYear} (ID: ${m.id}) ${m.isDefault ? '(Default)' : ''}`).join('\n')
+                        : "No payment methods found.";
+                    return {
+                        structuredContent: { paymentMethods: methods.data },
+                        content: [{ type: 'text', text: `Payment Methods:\n${summary}` }]
+                    };
+                }
+                case 'purchase_credits': {
+                    const writeAuth = requireScopes(extra, ['account:write']);
+                    if (!args.entityId || !args.amountCents)
+                        throw new Error("Missing entityId or amountCents for purchase_credits");
+                    const res = await client.purchaseCredits(args.entityId, args.amountCents, args.paymentMethodId, writeAuth?.token);
+                    return {
+                        structuredContent: { result: res.data },
+                        content: [{ type: 'text', text: `Successfully purchased credits. New balance available.` }]
+                    };
+                }
                 default:
                     throw new Error(`Unknown action: ${args.action}`);
             }

package/dist/tools/index.js

@@ -3,10 +3,12 @@ import { registerWorkerTools } from "./workers.js";
 import { registerAccountTools } from "./account.js";
 import { registerQualificationTools } from "./qualification.js";
 import { registerGeneralTools } from "./general.js";
+import { registerMessagesTools } from "./messages.js";
 export function registerAllTools(server, client) {
     registerTasksTools(server, client);
     registerWorkerTools(server, client);
     registerAccountTools(server, client);
     registerQualificationTools(server, client);
     registerGeneralTools(server, client);
+    registerMessagesTools(server, client);
 }

package/dist/tools/messages.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { requireScopes } from "../auth/access.js";
+import { HAPTICPAPER_WIDGET_URI } from "../constants/widget.js";
+function oauthSecuritySchemes(scopes) {
+    return [
+        { type: 'oauth2', scopes },
+    ];
+}
+function toolDescriptorMeta(invoking, invoked, scopes) {
+    return {
+        'openai/outputTemplate': HAPTICPAPER_WIDGET_URI,
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetAccessible': true,
+        securitySchemes: oauthSecuritySchemes(scopes),
+    };
+}
+function toolInvocationMeta(invoking, invoked, widgetSessionId) {
+    return {
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetSessionId': widgetSessionId,
+    };
+}
+const MessagesToolSchema = z.object({
+    action: z.enum(['send', 'list']).describe("Action to perform on messages"),
+    taskId: z.string().uuid().describe("Task ID context for the message"),
+    // Send params
+    recipientId: z.string().uuid().optional().describe("User ID to send message to (required for send)"),
+    content: z.string().min(1).optional().describe("Message content (required for send)"),
+}).describe("Communicate with workers or agents. Actions: send (requires taskId, recipientId, content), list (requires taskId).");
+export function registerMessagesTools(server, client) {
+    const messagesHandler = async (args, extra) => {
+        try {
+            switch (args.action) {
+                case 'send': {
+                    const auth = requireScopes(extra, ['messages:write']);
+                    if (!args.recipientId || !args.content)
+                        throw new Error("Missing recipientId or content for send action");
+                    const message = await client.sendMessage({
+                        taskId: args.taskId,
+                        recipientId: args.recipientId,
+                        content: args.content
+                    }, auth?.token);
+                    const widgetSessionId = `task:${args.taskId}`;
+                    return {
+                        structuredContent: { message },
+                        content: [{ type: 'text', text: `Message sent to ${args.recipientId}` }],
+                        _meta: { ...toolInvocationMeta('Sending message', 'Message sent', widgetSessionId), message }
+                    };
+                }
+                case 'list': {
+                    const auth = requireScopes(extra, ['messages:read']);
+                    const result = await client.getTaskMessages(args.taskId, auth?.token);
+                    const messages = result.messages || [];
+                    const widgetSessionId = `task:${args.taskId}`;
+                    const summary = messages.length
+                        ? messages.map((m) => `[${m.sender_name || 'User'}]: ${m.content}`).join('\n')
+                        : "No messages yet.";
+                    return {
+                        structuredContent: { messages },
+                        content: [{ type: 'text', text: `Messages for task ${args.taskId}:\n${summary}` }],
+                        _meta: { ...toolInvocationMeta('Listing messages', 'Messages loaded', widgetSessionId), messages }
+                    };
+                }
+                default:
+                    throw new Error(`Unknown action: ${args.action}`);
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    };
+    server.registerTool('messages', {
+        title: 'Messaging',
+        description: 'Communicate with workers or clients. Actions: send, list.',
+        inputSchema: MessagesToolSchema,
+        _meta: toolDescriptorMeta('Messaging', 'Message sent', ['messages:read', 'messages:write']),
+    }, messagesHandler);
+}

package/dist/tools/tasks.js

@@ -34,13 +34,18 @@ const CreateTaskSchema = z.object({
     title: z.string().min(5).max(200).describe("Short title for the task"),
     description: z.string().min(20).max(5000).describe("Detailed description of what needs to be done"),
     budget: z.number().min(5).max(500).describe("Payment to worker in dollars"),
+    taskType: z.string().optional().describe("Type of task (e.g., 'research', 'writing')"),
+    priority: z.enum(['low', 'normal', 'high']).optional().describe("Task priority level"),
+    estimatedHours: z.number().positive().optional().describe("Estimated hours to complete"),
+    deadline: z.string().datetime().optional().describe("When the task must be completed by (ISO string)"),
+    requiredSkills: z.array(z.string()).optional().describe("List of skills required"),
+    tags: z.record(z.string()).optional().describe("Key-value tags for categorization"),
     location: z.object({
         address: z.string().describe("Street address where task will be performed"),
         city: z.string().optional(),
         state: z.string().optional(),
         zip: z.string().optional(),
     }).optional().describe("Location for physical tasks"),
-    deadline: z.string().datetime().optional().describe("When the task must be completed by"),
     requirements: z.object({
         proofOfWork: z.boolean().default(true),
         gpsRequired: z.boolean().default(true),
@@ -48,26 +53,57 @@ const CreateTaskSchema = z.object({
     }).optional(),
     entityId: z.string().uuid().optional().describe("Entity ID to creating/billing this task"),
 });
-const UpdateTaskSchema = CreateTaskSchema.partial().extend({
-    taskId: z.string().uuid().describe("ID of the task to update"),
-});
 const TasksToolSchema = z.object({
-    action: z.enum(['create', 'get', 'list', 'update', 'cancel']).describe("Action to perform on the tasks resource"),
-    // Create params
+    action: z.enum(['create', 'get', 'list', 'update', 'cancel', 'assign', 'submit_deliverable', 'add_tags', 'leave_review']).describe("Action to perform on the tasks resource"),
+    // Create/Update params
     title: CreateTaskSchema.shape.title.optional(),
     description: CreateTaskSchema.shape.description.optional(),
     budget: CreateTaskSchema.shape.budget.optional(),
-    location: CreateTaskSchema.shape.location.optional(),
+    taskType: CreateTaskSchema.shape.taskType.optional(),
+    priority: CreateTaskSchema.shape.priority.optional(),
+    estimatedHours: CreateTaskSchema.shape.estimatedHours.optional(),
     deadline: CreateTaskSchema.shape.deadline.optional(),
-    requirements: CreateTaskSchema.shape.requirements.optional(),
-    entityId: CreateTaskSchema.shape.entityId.optional(),
-    // Get/Update/Cancel params
-    taskId: z.string().uuid().optional().describe("Task ID for get, update, or cancel actions"),
+    requiredSkills: CreateTaskSchema.shape.requiredSkills.optional(),
+    tags: CreateTaskSchema.shape.tags.optional(),
+    location: CreateTaskSchema.shape.location.optional(),
+    // Get/Update/Cancel/Assign/Deliverable params
+    taskId: z.string().uuid().optional().describe("Task ID context"),
     reason: z.string().optional().describe("Reason for cancellation"),
+    workerId: z.string().uuid().optional().describe("Worker ID to assign (for 'assign' action)"),
+    // Deliverable params
+    content: z.string().optional().describe("Content of the deliverable (for 'submit_deliverable')"),
+    deliverableType: z.string().optional().describe("Type of deliverable (for 'submit_deliverable')"),
+    // Detailed Requirements
+    requirements: z.object({
+        files: z.array(z.object({
+            name: z.string().describe("Name of the required file"),
+            description: z.string().describe("Description of what the file should contain"),
+            required: z.boolean().default(true).describe("Is this file mandatory?")
+        })).optional(),
+        questions: z.array(z.object({
+            text: z.string().describe("Question text"),
+            type: z.enum(['text', 'select', 'boolean']).describe("Answer type"),
+            options: z.array(z.string()).optional().describe("Options for select type"),
+            required: z.boolean().default(true)
+        })).optional()
+    }).optional().describe("Structured requirements for the task (files, questions)"),
+    // Pricing Model (passed via metadata)
+    pricing: z.object({
+        model: z.enum(['fixed_price', 'per_unit', 'hourly']),
+        unitName: z.string().optional().describe("Name of unit (e.g. 'bug', 'page')"),
+        rateCents: z.number().optional().describe("Price per unit in cents"),
+        maxUnits: z.number().optional().describe("Max units allowed"),
+    }).optional().describe("Advanced pricing model (e.g. per-bug bounty)"),
+    entityId: z.string().uuid().optional().describe("Entity ID to bill/attribute task to"),
     // List params
-    status: z.enum(['open', 'assigned', 'completed', 'cancelled']).optional().describe("Filter by status for list action"),
+    status: z.enum(['open', 'pending', 'assigned', 'in_progress', 'completed', 'cancelled']).optional().describe("Filter by status for list action"),
+    role: z.enum(['client', 'worker']).optional().describe("Filter by role (client or worker)"),
     limit: z.number().min(1).max(50).optional().describe("Limit number of tasks returned"),
-}).describe("Manage tasks lifecycle: create, read, update, cancel. Actions determine required fields.");
+    // Review params
+    revieweeId: z.string().uuid().optional().describe("User ID of the person being reviewed (for 'leave_review')"),
+    rating: z.number().min(1).max(5).optional().describe("Rating from 1 to 5 (for 'leave_review')"),
+    comment: z.string().optional().describe("Review comment (for 'leave_review')"),
+}).describe("Manage tasks lifecycle. Actions: create (requires title, description, budget; supports optional requirements, pricing), get (requires taskId), list (optional status, role), update (requires taskId), cancel (requires taskId), assign (requires taskId, workerId), submit_deliverable (requires taskId, content, deliverableType), add_tags (requires taskId, tags), leave_review (requires taskId, revieweeId, rating).");
 export function registerTasksTools(server, client) {
     // Helper for structured dispatch
     const tasksHandler = async (args, extra) => {
@@ -75,7 +111,6 @@ export function registerTasksTools(server, client) {
             switch (args.action) {
                 case 'create': {
                     const auth = requireScopes(extra, ['tasks:write']);
-                    // Validate create params manually or rely on backend validation
                     if (!args.title || !args.description || !args.budget) {
                         throw new Error("Missing required fields for create (title, description, budget)");
                     }
@@ -83,8 +118,13 @@ export function registerTasksTools(server, client) {
                         title: args.title,
                         description: args.description,
                         budget: args.budget,
-                        location: args.location,
+                        taskType: args.taskType,
+                        priority: args.priority,
+                        estimatedHours: args.estimatedHours,
                         deadline: args.deadline,
+                        requiredSkills: args.requiredSkills,
+                        tags: args.tags,
+                        location: args.location,
                         requirements: args.requirements,
                         entityId: args.entityId
                     };
@@ -104,7 +144,7 @@ export function registerTasksTools(server, client) {
                     const widgetSessionId = `task:${task.id}`;
                     return {
                         structuredContent: { task },
-                        content: [{ type: 'text', text: `Task ${task.id}: ${task.status}` }],
+                        content: [{ type: 'text', text: `Task ${task.id}: ${task.status}\nTitle: ${task.title}\nDescription: ${task.description}` }],
                         _meta: { ...toolInvocationMeta('Fetching task', 'Task details ready', widgetSessionId), task }
                     };
                 }
@@ -116,7 +156,7 @@ export function registerTasksTools(server, client) {
                     const summary = items.length ? items.map((t) => `- [${t.status}] ${t.title} ($${t.budget}) (ID: ${t.id})`).join('\n') : "No tasks found.";
                     return {
                         structuredContent: { tasks: items },
-                        content: [{ type: 'text', text: `My tasks:\n${summary}` }],
+                        content: [{ type: 'text', text: `Tasks list:\n${summary}` }],
                         _meta: { ...toolInvocationMeta('Listing tasks', 'Tasks loaded', widgetSessionId), tasks: items }
                     };
                 }
@@ -124,7 +164,6 @@ export function registerTasksTools(server, client) {
                     const auth = requireScopes(extra, ['tasks:write']);
                     if (!args.taskId)
                         throw new Error("Missing taskId for update action");
-                    // Construct update payload from optional args
                     const updatePayload = {};
                     if (args.title)
                         updatePayload.title = args.title;
@@ -134,6 +173,10 @@ export function registerTasksTools(server, client) {
                         updatePayload.budget = args.budget;
                     if (args.deadline)
                         updatePayload.deadline = args.deadline;
+                    if (args.priority)
+                        updatePayload.priority = args.priority; // New
+                    if (args.status)
+                        updatePayload.status = args.status; // New
                     if (args.requirements)
                         updatePayload.requirements = args.requirements;
                     const task = await client.updateTask(args.taskId, updatePayload, auth?.token);
@@ -156,6 +199,60 @@ export function registerTasksTools(server, client) {
                         _meta: { ...toolInvocationMeta('Cancelling task', 'Task cancelled', widgetSessionId), result: res }
                     };
                 }
+                case 'assign': { // New
+                    const auth = requireScopes(extra, ['tasks:write']);
+                    if (!args.taskId || !args.workerId)
+                        throw new Error("Missing taskId or workerId for assign action");
+                    const task = await client.assignTask(args.taskId, args.workerId, auth?.token);
+                    const widgetSessionId = `task:${args.taskId}`;
+                    return {
+                        structuredContent: { task },
+                        content: [{ type: 'text', text: `Assigned task ${args.taskId} to worker ${args.workerId}.` }],
+                        _meta: { ...toolInvocationMeta('Assigning task', 'Task assigned', widgetSessionId), task }
+                    };
+                }
+                case 'submit_deliverable': { // New
+                    const auth = requireScopes(extra, ['tasks:write']);
+                    if (!args.taskId || !args.content || !args.deliverableType)
+                        throw new Error("Missing taskId, content, or deliverableType for submit_deliverable");
+                    const res = await client.submitDeliverable(args.taskId, {
+                        content: args.content,
+                        deliverableType: args.deliverableType
+                    }, auth?.token);
+                    const widgetSessionId = `task:${args.taskId}`;
+                    return {
+                        structuredContent: { deliverable: res.deliverable },
+                        content: [{ type: 'text', text: `Deliverable submitted for task ${args.taskId}.` }],
+                        _meta: { ...toolInvocationMeta('Submitting deliverable', 'Deliverable submitted', widgetSessionId), deliverable: res }
+                    };
+                }
+                case 'add_tags': { // New
+                    const auth = requireScopes(extra, ['tasks:write']);
+                    if (!args.taskId || !args.tags)
+                        throw new Error("Missing taskId or tags for add_tags action");
+                    const task = await client.updateTaskTags(args.taskId, args.tags, auth?.token);
+                    const widgetSessionId = `task:${args.taskId}`;
+                    return {
+                        structuredContent: { task },
+                        content: [{ type: 'text', text: `Tags updated for task ${args.taskId}.` }],
+                        _meta: { ...toolInvocationMeta('Updating tags', 'Tags updated', widgetSessionId), task }
+                    };
+                }
+                case 'leave_review': { // New
+                    const auth = requireScopes(extra, ['tasks:write']);
+                    if (!args.taskId || !args.revieweeId || !args.rating)
+                        throw new Error("Missing taskId, revieweeId, or rating for leave_review");
+                    const res = await client.leaveReview({
+                        taskId: args.taskId,
+                        revieweeId: args.revieweeId,
+                        rating: args.rating,
+                        comment: args.comment
+                    }, auth?.token);
+                    return {
+                        structuredContent: { review: res.review },
+                        content: [{ type: 'text', text: `Review submitted for task ${args.taskId}.` }]
+                    };
+                }
                 default:
                     throw new Error(`Unknown action: ${args.action}`);
             }
@@ -169,7 +266,7 @@ export function registerTasksTools(server, client) {
     };
     server.registerTool('tasks', {
         title: 'Manage Tasks',
-        description: 'Manage tasks lifecycle. Actions: create, get, list, update, cancel. Use this tool for all task-related operations.',
+        description: 'Manage tasks lifecycle. Actions: create, get, list, update, cancel, assign, submit_deliverable, add_tags. Use this tool for all task-related operations.',
         inputSchema: TasksToolSchema,
         _meta: toolDescriptorMeta('Managing tasks', 'Task operation complete', ['tasks:read', 'tasks:write']),
     }, tasksHandler);

package/dist/tools/workers.js

@@ -39,30 +39,50 @@ const SearchWorkersSchema = z.object({
     skills: z.array(z.string()).optional()
 });
 const WorkersToolSchema = z.object({
-    action: z.enum(['search', 'get_profile']).describe("Action to perform on the workers resource"),
+    action: z.enum(['search', 'get_profile', 'update_profile', 'manage_skills', 'manage_certifications']).describe("Action to perform on the workers resource"),
     // Search params
     taskDescription: SearchWorkersSchema.shape.taskDescription.optional(),
     location: SearchWorkersSchema.shape.location.optional(),
     skills: SearchWorkersSchema.shape.skills.optional(),
-    // Get params
+    minRating: z.number().min(0).max(5).optional().describe("Minimum star rating"),
+    maxRate: z.number().min(0).optional().describe("Maximum hourly rate"),
+    limit: z.number().min(1).max(50).optional().describe("Max number of records"),
+    // Get/Profile params
     workerId: z.string().uuid().optional().describe("Worker ID to retrieve profile"),
-}).describe("Find and view worker profiles. Actions: search, get_profile.");
+    // Update Profile params
+    bio: z.string().optional().describe("Worker bio"),
+    hourlyRate: z.number().optional().describe("Hourly rate in USD"),
+    availabilityStatus: z.enum(['available', 'busy', 'offline']).optional().describe("Current availability"),
+    // Skill/Cert params
+    subAction: z.enum(['add', 'delete']).optional().describe("Add or delete sub-item"),
+    skillName: z.string().optional(),
+    proficiencyLevel: z.string().optional(),
+    yearsExperience: z.number().optional(),
+    itemId: z.string().uuid().optional().describe("ID of skill/cert/license to delete"),
+    certName: z.string().optional(),
+    certIssuer: z.string().optional(),
+    certIssuedAt: z.string().optional(),
+    certExpiresAt: z.string().optional(),
+}).describe("Find and view worker profiles. Actions: search (requires taskDescription), get_profile (requires workerId), update_profile, manage_skills, manage_certifications.");
 export function registerWorkerTools(server, client) {
     const workersHandler = async (args, extra) => {
         try {
             switch (args.action) {
                 case 'search': {
                     const auth = requireScopes(extra, ['workers:read']);
-                    if (!args.taskDescription)
-                        throw new Error("Missing taskDescription for search action");
+                    // if (!args.taskDescription) throw new Error("Missing taskDescription for search action");
                     const searchArgs = {
-                        taskDescription: args.taskDescription,
+                        taskDescription: args.taskDescription, // This might be optional? 
                         location: args.location,
-                        skills: args.skills
+                        skills: args.skills,
+                        minRating: args.minRating,
+                        maxRate: args.maxRate,
+                        limit: args.limit
                     };
                     const result = await client.searchWorkers(searchArgs, auth?.token);
                     const widgetSessionId = stableSessionId('workers', JSON.stringify({ userId: auth?.userId ?? auth?.clientId, args: searchArgs }));
-                    if (!result.workers || result.workers.length === 0) {
+                    const workers = result.workers || [];
+                    if (workers.length === 0) {
                         return {
                             structuredContent: { workers: [], suggestedBudget: result?.suggestedBudget },
                             content: [{ type: 'text', text: 'No workers found matching criteria.' }],
@@ -71,12 +91,12 @@ export function registerWorkerTools(server, client) {
                     }
                     return {
                         structuredContent: {
-                            workers: result.workers.map((w) => ({
-                                id: w.id, name: w.name, rating: w.rating, distanceMiles: w.distanceMiles, estimatedArrival: w.estimatedArrival,
+                            workers: workers.map((w) => ({
+                                id: w.id, name: w.display_name, rating: w.average_rating, rate: w.hourly_rate, skills: w.skills
                             })),
                             suggestedBudget: result.suggestedBudget,
                         },
-                        content: [{ type: 'text', text: `Found ${result.workers.length} workers. Suggested budget: $${result.suggestedBudget}` }],
+                        content: [{ type: 'text', text: `Found ${workers.length} workers.` }],
                         _meta: { ...toolInvocationMeta('Searching workers', 'Worker results ready', widgetSessionId), result }
                     };
                 }
@@ -88,10 +108,66 @@ export function registerWorkerTools(server, client) {
                     const widgetSessionId = `worker:${args.workerId}`;
                     return {
                         structuredContent: { worker },
-                        content: [{ type: 'text', text: `Worker profile loaded: ${worker?.id ?? args.workerId}` }],
+                        content: [{ type: 'text', text: `Worker profile loaded: ${worker?.displayName ?? args.workerId}` }],
                         _meta: { ...toolInvocationMeta('Loading profile', 'Worker profile ready', widgetSessionId), worker }
                     };
                 }
+                case 'update_profile': {
+                    const auth = requireScopes(extra, ['workers:write']);
+                    const updateData = {};
+                    if (args.bio)
+                        updateData.bio = args.bio;
+                    if (args.hourlyRate)
+                        updateData.hourlyRate = args.hourlyRate;
+                    if (args.availabilityStatus)
+                        updateData.availabilityStatus = args.availabilityStatus;
+                    const res = await client.updateWorkerProfile(updateData, auth?.token);
+                    return {
+                        content: [{ type: 'text', text: "Profile updated successfully." }],
+                        structuredContent: { profile: res.profile }
+                    };
+                }
+                case 'manage_skills': {
+                    const auth = requireScopes(extra, ['workers:write']);
+                    if (args.subAction === 'add') {
+                        if (!args.skillName || !args.proficiencyLevel)
+                            throw new Error("Missing skillName or proficiencyLevel");
+                        const res = await client.addSkill({
+                            name: args.skillName,
+                            proficiencyLevel: args.proficiencyLevel,
+                            yearsExperience: args.yearsExperience || 0
+                        }, auth?.token);
+                        return { content: [{ type: 'text', text: "Skill added." }], structuredContent: { skill: res.skill } };
+                    }
+                    else if (args.subAction === 'delete') {
+                        if (!args.itemId)
+                            throw new Error("Missing itemId (skill ID) to delete");
+                        await client.deleteSkill(args.itemId, auth?.token);
+                        return { content: [{ type: 'text', text: "Skill deleted." }] };
+                    }
+                    throw new Error("Invalid subAction for manage_skills");
+                }
+                case 'manage_certifications': {
+                    const auth = requireScopes(extra, ['workers:write']);
+                    if (args.subAction === 'add') {
+                        if (!args.certName || !args.certIssuer || !args.certIssuedAt)
+                            throw new Error("Missing cert details");
+                        const res = await client.addCertification({
+                            name: args.certName,
+                            issuer: args.certIssuer,
+                            issuedAt: args.certIssuedAt,
+                            expiresAt: args.certExpiresAt
+                        }, auth?.token);
+                        return { content: [{ type: 'text', text: "Certification added." }], structuredContent: { certification: res.certification } };
+                    }
+                    else if (args.subAction === 'delete') {
+                        if (!args.itemId)
+                            throw new Error("Missing itemId (cert ID) to delete");
+                        await client.deleteCertification(args.itemId, auth?.token);
+                        return { content: [{ type: 'text', text: "Certification deleted." }] };
+                    }
+                    throw new Error("Invalid subAction for manage_certifications");
+                }
                 default:
                     throw new Error(`Unknown action: ${args.action}`);
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hapticpaper/mcp-server",
   "mcpName": "com.hapticpaper/mcp",
-  "version": "1.0.26",
+  "version": "1.0.29",
   "description": "Official MCP Server for Haptic Paper - Connect your account to create human tasks from agentic pipelines.",
   "type": "module",
   "main": "dist/index.js",

package/server.json

@@ -25,7 +25,7 @@
     "subfolder": "packages/mcp-server"
   },
   "websiteUrl": "https://hapticpaper.com/developer",
-  "version": "1.0.26",
+  "version": "1.0.29",
   "remotes": [
     {
       "type": "streamable-http",
@@ -37,7 +37,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@hapticpaper/mcp-server",
-      "version": "1.0.26",
+      "version": "1.0.29",
       "transport": {
         "type": "stdio"
       },