@projectsolo/solo-mission-mcp 0.19.0

package/src/tools/missions.ts

@@ -0,0 +1,293 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { apiGet, apiPost } from '../api/client.js';
+
+export const missionTools: Tool[] = [
+  {
+    name: 'create_mission',
+    description: 'Create a new mission. Off-chain missions (no budget field) are always free — no payment, no escrow. For paid missions with EscrowVault escrow, include the budget field — the response will contain funding_params for you to call createTask() on the contract.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['coffee_chat', 'opinion', 'survey', 'general', 'media_review'],
+          description: 'Type of mission. Use "media_review" for audio/music rating missions.',
+        },
+        title: { type: 'string', description: 'Mission title (max 100 chars)' },
+        description: { type: 'string', description: 'Detailed mission description (max 2000 chars). Supports Markdown — use ## headings, - bullet lists, and **bold** to structure your content. The platform renders it as formatted text.' },
+        requirements: {
+          type: 'object',
+          description: 'Optional participant requirements',
+          properties: {
+            skills: { type: 'array', items: { type: 'string' } },
+            location: { type: 'string' },
+            languages: { type: 'array', items: { type: 'string' } },
+            min_rating: { type: 'number', minimum: 0, maximum: 5 },
+          },
+        },
+        reward_usdt: { type: 'number', minimum: 0, description: 'Deprecated — ignored for off-chain missions (which are always free). Has no effect. Omit this field.' },
+        max_participants: { type: 'number', minimum: 1, description: 'Maximum number of participants' },
+        expires_in_hours: { type: 'number', minimum: 1, description: 'Hours until mission expires' },
+        budget: { type: 'number', description: 'Total mission budget in USDC. Enables on-chain escrow. Must satisfy: base_reward * max_humans + lottery_prize_per_winner * lottery_winner_count <= budget.' },
+        max_humans: { type: 'number', minimum: 1, description: 'On-chain: maximum number of participants (both base-reward and lottery entrants).' },
+        base_reward: { type: 'number', minimum: 0, description: 'Per-participant base reward in USDC paid to every qualified human. Defaults to 0. Set to 0 for pure-lottery missions.' },
+        reward_per_human: { type: 'number', minimum: 0, description: 'Deprecated — use base_reward instead.' },
+        lottery_winner_count: { type: 'integer', minimum: 1, description: 'Number of winners randomly selected from all qualified participants. Must be <= max_humans. Must be paired with lottery_prize_per_winner. Winners are chosen deterministically from the on-chain seed reveal — auditable by anyone.' },
+        lottery_prize_per_winner: { type: 'number', minimum: 0, description: 'Additional prize in USDC paid to each lottery winner on top of base_reward. Must be paired with lottery_winner_count.' },
+        hiring_duration_hours: { type: 'number', minimum: 1, description: 'How long (hours) the mission accepts applications and the agent hires/rejects. The hiring window closes at now + hiring_duration_hours. Finalize-qualification cannot be called before this.' },
+        work_duration_hours: { type: 'number', minimum: 2, description: 'How long (hours) hired participants have to complete the work. Agent must call settle_mission before this period ends. Minimum is 2, not 1 — the contract requires at least 1 hour of settlement window remaining when finalize_qualification is called, and finalize can only happen after the hiring window already closes, so a value of exactly 1 leaves no reachable window at all.' },
+        auto_accept_applicants: { type: 'boolean', description: 'When true, applicants are automatically hired when they apply — no manual hire_participant call needed. First-come first-served up to max_humans. Face verification is still required. Ideal for open media_review missions.' },
+      },
+      required: ['type', 'title', 'description'],
+    },
+  },
+  {
+    name: 'list_missions',
+    description: 'List missions created by this agent. Filter by status to manage your mission portfolio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['pending_funding', 'active', 'qualifying', 'completed', 'refundable', 'refunded', 'cancelled', 'expired'],
+          description: 'Filter by status',
+        },
+        limit: { type: 'number', description: 'Max results (default 20)' },
+        page: { type: 'number', description: 'Page number (default 1)' },
+      },
+    },
+  },
+  {
+    name: 'get_mission',
+    description: 'Get details of a specific mission by ID, including all participants. Each participant includes a conversation_id once the human has tapped "Say Hi" — use it directly with watch_conversation or send_message. Each participant also includes an agent_rating field ({ rating: 1–5, comment?: string, updated_at }) if that human has rated the agent; null if not rated or if the 7-day rating window after mission completion has closed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'Mission ID' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'confirm_funding',
+    description: 'After calling createTask() on the EscrowVault contract, confirm the funding via the SOLO API. The backend verifies the transaction on-chain. Mission transitions from pending_funding → active. tx_hash is optional — backend reconciles from the contract if omitted. For media_review missions: returns 409 if no tracks are confirmed yet — call add_mission_track first. Also returns 409 if the on-chain task\'s budget, lottery, deadline, or seed_commit values do not match what create_mission originally quoted (e.g. createTask() was called with hand-typed or re-derived values instead of the exact funding_params fields) — unlike the "not yet FUNDED" 409, this one is NOT retryable: the task_id can never be confirmed. Call cancelTask() on-chain to reclaim the full escrow, then call create_mission again.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        tx_hash: { type: 'string', description: 'Transaction hash of createTask() call (optional)' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'hire_participant',
+    description: 'Accept a human applicant for a mission. Only applied humans can be hired. Hired humans can start work via conversations. Only valid while mission is active.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        uid: { type: 'string', description: 'Firebase UID of the applicant to hire' },
+      },
+      required: ['mission_id', 'uid'],
+    },
+  },
+  {
+    name: 'reject_participant',
+    description: 'Reject a human applicant or hired participant. Valid for applied or hired status, before finalize_qualification is called.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        uid: { type: 'string', description: 'Firebase UID of the participant to reject' },
+      },
+      required: ['mission_id', 'uid'],
+    },
+  },
+  {
+    name: 'finalize_qualification',
+    description: 'Lock in the qualified participants after reviewing their work. For standard missions provide an explicit list of UIDs whose work was accepted. For media_review missions pass an empty body — qualified_human_uids is ignored and the backend auto-qualifies anyone who rated every track. For on-chain missions, the backend calls finalizeQualification() on EscrowVault. Mission transitions to qualifying.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        qualified_human_uids: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Firebase UIDs of humans whose work was accepted. Ignored for media_review missions (auto-derived from rating completion).',
+        },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'settle_mission',
+    description: 'Settle the mission after finalize_qualification. For on-chain missions, calls settleTask() on EscrowVault only (aggregate payout numbers, no per-wallet computation); mission transitions to completed or refundable. Rewards are NOT immediately claimable — a separate batched process publishes the Merkle root that makes them claimable, which can take anywhere from minutes to over an hour depending on the review window. For free (off-chain) missions, marks qualified participants as completed — no payment is involved.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'cancel_mission',
+    description: 'Cancel an off-chain mission directly. Valid when status is active or qualifying. For on-chain missions, use get_cancel_params instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'Mission ID' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'get_cancel_params',
+    description: 'Get on-chain transaction parameters to cancel a funded mission via cancelTask() on EscrowVault. Only valid before qualify_deadline. After qualify_deadline, use get_emergency_refund_params instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'confirm_cancel',
+    description: 'After executing cancelTask() on EscrowVault, confirm the cancellation on the SOLO platform. Mission transitions to cancelled.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        tx_hash: { type: 'string', description: 'Transaction hash of cancelTask() (optional)' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'get_emergency_refund_params',
+    description: 'Get on-chain transaction parameters to force-refund a mission after the settlement_deadline has passed without settlement. Returns eligible: true with params if eligible, or eligible: false with retry_after if not yet past the deadline.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'confirm_emergency_refund',
+    description: 'After executing emergencyRefund() on EscrowVault, confirm on the SOLO platform. Mission transitions to cancelled.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        tx_hash: { type: 'string', description: 'Transaction hash of emergencyRefund() (optional)' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'get_refund_params',
+    description: 'Get on-chain transaction parameters to claim unused budget via claimRefund() on EscrowVault. Only valid when mission is in refundable state (settled with leftover budget).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'confirm_refund',
+    description: 'After executing claimRefund() on EscrowVault, confirm the refund on the SOLO platform. Mission transitions to refunded.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string' },
+        tx_hash: { type: 'string', description: 'Transaction hash of claimRefund() (optional)' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'rate_participant',
+    description: 'Leave a rating and optional comment for a mission participant. Requires the mission to be settled (completed, refundable, or refunded) and must be submitted within 7 days of mission completion. Limited to one rating per participant per mission; calling again overwrites the previous rating/comment.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'Mission ID' },
+        uid: { type: 'string', description: 'Participant UID' },
+        rating: { type: 'number', minimum: 1, maximum: 5, description: 'Rating 1-5' },
+        comment: { type: 'string', description: 'Optional comment (max 500 chars). Shown publicly on the participant\'s profile.' },
+      },
+      required: ['mission_id', 'uid', 'rating'],
+    },
+  },
+];
+
+export async function handleMissionTool(name: string, args: Record<string, any>): Promise<unknown> {
+  switch (name) {
+    case 'create_mission':
+      return apiPost('/agent/missions', args);
+
+    case 'list_missions': {
+      const params: Record<string, any> = {};
+      if (args.status) params.status = args.status;
+      if (args.limit) params.limit = args.limit;
+      if (args.page) params.page = args.page;
+      return apiGet('/agent/missions', params);
+    }
+
+    case 'get_mission':
+      return apiGet(`/agent/missions/${args.mission_id}`);
+
+    case 'confirm_funding':
+      return apiPost(`/agent/missions/${args.mission_id}/confirm-funding`, { tx_hash: args.tx_hash });
+
+    case 'hire_participant':
+      return apiPost(`/agent/missions/${args.mission_id}/participants/${args.uid}/hire`);
+
+    case 'reject_participant':
+      return apiPost(`/agent/missions/${args.mission_id}/participants/${args.uid}/reject`);
+
+    case 'finalize_qualification':
+      return apiPost(`/agent/missions/${args.mission_id}/finalize-qualification`, {
+        qualified_human_uids: args.qualified_human_uids,
+      });
+
+    case 'settle_mission':
+      return apiPost(`/agent/missions/${args.mission_id}/settle`);
+
+    case 'cancel_mission':
+      return apiPost(`/agent/missions/${args.mission_id}/cancel`);
+
+    case 'get_cancel_params':
+      return apiGet(`/agent/missions/${args.mission_id}/cancel-params`);
+
+    case 'confirm_cancel':
+      return apiPost(`/agent/missions/${args.mission_id}/confirm-cancel`, { tx_hash: args.tx_hash });
+
+    case 'get_emergency_refund_params':
+      return apiGet(`/agent/missions/${args.mission_id}/emergency-refund-params`);
+
+    case 'confirm_emergency_refund':
+      return apiPost(`/agent/missions/${args.mission_id}/confirm-emergency-refund`, { tx_hash: args.tx_hash });
+
+    case 'get_refund_params':
+      return apiGet(`/agent/missions/${args.mission_id}/refund-params`);
+
+    case 'confirm_refund':
+      return apiPost(`/agent/missions/${args.mission_id}/confirm-refund`, { tx_hash: args.tx_hash });
+
+    case 'rate_participant':
+      return apiPost(`/agent/missions/${args.mission_id}/participants/${args.uid}/comment`, {
+        rating: args.rating,
+        comment: args.comment,
+      });
+
+    default:
+      throw new Error(`Unknown mission tool: ${name}`);
+  }
+}

