outrank-cli 0.6.0 → 0.7.0

package/src/adapters/mcp/resources.js

@@ -0,0 +1,69 @@
+import { CliErrorCode, codedError } from '../../core/errors.js';
+import { EntitlementMode, IdentityStatus } from './constants.js';
+
+export const WHOAMI_RESOURCE_URI = 'outrank://whoami';
+const WHOAMI_RESOURCE_NAME = 'whoami';
+const JSON_MIME_TYPE = 'application/json';
+const JSON_INDENT = 2;
+const MAX_URI_CHARS = 200;
+const WHOAMI_RESOURCE_DESCRIPTION =
+  'The organization this server works on, what the server knows about its entitlements, and which toolsets are ' +
+  'listed. Read it instead of calling auth_whoami when the question is only "who am I connected as".';
+
+const toolsetsIn = (selection, mode) =>
+  Object.entries(selection.enabled)
+    .filter(([, toolsetMode]) => toolsetMode === mode)
+    .map(([toolset]) => toolset);
+
+const MAX_ERROR_TEXT_CHARS = 500;
+
+const boundedError = (error) => {
+  if (!error || typeof error !== 'object') return null;
+  const code = typeof error.code === 'string' ? error.code.slice(0, MAX_ERROR_TEXT_CHARS) : null;
+  const message = typeof error.message === 'string' ? error.message.slice(0, MAX_ERROR_TEXT_CHARS) : null;
+  return { code, message };
+};
+
+export const buildWhoamiResource = (session) => {
+  const identity = session.identity();
+  const selection = session.selection();
+  const failure = session.failure();
+  return {
+    organization: session.organization(),
+    identity: {
+      status: identity.status,
+      ...(identity.status === IdentityStatus.OK ? { entitlements: identity.entitlements ?? null } : {}),
+      ...(identity.status === IdentityStatus.FAILED ? { error: boundedError(identity.error) } : {}),
+    },
+    configuration_error: failure ? boundedError(failure.error) : null,
+    toolsets: {
+      source: selection.source,
+      fallback_reason: session.fallbackReason(),
+      read_only: selection.readOnly,
+      full: toolsetsIn(selection, EntitlementMode.FULL),
+      read: toolsetsIn(selection, EntitlementMode.READ),
+      off: selection.disabledToolsets,
+    },
+    tool_count: selection.tools.length,
+  };
+};
+
+export const listResources = () => [
+  {
+    uri: WHOAMI_RESOURCE_URI,
+    name: WHOAMI_RESOURCE_NAME,
+    description: WHOAMI_RESOURCE_DESCRIPTION,
+    mimeType: JSON_MIME_TYPE,
+  },
+];
+
+const UNKNOWN_RESOURCE_GUIDANCE = `The only resource is ${WHOAMI_RESOURCE_URI}.`;
+
+export const readResource = (session, uri) => {
+  if (uri !== WHOAMI_RESOURCE_URI) {
+    const shown = String(uri).slice(0, MAX_URI_CHARS);
+    throw codedError(CliErrorCode.INVALID_USAGE, `Unknown resource: ${shown}.`, UNKNOWN_RESOURCE_GUIDANCE);
+  }
+  const text = JSON.stringify(buildWhoamiResource(session), null, JSON_INDENT);
+  return { contents: [{ uri: WHOAMI_RESOURCE_URI, mimeType: JSON_MIME_TYPE, text }] };
+};

package/src/adapters/mcp/result.js

@@ -1,9 +1,55 @@
 const CONFIG_PATH_DETAIL = 'config_path';
 const DETAILS_FIELD = 'details';
 const TEXT_CONTENT_TYPE = 'text';
+export const UNTRUSTED_TEXT_FIELD = 'untrusted_counterparty_text';
+const PATH_SEPARATOR = '.';
+const EACH_ELEMENT_SUFFIX = '[]';
 
 const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 
