@hapticpaper/mcp-server 1.0.16 → 1.0.17

package/dist/tools/index.js

@@ -1,12 +1,4 @@
-import { registerTaskTools } from "./tasks.js";
-import { registerWorkerTools } from "./workers.js";
-import { registerEstimateTools } from "./estimates.js";
-import { registerQualificationTools } from "./qualification.js";
-import { registerAccountTools } from "./account.js";
+import { registerVerbTools } from "./verbs.js";
 export function registerAllTools(server, client) {
-    registerAccountTools(server, client);
-    registerTaskTools(server, client);
-    registerWorkerTools(server, client);
-    registerEstimateTools(server, client);
-    registerQualificationTools(server, client);
+    registerVerbTools(server, client);
 }

package/dist/tools/verbs.js

@@ -0,0 +1,413 @@
+import { z } from "zod";
+import { requireScopes } from "../auth/access.js";
+import { HAPTICPAPER_WIDGET_URI } from "../constants/widget.js";
+import crypto from 'node:crypto';
+// --- Shared Utilities (copied/adapted from tasks.ts/workers.ts) ---
+function stableSessionId(prefix, value) {
+    const raw = value ?? 'unknown';
+    const hash = crypto.createHash('sha256').update(raw).digest('hex').slice(0, 16);
+    return `${prefix}:${hash}`;
+}
+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,
+        ...(scopes.length > 0 ? { securitySchemes: oauthSecuritySchemes(scopes) } : {}),
+    };
+}
+function toolInvocationMeta(invoking, invoked, widgetSessionId) {
+    return {
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetSessionId': widgetSessionId,
+    };
+}
+// --- Tool Schemas ---
+const IntentSchema = z.object({
+    message: z.string().describe("The user's message expressing interest, a skill, or a potential need."),
+    context: z.array(z.object({
+        role: z.enum(['user', 'assistant']),
+        content: z.string(),
+    })).optional().describe("Previous conversation context to help understand the intent."),
+    sessionId: z.string().uuid().optional().describe("If continuing an existing qualification/intent session."),
+});
+const CreateSchema = z.object({
+    resource: z.enum(['task', 'worker_profile']).describe("The type of resource to create."),
+    data: z.object({
+        title: z.string().optional(),
+        description: z.string().optional(),
+        budget: z.number().optional(),
+        location: z.object({
+            address: z.string(),
+            city: z.string().optional(),
+            state: z.string().optional(),
+            zip: z.string().optional(),
+        }).optional(),
+        deadline: z.string().datetime().optional(),
+        skills: z.array(z.string()).optional().describe("List of required skills (for tasks) or possessed skills (for workers)."),
+        entityId: z.string().uuid().optional().describe("Enterprise Entity ID for billing (tasks only)."),
+        hourlyRate: z.number().optional().describe("For worker profiles."),
+        bio: z.string().optional().describe("For worker profiles."),
+    }).describe("Data for the resource creation."),
+});
+const GetSchema = z.object({
+    resource: z.enum(['task', 'worker', 'account', 'balance', 'estimate']).describe("The type of resource to retrieve."),
+    id: z.string().optional().describe("The ID of the resource (required for task and worker)."),
+    estimateParams: z.object({
+        description: z.string().describe('Task description'),
+        urgency: z.enum(['flexible', 'today', 'urgent']).optional(),
+        location: z.object({ address: z.string() }).optional(),
+    }).optional().describe("Parameters for calculating an estimate."),
+});
+const UpdateSchema = z.object({
+    resource: z.enum(['task', 'worker_profile']).describe("The type of resource to update."),
+    id: z.string().uuid().describe("The ID of the resource to update."),
+    data: z.object({
+        title: z.string().optional(),
+        description: z.string().optional(),
+        budget: z.number().optional(),
+        status: z.string().optional(),
+        skills: z.array(z.string()).optional(),
+        hourlyRate: z.number().optional(),
+        availabilityStatus: z.enum(['available', 'busy', 'offline']).optional(),
+    }).describe("The fields to update."),
+});
+const TerminateSchema = z.object({
+    resource: z.enum(['task']).describe("The type of resource to terminate/cancel."),
+    id: z.string().uuid().describe("The ID of the resource."),
+    reason: z.string().optional().describe("Reason for termination."),
+});
+const SearchAndBrowseSchema = z.object({
+    resource: z.enum(['workers', 'skill_categories']).describe("The type of resource to search for or browse."),
+    query: z.object({
+        text: z.string().optional().describe("Free text search query"),
+        skills: z.array(z.string()).optional().describe("Specific skills to look for"),
+        location: z.object({
+            address: z.string(),
+            radiusMiles: z.number().default(10)
+        }).optional(),
+    }).optional().describe("Search criteria. You don't need a perfect query; we'll provide suggestions."),
+});
+const InteractWithHapticSchema = z.object({
+    action: z.enum(['list_my_tasks']).describe("The management action to perform."),
+    filters: z.object({
+        status: z.enum(['open', 'assigned', 'completed', 'cancelled']).optional(),
+        limit: z.number().min(1).max(50).optional(),
+    }).optional(),
+});
+const ApiSchema = z.object({
+    method: z.enum(['GET', 'POST', 'PATCH', 'DELETE', 'PUT']).describe("HTTP Method"),
+    path: z.string().describe("API Endpoint path (e.g., '/tasks')"),
+    body: z.record(z.any()).optional().describe("JSON body for the request"),
+    queryParams: z.record(z.string()).optional().describe("URL query parameters"),
+});
+// --- Tool Registration ---
+export function registerVerbTools(server, client) {
+    // 1. intent
+    server.registerTool("intent", {
+        title: "Signal Intent or Skill",
+        description: "Use this tool when the user expresses an interest in earning money, demonstrates a skill, or has a vague need. It starts or continues a conversational qualification flow. \n\n" +
+            "Examples:\n" +
+            "- \"I want to make money\"\n" +
+            "- \"I know how to fix bikes\"\n" +
+            "- \"I need help with something\"\n",
+        inputSchema: IntentSchema,
+        _meta: toolDescriptorMeta('Analyzing intent...', 'Intent processed'),
+    }, async (args, extra) => {
+        try {
+            // If we have a sessionId, it's likely a continue
+            if (args.sessionId && args.message) {
+                const result = await client.continueQualification(args.sessionId, args.message);
+                return {
+                    content: [{ type: 'text', text: result.nextPrompt?.text || "Processed." }],
+                    structuredContent: result, // Pass full result
+                    _meta: { ...toolInvocationMeta('Processing...', 'Done', `qual:${args.sessionId}`), result }
+                };
+            }
+            // Otherwise it's a discovery
+            const result = await client.discoverEarningOpportunity({
+                userMessage: args.message,
+                conversationContext: args.context
+            });
+            return {
+                content: [{ type: 'text', text: result.nextPrompt?.text || "Started qualification." }],
+                structuredContent: result,
+                _meta: { ...toolInvocationMeta('Starting...', 'Started', `qual:${result.sessionId}`), result }
+            };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 2. create
+    server.registerTool("create", {
+        title: "Create Resource",
+        description: "Use this tool to create new resources like tasks. \n\n" +
+            "Resources:\n" +
+            "- `task`: Create a task for a worker. Requires title, description, budget. Supports `skills` list. \n" +
+            "- `worker_profile`: (For future use) Create a worker profile.\n",
+        inputSchema: CreateSchema,
+        _meta: toolDescriptorMeta('Creating resource...', 'Resource created', ['tasks:write']),
+    }, async (args, extra) => {
+        try {
+            if (args.resource === 'task') {
+                const auth = requireScopes(extra, ['tasks:write']);
+                // Map skills to requirements
+                const taskPayload = {
+                    ...args.data,
+                    requirements: {
+                        ...(args.data.requirements || {}),
+                        skills: args.data.skills // Mapping skills here!
+                    }
+                };
+                const task = await client.createTask(taskPayload, auth?.token);
+                return {
+                    content: [{ type: 'text', text: `Created task "${task.title}" (ID: ${task.id})` }],
+                    structuredContent: { task },
+                    _meta: { ...toolInvocationMeta('Creating task...', 'Task created', `task:${task.id}`), task }
+                };
+            }
+            if (args.resource === 'worker_profile') {
+                // Placeholder for future implementation or if endpoint existed
+                return { isError: true, content: [{ type: 'text', text: "Worker profile creation via generic create is not yet fully linked." }] };
+            }
+            return { isError: true, content: [{ type: 'text', text: "Unknown resource type" }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 3. get
+    server.registerTool("get", {
+        title: "Get Resource",
+        description: "Retrieve details for tasks, workers, or account info.\n",
+        inputSchema: GetSchema,
+        _meta: toolDescriptorMeta('Fetching...', 'Ready', ['tasks:read', 'workers:read']),
+    }, async (args, extra) => {
+        try {
+            if (args.resource === 'task') {
+                const auth = requireScopes(extra, ['tasks:read']);
+                if (!args.id)
+                    throw new Error("Task ID required");
+                const task = await client.getTask(args.id, auth?.token);
+                const skillStr = task.requirements?.skills?.join(', ') || 'None';
+                return {
+                    content: [{ type: 'text', text: `Task: ${task.title}\nStatus: ${task.status}\nBudget: $${task.budget}\nSkills: ${skillStr}\nDescription: ${task.description}` }],
+                    structuredContent: { task },
+                    _meta: { ...toolInvocationMeta('Fetching task...', 'Task loaded', `task:${task.id}`), task }
+                };
+            }
+            if (args.resource === 'worker') {
+                const auth = requireScopes(extra, ['workers:read']);
+                if (!args.id)
+                    throw new Error("Worker ID required");
+                const worker = await client.getWorkerProfile(args.id, auth?.token);
+                return {
+                    content: [{ type: 'text', text: `Worker: ${worker.name || 'Anonymous'}\nRating: ${worker.rating}\nHourly: $${worker.hourlyRate}` }],
+                    structuredContent: { worker },
+                    _meta: { ...toolInvocationMeta('Fetching worker...', 'Worker loaded', `worker:${args.id}`), worker }
+                };
+            }
+            if (args.resource === 'account' || args.resource === 'balance') {
+                const auth = requireScopes(extra, ['tasks:read']); // Assuming generic scope
+                const account = await client.getAccount(auth?.token);
+                return {
+                    content: [{ type: 'text', text: `Account Balance: $${account.balanceCredits}\nEmail: ${account.email}` }],
+                    structuredContent: { account },
+                    _meta: { ...toolInvocationMeta('Fetching account...', 'Account loaded', `account:${account.userId}`), account }
+                };
+            }
+            if (args.resource === 'estimate') {
+                const auth = requireScopes(extra, ['tasks:read']);
+                if (!args.estimateParams)
+                    throw new Error("estimateParams required for estimate");
+                const est = await client.getEstimate(args.estimateParams, auth?.token);
+                return {
+                    content: [{ type: 'text', text: `Estimate: $${est.estimatedPrice} (${est.priceRange?.min}-${est.priceRange?.max}), time: ${est.estimatedCompletionTime}` }],
+                    structuredContent: { estimate: est },
+                    _meta: { ...toolInvocationMeta('Calculating...', 'Estimate ready', `est:${Date.now()}`), estimate: est }
+                };
+            }
+            return { isError: true, content: [{ type: 'text', text: "Unknown resource type" }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 4. update
+    server.registerTool("update", {
+        title: "Update Resource",
+        description: "Update details of an existing resource.",
+        inputSchema: UpdateSchema,
+        _meta: toolDescriptorMeta('Updating...', 'Updated', ['tasks:write']),
+    }, async (args, extra) => {
+        try {
+            if (args.resource === 'task') {
+                const auth = requireScopes(extra, ['tasks:write']);
+                // Map skills if present
+                const updatePayload = {
+                    ...args.data,
+                    ...(args.data.skills ? { requirements: { skills: args.data.skills } } : {})
+                };
+                const task = await client.updateTask(args.id, updatePayload, auth?.token);
+                return {
+                    content: [{ type: 'text', text: `Updated task ${task.id}` }],
+                    structuredContent: { task },
+                    _meta: { ...toolInvocationMeta('Updating task...', 'Task updated', `task:${task.id}`), task }
+                };
+            }
+            return { isError: true, content: [{ type: 'text', text: "Only task updates are currently supported." }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 5. terminate
+    server.registerTool("terminate", {
+        title: "Terminate Resource",
+        description: "Cancel or terminate a process or resource (e.g., a task).",
+        inputSchema: TerminateSchema,
+        _meta: toolDescriptorMeta('Terminating...', 'Terminated', ['tasks:write']),
+    }, async (args, extra) => {
+        try {
+            if (args.resource === 'task') {
+                const auth = requireScopes(extra, ['tasks:write']);
+                const res = await client.cancelTask(args.id, args.reason, auth?.token);
+                return {
+                    content: [{ type: 'text', text: `Task ${args.id} terminated.` }],
+                    structuredContent: res,
+                    _meta: { ...toolInvocationMeta('Cancelling...', 'Cancelled', `task:${args.id}`), res }
+                };
+            }
+            return { isError: true, content: [{ type: 'text', text: "Unknown resource" }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 6. search_and_browse
+    server.registerTool("search_and_browse", {
+        title: "Search and Browse",
+        description: "Use this tool to find workers or explore possibilities. You don't need a perfect query; we'll provide suggestions. Great for 'I need help with X' vague requests.",
+        inputSchema: SearchAndBrowseSchema,
+        _meta: toolDescriptorMeta('Searching...', 'Results found', ['workers:read']),
+    }, async (args, extra) => {
+        try {
+            if (args.resource === 'workers') {
+                const auth = requireScopes(extra, ['workers:read']);
+                const criteria = {
+                    description: args.query?.text,
+                    skills: args.query?.skills,
+                    location: args.query?.location
+                };
+                const result = await client.searchWorkers(criteria, auth?.token);
+                const summary = result.workers?.length
+                    ? `Found ${result.workers.length} workers.`
+                    : "No exact matches, but here are some suggestions...";
+                return {
+                    content: [{ type: 'text', text: summary }],
+                    structuredContent: result,
+                    _meta: { ...toolInvocationMeta('Searching workers...', 'Workers found', `search:${Date.now()}`), result }
+                };
+            }
+            if (args.resource === 'skill_categories') {
+                const cats = await client.getSkillCategories();
+                const text = cats
+                    .map((c) => `### ${c.name}\n${c.description}\nRange: $${c.priceRange.min}-$${c.priceRange.max}`)
+                    .join('\n\n');
+                return {
+                    content: [{ type: 'text', text }],
+                    structuredContent: { categories: cats },
+                    _meta: { ...toolInvocationMeta('Browsing skills...', 'Categories loaded', `skills:${Date.now()}`), categories: cats }
+                };
+            }
+            return { isError: true, content: [{ type: 'text', text: "Unknown resource" }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 7. interact_with_haptic
+    server.registerTool("interact_with_haptic", {
+        title: "Interact with Haptic",
+        description: "Management dashboard actions like listing tasks, checking alerts, etc.",
+        inputSchema: InteractWithHapticSchema,
+        _meta: toolDescriptorMeta('Interacting...', 'Done', ['tasks:read']),
+    }, async (args, extra) => {
+        try {
+            if (args.action === 'list_my_tasks') {
+                const auth = requireScopes(extra, ['tasks:read']);
+                const tasks = await client.listTasks(args.filters, auth?.token);
+                const items = Array.isArray(tasks) ? tasks : tasks?.tasks ?? [];
+                const summary = items
+                    .map((t) => `- [${t.status}] ${t.title} ($${t.budget}) (ID: ${t.id})`)
+                    .join('\n');
+                return {
+                    content: [{ type: 'text', text: `My Tasks:\n${summary}` }],
+                    structuredContent: { tasks: items },
+                    _meta: { ...toolInvocationMeta('Listing tasks...', 'Tasks listed', `list:${Date.now()}`), tasks: items }
+                };
+            }
+            return { isError: true, content: [{ type: 'text', text: "Unknown action" }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+        }
+    });
+    // 8. api
+    const apiDoc = `
+API CHEATSHEET:
+- GET /tasks: List tasks
+- POST /tasks: Create task {title, description, budget, requirements: {skills: []}}
+- GET /tasks/{id}: Get task
+- PATCH /tasks/{id}: Update task
+- POST /workers/search: Search workers {taskDescription, skillsRequired: []}
+- GET /workers/profile: Get profile
+    `.trim();
+    server.registerTool("api", {
+        title: "Raw API Access",
+        description: "Make any request to the Haptic Paper API. Use this if other tools don't cover your use case.\n\n" + apiDoc,
+        inputSchema: ApiSchema,
+        _meta: toolDescriptorMeta('Calling API...', 'Call complete'),
+    }, async (args, extra) => {
+        try {
+            // Security note: In a real scenario, this is dangerous. 
+            // We assume the client methods will handle auth. 
+            // Since HapticPaperClient is wrapper based, we might expose a raw 'request' method or just map common ones.
+            // But `HapticPaperClient` uses `axios` and exposes `client`. 
+            // We can't easily access private `client` property in TS unless we change it or use `(client as any).client`.
+            // For now, let's just say "Not implemented for raw access" or try to hack it if critical.
+            // Ideally, we should add a `request` method to HapticPaperClient.
+            // Let's rely on the fact that we can add a method to client or cast it.
+            const axiosInstance = client.client;
+            const auth = requireScopes(extra, []); // Wide open for now? Or specific scopes?
+            // We need a token.
+            const token = auth?.token;
+            const response = await axiosInstance.request({
+                method: args.method,
+                url: args.path,
+                data: args.body,
+                params: args.queryParams,
+                headers: token ? { Authorization: `Bearer ${token}` } : {}
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }],
+                structuredContent: response.data,
+                _meta: { ...toolInvocationMeta('API Call', 'Success', `api:${Date.now()}`), data: response.data }
+            };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: `API Error: ${err.message} - ${JSON.stringify(err.response?.data)}` }] };
+        }
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hapticpaper/mcp-server",
   "mcpName": "com.hapticpaper/mcp",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "Official MCP Server for Haptic Paper - Connect your account to create human tasks from agentic pipelines.",
   "type": "module",
   "main": "dist/index.js",
@@ -44,8 +44,11 @@
     "@types/jest": "^29.5.11",
     "@types/jsonwebtoken": "^9.0.6",
     "@types/node": "^20.11.0",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.1",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.3.3"
+  },
+  "overrides": {
+    "test-exclude": "^7.0.1"
   }
 }

package/server.json

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