@humanops/mcp-server 0.3.2 → 0.3.3

package/dist/index.js

@@ -522,7 +522,10 @@ const PostTaskInputSchema = z.object({
         lng: z.number(),
         address: z.string().min(1),
     }),
-    reward_usd: z.number().min(MIN_TASK_VALUE_USD).max(MAX_TASK_VALUE_USD),
+    urgency: z.enum(["standard", "priority", "urgent"]).optional(),
+    reward_usd: z.number().min(MIN_TASK_VALUE_USD).max(MAX_TASK_VALUE_USD).optional(),
+    max_budget_usd: z.number().min(MIN_TASK_VALUE_USD).max(MAX_TASK_VALUE_USD).optional(),
+    proposal_deadline_minutes: z.number().int().min(15).max(10080).optional(),
     deadline: z.string().datetime(),
     proof_requirements: z.array(z.string().min(1).max(500)).min(1).max(10),
     task_type: TaskTypeEnum,
@@ -535,10 +538,37 @@ const PostTaskInputSchema = z.object({
         .optional(),
     callback_secret: z.string().min(16).max(128).optional(),
     idempotency_key: z.string().min(1).max(200).optional(),
+}).refine((d) => (d.reward_usd !== undefined || d.max_budget_usd !== undefined) &&
+    !(d.reward_usd !== undefined && d.max_budget_usd !== undefined), {
+    message: "Provide either reward_usd (fixed price) or max_budget_usd (proposal mode), not both",
+    path: ["reward_usd"],
 });
 const GetTaskResultInputSchema = z.object({
     task_id: z.string().min(1),
 });
+const SubmitReviewInputSchema = z.object({
+    task_id: z.string().min(1),
+    rating: z.number().int().min(1).max(10),
+    comment: z.string().min(1).max(1000).optional(),
+});
+const GetOperatorReviewsInputSchema = z.object({
+    operator_id: z.string().min(1),
+});
+const ListProposalsInputSchema = z.object({
+    task_id: z.string().min(1),
+});
+const AwardProposalToolInputSchema = z.object({
+    task_id: z.string().min(1),
+    proposal_id: z.string().min(1),
+});
+const RejectProposalToolInputSchema = z.object({
+    task_id: z.string().min(1),
+    proposal_id: z.string().min(1),
+    reason: z.string().max(200).optional(),
+});
+const CancelProposalWindowInputSchema = z.object({
+    task_id: z.string().min(1),
+});
 const FundAccountInputSchema = z.object({
     amount_usd: z.number().min(MIN_DEPOSIT_USD).max(MAX_DEPOSIT_USD),
     payment_method: z.enum(["usdc", "card", "bank_transfer"]).default("usdc"),
@@ -612,7 +642,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "post_task",
-            description: "Create a new task for a human operator. Supports physical tasks (VERIFICATION, PHOTO, DELIVERY, INSPECTION), digital tasks (CAPTCHA_SOLVING, FORM_FILLING, etc.), and credential tasks (ACCOUNT_CREATION, API_KEY_PROCUREMENT, etc.). For digital tasks prefer dispatch_digital_task; for credential tasks prefer dispatch_credential_task. Funds will be escrowed from your account (reward + platform fee).",
+            description: "Create a new task for a human operator. Supports physical tasks (VERIFICATION, PHOTO, DELIVERY, INSPECTION), digital tasks (CAPTCHA_SOLVING, FORM_FILLING, etc.), and credential tasks (ACCOUNT_CREATION, API_KEY_PROCUREMENT, etc.). For digital tasks prefer dispatch_digital_task; for credential tasks prefer dispatch_credential_task. Provide either reward_usd (fixed price; escrowed at creation) OR max_budget_usd (proposal mode; escrow created when you award a proposal).",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -623,7 +653,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         properties: { lat: { type: "number" }, lng: { type: "number" }, address: { type: "string" } },
                         required: ["lat", "lng", "address"],
                     },
-                    reward_usd: { type: "number" },
+                    urgency: {
+                        type: "string",
+                        enum: ["standard", "priority", "urgent"],
+                        description: "Urgency level (standard=24h pickup, priority=4h pickup, urgent=1h pickup + 4h completion SLA).",
+                    },
+                    reward_usd: { type: "number", description: "Fixed-price mode: reward in USD" },
+                    max_budget_usd: { type: "number", description: "Proposal mode: maximum budget in USD (alternative to reward_usd)" },
+                    proposal_deadline_minutes: { type: "number", description: "Proposal window length in minutes (default: 120)" },
                     deadline: { type: "string", description: "ISO 8601 deadline for task completion" },
                     proof_requirements: { type: "array", items: { type: "string" } },
                     task_type: {
@@ -634,7 +671,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     callback_secret: { type: "string", description: "Optional secret to sign webhook callbacks" },
                     idempotency_key: { type: "string", description: "Optional key to make task creation safe to retry" },
                 },
-                required: ["title", "description", "location", "reward_usd", "deadline", "proof_requirements", "task_type"],
+                required: ["title", "description", "location", "deadline", "proof_requirements", "task_type"],
             },
         },
         {
@@ -738,6 +775,30 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["task_id"],
             },
         },
