@reproapp/mcp 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/mcp",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Repro MCP server for AI-assisted debugging and privacy policy workflows",
   "license": "MIT",
   "type": "commonjs",

package/src/index.js

@@ -16,7 +16,8 @@ const SERVER_INSTRUCTIONS = [
   'For Repro-scoped questions about sessions, requests, traces, privacy policies, apps, or configuration, use the Repro MCP tools only.',
   'Do not create local scripts, read cached Repro auth files, or call Repro HTTP APIs directly for Repro data or policy workflows.',
   'For privacy policy writes, inspect first and then use exact statementSid(s) or blockerSetId. Broad natural-language policy update queries are read-only.',
-  'When a Repro tool returns valuePreview/valueLink for a large payload, return that preview and link to the user and stop there. Do not automatically follow the link or re-query for the full value unless the user explicitly asks for the full payload or raw value. Exact large-value expansion requires expandLargeValue=true and explicit user intent.',
+  'For factual debugging questions, use exact evidence tools first and answer from their structured output. Use investigate only after exact evidence is gathered, or when the user explicitly asks for synthesis/root cause.',
+  'Never answer that captured client data is absent because code appears to omit it. Verify with request, DB, trace, function-call, and message payload tools, then say exactly what Repro captured or did not capture.',
 ].join(' ');
 const DEFAULT_REPRO_AI_BASE_URL = 'https://repro-ai-u8lhw.ondigitalocean.app';
 const DEFAULT_REPRO_API_BASE_URL = 'https://repro-api-d7288.ondigitalocean.app/api';
@@ -194,6 +195,31 @@ const LOCAL_TOOL_DEFINITIONS = [
   },
 ];
 
