mojulo 0.0.0 → 0.1.1

package/lib/mcp/tools/fleet.js

@@ -0,0 +1,391 @@
+/**
+ * MCP Ring 2.5 — fleet read tools.
+ *
+ * Peers of the dashboard's `/data` pane. Same fan-out substrate (bot-fleet.js),
+ * same posture (no conversation content crosses to the control plane —
+ * aggregates pass through process memory for the duration of one call).
+ *
+ * Shape rules enforced here (mirroring MCP-side feedback):
+ *
+ *   - Every fleet tool returns `unreachable: [{ botId, botName, reason, status? }]`
+ *     in the same shape so the agent can detect "all bots responded?" with
+ *     one check across tools.
+ *   - Cache-backed tools return `cache: { fromCache, cachedAt, ttlMs }`
+ *     so the agent can answer "is this current?" honestly.
+ *   - Descriptions advertise rollup-only nature and point at the per-bot
+ *     drill-in tool (`get_conversation`) for actual content.
+ *   - Descriptions name operational realism (~1–3s warm, ~30s cold fan-out).
+ *   - Tool names are prefixed `fleet_*` so the agent can tell at a glance
+ *     which surface it's hitting.
+ *
+ * The fan-out path stays opportunistic: a slow / down bot doesn't block the
+ * tool — its row lands in `unreachable[]` instead.
+ */
+
+import { fanOut, listConnectedDeployments } from '@/lib/deployers/bot-fleet';
+import { registerTool } from '@/lib/mcp/server';
+
+const CACHE_TTL_MS = 60_000;
+const summaryCache = new Map(); // key -> { expiresAt, cachedAt, payload }
+
+function normalizeUnreachable(unreachable) {
+  return (unreachable || []).map((u) => ({
+    botId: u.id,
+    botName: u.botName,
+    reason: u.reason,
+    ...(u.status ? { status: u.status } : {}),
+    ...(u.message ? { message: u.message } : {}),
+  }));
+}
+
+function unreachableFromResults(results) {
+  return results
+    .filter((r) => !r.ok)
+    .map((r) => ({
+      botId: r.deployment.id,
+      botName: r.deployment.botName,
+      reason: r.reason,
+      ...(r.status ? { status: r.status } : {}),
+      ...(r.message ? { message: r.message } : {}),
+    }));
+}
+
+function filterDeployments(all, ids) {
+  if (!Array.isArray(ids) || ids.length === 0) return all;
+  const wanted = new Set(ids);
+  return all.filter((d) => wanted.has(d.id));
+}
+
+function summaryCacheKey(startDate, endDate, deployments) {
+  const ids = deployments.map((d) => d.id).sort().join(',');
+  return `${startDate || ''}|${endDate || ''}|${ids}`;
+}
+
+async function fleetAnalyticsSummaryHandler(input, _ctx) {
+  const { startDate, endDate, deploymentIds } = input || {};
+  const all = await listConnectedDeployments();
+  const deployments = filterDeployments(all, deploymentIds);
+
+  const cacheKey = summaryCacheKey(startDate, endDate, deployments);
+  const cached = summaryCache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) {
+    return {
+      ...cached.payload,
+      cache: {
+        fromCache: true,
+        cachedAt: new Date(cached.cachedAt).toISOString(),
+        ttlMs: CACHE_TTL_MS,
+      },
+    };
+  }
+
+  const qs = new URLSearchParams();
+  if (startDate) qs.set('startDate', String(startDate));
+  if (endDate) qs.set('endDate', String(endDate));
+  const path = `/api/analytics/summary${qs.toString() ? `?${qs.toString()}` : ''}`;
+
+  const { results, totalCount, reachableCount, unreachableCount } =
+    await fanOut(path, { deployments });
+
+  const totals = { conversations: 0, turns: 0 };
+  const dailyMap = new Map();
+  const heatMap = new Map();
+  const perBot = [];
+
+  for (const r of results) {
+    if (!r.ok) continue;
+    const d = r.data || {};
+    const t = d.totals || {};
+    totals.conversations += t.conversations || 0;
+    totals.turns += t.turns || 0;
+    perBot.push({
+      botId: r.deployment.id,
+      botName: r.deployment.botName,
+      conversations: t.conversations || 0,
+      turns: t.turns || 0,
+      avgTurnsPerConversation: t.avgTurnsPerConversation || 0,
+      firstAt: t.firstAt || null,
+      lastAt: t.lastAt || null,
+    });
+    for (const row of d.daily || []) {
+      const cur = dailyMap.get(row.date) || { conversations: 0, turns: 0 };
+      cur.conversations += row.conversations || 0;
+      cur.turns += row.turns || 0;
+      dailyMap.set(row.date, cur);
+    }
+    for (const cell of d.heatmap || []) {
+      const k = `${cell.dow}-${cell.hour}`;
+      heatMap.set(k, (heatMap.get(k) || 0) + (cell.turns || 0));
+    }
+  }
+
+  const daily = Array.from(dailyMap.entries())
+    .map(([date, v]) => ({ date, ...v }))
+    .sort((a, b) => (a.date < b.date ? -1 : 1));
+  const heatmap = Array.from(heatMap.entries()).map(([k, turns]) => {
+    const [dow, hour] = k.split('-').map(Number);
+    return { dow, hour, turns };
+  });
+  const topBots = [...perBot]
+    .sort((a, b) => b.turns - a.turns)
+    .slice(0, 10);
+
+  // Pull a thin protocol mix per-call too — it's cheap and the dashboard
+  // surfaces it implicitly via the SQL Explorer's protocol_stats table.
+  const protoFan = await fanOut(path.replace('/summary', '/protocol_stats'), {
+    deployments,
+  });
+  const protoMap = new Map();
+  for (const r of protoFan.results) {
+    if (!r.ok) continue;
+    for (const row of (r.data && r.data.rows) || []) {
+      const cur = protoMap.get(row.protocol) || { turns: 0, conversationsTouched: 0 };
+      cur.turns += row.turns || 0;
+      cur.conversationsTouched += row.conversations_touched || 0;
+      protoMap.set(row.protocol, cur);
+    }
+  }
+  const protocolMix = Array.from(protoMap.entries())
+    .map(([protocol, v]) => ({ protocol, ...v }))
+    .sort((a, b) => b.turns - a.turns);
+
+  const payload = {
+    totals: {
+      ...totals,
+      avgTurnsPerConversation: totals.conversations
+        ? Number((totals.turns / totals.conversations).toFixed(2))
+        : 0,
+      activeBots: reachableCount,
+      totalBots: totalCount,
+    },
+    daily,
+    heatmap,
+    topBots,
+    protocolMix,
+    perBot,
+    unreachable: unreachableFromResults(results),
+  };
+
+  const now = Date.now();
+  summaryCache.set(cacheKey, {
+    expiresAt: now + CACHE_TTL_MS,
+    cachedAt: now,
+    payload,
+  });
+  if (summaryCache.size > 64) {
+    for (const [k, v] of summaryCache.entries()) {
+      if (v.expiresAt <= Date.now()) summaryCache.delete(k);
+    }
+  }
+
+  return {
+    ...payload,
+    cache: {
+      fromCache: false,
+      cachedAt: new Date(now).toISOString(),
+      ttlMs: CACHE_TTL_MS,
+    },
+  };
+}
+
+async function fleetQueryConversationsHandler(input, _ctx) {
+  const {
+    startDate,
+    endDate,
+    conversationId,
+    deploymentIds,
+    limit = 50,
+    offset = 0,
+  } = input || {};
+
+  if (!startDate && !endDate && !conversationId) {
+    throw new Error(
+      'fleet_query_conversations requires at least one of startDate, endDate, or conversationId. The single-bot /api/conversations contract requires a filter — same here.',
+    );
+  }
+
+  const all = await listConnectedDeployments();
+  const deployments = filterDeployments(all, deploymentIds);
+
+  const qs = new URLSearchParams();
+  if (startDate) qs.set('startDate', String(startDate));
+  if (endDate) qs.set('endDate', String(endDate));
+  if (conversationId) qs.set('conversationId', String(conversationId));
+  qs.set('limit', '50');
+  qs.set('offset', '0');
+  const path = `/api/conversations?${qs.toString()}`;
+
+  const { results, totalCount, reachableCount, unreachableCount } =
+    await fanOut(path, { deployments });
+
+  const merged = [];
+  for (const r of results) {
+    if (!r.ok) continue;
+    const convos = (r.data && r.data.conversations) || [];
+    for (const c of convos) {
+      merged.push({
+        botId: r.deployment.id,
+        botName: r.deployment.botName,
+        conversationId: c.conversation_id,
+        startedAt: c.started_at,
+        lastActivity: c.last_activity,
+        turnCount: c.turn_count,
+      });
+    }
+  }
+
+  merged.sort((a, b) => (a.lastActivity < b.lastActivity ? 1 : -1));
+  const cap = 500;
+  const truncated = merged.length > cap;
+  const capped = truncated ? merged.slice(0, cap) : merged;
+  const page = capped.slice(offset, offset + limit);
+
+  return {
+    conversations: page,
+    pagination: {
+      limit,
+      offset,
+      total: capped.length,
+      returned: page.length,
+      hasMore: offset + page.length < capped.length,
+      truncated,
+    },
+    fleet: {
+      totalBots: totalCount,
+      reachableBots: reachableCount,
+      unreachableBots: unreachableCount,
+    },
+    unreachable: unreachableFromResults(results),
+  };
+}
+
+async function verifyFleetChainsHandler(input, _ctx) {
+  const { startDate, endDate, deploymentIds } = input || {};
+  const all = await listConnectedDeployments();
+  const deployments = filterDeployments(all, deploymentIds);
+
+  const qs = new URLSearchParams();
+  if (startDate) qs.set('startDate', String(startDate));
+  if (endDate) qs.set('endDate', String(endDate));
+  const path = `/api/verify/all${qs.toString() ? `?${qs.toString()}` : ''}`;
+
+  const { results, totalCount, reachableCount, unreachableCount } =
+    await fanOut(path, { deployments, timeoutMs: 30_000 });
+
+  let totalTurns = 0;
+  let invalidTurns = 0;
+  let conversationsVerified = 0;
+  const failed = [];
+  const perBot = [];
+
+  for (const r of results) {
+    if (!r.ok) continue;
+    const d = r.data || {};
+    totalTurns += d.totalTurns || 0;
+    invalidTurns += d.invalidTurns || 0;
+    conversationsVerified += d.conversationsVerified || 0;
+    perBot.push({
+      botId: r.deployment.id,
+      botName: r.deployment.botName,
+      valid: !!d.valid,
+      totalTurns: d.totalTurns || 0,
+      invalidTurns: d.invalidTurns || 0,
+      conversationsVerified: d.conversationsVerified || 0,
+    });
+    for (const f of d.failed || []) {
+      failed.push({
+        botId: r.deployment.id,
+        botName: r.deployment.botName,
+        conversationId: f.conversationId,
+        turn: f.turn,
+        timestamp: f.timestamp,
+        reason: f.reason,
+      });
+    }
+  }
+
+  return {
+    valid: invalidTurns === 0 && unreachableCount === 0,
+    totalTurns,
+    invalidTurns,
+    conversationsVerified,
+    failed,
+    perBot,
+    fleet: {
+      totalBots: totalCount,
+      reachableBots: reachableCount,
+      unreachableBots: unreachableCount,
+    },
+    unreachable: unreachableFromResults(results),
+  };
+}
+
+export function registerFleetTools() {
+  registerTool({
+    name: 'fleet_analytics_summary',
+    description:
+      "Fleet-wide activity rollup: totals, daily turn/conversation counts, top bots by activity, protocol usage mix, plus a per-bot breakdown keyed by botId. Aggregates and metadata only — for conversation content, use get_conversation against a specific bot (use fleet_query_conversations first to locate which bot a conversation lives on). Hits a 60s in-process cache shared with the dashboard's Analytics tab; cold (cache miss) takes ~1–3s warm, up to ~30s when every bot has to fan-out fresh. Response includes `cache: { fromCache, cachedAt, ttlMs }` so you can tell whether the data is current and `unreachable: [{ botId, botName, reason }]` so you can detect partial fleets. Optional `startDate`/`endDate` ISO bounds; optional `deploymentIds` to scope to a subset (default: every connected bot).",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        startDate: { type: 'string', description: 'ISO timestamp lower bound on turn timestamp.' },
+        endDate: { type: 'string', description: 'ISO timestamp upper bound on turn timestamp.' },
+        deploymentIds: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional — restrict the fan-out to these deployment ids. Defaults to every connected bot.',
+        },
+      },
+    },
+    handler: fleetAnalyticsSummaryHandler,
+  });
+
+  registerTool({
+    name: 'fleet_query_conversations',
+    description:
+      "Locate conversations across every connected bot. Returns conversation summaries only — `{ botId, botName, conversationId, startedAt, lastActivity, turnCount }` — never turn content. To read a conversation's actual content, call `get_conversation` against the bot named by `botId`; the two-step pattern (fleet-locate, then per-bot-read) preserves the 'conversation data never crosses to the control plane' posture. Requires at least one of `startDate` / `endDate` / `conversationId` — same contract as the per-bot /api/conversations endpoint, which refuses unfiltered scans. Operational realism: typically 1–3s, up to ~30s cold across a large fleet. Response includes `unreachable: [{ botId, botName, reason }]` to flag bots that didn't answer.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        startDate: { type: 'string', description: 'ISO timestamp lower bound on first-turn timestamp.' },
+        endDate: { type: 'string', description: 'ISO timestamp upper bound on first-turn timestamp.' },
+        conversationId: { type: 'string', description: 'Optional substring match on conversation id.' },
+        deploymentIds: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional — restrict the fan-out to these deployment ids.',
+        },
+        limit: { type: 'integer', minimum: 1, maximum: 200, default: 50 },
+        offset: { type: 'integer', minimum: 0, default: 0 },
+      },
+    },
+    handler: fleetQueryConversationsHandler,
+  });
+
+  registerTool({
+    name: 'verify_fleet_chains',
+    description:
+      "Walk the tamper-evident hash chain across every connected bot in one call. This is the audit story scaled to fleet level — each bot still owns its own chain, but the aggregate roll-up is something only the control plane can produce. Returns `{ valid, totalTurns, invalidTurns, conversationsVerified, failed: [{ botId, botName, conversationId, turn, reason }], perBot: [...], unreachable: [...] }`. `valid: true` requires zero invalid turns AND zero unreachable bots — a fleet with dark bots can't be conclusively audited. Optional `startDate` / `endDate` ISO bounds narrow which conversations are walked. Operational realism: walks every turn on each reachable bot, so heavy fleets at full history take longer than other fleet tools — typically 2–10s, more on bots with very large databases.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        startDate: { type: 'string', description: 'ISO timestamp lower bound on first-turn timestamp.' },
+        endDate: { type: 'string', description: 'ISO timestamp upper bound on first-turn timestamp.' },
+        deploymentIds: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional — restrict the audit to these deployment ids.',
+        },
+      },
+    },
+    handler: verifyFleetChainsHandler,
+  });
+}
+
+// Exported for tests.
+export {
+  fleetAnalyticsSummaryHandler,
+  fleetQueryConversationsHandler,
+  verifyFleetChainsHandler,
+  normalizeUnreachable,
+};

