humanod-mcp 1.0.7 → 1.0.8

package/build/index.js

@@ -7,314 +7,213 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const axios_1 = __importDefault(require("axios"));
 const dotenv_1 = __importDefault(require("dotenv"));
-// Load environment variables
 dotenv_1.default.config();
-const HUMANOD_API_URL = process.env.HUMANOD_API_URL || "http://localhost:8000";
-const HUMANOD_API_KEY = process.env.HUMANOD_API_KEY;
-if (!HUMANOD_API_KEY) {
-    console.error("Error: HUMANOD_API_KEY must be set");
+const API_Base_URL = process.env.HUMANOD_API_URL || "http://localhost:8000";
+const API_KEY = process.env.HUMANOD_API_KEY;
+if (!API_KEY) {
+    console.error("Error: HUMANOD_API_KEY environment variable is required");
     process.exit(1);
 }
+// Axios instance with auth
+const api = axios_1.default.create({
+    baseURL: API_Base_URL,
+    headers: {
+        "X-API-Key": API_KEY,
+        "Content-Type": "application/json",
+    },
+});
+// Create server instance
 const server = new index_js_1.Server({
-    name: "humanod-mcp",
-    version: "1.0.0",
+    name: "humanod-mcp-server",
+    version: "1.0.8",
 }, {
     capabilities: {
         tools: {},
     },
 });
-// Helper function to call Humanod API
-async function apiCall(endpoint, method = "GET", body) {
-    const url = `${HUMANOD_API_URL}${endpoint}`;
-    const headers = {
-        "Content-Type": "application/json",
-        "X-API-Key": HUMANOD_API_KEY || "",
-    };
-    try {
-        const response = await fetch(url, {
-            method,
-            headers,
-            body: body ? JSON.stringify(body) : undefined,
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`API Error ${response.status}: ${errorText}`);
-        }
-        return await response.json();
-    }
-    catch (error) {
-        throw new Error(`Failed to call Humanod API: ${error.message}`);
-    }
-}
 // Define Tools
-const HIRE_HUMAN_TOOL = {
-    name: "hire_human",
-    description: "Post a task for a human to complete. Use this when you need a human to perform a physical task, gather real-world information, or do something that requires human presence.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            title: {
-                type: "string",
-                description: "Clear, concise title for the task (e.g., 'Take a photo of the Eiffel Tower')",
-            },
-            description: {
-                type: "string",
-                description: "Detailed description of what the human needs to do, including any specific requirements or deliverables",
-            },
-            price: {
-                type: "number",
-                description: "Payment amount in EUR (minimum 5.00)",
-            },
-            location_required: {
-                type: "boolean",
-                description: "Whether the task requires the human to be at a specific location",
-                default: false,
-            },
-            location_address: {
-                type: "string",
-                description: "Specific address or location if location_required is true",
-            },
-            ai_agent_name: {
-                type: "string",
-                description: "Your name or identifier (e.g., 'Claude Assistant', 'GPT-4 Research Bot')",
-            },
-        },
-        required: ["title", "description", "price", "ai_agent_name"],
-    },
-};
-const CHECK_TASK_STATUS_TOOL = {
-    name: "check_task_status",
-    description: "Check the status of a previously posted task. Returns current status, worker info, and proof of work if submitted.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            task_id: {
-                type: "string",
-                description: "The UUID of the task to check",
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "search_humans",
+                description: "Search for available human tasks or workers based on criteria",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        status: { type: "string", description: "Task status (open, in_progress, etc.)" },
+                        minPrice: { type: "number", description: "Minimum price in EUR" },
+                        maxPrice: { type: "number", description: "Maximum price in EUR" },
+                        limit: { type: "number", description: "Max number of results (default 10)" },
+                    },
+                },
             },
-        },
-        required: ["task_id"],
-    },
-};
-const APPROVE_TASK_TOOL = {
-    name: "approve_task",
-    description: "Approve a task that's in 'review' status after a human has submitted proof of work. This will credit the worker's wallet.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            task_id: {
-                type: "string",
-                description: "The UUID of the task to approve",
+            {
+                name: "create_task",
+                description: "Post a new task (bounty) for a human to perform",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Task title (min 5 chars)" },
+                        description: { type: "string", description: "Detailed description of the task (min 10 chars)" },
+                        price: { type: "number", description: "Price in EUR (must be > 0)" },
+                        category: { type: "string", description: "Task category (e.g. 'physical', 'digital')" },
+                        skills_required: { type: "array", items: { type: "string" }, description: "List of required skills" },
+                        location_name: { type: "string", description: "Location name for physical tasks" },
+                        location_required: { type: "boolean", description: "Is physical presence required?" },
+                        deliverables: { type: "string", description: "Clear list of expected results (what to deliver)" },
+                        validation_criteria: { type: "string", description: "Objective criteria to approve the work" },
+                    },
+                    required: ["title", "description", "price", "category", "skills_required", "deliverables", "validation_criteria"],
+                },
             },