+        {
+            name: "submit_review",
+            description: "Submit a 1-10 rating (and optional comment) for the operator on a COMPLETED task. One review per task. Comments are screened for safety.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "The completed task ID" },
+                    rating: { type: "number", description: "Integer rating 1-10" },
+                    comment: { type: "string", description: "Optional comment (max 1000 chars)" },
+                },
+                required: ["task_id", "rating"],
+            },
+        },
+        {
+            name: "get_operator_reviews",
+            description: "Get an operator's approved reviews and aggregate rating (agent-facing). Useful for building trust signals and choosing operators.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    operator_id: { type: "string", description: "Operator ID" },
+                },
+                required: ["operator_id"],
+            },
+        },
         {
             name: "register_agent",
             description: "Register a new HumanOps agent account. Returns an API key for authentication. You start in SANDBOX tier (tasks auto-complete with simulated operators). Verify your email to upgrade to VERIFIED tier.",
@@ -845,6 +906,49 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["task_id"],
             },
         },
+        {
+            name: "list_proposals",
+            description: "List proposals for a proposal-mode task. Use this after creating a task with max_budget_usd.",
+            inputSchema: {
+                type: "object",
+                properties: { task_id: { type: "string", description: "The task ID" } },
+                required: ["task_id"],
+            },
+        },
+        {
+            name: "award_proposal",
+            description: "Award a proposal for a proposal-mode task. This creates escrow at award time and assigns the operator.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "The task ID" },
+                    proposal_id: { type: "string", description: "The proposal ID to award" },
+                },
+                required: ["task_id", "proposal_id"],
+            },
+        },
+        {
+            name: "reject_proposal",
+            description: "Reject a proposal for a proposal-mode task (optional reason).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "The task ID" },
+                    proposal_id: { type: "string", description: "The proposal ID to reject" },
+                    reason: { type: "string", description: "Optional rejection reason" },
+                },
+                required: ["task_id", "proposal_id"],
+            },
+        },
+        {
+            name: "cancel_proposal_window",
+            description: "Close the proposal window by cancelling the task. This is useful when you no longer want proposals for a task in proposal mode.",
+            inputSchema: {
+                type: "object",
+                properties: { task_id: { type: "string", description: "The task ID to cancel" } },
+                required: ["task_id"],
+            },
+        },
         {
             name: "approve_estimate",
             description: "Approve an operator's time estimate for a task. The operator will be notified and can start working. Only works when task status is ESTIMATE_PENDING.",
@@ -1038,6 +1142,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
                 return { content: [{ type: "text", text: JSON.stringify(focused, null, 2) }] };
             }
+            case "submit_review": {
+                const parsed = SubmitReviewInputSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Error: invalid input: ${parsed.error.message}` }],
+                        isError: true,
+                    };
+                }
+                const { task_id, rating, comment } = parsed.data;
+                const result = await apiRequest(`/api/v1/tasks/${encodeURIComponent(task_id)}/review`, {
+                    method: "POST",
+                    body: JSON.stringify({ rating, ...(comment ? { comment } : {}) }),
+                });
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "get_operator_reviews": {
+                const parsed = GetOperatorReviewsInputSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Error: invalid input: ${parsed.error.message}` }],
+                        isError: true,
+                    };
+                }
+                const result = await apiRequest(`/api/v1/operators/${encodeURIComponent(parsed.data.operator_id)}/reviews`, {
+                    method: "GET",
+                });
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
             case "get_deposit_address": {
                 const result = await apiRequest("/api/v1/agents/deposit-address", {
                     method: "GET",
@@ -1228,6 +1360,61 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 });
                 return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
             }
+            case "list_proposals": {
+                const parsed = ListProposalsInputSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Error: invalid input: ${parsed.error.message}` }],
+                        isError: true,
+                    };
+                }
+                const data = await apiRequest(`/api/v1/tasks/${encodeURIComponent(parsed.data.task_id)}/proposals`, {
+                    method: "GET",
+                });
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            }
+            case "award_proposal": {
+                const parsed = AwardProposalToolInputSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Error: invalid input: ${parsed.error.message}` }],
+                        isError: true,
+                    };
+                }
+                const result = await apiRequest(`/api/v1/tasks/${encodeURIComponent(parsed.data.task_id)}/award-proposal`, {
+                    method: "POST",
+                    body: JSON.stringify({ proposal_id: parsed.data.proposal_id }),
+                });
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "reject_proposal": {
+                const parsed = RejectProposalToolInputSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Error: invalid input: ${parsed.error.message}` }],
+                        isError: true,
+                    };
+                }
+                const body = parsed.data.reason ? { reason: parsed.data.reason } : {};
+                const result = await apiRequest(`/api/v1/tasks/${encodeURIComponent(parsed.data.task_id)}/proposals/${encodeURIComponent(parsed.data.proposal_id)}/reject`, {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                });
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "cancel_proposal_window": {
+                const parsed = CancelProposalWindowInputSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Error: invalid input: ${parsed.error.message}` }],
+                        isError: true,
+                    };
+                }
+                const result = await apiRequest(`/api/v1/tasks/${encodeURIComponent(parsed.data.task_id)}/cancel`, {
+                    method: "POST",
+                });
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
             case "approve_estimate": {
                 const parsed = GetTaskResultInputSchema.safeParse(args);
                 if (!parsed.success) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanops/mcp-server",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "mcpName": "io.github.thepianistdirector/humanops",
   "description": "MCP server for AI agents to dispatch real-world tasks to verified human operators via HumanOps",
   "type": "module",