humanlypossible 0.2.2 → 0.2.4

package/dist/mcp-7IK2TXZV.js

@@ -1,851 +0,0 @@
-#!/usr/bin/env node
-
-// src/mcp.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-var API_URL = process.env.HUMANLYPOSSIBLE_API_URL || "https://humanlypossible.ai";
-var API_KEY = process.env.HUMANLYPOSSIBLE_API_KEY;
-if (!API_KEY) {
-  console.error(
-    "HUMANLYPOSSIBLE_API_KEY not set. Starting in bootstrap mode \u2014 use the signup tool to authenticate."
-  );
-}
-function mapHttpStatusToErrorCode(status) {
-  switch (status) {
-    case 401:
-      return "UNAUTHORIZED";
-    case 403:
-      return "FORBIDDEN";
-    case 404:
-      return "NOT_FOUND";
-    case 409:
-      return "CONFLICT";
-    case 400:
-    case 422:
-      return "VALIDATION_ERROR";
-    default:
-      return status >= 500 ? "INTERNAL_ERROR" : "VALIDATION_ERROR";
-  }
-}
-function formatError(error) {
-  return JSON.stringify({ error }, null, 2);
-}
-async function apiRequest(path, options = {}) {
-  if (!API_KEY) {
-    return {
-      error: {
-        code: "UNAUTHORIZED",
-        message: "No API key configured. Call the signup tool first to authenticate."
-      }
-    };
-  }
-  const { method = "GET", body, params } = options;
-  let url = `${API_URL}/api/v0${path}`;
-  if (params) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value !== void 0) {
-        searchParams.set(key, String(value));
-      }
-    }
-    const queryString = searchParams.toString();
-    if (queryString) {
-      url += `?${queryString}`;
-    }
-  }
-  try {
-    const res = await fetch(url, {
-      method,
-      headers: {
-        Authorization: `Bearer ${API_KEY}`,
-        "Content-Type": "application/json"
-      },
-      body: body ? JSON.stringify(body) : void 0
-    });
-    const json = await res.json();
-    if (!res.ok) {
-      const errorMessage = json.error || `HTTP ${res.status}`;
-      return {
-        error: {
-          code: mapHttpStatusToErrorCode(res.status),
-          message: errorMessage,
-          details: json.details
-        }
-      };
-    }
-    return { data: json };
-  } catch (err) {
-    return {
-      error: {
-        code: "NETWORK_ERROR",
-        message: err instanceof Error ? err.message : "Request failed"
-      }
-    };
-  }
-}
-var VerificationLevel = z.enum(["L0", "L1", "L2", "L3", "L4"]);
-var OracleType = z.enum(["hp", "requester", "executor", "third_party"]);
-var EvidenceKind = z.enum([
-  "photo",
-  "video",
-  "audio",
-  "receipt",
-  "signature",
-  "measurement",
-  "json",
-  "pdf",
-  "log",
-  "note"
-]);
-var OutcomeState = z.enum([
-  "queued",
-  "matching",
-  "running",
-  "needs_input",
-  "under_review",
-  "completed",
-  "failed",
-  "expired",
-  "disputed"
-]);
-var EvidenceRequirement = z.object({
-  kind: EvidenceKind.optional().describe("Type of evidence required"),
-  name: z.string().optional().describe("Name/label for this evidence requirement"),
-  description: z.string().optional().describe("Description of what is needed"),
-  min: z.number().int().min(0).optional().describe("Minimum number of items required"),
-  max: z.number().int().min(0).optional().describe("Maximum number of items allowed")
-});
-var Verification = z.object({
-  level: VerificationLevel.optional().describe("Verification level (L0-L4)"),
-  oracle: OracleType.optional().describe("Who verifies the outcome"),
-  dispute_window_seconds: z.number().int().min(0).optional().describe("Time window for disputes")
-});
-var Budget = z.object({
-  max_usd: z.number().min(0).optional().describe("Maximum budget in USD"),
-  model: z.enum(["fixed", "not_to_exceed", "per_hour"]).optional().describe("Pricing model")
-});
-var Constraints = z.object({
-  location: z.string().optional().describe("Location constraint (address or coordinates)"),
-  tools_allowed: z.array(z.string()).optional().describe("List of allowed tools"),
-  data_handling: z.enum(["no_pii", "redacted", "allowed"]).optional().describe("Data handling policy"),
-  requires_license: z.boolean().optional().describe("Whether a license is required")
-});
-var Prefs = z.object({
-  prefer: z.enum(["human", "agent", "either"]).optional().describe("Preferred executor type"),
-  optimize_for: z.enum(["cost", "speed", "quality", "verification"]).optional().describe("Optimization priority")
-});
-var OutcomeInput = z.object({
-  kind: EvidenceKind.optional().describe("Type of input"),
-  name: z.string().optional().describe("Name/label for this input"),
-  mime_type: z.string().optional().describe("MIME type of the content"),
-  url: z.string().url().optional().describe("URL to the content"),
-  text: z.string().optional().describe("Text content"),
-  bytes_base64: z.string().optional().describe("Base64-encoded binary content")
-});
-var StatusProgress = z.object({
-  pct: z.number().min(0).max(100).optional().describe("Completion percentage"),
-  checkpoints: z.array(z.string()).optional().describe("Completed checkpoints")
-});
-var RequestedInputs = z.object({
-  prompt: z.string().describe("Prompt explaining what input is needed"),
-  evidence_kind: z.array(EvidenceKind).optional().describe("Types of evidence that can be provided")
-});
-var StatusUpdate = z.object({
-  state: OutcomeState.optional().describe("New state"),
-  message: z.string().optional().describe("Status message"),
-  progress: StatusProgress.optional().describe("Progress information"),
-  requested_inputs: RequestedInputs.optional().describe("Request for additional inputs")
-});
-var Artifact = z.object({
-  id: z.string().describe("Artifact ID"),
-  kind: EvidenceKind.describe("Type of artifact"),
-  name: z.string().optional().describe("Name of the artifact"),
-  mime_type: z.string().optional().describe("MIME type"),
-  url: z.string().optional().describe("URL to access the artifact"),
-  text_preview: z.string().optional().describe("Text preview of the content"),
-  meta: z.record(z.unknown()).optional().describe("Additional metadata")
-});
-var Resolution = z.object({
-  accepted: z.boolean().describe("Whether the outcome was accepted"),
-  decided_at: z.string().datetime().describe("When the decision was made"),
-  oracle: OracleType.describe("Who made the decision"),
-  reason: z.string().optional().describe("Reason for the decision"),
-  failures: z.array(z.string()).optional().describe("List of failures if not accepted")
-});
-var Receipt = z.object({
-  verification_level: VerificationLevel.describe("Verification level achieved"),
-  hashes: z.record(z.string()).optional().describe("Content hashes"),
-  timestamps: z.object({
-    started_at: z.string().datetime().optional(),
-    completed_at: z.string().datetime().optional()
-  }).optional().describe("Timing information"),
-  location_proof: z.object({
-    gps_points: z.array(
-      z.object({
-        lat: z.number(),
-        lon: z.number(),
-        ts: z.string().datetime()
-      })
-    ).optional(),
-    radius_m: z.number().optional()
-  }).optional().describe("Location verification data"),
-  audit_log_url: z.string().url().optional().describe("URL to audit log"),
-  executor_attestation: z.string().optional().describe("Executor attestation")
-});
-var ResultSubmission = z.object({
-  resolution: Resolution.describe("Resolution details"),
-  artifacts: z.array(Artifact).describe("Submitted artifacts"),
-  receipt: Receipt.describe("Verification receipt")
-});
-var server = new McpServer({
-  name: "humanlypossible",
-  version: "0.4.0"
-});
-server.resource(
-  "guide",
-  "humanlypossible://guide",
-  async () => ({
-    contents: [
-      {
-        uri: "humanlypossible://guide",
-        mimeType: "text/markdown",
-        text: `# HumanlyPossible v0 Outcome Protocol
-
-## Quick Start
-
-1. Create an outcome request
-2. Poll status
-3. Provide extra inputs if requested
-4. Fetch result when completed
-
-## Requester Tools
-
-- \`request_outcome\` - Create a new outcome request
-- \`list_outcomes\` - List your outcome requests with filters
-- \`get_status\` - Check status of an outcome
-- \`send_inputs\` - Provide additional inputs if requested
-- \`get_result\` - Fetch result when completed
-
-## Executor Tools
-
-- \`list_available_outcomes\` - List outcomes available for claiming
-- \`claim_outcome\` - Claim an outcome for execution
-- \`submit_result\` - Submit artifacts/result for an outcome
-- \`update_status\` - Update outcome status during execution
-
-## Example Request
-
-\`\`\`json
-{
-  "outcome": "6 exterior photos of 123 Main St are captured in daylight",
-  "resolve_by": "2026-02-06T20:00:00Z",
-  "evidence": [{ "kind": "photo", "min": 6 }],
-  "verification": { "level": "L1", "oracle": "hp" },
-  "constraints": { "location": "123 Main St, SF" }
-}
-\`\`\`
-
-## Evidence Kinds
-photo, video, audio, receipt, signature, measurement, json, pdf, log, note
-
-## Verification Levels
-- L0: No verification
-- L1: Basic verification
-- L2: Standard verification
-- L3: Enhanced verification
-- L4: Maximum verification
-
-## Outcome States
-queued, matching, running, needs_input, under_review, completed, failed, expired, disputed
-
-## Adapter Routing
-
-Outcomes are automatically routed to the best available service adapter:
-
-### Available Adapters
-
-**Uber Direct** (delivery, courier, logistics)
-- Categories: food_delivery, courier, delivery, logistics
-- Params: pickup_address, pickup_name, pickup_phone, dropoff_address, dropoff_name, dropoff_phone, manifest_description
-- Example: \`{ adapter_hint: "delivery", params: { pickup_address: "123 Main St", dropoff_address: "456 Oak Ave" } }\`
-
-**Twilio** (communication, messaging)
-- Categories: communication, sms, voice, messaging, phone_call
-- Params: to (E.164 phone), from (optional), body, channel (sms|voice)
-- Example: \`{ adapter_hint: "sms", params: { to: "+15551234567", body: "Your order is ready" } }\`
-
-**Native Marketplace** (general, manual, human)
-- Default fallback for outcomes that don't match a service adapter
-- Outcomes stay in 'matching' for human/AI executors to claim
-
-### Routing Cascade
-1. If adapter_hint is provided, route to matching adapter
-2. If no hint, use LLM to interpret the outcome and select an adapter
-3. If no adapter matches, fall through to native marketplace
-
-## Error Codes
-- UNAUTHORIZED: API key invalid or missing
-- FORBIDDEN: Actor lacks required permissions
-- NOT_FOUND: Outcome not found
-- CONFLICT: Outcome already claimed or invalid state transition
-- VALIDATION_ERROR: Invalid request parameters
-- INTERNAL_ERROR: Server error
-- NETWORK_ERROR: Network connectivity issue
-`
-      }
-    ]
-  })
-);
-server.registerTool(
-  "request_outcome",
-  {
-    title: "Request Outcome",
-    description: `Create a new outcome request. Delegates a real-world task to humans or service adapters.
-
-The platform automatically routes outcomes to the best available adapter:
-- Use adapter_hint to target a specific service category (e.g. "delivery", "sms", "voice")
-- Use params to provide structured parameters matching the adapter's schema
-- Without hints, the platform uses LLM interpretation to route to the best adapter
-- Outcomes that don't match any adapter go to the native marketplace for human/AI claim
-
-Available adapter categories:
-- delivery/courier/logistics: Uber Direct (pickup_address, dropoff_address, etc.)
-- sms/voice/messaging: Twilio (to, body, channel)
-- general/manual: Native marketplace (any outcome)
-
-Returns:
-  { "id": "<uuid>" } - The outcome request ID for tracking
-
-Error Codes:
-  - VALIDATION_ERROR: Invalid parameters
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      outcome: z.string().min(1).describe("Clear description of the desired outcome"),
-      resolve_by: z.string().describe("ISO 8601 deadline (e.g. 2026-02-06T20:00:00Z)"),
-      params: z.record(z.unknown()).optional().describe("Structured params for adapter routing (e.g. { to: '+1234567890', body: 'Hello' } for SMS)"),
-      adapter_hint: z.string().optional().describe("Hint for adapter selection (e.g. 'delivery', 'sms', 'voice', 'courier')"),
-      evidence: z.array(EvidenceRequirement).optional().describe("Evidence requirements"),
-      verification: Verification.optional().describe("Verification settings"),
-      budget: Budget.optional().describe("Budget constraints"),
-      constraints: Constraints.optional().describe("Execution constraints"),
-      prefs: Prefs.optional().describe("Execution preferences")
-    },
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: true
-    }
-  },
-  async (params) => {
-    const body = {
-      outcome: params.outcome,
-      resolve_by: params.resolve_by
-    };
-    if (params.params) body.params = params.params;
-    if (params.adapter_hint) body.adapter_hint = params.adapter_hint;
-    if (params.evidence) body.evidence = params.evidence;
-    if (params.verification) body.verification = params.verification;
-    if (params.budget) body.budget = params.budget;
-    if (params.constraints) body.constraints = params.constraints;
-    if (params.prefs) body.prefs = params.prefs;
-    const { data, error } = await apiRequest("/outcomes", {
-      method: "POST",
-      body
-    });
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "list_outcomes",
-  {
-    title: "List Outcomes",
-    description: `List your outcome requests with optional filters.
-
-Returns:
-  {
-    "items": [...],
-    "has_more": true|false,
-    "next_cursor": "<ISO 8601 timestamp>"
-  }
-
-Error Codes:
-  - VALIDATION_ERROR: Invalid filter parameters
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      state: OutcomeState.optional().describe("Filter by state"),
-      limit: z.number().int().min(1).max(100).optional().describe("Max results (default 20, max 100)"),
-      created_before: z.string().optional().describe("Cursor for pagination (ISO 8601 timestamp)")
-    },
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { data, error } = await apiRequest("/outcomes", {
-      params: {
-        state: params.state,
-        limit: params.limit,
-        created_before: params.created_before
-      }
-    });
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "get_status",
-  {
-    title: "Get Outcome Status",
-    description: `Get the current status of an outcome request.
-
-Returns:
-  {
-    "id": "<uuid>",
-    "state": "queued|matching|running|needs_input|under_review|completed|failed|expired|disputed",
-    "updated_at": "<ISO 8601 timestamp>",
-    "message": "<optional status message>",
-    "progress": { "pct": 0-100, "checkpoints": [...] },
-    "requested_inputs": { "prompt": "...", "evidence_kind": [...] }
-  }
-
-Error Codes:
-  - NOT_FOUND: Outcome not found
-  - FORBIDDEN: Not authorized to view this outcome
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      id: z.string().describe("Outcome request ID (UUID)")
-    },
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { data, error } = await apiRequest(
-      `/outcomes/${params.id}/status`
-    );
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "send_inputs",
-  {
-    title: "Send Inputs",
-    description: `Provide additional inputs for an outcome request.
-
-Returns:
-  { "ok": true }
-
-Error Codes:
-  - NOT_FOUND: Outcome not found
-  - FORBIDDEN: Not authorized to send inputs
-  - VALIDATION_ERROR: Invalid input format
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      id: z.string().describe("Outcome request ID (UUID)"),
-      inputs: z.array(OutcomeInput).describe("Array of input objects")
-    },
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { data, error } = await apiRequest(
-      `/outcomes/${params.id}/inputs`,
-      {
-        method: "POST",
-        body: params.inputs
-      }
-    );
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "get_result",
-  {
-    title: "Get Outcome Result",
-    description: `Fetch the result for a completed outcome request.
-
-Returns:
-  {
-    "id": "<uuid>",
-    "resolution": { "accepted": true|false, "decided_at": "...", "oracle": "..." },
-    "artifacts": [...],
-    "receipt": { "verification_level": "L0-L4", ... }
-  }
-
-Error Codes:
-  - NOT_FOUND: Outcome not found or not yet completed
-  - FORBIDDEN: Not authorized to view this outcome
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      id: z.string().describe("Outcome request ID (UUID)")
-    },
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { data, error } = await apiRequest(
-      `/outcomes/${params.id}/result`
-    );
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "list_available_outcomes",
-  {
-    title: "List Available Outcomes",
-    description: `List outcomes available for claiming. Requires executor permissions (can_execute=true).
-
-Returns:
-  {
-    "items": [
-      {
-        "id": "<uuid>",
-        "state": "queued|matching",
-        "resolve_by": "<ISO 8601>",
-        "outcome": "<description>",
-        "budget": { ... },
-        "constraints": { ... },
-        "created_at": "<ISO 8601>"
-      },
-      ...
-    ],
-    "limit": 20,
-    "offset": 0
-  }
-
-Error Codes:
-  - FORBIDDEN: Actor lacks execute permissions
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      limit: z.number().int().min(1).max(100).optional().describe("Max results (default 20, max 100)"),
-      offset: z.number().int().min(0).optional().describe("Offset for pagination (default 0)")
-    },
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { data, error } = await apiRequest("/outcomes/available", {
-      params: {
-        limit: params.limit,
-        offset: params.offset
-      }
-    });
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "claim_outcome",
-  {
-    title: "Claim Outcome",
-    description: `Claim an outcome for execution. Requires executor permissions (can_execute=true).
-
-Returns:
-  {
-    "id": "<uuid>",
-    "executor_actor_id": "<uuid>",
-    "state": "running",
-    "status": { ... }
-  }
-
-Error Codes:
-  - NOT_FOUND: Outcome not found
-  - FORBIDDEN: Actor lacks execute permissions
-  - CONFLICT: Outcome already claimed by another executor
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      id: z.string().describe("Outcome request ID (UUID) to claim")
-    },
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { data, error } = await apiRequest(`/outcomes/${params.id}/claim`, {
-      method: "POST"
-    });
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "update_status",
-  {
-    title: "Update Outcome Status",
-    description: `Update the status of an outcome you are executing. Use this to report progress, request inputs, or change state.
-
-Returns:
-  {
-    "id": "<uuid>",
-    "state": "...",
-    "status": { ... }
-  }
-
-Error Codes:
-  - NOT_FOUND: Outcome not found
-  - FORBIDDEN: Not the executor of this outcome
-  - CONFLICT: Outcome not claimed
-  - VALIDATION_ERROR: Invalid status update
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      id: z.string().describe("Outcome request ID (UUID)"),
-      state: OutcomeState.optional().describe("New state"),
-      message: z.string().optional().describe("Status message"),
-      progress: StatusProgress.optional().describe("Progress information"),
-      requested_inputs: RequestedInputs.optional().describe("Request for additional inputs from requester")
-    },
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { id, ...statusUpdate } = params;
-    if (!statusUpdate.state && !statusUpdate.message && !statusUpdate.progress && !statusUpdate.requested_inputs) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: formatError({
-              code: "VALIDATION_ERROR",
-              message: "At least one status field (state, message, progress, or requested_inputs) is required"
-            })
-          }
-        ],
-        isError: true
-      };
-    }
-    const { data, error } = await apiRequest(`/outcomes/${id}/submit`, {
-      method: "POST",
-      body: { status: statusUpdate }
-    });
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "submit_result",
-  {
-    title: "Submit Outcome Result",
-    description: `Submit the final result for an outcome you are executing. This completes the outcome.
-
-The result must include:
-- resolution: Whether the outcome was achieved, when, and by whom
-- artifacts: Evidence/deliverables produced
-- receipt: Verification proof
-
-Returns:
-  {
-    "id": "<uuid>",
-    "state": "completed|failed",
-    "status": { ... },
-    "result": { ... }
-  }
-
-Error Codes:
-  - NOT_FOUND: Outcome not found
-  - FORBIDDEN: Not the executor of this outcome
-  - CONFLICT: Outcome not claimed or already completed
-  - VALIDATION_ERROR: Invalid result format
-  - UNAUTHORIZED: Invalid API key`,
-    inputSchema: {
-      id: z.string().describe("Outcome request ID (UUID)"),
-      resolution: Resolution.describe("Resolution details"),
-      artifacts: z.array(Artifact).describe("Evidence/deliverables produced"),
-      receipt: Receipt.describe("Verification proof")
-    },
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    }
-  },
-  async (params) => {
-    const { id, ...result } = params;
-    const { data, error } = await apiRequest(`/outcomes/${id}/submit`, {
-      method: "POST",
-      body: { result }
-    });
-    if (error) {
-      return {
-        content: [{ type: "text", text: formatError(error) }],
-        isError: true
-      };
-    }
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  }
-);
-server.registerTool(
-  "signup",
-  {
-    title: "Sign Up / Log In",
-    description: `Create an account or log into an existing one to get an API key. This is required before using any other tools if no API key was provided at startup.
-
-Returns:
-  {
-    "api_key": "hp_...",
-    "actor_id": "<uuid>",
-    "key_prefix": "hp_abc",
-    "scopes": ["outcomes:read", "outcomes:write"],
-    "is_new_account": true|false
-  }
-
-Error Codes:
-  - VALIDATION_ERROR: Missing fields or weak password
-  - UNAUTHORIZED: Wrong password for existing account`,
-    inputSchema: {
-      email: z.string().describe("Email address"),
-      password: z.string().describe("Password (min 8 characters)"),
-      display_name: z.string().optional().describe("Display name for the account"),
-      actor_kind: z.enum(["human", "ai", "org"]).optional().describe("Type of actor (default: ai)")
-    },
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: true
-    }
-  },
-  async (params) => {
-    try {
-      const res = await fetch(`${API_URL}/api/v0/auth/signup`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(params)
-      });
-      const json = await res.json();
-      if (!res.ok) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: formatError({
-                code: mapHttpStatusToErrorCode(res.status),
-                message: json.error || `HTTP ${res.status}`
-              })
-            }
-          ],
-          isError: true
-        };
-      }
-      API_KEY = json.api_key;
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(json, null, 2)
-          }
-        ]
-      };
-    } catch (err) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: formatError({
-              code: "NETWORK_ERROR",
-              message: err instanceof Error ? err.message : "Signup request failed"
-            })
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-);
-async function startMcpServer() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-startMcpServer();
-export {
-  startMcpServer
-};