package/lib/mcp/tools/jobs-tools.js

@@ -0,0 +1,240 @@
+/**
+ * MCP Phase 2 — long-running tools wrapped as jobs.
+ *
+ * `process_documents` and `save_modular_bot` from BUILDER_TOOLS can take 10s+
+ * (document parsing + embedding + per-doc LLM summary; or build pipeline +
+ * docker package + LLM identity composition). MCP clients don't all surface
+ * progress notifications well, so we wrap them: return { jobId } immediately,
+ * the model polls via `poll_job`.
+ *
+ * Also adds an in-protocol document upload path (`upload_document_from_url`)
+ * since the web flow uses a separate form-data endpoint that MCP can't reach.
+ */
+
+import { BUILDER_TOOLS } from '@/lib/builder/tools';
+import { executeBuilderTool } from '@/lib/builder/tool-executors';
+import { BuilderSessionRepository } from '@/lib/db/repositories/builderSessions';
+import { DocumentRepository } from '@/lib/db/repositories/documents';
+import {
+  getOrCreateBuilderSession,
+} from '@/lib/mcp/session-binding';
+import { registerTool } from '@/lib/mcp/server';
+import { startJob, getJob } from '@/lib/mcp/jobs';
+import { parseDocument } from '@/lib/document-parser';
+import { uploadFile } from '@/lib/storage';
+
+const JOB_TOOL_NAMES = ['process_documents', 'save_modular_bot'];
+
+function findBuilderToolSchema(name) {
+  const tool = BUILDER_TOOLS.find((t) => t.name === name);
+  if (!tool) throw new Error(`BUILDER_TOOLS is missing ${name}`);
+  return tool;
+}
+
+function makeJobHandler(toolName) {
+  return async function handle(input, mcpContext) {
+    const session = await getOrCreateBuilderSession(
+      mcpContext.mcpSessionId,
+      mcpContext.userId
+    );
+
+    return startJob({
+      tool: toolName,
+      mcpSessionId: mcpContext.mcpSessionId,
+      builderSessionId: session.id,
+      task: async () => {
+        // Re-fetch session on the worker side — there could be writes from
+        // other tools between job start and run.
+        const fresh = await BuilderSessionRepository.findById(session.id);
+        const ctx = { session: fresh, userId: mcpContext.userId };
+        const result = await executeBuilderTool(toolName, input, ctx);
+        if (!result.success) {
+          throw new Error(result.error || `${toolName} failed`);
+        }
+        return result.result;
+      },
+    });
+  };
+}
+
+const MIME_BY_EXT = {
+  pdf: 'application/pdf',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  txt: 'text/plain',
+  md: 'text/markdown',
+  html: 'text/html',
+  htm: 'text/html',
+};
+
+const MAX_DOC_BYTES = 25 * 1024 * 1024; // 25 MB — same ballpark as the web upload form.
+
+async function uploadDocumentFromUrlHandler(input, _mcpContext) {
+  const { url, base64, text, fileName } = input || {};
+
+  const providedCount = [url, base64, text].filter(Boolean).length;
+  if (providedCount === 0) {
+    throw new Error('Provide one of `url`, `base64` (with `fileName`), or `text` (with `fileName`).');
+  }
+  if (providedCount > 1) {
+    throw new Error('Provide only one of `url`, `base64`, or `text` — they are mutually exclusive.');
+  }
+
+  let buffer;
+  let resolvedName = fileName;
+  let resolvedMime;
+  // When the caller hands us already-extracted text (e.g. piped from another
+  // MCP server like Google Docs), skip the parser — the text IS the parsed
+  // form. Set this so we don't burn cycles re-parsing a .txt blob that
+  // officeparser doesn't even understand.
+  let prextractedText = null;
+
+  if (url) {
+    if (!/^https?:\/\//i.test(url)) {
+      throw new Error('url must be http(s)://');
+    }
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      throw new Error(`Fetch failed: ${resp.status} ${resp.statusText}`);
+    }
+    const ab = await resp.arrayBuffer();
+    if (ab.byteLength > MAX_DOC_BYTES) {
+      throw new Error(`Document too large: ${ab.byteLength} bytes (max ${MAX_DOC_BYTES})`);
+    }
+    buffer = Buffer.from(ab);
+    resolvedMime = resp.headers.get('content-type')?.split(';')[0]?.trim() || undefined;
+    if (!resolvedName) {
+      const path = new URL(url).pathname;
+      resolvedName = path.split('/').pop() || 'document';
+    }
+  } else if (base64) {
+    if (!fileName) {
+      throw new Error('fileName is required when uploading via base64.');
+    }
+    buffer = Buffer.from(base64, 'base64');
+    if (buffer.length === 0) {
+      throw new Error('base64 decoded to zero bytes.');
+    }
+    if (buffer.length > MAX_DOC_BYTES) {
+      throw new Error(`Document too large: ${buffer.length} bytes (max ${MAX_DOC_BYTES})`);
+    }
+  } else {
+    if (!fileName) {
+      throw new Error('fileName is required when uploading via text.');
+    }
+    if (typeof text !== 'string' || text.trim().length === 0) {
+      throw new Error('text must be a non-empty string.');
+    }
+    buffer = Buffer.from(text, 'utf8');
+    if (buffer.length > MAX_DOC_BYTES) {
+      throw new Error(`Document too large: ${buffer.length} bytes (max ${MAX_DOC_BYTES})`);
+    }
+    prextractedText = text;
+    resolvedMime = 'text/plain';
+  }
+
+  if (!resolvedMime) {
+    const ext = (resolvedName || '').split('.').pop()?.toLowerCase();
+    resolvedMime = MIME_BY_EXT[ext] || 'application/octet-stream';
+  }
+
+  let parsedText;
+  if (prextractedText !== null) {
+    parsedText = prextractedText;
+  } else {
+    // Parse the document up front; if it's unparseable, surface the failure now
+    // rather than have process_documents skip it silently.
+    try {
+      parsedText = await parseDocument(buffer, resolvedName);
+    } catch (err) {
+      throw new Error(`Failed to parse document: ${err.message}`);
+    }
+  }
+
+  const storagePath = `documents/${Date.now()}-${resolvedName}`;
+  await uploadFile(storagePath, buffer, null, { contentType: resolvedMime });
+
+  const document = await DocumentRepository.create({
+    storagePath,
+    originalName: resolvedName,
+    mimeType: resolvedMime,
+    sizeBytes: buffer.length,
+    parsedText,
+  });
+
+  return {
+    documentId: document.id,
+    originalName: document.originalName,
+    mimeType: document.mimeType,
+    sizeBytes: document.sizeBytes,
+    message: `Uploaded ${document.originalName}. Pass its id to process_documents.`,
+  };
+}
+
+async function pollJobHandler(input, _mcpContext) {
+  const { jobId } = input || {};
+  if (!jobId) throw new Error('jobId is required');
+  const job = await getJob(jobId);
+  if (!job) throw new Error(`Job not found: ${jobId}`);
+  return {
+    jobId: job.id,
+    tool: job.tool,
+    status: job.status,
+    progress: job.progress,
+    result: job.result,
+    error: job.error,
+  };
+}
+
+export function registerJobsTools() {
+  for (const name of JOB_TOOL_NAMES) {
+    const schema = findBuilderToolSchema(name);
+    registerTool({
+      name: schema.name,
+      description: `${schema.description}\n\n(This tool runs as a background job. It returns { jobId } immediately; call \`poll_job\` until status is "done" or "error".)`,
+      inputSchema: schema.input_schema,
+      handler: makeJobHandler(name),
+    });
+  }
+
+  registerTool({
+    name: 'upload_document_from_url',
+    description:
+      'Upload a document (PDF / DOCX / TXT / MD / HTML) to the control plane for the bot under construction. Provide exactly one of: `url` to fetch from, `base64` binary content with `fileName`, or `text` plain-text content with `fileName` (use this when piping already-extracted text from another MCP server like Google Docs — skips the binary round-trip). Returns a `documentId` you can pass to `process_documents`.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: {
+          type: 'string',
+          description: 'http(s) URL to fetch the document from. Mutually exclusive with `base64` and `text`.',
+        },
+        base64: {
+          type: 'string',
+          description: 'Base64-encoded document content. Requires `fileName`. Mutually exclusive with `url` and `text`.',
+        },
+        text: {
+          type: 'string',
+          description: 'Already-extracted plain-text content (skips the parser). Requires `fileName`. Mutually exclusive with `url` and `base64`. Use this when the source MCP server already returned text content — avoids needlessly base64-encoding through the model.',
+        },
+        fileName: {
+          type: 'string',
+          description: 'Original filename (used for display). Required with `base64` and `text`; optional with `url` (inferred from path).',
+        },
+      },
+    },
+    handler: uploadDocumentFromUrlHandler,
+  });
+
+  registerTool({
+    name: 'poll_job',
+    description:
+      'Check the status of a background job started by `process_documents`, `save_modular_bot`, or other job-based tools. Returns { status: "pending" | "running" | "done" | "error", progress, result, error }.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        jobId: { type: 'string', description: 'The jobId returned from the original tool call.' },
+      },
+      required: ['jobId'],
+    },
+    handler: pollJobHandler,
+  });
+}