+const TOOL_DESCRIPTION_OVERRIDES = {
+  investigate:
+    'Synthesize a root-cause hypothesis from Repro evidence after exact telemetry tools have been checked. Do not use this as the first or only tool for factual inventory questions about requests, DB changes, traces, function args/returns, emails, Kafka/RabbitMQ/messages, or payload contents; call the exact evidence tool first and cite that output.',
+  list_requests:
+    'Exact evidence tool: list captured HTTP and backend transport requests in scope. Use this before investigate whenever the user asks what request happened, which endpoint ran, request timing/status, or which request RID anchors later DB/trace/message evidence.',
+  get_request:
+    'Exact evidence tool: fetch one captured request by RID, including request/response bodies and captured value refs when present. Use this before answering factual questions about a specific request payload, response, endpoint, or transport message wrapper.',
+  get_requests_relative_to_anchor:
+    'Exact evidence tool: list captured requests before or after an action/request/DB anchor. Use for ordering questions and localizing the request sequence around a UI action or backend event.',
+  get_db_changes:
+    'Exact evidence tool: fetch captured DB/Redis changes. Use this before answering what collections, documents, fields, queries, mutations, or result metadata changed. Set includeQueryDetails when the user needs query/update/body details.',
+  get_trace:
+    'Exact evidence tool: fetch captured trace batches for a request RID. Use this before answering which functions ran, trace timing, thrown errors, or trace event details for a request.',
+  get_action_path:
+    'Exact evidence tool: fetch the correlated action path with requests, DB changes, and emails/messages when available. Use this to connect a UI action to backend evidence before giving a narrative answer.',
+  get_function_candidates:
+    'Exact evidence tool: find likely captured functions for an action/request/function search. Use this before get_function_calls when the exact function anchor is unclear.',
+  get_function_calls:
+    'Exact evidence tool: fetch concrete captured function calls, arguments, return values, errors, and value refs. Use this before answering what function handled something or what args/returns were captured.',
+  get_kafka_messages:
+    'Exact evidence tool: fetch captured Kafka publish/consume payloads. Use this for messaging questions and payload contents; for exact single-message lookups, the MCP server expands captured large values automatically.',
+  get_captured_value:
+    'Exact evidence tool: fetch the full masked value behind a captured valueId. Use this whenever another tool reports a captured value reference or large_value_available before claiming the payload is unavailable.',
+};
+
 function loadConfig(env = process.env) {
   const baseUrl = normalizeBaseUrl(env.REPRO_AI_BASE_URL || DEFAULT_REPRO_AI_BASE_URL);
   const apiBaseUrl = normalizeOptionalBaseUrl(env.REPRO_API_BASE_URL, DEFAULT_REPRO_API_BASE_URL);
@@ -1142,11 +1168,20 @@ async function handleRpcMessage(message, config, client, getTools) {
 function publicToolDefinition(tool) {
   return {
     name: tool.name,
-    description: tool.description,
+    description: publicToolDescription(tool),
     inputSchema: tool.inputSchema,
   };
 }
 
+function publicToolDescription(tool) {
+  const base = typeof tool?.description === 'string' ? tool.description.trim() : '';
+  const override = TOOL_DESCRIPTION_OVERRIDES[tool?.name];
+  if (!override) {
+    return base;
+  }
+  return base ? `${override} ${base}` : override;
+}
+
 function normalizeToolCatalog(catalog) {
   if (!catalog || typeof catalog !== 'object' || !Array.isArray(catalog.tools)) {
     throw new Error('repro-ai returned an invalid tool catalog');
@@ -1193,9 +1228,10 @@ async function executeTool(params, config, client, getTools) {
     throw rpcError(-32602, `Unknown tool: ${name}`);
   }
 
-  const response = await client.executeTool(name, input);
+  const response = await client.executeTool(name, inputWithExactCapturedPayloads(name, input));
+  const expandedResponse = await expandLinkedCapturedPayloads(name, response, client, input);
 
-  const augmented = augmentPaths(response, config.pathMappings);
+  const augmented = augmentPaths(expandedResponse, config.pathMappings);
   const isError =
     augmented &&
     typeof augmented === 'object' &&
@@ -1214,58 +1250,202 @@ async function executeTool(params, config, client, getTools) {
   };
 }
 
-function formatLocalToolContentText(name, value) {
-  if (name === 'inspect_privacy_policy' || name === 'list_privacy_policy_blockers') {
-    const text = renderPolicyInspectionText(value);
-    if (text) return text;
+function inputWithExactCapturedPayloads(name, input) {
+  if (name !== 'get_kafka_messages') {
+    return input;
   }
-  if (name === 'check_privacy_coverage') {
-    const text = renderPrivacyCoverageText(value);
-    if (text) return text;
+  return {
+    ...input,
+    includeLargeValues: true,
+    expandLargeValue: true,
+  };
+}
+
+async function expandLinkedCapturedPayloads(name, response, client, originalInput = {}) {
+  if (name !== 'get_kafka_messages') {
+    return response;
   }
-  if (name === 'get_kafka_messages') {
-    const text = renderKafkaMessagesText(value);
-    if (text) return text;
+
+  const root = cloneJson(response) ?? response;
+  const visited = new Set();
+
+  while (true) {
+    const links = collectCapturedPayloadLinks(root)
+      .filter((entry) => !visited.has(capturedPayloadLinkKey(entry.link)));
+    if (!links.length) {
+      return root;
+    }
+
+    for (const { link } of links) {
+      const key = capturedPayloadLinkKey(link);
+      visited.add(key);
+
+      const toolName = typeof link.tool === 'string' ? link.tool : '';
+      if (toolName !== 'get_kafka_messages') {
+        throw new Error(`Cannot expand captured payload through unsupported MCP tool: ${toolName || 'unknown'}`);
+      }
+
+      const linkArgs = link.arguments && typeof link.arguments === 'object' && !Array.isArray(link.arguments)
+        ? link.arguments
+        : {};
+      const scopedLinkArgs = {
+        ...originalInput,
+        ...linkArgs,
+      };
+      const expanded = await client.executeTool(toolName, inputWithExactCapturedPayloads(toolName, scopedLinkArgs));
+      const expandedLookup = lookupLinkedPayloadValue(expanded, link.path);
+      if (!expandedLookup.found) {
+        throw new Error(`Repro MCP could not expand captured payload at ${link.path || 'unknown path'}`);
+      }
+
+      const applied = replaceLinkedPayloadValue(root, link.path, expandedLookup.value);
+      if (!applied) {
+        throw new Error(`Repro MCP could not replace captured payload at ${link.path || 'unknown path'}`);
+      }
+    }
   }
-  return JSON.stringify(value, null, 2);
 }
 
-function renderKafkaMessagesText(value) {
+function collectCapturedPayloadLinks(value, out = []) {
   if (!value || typeof value !== 'object') {
-    return null;
+    return out;
   }
-  const data = value.data && typeof value.data === 'object' ? value.data : null;
-  const items = Array.isArray(data?.items) ? data.items : [];
-  if (!items.length) {
-    return null;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectCapturedPayloadLinks(item, out);
+    }
+    return out;
   }
 
-  const lines = [`Found ${items.length} Kafka message${items.length === 1 ? '' : 's'}.`];
-  let omittedCount = 0;
+  const link = value.valueOmitted === true ? value.valueLink : value.rawValueLink;
+  if (
+    (value.valueOmitted === true || value.rawValueOmitted === true) &&
+    link &&
+    typeof link === 'object' &&
+    link.kind === 'mcp-tool-call' &&
+    typeof link.tool === 'string' &&
+    typeof link.path === 'string'
+  ) {
+    out.push({ holder: value, link });
+  }
 
-  for (const item of items.slice(0, 3)) {
-    const request = item?.request && typeof item.request === 'object' ? item.request : {};
-    const message = item?.message && typeof item.message === 'object' ? item.message : {};
-    lines.push(
-      [
-        typeof request.rid === 'string' ? `RID ${request.rid}` : null,
-        typeof message.topic === 'string' ? `topic ${message.topic}` : null,
-        typeof message.offset !== 'undefined' ? `offset ${message.offset}` : null,
-        typeof message.key !== 'undefined' ? `key ${message.key}` : null,
-      ].filter(Boolean).join(' | '),
-    );
-    if (message.valueOmitted === true || message.rawValueOmitted === true) {
-      omittedCount += 1;
+  for (const nested of Object.values(value)) {
+    collectCapturedPayloadLinks(nested, out);
+  }
+  return out;
+}
+
+function capturedPayloadLinkKey(link) {
+  return JSON.stringify({
+    tool: link?.tool ?? null,
+    path: link?.path ?? null,
+    arguments: link?.arguments ?? null,
+  });
+}
+
+function lookupLinkedPayloadValue(root, pathExpression) {
+  const segments = parseLinkedPayloadPath(pathExpression);
+  if (!segments.length) {
+    return { found: false };
+  }
+  return lookupPathCandidates(root, segments);
+}
+
+function replaceLinkedPayloadValue(root, pathExpression, value) {
+  const segments = parseLinkedPayloadPath(pathExpression);
+  if (!segments.length) {
+    return false;
+  }
+  const candidates = pathCandidateSegments(segments);
+  for (const candidate of candidates) {
+    const parentLookup = getAtPath(root, candidate.slice(0, -1));
+    if (!parentLookup.found || !parentLookup.value || typeof parentLookup.value !== 'object') {
+      continue;
     }
+    const leaf = candidate[candidate.length - 1];
+    parentLookup.value[leaf] = value;
+    if (leaf === 'value') {
+      delete parentLookup.value.valueOmitted;
+      delete parentLookup.value.valuePreview;
+      delete parentLookup.value.valueLink;
+    } else if (leaf === 'rawValue') {
+      delete parentLookup.value.rawValueOmitted;
+      delete parentLookup.value.rawValuePreview;
+      delete parentLookup.value.rawValueLink;
+    }
+    return true;
   }
+  return false;
+}
 
-  if (omittedCount > 0) {
-    lines.push(
-      'Large Kafka payload preview returned. Do not fetch the full value automatically. Only follow valueLink if the user explicitly asks for the full payload or raw value. Exact expansion requires expandLargeValue=true.'
-    );
+function lookupPathCandidates(root, segments) {
+  for (const candidate of pathCandidateSegments(segments)) {
+    const lookup = getAtPath(root, candidate);
+    if (lookup.found) {
+      return lookup;
+    }
   }
+  return { found: false };
+}
+
+function pathCandidateSegments(segments) {
+  return [
+    ['data', ...segments],
+    segments,
+  ];
+}
 
-  return lines.filter(Boolean).join('\n');
+function parseLinkedPayloadPath(pathExpression) {
+  if (typeof pathExpression !== 'string' || !pathExpression.trim()) {
+    return [];
+  }
+  const segments = [];
+  const pattern = /([A-Za-z_$][\w$-]*)|\[(\d+)\]/g;
+  let match;
+  while ((match = pattern.exec(pathExpression)) !== null) {
+    if (typeof match[1] === 'string') {
+      segments.push(match[1]);
+    } else if (typeof match[2] === 'string') {
+      segments.push(Number.parseInt(match[2], 10));
+    }
+  }
+  return segments;
+}
+
+function getAtPath(root, segments) {
+  let current = root;
+  for (const segment of segments) {
+    if (current == null) {
+      return { found: false };
+    }
+    if (typeof segment === 'number') {
+      if (!Array.isArray(current) || segment < 0 || segment >= current.length) {
+        return { found: false };
+      }
+      current = current[segment];
+      continue;
+    }
+    if (typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, segment)) {
+      return { found: false };
+    }
+    current = current[segment];
+  }
+  return { found: true, value: current };
+}
+
+function formatLocalToolContentText(name, value) {
+  if (name === 'inspect_privacy_policy' || name === 'list_privacy_policy_blockers') {
+    const text = renderPolicyInspectionText(value);
+    if (text) return text;
+  }
+  if (name === 'check_privacy_coverage') {
+    const text = renderPrivacyCoverageText(value);
+    if (text) return text;
+  }
+  if (name === 'get_kafka_messages') {
+    return JSON.stringify(value, null, 2);
+  }
+  return JSON.stringify(value, null, 2);
 }
 
 function mergeLocalTools(remoteTools) {