@explyt/ai-agent 0.1.0-rc.1 → 0.1.4

package/node_modules/pi-mcp-adapter/mcp-probe.ts

@@ -1,187 +0,0 @@
-const PROBE_TIMEOUT_MS = 5_000;
-const MODERN_PROTOCOL_VERSION = "2026-07-28";
-const LEGACY_PROTOCOL_VERSION = "2025-06-18";
-const JSON_ACCEPT = "application/json, text/event-stream";
-const SSE_ACCEPT = "text/event-stream";
-const MODERN_FALLBACK_STATUSES = new Set([400, 401, 404, 405, 406, 415]);
-const POST_ENDPOINT_MISMATCH_STATUSES = new Set([404, 405, 406, 415]);
-
-export interface McpProbeResult {
-  isMcp: boolean;
-  classification: string;
-}
-
-const DISCOVER_REQUEST = {
-  jsonrpc: "2.0",
-  id: 1,
-  method: "server/discover",
-  params: {},
-};
-
-const INITIALIZE_REQUEST = {
-  jsonrpc: "2.0",
-  id: 1,
-  method: "initialize",
-  params: {
-    protocolVersion: LEGACY_PROTOCOL_VERSION,
-    capabilities: {},
-    clientInfo: { name: "pi-mcp-probe", version: "2.1.2" },
-  },
-};
-
-type ProbeStrategy =
-  | { kind: "modern"; request: RequestInit; allowJson: true }
-  | { kind: "legacy-post"; request: RequestInit; allowJson: true }
-  | { kind: "legacy-sse"; request: RequestInit; allowJson: false };
-
-const MODERN_STRATEGY: ProbeStrategy = {
-  kind: "modern",
-  request: {
-    method: "POST",
-    headers: {
-      Accept: JSON_ACCEPT,
-      "Content-Type": "application/json",
-      "MCP-Protocol-Version": MODERN_PROTOCOL_VERSION,
-      "Mcp-Method": "server/discover",
-    },
-    body: JSON.stringify(DISCOVER_REQUEST),
-  },
-  allowJson: true,
-};
-
-const LEGACY_POST_STRATEGY: ProbeStrategy = {
-  kind: "legacy-post",
-  request: {
-    method: "POST",
-    headers: {
-      Accept: JSON_ACCEPT,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(INITIALIZE_REQUEST),
-  },
-  allowJson: true,
-};
-
-const LEGACY_SSE_STRATEGY: ProbeStrategy = {
-  kind: "legacy-sse",
-  request: { headers: { Accept: SSE_ACCEPT } },
-  allowJson: false,
-};
-
-type JsonRpcEnvelopeInfo =
-  | { kind: "result"; protocolVersion: unknown }
-  | { kind: "error" };
-
-type ProbeOutcome =
-  | { kind: "mcp"; result: McpProbeResult }
-  | { kind: "unsupported-modern" }
-  | { kind: "unrecognized" };
-
-interface ProbeResult {
-  response: Response;
-  outcome: ProbeOutcome;
-}
-
-function jsonRpcEnvelopeInfo(value: unknown): JsonRpcEnvelopeInfo | null {
-  if (typeof value !== "object" || value === null || (value as { jsonrpc?: unknown }).jsonrpc !== "2.0") {
-    return null;
-  }
-  if ("result" in value) {
-    const result = (value as { result?: unknown }).result;
-    return {
-      kind: "result",
-      protocolVersion: typeof result === "object" && result !== null
-        ? (result as { protocolVersion?: unknown }).protocolVersion
-        : undefined,
-    };
-  }
-  if ("error" in value) return { kind: "error" };
-  return null;
-}
-
-function isBearerChallenge(response: Response): boolean {
-  return /(?:^|,)\s*Bearer\b/i.test(response.headers.get("www-authenticate") ?? "");
-}
-
-function responseKind(response: Response): string {
-  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  if (contentType === "text/html") return "HTML";
-  if (contentType) return contentType;
-  return "an untyped response";
-}
-
-async function getJsonRpcEnvelopeInfo(response: Response): Promise<JsonRpcEnvelopeInfo | null> {
-  try {
-    return jsonRpcEnvelopeInfo(JSON.parse(await response.text()));
-  } catch {
-    return null;
-  }
-}
-
-async function classifyResponse(response: Response, strategy: ProbeStrategy): Promise<ProbeOutcome> {
-  const isSse = response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream");
-  if (response.ok && isSse) {
-    return { kind: "mcp", result: { isMcp: true, classification: "endpoint responded with an MCP event stream" } };
-  }
-
-  const envelope = (strategy.allowJson || response.status === 401) ? await getJsonRpcEnvelopeInfo(response) : null;
-  if (response.ok && strategy.allowJson && envelope) {
-    if (strategy.kind === "modern" && (envelope.kind === "error" || envelope.protocolVersion !== MODERN_PROTOCOL_VERSION)) {
-      return { kind: "unsupported-modern" };
-    }
-    return {
-      kind: "mcp",
-      result: {
-        isMcp: true,
-        classification: strategy.kind === "modern"
-          ? `endpoint supports stateless MCP ${MODERN_PROTOCOL_VERSION} server/discover`
-          : "endpoint responded with a JSON-RPC 2.0 envelope",
-      },
-    };
-  }
-  if (response.status === 401 && isBearerChallenge(response) && envelope) {
-    return {
-      kind: "mcp",
-      result: {
-        isMcp: true,
-        classification: strategy.kind === "modern"
-          ? `endpoint requires Bearer authentication during MCP ${MODERN_PROTOCOL_VERSION} server/discover probing`
-          : "endpoint requires Bearer authentication and responded with a JSON-RPC 2.0 error",
-      },
-    };
-  }
-
-  return { kind: "unrecognized" };
-}
-
-async function probe(url: string | URL, strategy: ProbeStrategy): Promise<ProbeResult> {
-  const response = await fetch(url, {
-    ...strategy.request,
-    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
-  });
-  return { response, outcome: await classifyResponse(response, strategy) };
-}
-
-function notMcp(response: Response): McpProbeResult {
-  return {
-    isMcp: false,
-    classification: `endpoint returned ${responseKind(response)} (${response.status}) — this URL does not appear to speak MCP`,
-  };
-}
-
-/** Makes one unauthenticated metadata-only request to identify an HTTP endpoint's protocol shape. */
-export async function probeMcpEndpoint(url: string | URL): Promise<McpProbeResult> {
-  const { response: modernResponse, outcome: modernOutcome } = await probe(url, MODERN_STRATEGY);
-  if (modernOutcome.kind === "mcp") return modernOutcome.result;
-
-  if (modernOutcome.kind !== "unsupported-modern" && !MODERN_FALLBACK_STATUSES.has(modernResponse.status)) {
-    return notMcp(modernResponse);
-  }
-
-  const { response: postResponse, outcome: postOutcome } = await probe(url, LEGACY_POST_STRATEGY);
-  if (postOutcome.kind === "mcp") return postOutcome.result;
-  if (!POST_ENDPOINT_MISMATCH_STATUSES.has(postResponse.status)) return notMcp(postResponse);
-
-  const { response: getResponse, outcome: getOutcome } = await probe(url, LEGACY_SSE_STRATEGY);
-  return getOutcome.kind === "mcp" ? getOutcome.result : notMcp(getResponse);
-}