package/src/tools/realtime.ts

@@ -0,0 +1,163 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { startPolling, drainQueue, stopPolling, listWatched, getPollIntervalMs } from '../realtime/poller.js';
+import { startMissionPolling, drainMissionQueue, stopMissionPolling, listWatchedMissions } from '../realtime/missionPoller.js';
+
+export const realtimeTools: Tool[] = [
+  {
+    name: 'watch_conversation',
+    description: 'Start watching a conversation for new messages. Uses a Fibonacci delay schedule: starts at 1s, advances on each miss (up to 600s cap), resets to 1s when the human replies. Drain buffered messages with get_pending_messages.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        conversation_id: { type: 'string', description: 'Conversation ID to watch' },
+      },
+      required: ['conversation_id'],
+    },
+  },
+  {
+    name: 'get_pending_messages',
+    description: 'Return and clear all buffered new messages for a watched conversation.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        conversation_id: { type: 'string', description: 'Conversation ID' },
+      },
+      required: ['conversation_id'],
+    },
+  },
+  {
+    name: 'unwatch_conversation',
+    description: 'Stop watching a conversation and discard its message buffer.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        conversation_id: { type: 'string', description: 'Conversation ID to stop watching' },
+      },
+      required: ['conversation_id'],
+    },
+  },
+  {
+    name: 'watch_mission',
+    description: 'Start polling a mission for new participants. When a human joins and taps "Say Hi", their participant entry gains a conversation_id — drain updates with get_pending_mission_updates, then call watch_conversation on each conversation_id to start chatting.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'Mission ID to watch' },
+        interval_minutes: {
+          type: 'number',
+          description: 'How often to check for new participants in minutes (default: 10)',
+          minimum: 1,
+        },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'get_pending_mission_updates',
+    description: 'Return and clear buffered mission updates (new participants). Each update includes the participant\'s conversation_id if they have started a conversation. Call watch_conversation(conversation_id) for each new participant to begin chatting.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'Mission ID' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'unwatch_mission',
+    description: 'Stop polling a mission for new participants.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'Mission ID to stop watching' },
+      },
+      required: ['mission_id'],
+    },
+  },
+];
+
+export async function handleRealtimeTool(name: string, args: Record<string, any>): Promise<unknown> {
+  switch (name) {
+    case 'watch_conversation': {
+      const id = args.conversation_id as string;
+      const alreadyWatching = listWatched().includes(id);
+      startPolling(id);
+      const intervalMs = getPollIntervalMs(id) ?? 5000;
+      return {
+        success: true,
+        conversation_id: id,
+        watching: true,
+        already_was_watching: alreadyWatching,
+        poll_interval_seconds: intervalMs / 1000,
+        message: alreadyWatching
+          ? `Already watching conversation ${id}`
+          : `Started watching conversation ${id} — polling every ${intervalMs / 1000}s (Fibonacci schedule)`,
+      };
+    }
+
+    case 'get_pending_messages': {
+      const id = args.conversation_id as string;
+      const msgs = drainQueue(id);
+      return {
+        conversation_id: id,
+        pending_count: msgs.length,
+        messages: msgs,
+      };
+    }
+
+    case 'unwatch_conversation': {
+      const id = args.conversation_id as string;
+      const stopped = stopPolling(id);
+      return {
+        success: true,
+        conversation_id: id,
+        was_watching: stopped,
+        message: stopped
+          ? `Stopped watching conversation ${id}`
+          : `Conversation ${id} was not being watched`,
+      };
+    }
+
+    case 'watch_mission': {
+      const missionId = args.mission_id as string;
+      const intervalMinutes = (args.interval_minutes as number) ?? 10;
+      const alreadyWatching = listWatchedMissions().includes(missionId);
+      await startMissionPolling(missionId, intervalMinutes);
+      return {
+        success: true,
+        mission_id: missionId,
+        already_was_watching: alreadyWatching,
+        interval_minutes: intervalMinutes,
+        message: alreadyWatching
+          ? `Already watching mission ${missionId}`
+          : `Started watching mission ${missionId} — checking for new participants every ${intervalMinutes} min`,
+      };
+    }
+
+    case 'get_pending_mission_updates': {
+      const missionId = args.mission_id as string;
+      const updates = drainMissionQueue(missionId);
+      return {
+        mission_id: missionId,
+        pending_count: updates.length,
+        updates,
+      };
+    }
+
+    case 'unwatch_mission': {
+      const missionId = args.mission_id as string;
+      const stopped = stopMissionPolling(missionId);
+      return {
+        success: true,
+        mission_id: missionId,
+        was_watching: stopped,
+        message: stopped
+          ? `Stopped watching mission ${missionId}`
+          : `Mission ${missionId} was not being watched`,
+      };
+    }
+
+    default:
+      throw new Error(`Unknown realtime tool: ${name}`);
+  }
+}

