Function probeEndpoint

packages/plugins/mcp/src/sdk/plugin.ts:911–1050

(input: string | McpProbeEndpointInput)

      const httpClientLayer = options?.httpClientLayer ?? ctx.httpClientLayer;

      const probeEndpoint = (input: string | McpProbeEndpointInput) =>
        Effect.gen(function* () {
          const endpoint = typeof input === "string" ? input : input.endpoint;
          const trimmed = endpoint.trim();
          if (!trimmed) {
            return yield* new McpConnectionError({
              transport: "remote",
              message: "Endpoint URL is required",
            });
          }

          const name = yield* Effect.try({
            try: () => new URL(trimmed).hostname,
            catch: () => "mcp",
          }).pipe(Effect.orElseSucceed(() => "mcp"));
          const slug = deriveMcpNamespace({ endpoint: trimmed });

          const probeHeaders = typeof input === "string" ? undefined : input.headers;
          const probeQueryParams = typeof input === "string" ? undefined : input.queryParams;

          const connector = createMcpConnector({
            transport: "remote",
            endpoint: trimmed,
            headers: probeHeaders,
            queryParams: probeQueryParams,
            httpClientLayer,
          });

          const result = yield* discoverTools(connector).pipe(
            Effect.map((m) => ({ ok: true as const, manifest: m })),
            Effect.catch(() => Effect.succeed({ ok: false as const, manifest: null })),
            Effect.withSpan("mcp.plugin.discover_tools"),
          );

          if (result.ok && result.manifest) {
            return {
              connected: true,
              requiresAuthentication: false,
              requiresOAuth: false,
              supportsDynamicRegistration: false,
              name: result.manifest.server?.name ?? name,
              slug,
              toolCount: result.manifest.tools.length,
              serverName: result.manifest.server?.name ?? null,
              instructions: result.manifest.server?.instructions ?? null,
            } satisfies McpProbeResult;
          }

          // Confirm the endpoint actually speaks MCP before classifying it as
          // OAuth-protected (an OAuth-protected non-MCP service would
          // otherwise be misclassified).
          const shape = yield* probeMcpEndpointShape(trimmed, {
            httpClientLayer,
            headers: probeHeaders,
            queryParams: probeQueryParams,
          });

          // A `not-mcp`/auth-required shape only proves the endpoint returned