+const wrapText = (value) => {
+  if (typeof value === 'string') return { [UNTRUSTED_TEXT_FIELD]: value };
+  if (Array.isArray(value)) return value.map(wrapText);
+  if (!isPlainObject(value)) return value;
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, wrapText(entry)]));
+};
+
+const transformAtPath = (value, segments, transform) => {
+  if (segments.length === 0) return transform(value);
+  const [head, ...rest] = segments;
+  const eachElement = head.endsWith(EACH_ELEMENT_SUFFIX);
+  const key = eachElement ? head.slice(0, -EACH_ELEMENT_SUFFIX.length) : head;
+  if (!isPlainObject(value) || !Object.hasOwn(value, key)) return value;
+  const child = value[key];
+  if (eachElement) {
+    if (!Array.isArray(child)) return value;
+    return { ...value, [key]: child.map((element) => transformAtPath(element, rest, transform)) };
+  }
+  return { ...value, [key]: transformAtPath(child, rest, transform) };
+};
+
+const segmentsOf = (fieldPath) => (fieldPath ? fieldPath.split(PATH_SEPARATOR) : []);
+
+const wrapPaths = (data, paths) =>
+  paths.reduce((current, fieldPath) => transformAtPath(current, segmentsOf(fieldPath), wrapText), data);
+
+const wrapFlaggedRecords = (data, paths, { record, flag }) => {
+  const prefixLength = record ? record.length + PATH_SEPARATOR.length : 0;
+  const recordPaths = paths.map((fieldPath) => fieldPath.slice(prefixLength));
+  return transformAtPath(data, segmentsOf(record), (entry) =>
+    !isPlainObject(entry) || entry[flag] === false ? entry : wrapPaths(entry, recordPaths),
+  );
+};
+
+export const wrapUntrustedFields = (data, paths, when = null) =>
+  when ? wrapFlaggedRecords(data, paths, when) : wrapPaths(data, paths);
+
+const untrustedFields = (spec) =>
+  isPlainObject(spec?.mcp) && Array.isArray(spec.mcp.untrustedFields) ? spec.mcp.untrustedFields : [];
+
+const untrustedWhen = (spec) =>
+  isPlainObject(spec?.mcp) && isPlainObject(spec.mcp.untrustedWhen) ? spec.mcp.untrustedWhen : null;
+
 const omitKeys = (value, keys) => {
   if (!isPlainObject(value)) return value;
   return Object.fromEntries(Object.entries(value).filter(([key]) => !keys.includes(key)));
@@ -20,7 +66,8 @@ export const sanitizeEnvelope = (envelope, spec) => {
     const rest = omitKeys(error, [DETAILS_FIELD]);
     return { ...envelope, error: hasDetails ? { ...rest, details } : rest };
   }
-  return { ...envelope, data: omitKeys(envelope.data, hidden) };
+  const visible = omitKeys(envelope.data, hidden);
+  return { ...envelope, data: wrapUntrustedFields(visible, untrustedFields(spec), untrustedWhen(spec)) };
 };
 
 export const toToolResult = (envelope, { spec, organization } = {}) => {

package/src/adapters/mcp/routeOverrides.js

@@ -0,0 +1,17 @@
+export const MULTI_REQUEST_COMMAND_IDS = Object.freeze(['marketplace.seller.onboard']);
+
+export const SEQUENTIAL_ROUTE_KEYS = Object.freeze(['POST /billing/purchase-products']);
+
+export const ROUTE_TOOL_OVERRIDES = Object.freeze({
+  'POST /billing/purchase-products': ['billing.purchase-products.quote', 'billing.purchase-products.buy'],
+  'GET /articles': ['articles.list'],
+  'GET /products/{}/backlinks/subscribe-quote': ['products.backlinks.subscribe-quote'],
+  'PATCH /marketplace/target-pages/{}': [
+    'marketplace.buyer.target-pages.pause',
+    'marketplace.buyer.target-pages.activate',
+  ],
+  'POST /products/{}/marketplace/buyer/participation': [
+    'marketplace.buyer.participation.on',
+    'marketplace.buyer.participation.off',
+  ],
+});

package/src/adapters/mcp/routes.js

@@ -0,0 +1,346 @@
+import { toSnakeCase, toolName } from '../../commands/registry.js';
+import { API_BASE_PATH, Surface } from '../../core/constants.js';
+import { renderMcpReference } from '../../core/context.js';
+import { cliSuccess } from '../../core/errors.js';
+import { parseFieldValue } from '../../core/schema.js';
+import { MULTI_REQUEST_COMMAND_IDS, ROUTE_TOOL_OVERRIDES, SEQUENTIAL_ROUTE_KEYS } from './routeOverrides.js';
+
+const PROBE_VALUE_PREFIX = '\u0000probe:';
+const PROBE_VALUE_SUFFIX = '\u0000';
+const PATH_PARAM_PATTERN = /\{([a-zA-Z0-9_]+)\}/g;
+const PATH_PARAM_SEGMENT_PATTERN = /^\{[a-zA-Z0-9_]+\}$/;
+const PLACEHOLDER_SEGMENT_PATTERN = /^(?:<[^>]+>|\{[^}]+\})$/;
+const PATH_SEPARATOR = '/';
+const METHOD_PAIR_SEPARATOR = '/';
+const ROUTE_KEY_SEPARATOR = ' ';
+const TOOL_ALTERNATIVE_SEPARATOR = ' or ';
+const TOOL_SEQUENCE_SEPARATOR = ', then ';
+const ATTACHED_CONTINUATION_PATTERN = /^[@+%=~\w-]/;
+const UNPARSED_QUERY_PATTERN = /^\?[A-Za-z0-9_%<{]/;
+const TIME_LIKE_CONTINUATION_PATTERN = /^:\w/;
+const PATH_DOT_CONTINUATION_PATTERN = /^\.(?!\.\.(?![./]))[./\w]/;
+const PREFERRED_AMBIGUOUS_METHOD = 'GET';
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+const SEGMENT_ALTERNATIVE_SEPARATOR = '|';
+const LITERAL_SEGMENT = '[A-Za-z0-9_-]+(?:\\.[A-Za-z0-9_-]+)*';
+const PLACEHOLDER_SEGMENT = '<[^>\\s/]+>|\\{[^}\\s/]+\\}';
+const LITERAL_ALTERNATIVES = `${LITERAL_SEGMENT}(?:\\${SEGMENT_ALTERNATIVE_SEPARATOR}${LITERAL_SEGMENT})*`;
+const PATH_SEGMENT = `(?:${LITERAL_ALTERNATIVES}|${PLACEHOLDER_SEGMENT})`;
+const ENCODED_BYTE = '%[0-9A-Fa-f]{2}';
+const QUERY_VALUE =
+  `(?:(?:[A-Za-z0-9_.~-]|${ENCODED_BYTE})*(?:[A-Za-z0-9_~-]|${ENCODED_BYTE})|<[^>\\s&]+>|\\{[^}\\s&]+\\})`;
+const QUERY_PAIR = `[A-Za-z0-9_]+=${QUERY_VALUE}`;
+const MAX_METHOD_ALTERNATIVES = 2;
+const METHOD_LIST =
+  `(?:${HTTP_METHODS.join('|')})` +
+  `(?:${METHOD_PAIR_SEPARATOR}(?:${HTTP_METHODS.join('|')})){0,${MAX_METHOD_ALTERNATIVES}}`;
+const MAX_REWRITTEN_TEXT_CHARS = 20_000;
+const MIN_LITERAL_MATCHES = 1;
+const OFFSET_ARGUMENT_POSITION = -2;
+const MENTION_BOUNDARY = '(?<![\\w./:-])';
+const PATH_ELLIPSIS = '...';
+const TRAILING_SEPARATOR = `(?:${PATH_SEPARATOR}(?=$|[\\s?.,;:)\\]'"\`]))?`;
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const MENTION_PATTERN = new RegExp(
+  `${MENTION_BOUNDARY}(?:(${METHOD_LIST}) )?(${escapeRegExp(API_BASE_PATH)}|${escapeRegExp(PATH_ELLIPSIS)})` +
+    `((?:${PATH_SEPARATOR}${PATH_SEGMENT})+)${TRAILING_SEPARATOR}(\\?${QUERY_PAIR}(?:&${QUERY_PAIR})*)?`,
+  'g',
+);
+
+const probeValue = (name) => `${PROBE_VALUE_PREFIX}${name}${PROBE_VALUE_SUFFIX}`;
+
+const probedInputName = (value) =>
+  typeof value === 'string' && value.startsWith(PROBE_VALUE_PREFIX) && value.endsWith(PROBE_VALUE_SUFFIX)
+    ? value.slice(PROBE_VALUE_PREFIX.length, -PROBE_VALUE_SUFFIX.length)
+    : null;
+
+const probeInput = (spec) => Object.fromEntries(Object.keys(spec.input).map((name) => [name, probeValue(name)]));
+
+const probeContext = (calls) => {
+  const record = async (request) => {
+    calls.push(request);
+    return cliSuccess({}, '');
+  };
+  return {
+    surface: Surface.MCP,
+    longRunning: false,
+    http: record,
+    request: async (request) => ({ result: await record(request), status: 0 }),
+    ref: () => '',
+  };
+};
+
+const resolveTemplate = (path, pathParams = {}) => {
+  const params = [];
+  const template = path.replace(PATH_PARAM_PATTERN, (_, name) => {
+    const value = pathParams[name];
+    const input = probedInputName(value) ?? (value === undefined || value === null ? name : null);
+    if (input === null) return encodeURIComponent(String(value));
+    params.push({ name, input });
+    return `{${name}}`;
+  });
+  return { template, params };
+};
+
+const resolveQuery = (query = {}) =>
+  Object.fromEntries(
+    Object.entries(query)
+      .map(([key, value]) => [key, probedInputName(value)])
+      .filter(([, input]) => input !== null),
+  );
+
+const segmentsOf = (pathname) => pathname.split(PATH_SEPARATOR).slice(1);
+
+const ANY_PARAM_SEGMENT = '{}';
+const routeKey = (method, template) =>
+  `${method}${ROUTE_KEY_SEPARATOR}${template.replace(PATH_PARAM_PATTERN, ANY_PARAM_SEGMENT)}`;
+
+const UNMAPPED_THREW = 'run() threw';
+const UNMAPPED_NO_PATH = 'the request has no path';
+const unmappedCallCount = (count) => `run() made ${count} requests instead of one`;
+
+const probeRoute = async (spec) => {
+  const calls = [];
+  try {
+    await spec.run(probeInput(spec), probeContext(calls));
+  } catch (error) {
+    return { reason: `${UNMAPPED_THREW}: ${String(error?.message ?? error)}` };
+  }
+  if (calls.length !== 1) return { reason: unmappedCallCount(calls.length) };
+  const [{ method = PREFERRED_AMBIGUOUS_METHOD, path, pathParams, query }] = calls;
+  if (typeof path !== 'string') return { reason: UNMAPPED_NO_PATH };
+  const { template, params } = resolveTemplate(path, pathParams);
+  return { method, template, segments: segmentsOf(template), params, query: resolveQuery(query), spec };
+};
+
+const isProbeCandidate = (spec) => spec.mcp !== false && spec.offline !== true;
+
+const mergeCandidates = (key, candidates) => {
+  const [first] = candidates;
+  const chosen =
+    candidates.length === 1
+      ? candidates
+      : (ROUTE_TOOL_OVERRIDES[key] ?? []).map((id) => candidates.find((route) => route.spec.id === id));
+  if (chosen.length === 0 || chosen.includes(undefined)) return null;
+  const { method, template, segments, params, query } = first;
+  const specs = chosen.map((candidate) => candidate.spec);
+  const dropped = candidates.filter((candidate) => !chosen.includes(candidate));
+  const sequential = SEQUENTIAL_ROUTE_KEYS.includes(key);
+  return {
+    route: { key, method, template, segments, params, query, specs, sequential },
+    superseded: dropped.map(toId),
+  };
+};
+
+const toId = (candidate) => candidate.spec.id;
+
+const describeCollision = (key, candidates) => `${key} is served by ${candidates.map(toId).join(', ')}`;
+
+export const buildRouteIndex = async (registry) => {
+  const grouped = new Map();
+  const unmapped = [];
+  for (const spec of registry.commands.filter(isProbeCandidate)) {
+    const route = await probeRoute(spec);
+    if (route.reason) {
+      unmapped.push({ id: spec.id, reason: route.reason });
+      continue;
+    }
+    const key = routeKey(route.method, route.template);
+    grouped.set(key, [...(grouped.get(key) ?? []), route]);
+  }
+  const routes = [];
+  const superseded = [];
+  const collisions = [];
+  for (const [key, candidates] of grouped) {
+    const merged = mergeCandidates(key, candidates);
+    if (merged === null) {
+      collisions.push(describeCollision(key, candidates));
+      continue;
+    }
+    routes.push(merged.route);
+    superseded.push(...merged.superseded);
+  }
+  if (collisions.length > 0) {
+    throw new Error(`MCP routes: add these to ROUTE_TOOL_OVERRIDES: ${collisions.join('; ')}`);
+  }
+  return Object.freeze({ routes, unmapped, superseded });
+};
+
+export const unexpectedProbeFailures = (index) =>
+  index.unmapped.filter(({ id }) => !MULTI_REQUEST_COMMAND_IDS.includes(id));
+
+const decodeQueryValue = (value) => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+
+const isPlaceholderSegment = (segment) => PLACEHOLDER_SEGMENT_PATTERN.test(segment);
+const isOpenSegment = (segment) => isPlaceholderSegment(segment) || segment.includes(SEGMENT_ALTERNATIVE_SEPARATOR);
+
+const alignedSegments = (route, mention) => {
+  const count = mention.segments.length;
+  if (mention.suffix) return route.segments.length >= count ? route.segments.slice(-count) : null;
+  return route.segments.length === count ? route.segments : null;
+};
+
+const literalMatches = (route, mention, lenient) => {
+  const aligned = alignedSegments(route, mention);
+  if (aligned === null) return null;
+  let matches = 0;
+  for (const [position, templateSegment] of aligned.entries()) {
+    const segment = mention.segments[position];
+    if (PATH_PARAM_SEGMENT_PATTERN.test(templateSegment)) {
+      if (segment.includes(SEGMENT_ALTERNATIVE_SEPARATOR)) return null;
+      continue;
+    }
+    if (isPlaceholderSegment(segment)) {
+      if (!lenient) return null;
+      continue;
+    }
+    if (!segment.split(SEGMENT_ALTERNATIVE_SEPARATOR).includes(templateSegment)) return null;
+    matches += 1;
+  }
+  return matches;
+};
+
+const scoreRoutes = (routes, mention, lenient) =>
+  routes
+    .map((route) => ({ route, matches: literalMatches(route, mention, lenient) }))
+    .filter(({ matches }) => matches !== null && matches >= MIN_LITERAL_MATCHES);
+
+const bestMatches = (scored) => {
+  const best = Math.max(...scored.map(({ matches }) => matches));
+  return scored.filter(({ matches }) => matches === best).map(({ route }) => route);
+};
+
+const preferMethod = (routes) => {
+  const methods = new Set(routes.map((route) => route.method));
+  if (methods.size === 1) return routes;
+  return routes.filter((route) => route.method === PREFERRED_AMBIGUOUS_METHOD);
+};
+
+const sharesToolset = (route, toolsets) =>
+  route.specs.some((spec) => spec.toolsets.some((toolset) => toolsets.includes(toolset)));
+
+const preferToolsets = (routes, toolsets) => {
+  const related = routes.filter((route) => sharesToolset(route, toolsets));
+  return related.length > 0 ? related : routes;
+};
+
+const isParameterRouteOfAnotherMethod = (index, mention) => scoreRoutes(index.routes, mention, false).length > 0;
+
+const matchRoutes = (index, method, mention, toolsets) => {
+  const candidates = index.routes.filter((route) => method === undefined || route.method === method);
+  const strict = scoreRoutes(candidates, mention, false);
+  if (strict.length === 0 && isParameterRouteOfAnotherMethod(index, mention)) return null;
+  const scored = strict.length > 0 ? strict : scoreRoutes(candidates, mention, true);
+  if (scored.length === 0) return null;
+  const byMethod = method === undefined ? preferMethod(bestMatches(scored)) : bestMatches(scored);
+  const tied = byMethod.length > 1 ? preferToolsets(byMethod, toolsets) : byMethod;
+  if (tied.length === 1 || (tied.length > 1 && mention.segments.some(isOpenSegment))) return tied;
+  return null;
+};
+
+const mentionedValues = (route, mention) => {
+  const values = [];
+  for (const [position, templateSegment] of alignedSegments(route, mention).entries()) {
+    const param = route.params.find((entry) => `{${entry.name}}` === templateSegment);
+    if (param) values.push([param.input, mention.segments[position]]);
+  }
+  for (const [key, value] of mention.query) {
+    values.push([Object.hasOwn(route.query, key) ? route.query[key] : key, decodeQueryValue(value)]);
+  }
+  return values;
+};
+
+const inputNamed = (spec, key) => Object.keys(spec.input).find((name) => name === key || toSnakeCase(name) === key);
+
+const toArgumentValue = (field, value) => {
+  if (isPlaceholderSegment(value)) return value;
+  try {
+    return parseFieldValue(field, value, '');
+  } catch {
+    return undefined;
+  }
+};
+
+const argumentsFor = (spec, values) => {
+  const args = Object.create(null);
+  for (const [key, value] of values) {
+    const input = inputNamed(spec, key);
+    if (input === undefined) return null;
+    const argument = toArgumentValue(spec.input[input], value);
+    if (argument === undefined) return null;
+    args[input] = argument;
+  }
+  return args;
+};
+
+const toolReferences = (routes, mention) => {
+  const seen = new Set();
+  const references = [];
+  for (const route of routes) {
+    const values = mentionedValues(route, mention);
+    for (const spec of route.specs) {
+      const args = argumentsFor(spec, values);
+      if (args === null) return null;
+      const name = toolName(spec.id);
+      const argumentText = renderMcpReference(spec, args).slice(name.length);
+      const key = `${name}${argumentText}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      references.push({ name, argumentText, args, sequential: route.sequential });
+    }
+  }
+  return references;
+};
+
+export const resolveMention = (index, mention, toolsets = []) => {
+  const matched = mention.methods.map((method) => matchRoutes(index, method, mention, toolsets));
+  if (matched.some((routes) => routes === null)) return null;
+  return toolReferences(matched.flat(), mention);
+};
+
+const renderMention = (index, mention, toolsets) => {
+  const references = resolveMention(index, mention, toolsets);
+  if (references === null) return null;
+  const separator = references.every((reference) => reference.sequential)
+    ? TOOL_SEQUENCE_SEPARATOR
+    : TOOL_ALTERNATIVE_SEPARATOR;
+  const argumentTexts = new Set(references.map((reference) => reference.argumentText));
+  if (argumentTexts.size === 1) {
+    const names = references.map((reference) => reference.name).join(separator);
+    return `${names}${references[0].argumentText}`;
+  }
+  return references.map((reference) => `${reference.name}${reference.argumentText}`).join(separator);
+};
+
+const continuesAfterMention = (rest) =>
+  rest.startsWith(PATH_SEPARATOR) ||
+  ATTACHED_CONTINUATION_PATTERN.test(rest) ||
+  UNPARSED_QUERY_PATTERN.test(rest) ||
+  TIME_LIKE_CONTINUATION_PATTERN.test(rest) ||
+  PATH_DOT_CONTINUATION_PATTERN.test(rest);
+
+const parseMention = ([text, methodText, prefix, pathname, queryText]) => ({
+  text,
+  methods: methodText === undefined ? [undefined] : methodText.split(METHOD_PAIR_SEPARATOR),
+  suffix: prefix === PATH_ELLIPSIS,
+  segments: segmentsOf(pathname),
+  query: queryText === undefined ? [] : queryText.slice(1).split('&').map((pair) => pair.split('=')),
+});
+
+export const rewriteRouteMentions = (index, text, { toolsets = [] } = {}) => {
+  if (text.length > MAX_REWRITTEN_TEXT_CHARS) return text;
+  return text.replace(MENTION_PATTERN, (...match) => {
+    const mention = parseMention(match);
+    const offset = match.at(OFFSET_ARGUMENT_POSITION);
+    if (continuesAfterMention(text.slice(offset + mention.text.length))) return mention.text;
+    return renderMention(index, mention, toolsets) ?? mention.text;
+  });
+};
+
+export const findRouteMentions = (text) => [...text.matchAll(MENTION_PATTERN)].map(parseMention);

package/src/adapters/mcp/server.js

@@ -1,5 +1,14 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 
 import { toolName } from '../../commands/registry.js';
@@ -7,6 +16,7 @@ import { describeUntrustedValue } from '../../core/config.js';
 import { CliErrorCode, MCP_USAGE_GUIDANCE, cliError, toErrorEnvelope } from '../../core/errors.js';
 import { executeCommand } from '../../core/execute.js';
 import {
+  ENTITLEMENT_CHANGING_COMMAND_IDS,
   MCP_PROGRESS_INTERVAL_MS,
   MCP_SERVER_NAME,
   MILLISECONDS_PER_SECOND,
@@ -14,9 +24,13 @@ import {
   WHOAMI_COMMAND_ID,
 } from './constants.js';
 import { describeField, describeTool, toolAnnotations } from './descriptions.js';
+import { createGuidanceRewriter } from './guidance.js';
 import { MCP_LABELS, buildToolInput, parseToolArguments, toRawInput } from './input.js';
 import { buildInstructions } from './instructions.js';
 import { createLogger, redactToolArguments } from './logger.js';
+import { getPrompt, listPrompts } from './prompts.js';
+import { unexpectedProbeFailures } from './routes.js';
+import { listResources, readResource } from './resources.js';
 import { toToolResult } from './result.js';
 import { createSession } from './session.js';
 import { isBlockedByOperator, isReadKind } from './toolsets.js';
@@ -59,6 +73,7 @@ export const createMcpServer = async ({
   readConfig,
   timeouts = {},
   logger = createLogger(),
+  throttle,
 }) => {
   const progressIntervalMs = timeouts.progressIntervalMs ?? MCP_PROGRESS_INTERVAL_MS;
   const definitions = new Map();
@@ -75,9 +90,24 @@ export const createMcpServer = async ({
     server.sendToolListChanged().catch((error) => {
       logger.debug('tool_list_changed_not_sent', { reason: String(error?.message ?? error) });
     });
+    server.sendPromptListChanged().catch((error) => {
+      logger.debug('prompt_list_changed_not_sent', { reason: String(error?.message ?? error) });
+    });
   };
 
-  const session = createSession({ registry, options, env, readConfig, timeouts, onToolsChanged: notifyToolsChanged });
+  const guidance = await createGuidanceRewriter(registry);
+  for (const { id, reason } of unexpectedProbeFailures(guidance.index)) {
+    logger.always('route_probe_failed', { command: id, reason });
+  }
+  const session = createSession({
+    registry,
+    options,
+    env,
+    readConfig,
+    timeouts,
+    onToolsChanged: notifyToolsChanged,
+    ...(throttle ? { throttle } : {}),
+  });
   await session.start();
 
   const withProgress = async (spec, extra, run) => {
@@ -122,6 +152,7 @@ export const createMcpServer = async ({
         );
         if (spec.id === WHOAMI_COMMAND_ID) session.noteWhoami(envelope);
         session.noteResult(envelope);
+        if (envelope.ok === true && ENTITLEMENT_CHANGING_COMMAND_IDS.includes(spec.id)) session.refreshIdentity();
         return envelope;
       } finally {
         release();
@@ -152,12 +183,24 @@ export const createMcpServer = async ({
     const spec = found && found.mcp !== false ? found : undefined;
     const envelope = await runTool(spec, params.name, params.arguments, extra);
     logToolCall({ spec, params, envelope, startedAt });
-    return toToolResult(envelope, { spec, organization: session.organization() });
+    return toToolResult(guidance.rewrite(envelope, spec), { spec, organization: session.organization() });
+  };
+
+  const asProtocolError = (run) => {
+    try {
+      return run();
+    } catch (error) {
+      if (error?.cliCode === CliErrorCode.INVALID_USAGE) throw new McpError(ErrorCode.InvalidParams, error.message);
+      throw error;
+    }
   };
 
   server = new Server(
     { name: MCP_SERVER_NAME, version },
-    { capabilities: { tools: { listChanged: true } }, instructions: buildInstructions({ session, version }) },
+    {
+      capabilities: { tools: { listChanged: true }, prompts: { listChanged: true }, resources: {} },
+      instructions: buildInstructions({ session, version }),
+    },
   );
   server.onerror = (error) => {
     logger.debug('protocol_error', { reason: String(error?.message ?? error) });
@@ -169,6 +212,14 @@ export const createMcpServer = async ({
     tools: session.selection().tools.map((spec) => definitionFor(spec).tool),
   }));
   server.setRequestHandler(CallToolRequestSchema, async (request, extra) => callTool(request.params, extra));
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: listPrompts(session.selection()) }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) =>
+    asProtocolError(() => getPrompt(session.selection(), request.params.name, request.params.arguments)),
+  );
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: listResources() }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) =>
+    asProtocolError(() => readResource(session, request.params.uri)),
+  );
 
   return { server, session };
 };