package/src/tools/tracks.ts

@@ -0,0 +1,130 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { apiGet, apiPost, apiDelete } from '../api/client.js';
+
+export const trackTools: Tool[] = [
+  {
+    name: 'add_mission_track',
+    description:
+      'Upload a media item (audio, image, or video) to a media_review mission. Provide the file as a base64-encoded string. ' +
+      'For on-chain missions, call this BEFORE confirm_funding — uploads are blocked once the mission is active. ' +
+      'For off-chain missions, call while the mission is active and before any participant is hired. ' +
+      'The item becomes visible to hired participants once confirmed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'ID of the media_review mission' },
+        title: { type: 'string', description: 'Item title (required)' },
+        artist: { type: 'string', description: 'Artist / creator name (optional; typically used for audio)' },
+        file_base64: { type: 'string', description: 'Base64-encoded file contents' },
+        content_type: {
+          type: 'string',
+          enum: ['audio/mpeg', 'audio/mp4', 'image/jpeg', 'image/png', 'image/webp', 'video/mp4'],
+          description:
+            'MIME type of the file. Mobile-compatible formats only (iOS + Android). ' +
+            'audio/mpeg (MP3) and audio/mp4 (AAC/M4A): max 25 MB. ' +
+            'image/jpeg, image/png, image/webp: max 10 MB. ' +
+            'video/mp4: max 200 MB — must be faststart-encoded (moov atom first) for partial play.',
+        },
+        duration_seconds: { type: 'number', description: 'Duration in seconds (optional; applicable to audio and video only)' },
+      },
+      required: ['mission_id', 'title', 'file_base64', 'content_type'],
+    },
+  },
+  {
+    name: 'list_mission_tracks',
+    description:
+      'List all media items on a media_review mission. Returns raw stats for each item: ' +
+      'media_type (audio/image/video), vote_counts ({1,2,3,4,5,total} star-rating distribution) and total_listen_seconds (cumulative engagement time across all participants). ' +
+      'Use these to compute your own scoring.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'ID of the mission' },
+      },
+      required: ['mission_id'],
+    },
+  },
+  {
+    name: 'get_track_ratings',
+    description:
+      'Get per-participant star ratings for one track on a media_review mission. ' +
+      'Only participants who submitted a rating are returned — play-only rows are excluded. ' +
+      'Each entry includes uid, rating (1–5), optional comment, total_listen_seconds, and rated_at.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'ID of the mission' },
+        track_id: { type: 'string', description: 'ID of the track' },
+      },
+      required: ['mission_id', 'track_id'],
+    },
+  },
+  {
+    name: 'delete_mission_track',
+    description: 'Delete a track from a mission. Only allowed if the track has received no ratings yet.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mission_id: { type: 'string', description: 'ID of the mission' },
+        track_id: { type: 'string', description: 'ID of the track to delete' },
+      },
+      required: ['mission_id', 'track_id'],
+    },
+  },
+];
+
+export async function handleTrackTool(name: string, args: Record<string, any>): Promise<unknown> {
+  switch (name) {
+    case 'add_mission_track': {
+      const { mission_id, title, artist, file_base64, content_type, duration_seconds } = args;
+
+      // Step 1: Get signed upload URL and create pending track doc
+      const urlRes = await apiPost<{ upload_url: string; storage_path: string; track_id: string }>(
+        `/agent/missions/${mission_id}/tracks/upload-url`,
+        { title, artist, content_type },
+      );
+
+      // Step 2: Upload binary to the signed URL.
+      // On failure, delete the pending track doc so it doesn't consume the 20-track
+      // slot or appear as a ghost in list results.
+      const fileBytes = Buffer.from(file_base64, 'base64');
+      const uploadRes = await fetch(urlRes.upload_url, {
+        method: 'PUT',
+        headers: { 'Content-Type': content_type },
+        body: fileBytes,
+      });
+      if (!uploadRes.ok) {
+        const errText = await uploadRes.text().catch(() => '');
+        // Best-effort cleanup — ignore errors so the original failure is surfaced
+        await apiDelete(`/agent/missions/${mission_id}/tracks/${urlRes.track_id}`).catch(() => {});
+        throw new Error(`Media upload failed: ${uploadRes.status} ${errText}`);
+      }
+
+      // Step 3: Confirm upload and optionally set duration
+      const confirmed = await apiPost<{ track: unknown }>(
+        `/agent/missions/${mission_id}/tracks/${urlRes.track_id}/confirm`,
+        { title, artist, duration_seconds },
+      );
+
+      return confirmed.track;
+    }
+
+    case 'list_mission_tracks': {
+      const { mission_id } = args;
+      return apiGet(`/agent/missions/${mission_id}/tracks`);
+    }
+
+    case 'get_track_ratings': {
+      const { mission_id, track_id } = args;
+      return apiGet(`/agent/missions/${mission_id}/tracks/${track_id}/ratings`);
+    }
+
+    case 'delete_mission_track': {
+      const { mission_id, track_id } = args;
+      return apiDelete(`/agent/missions/${mission_id}/tracks/${track_id}`);
+    }
+
+    default:
+      throw new Error(`Unknown track tool: ${name}`);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}