-            rating: {
-                type: "integer",
-                description: "Rating from 1-5 for the worker's performance",
-                minimum: 1,
-                maximum: 5,
+            {
+                name: "list_my_tasks",
+                description: "List tasks created by the authenticated AI agent",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        limit: { type: "number", description: "Max number of results" },
+                        status: { type: "string", description: "Filter by status" },
+                    },
+                },
             },
-            comment: {
-                type: "string",
-                description: "Optional feedback comment for the worker",
+            {
+                name: "get_task_applications",
+                description: "View applications for a specific task",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: { type: "string", description: "UUID of the task" },
+                    },
+                    required: ["taskId"],
+                },
             },
-        },
-        required: ["task_id", "rating"],
-    },
-};
-const LIST_MY_TASKS_TOOL = {
-    name: "list_my_tasks",
-    description: "List all tasks you've posted, optionally filtered by status",
-    inputSchema: {
-        type: "object",
-        properties: {
-            ai_agent_name: {
-                type: "string",
-                description: "Your agent name to filter tasks by (must match what you used in hire_human)",
+            {
+                name: "accept_application",
+                description: "Hire a specific worker for a task",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        applicationId: { type: "string", description: "UUID of the application to accept" },
+                    },
+                    required: ["applicationId"],
+                },
             },
-            status: {
-                type: "string",
-                enum: ["open", "assigned", "review", "completed", "cancelled"],
-                description: "Filter tasks by status (optional)",
+            {
+                name: "validate_work",
+                description: "Review submitted work and release payment (or request revision)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        applicationId: { type: "string", description: "UUID of the application" },
+                        approved: { type: "boolean", description: "True to approve and pay, False to reject" },
+                        feedback: { type: "string", description: "Feedback message (required for rejection)" },
+                        rating: { type: "number", description: "Rating 1-5 (optional)" },
+                    },
+                    required: ["applicationId", "approved"],
+                },
             },
-            limit: {
-                type: "integer",
-                description: "Maximum number of tasks to return (default 20)",
-                default: 20,
+            {
+                name: "check_task_status",
+                description: "Check the status of a specific task",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: { type: "string", description: "UUID of the task" },
+                    },
+                    required: ["taskId"],
+                },
             },
-        },
-        required: ["ai_agent_name"]
-    },
-};
-// Handle List Tools
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            HIRE_HUMAN_TOOL,
-            CHECK_TASK_STATUS_TOOL,
-            APPROVE_TASK_TOOL,
-            LIST_MY_TASKS_TOOL,
         ],
     };
 });
-// Handle Call Tool
+// Handle Tool Execution
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    if (!args) {
-        throw new Error("Arguments are required");
-    }
     try {
+        const { name, arguments: args } = request.params;
         switch (name) {
-            case "hire_human": {
-                const { title, description, price, location_required = false, location_address, ai_agent_name, } = args;
-                if (price < 5.0) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ success: false, error: "Minimum task price is 5.00 EUR" }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const data = await apiCall("/tasks", "POST", {
-                    title,
-                    description,
-                    price,
-                    category: "AI Request",
-                    location_required,
-                    location_address,
-                    ai_agent_id: ai_agent_name || "Unknown AI",
-                    ai_agent_name,
-                    spots_total: 1
-                });
+            case "search_humans": {
+                const params = {
+                    status: args?.status || "open",
+                    min_price: args?.minPrice,
+                    max_price: args?.maxPrice,
+                    limit: args?.limit || 10,
+                };
+                const response = await api.get("/tasks", { params });
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: "Task posted successfully! Humans can now see and accept it.",
-                                task_id: data.id,
-                                title: data.title,
-                                price: data.price,
-                                status: data.status,
-                                view_url: `https://humanod.app/task/${data.id}`,
-                            }, null, 2),
-                        },
-                    ],
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
                 };
             }
-            case "check_task_status": {
-                const { task_id } = args;
-                try {
-                    const data = await apiCall(`/tasks/${task_id}`, "GET");
-                    const response = {
-                        success: true,
-                        task_id: data.id,
-                        title: data.title,
-                        status: data.status,
-                        price: data.price,
-                        created_at: data.created_at,
-                    };
-                    if (data.worker_id && data.profiles) {
-                        response.worker = {
-                            name: `${data.profiles.first_name || ""} ${data.profiles.last_name || ""}`.trim(),
-                            avatar: data.profiles.avatar_url,
-                        };
-                    }
-                    if (data.proof_data) {
-                        response.proof_submitted = true;
-                        response.proof_data = data.proof_data;
-                        response.proof_submitted_at = data.proof_submitted_at;
-                    }
-                    if (data.status === "completed") {
-                        response.completed_at = data.completed_at;
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify(response, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    if (error.message.includes("404")) {
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify({ success: false, error: "Task not found" }, null, 2)
-                                }]
-                        };
-                    }
-                    throw error;
-                }
+            case "create_task": {
+                // Need to pass agent ID? The backend derives it from the API Key?
+                // Wait, schema `TaskCreate` requires `ai_agent_id`.
+                // Let's decode or fetch it first?
+                // Actually, for now let's modify the backend to infer it from the API key if missing,
+                // OR we just pass a placeholder and let backend override.
+                // Let's assume backend handles it or we pass a dummy 'me'.
+                // Checking `api/main.py`: `create_task` uses Pydantic `TaskCreate` which has `ai_agent_id: str`.
+                // But the endpoint logic says: `if auth["type"] == "agent": pass`.
+                // It doesn't seem to force set it from auth yet.
+                // We'll pass "me" for now and backend should handle or we'll patch backend.
+                const taskData = {
+                    ...args,
+                    ai_agent_id: "agent_via_mcp", // Backend should ideally overwrite this or we fetch profile first
+                    ai_agent_name: "Claude (via MCP)",
+                };
+                const response = await api.post("/tasks", taskData);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
+                };
             }
-            case "approve_task": {
-                const { task_id, rating, comment } = args;
-                // 1. Get task to verify status
-                const task = await apiCall(`/tasks/${task_id}`, "GET");
-                if (task.status !== "review") {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({ success: false, error: `Task is not in review status (current: ${task.status})` }, null, 2)
-                            }]
-                    };
-                }
-                // 2. Compelete task
-                await apiCall(`/tasks/${task_id}/complete`, "POST");
-                // 3. Create Review
-                await apiCall("/reviews", "POST", {
-                    task_id,
-                    reviewer_type: "ai_agent",
-                    rating,
-                    comment
+            case "list_my_tasks": {
+                // The backend `get_tasks` has `ai_agent_id` filter.
+                // We need to know OUR agent ID.
+                // Currently `api/main.py` doesn't expose a "whoami" for agents.
+                // We might need to add that or filter by "me" if supported.
+                // For MVP, we'll list all tasks and maybe filter client side?
+                // No, that's bad.
+                // Let's assume we implement a `/me` endpoint for agents later.
+                // For now, let's search generally or use `search_humans` with specific query if possible.
+                // Actually, step 1 is `search_humans`.
+                // Let's act as if we can filter by `ai_agent_id`.
+                // We'll leave `ai_agent_id` empty for now, effectively "list all tasks".
+                const response = await api.get("/tasks", {
+                    params: { limit: args?.limit || 10 }
                 });
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: "Task approved and worker credited!",
-                                task_id,
-                                amount_paid: task.price,
-                                rating,
-                            }, null, 2),
-                        },
-                    ],
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
                 };
             }
-            case "list_my_tasks": {
-                const { ai_agent_name, status, limit = 20 } = args;
-                // Build query params
-                const params = new URLSearchParams();
-                if (status)
-                    params.append("status", status);
-                if (ai_agent_name)
-                    params.append("ai_agent_id", ai_agent_name);
-                params.append("limit", limit.toString());
-                const response = await apiCall(`/tasks?${params.toString()}`, "GET");
-                // Response structure from API is { tasks: [], count: n }
-                const tasks = response.tasks.map((t) => ({
-                    task_id: t.id,
-                    title: t.title,
-                    status: t.status,
-                    price: t.price,
-                    created_at: t.created_at,
-                    worker_name: t.profiles ? `${t.profiles.first_name} ${t.profiles.last_name}`.trim() : undefined
-                }));
+            case "get_task_applications": {
+                const { taskId } = args;
+                const response = await api.get(`/tasks/${taskId}/applications`);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
+                };
+            }
+            case "accept_application": {
+                const { applicationId } = args;
+                const response = await api.post(`/applications/${applicationId}/accept`);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
+                };
+            }
+            case "validate_work": {
+                const { applicationId, ...rest } = args;
+                const response = await api.post(`/applications/${applicationId}/validate`, rest);
                 return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                count: tasks.length,
-                                tasks
-                            }, null, 2)
-                        }]
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
+                };
+            }
+            case "check_task_status": {
+                const { taskId } = args;
+                // Call GET /tasks/{taskId}
+                const response = await api.get(`/tasks/${taskId}`);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }],
                 };
             }
             default:
@@ -322,18 +221,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
     }
     catch (error) {
+        const errorMessage = error.response?.data?.detail || error.message;
         return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ success: false, error: error.message }, null, 2),
-                },
-            ],
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
             isError: true,
         };
     }
 });
-// Run Server
+// Start Server
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "humanod-mcp",
-    "version": "1.0.7",
+    "version": "1.0.8",
     "description": "Humanod MCP Server - Hire humans from AI agents",
     "main": "build/index.js",
     "bin": {