@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/mcp/config-writer.ts

@@ -67,9 +67,13 @@ export function validateServerName(name: string): string | undefined {
 	if (name.length > 100) {
 		return "Server name is too long (max 100 characters)";
 	}
-	// Check for invalid characters (only allow alphanumeric, dash, underscore, dot)
-	if (!/^[a-zA-Z0-9_.-]+$/.test(name)) {
-		return "Server name can only contain letters, numbers, dash, underscore, and dot";
+	// Check for invalid characters. Colon is allowed so namespaced plugin servers
+	// (e.g. "cloudflare:cloudflare-api" from a Claude Code marketplace plugin) can
+	// be persisted: the runtime already accepts colons in server names (tool names
+	// sanitize them via createMCPToolName) and `/mcp reauth` writes such names back
+	// as a user-config override that shadows the discovered entry.
+	if (!/^[a-zA-Z0-9_.:-]+$/.test(name)) {
+		return "Server name can only contain letters, numbers, dash, underscore, dot, and colon";
 	}
 	return undefined;
 }

package/src/mcp/json-rpc.ts

@@ -6,6 +6,28 @@
  */
 import { logger } from "@prometheus-ai/utils";
 
+/** Hard ceiling on a single MCP HTTP request when the caller provides no signal. */
+const MCP_DEFAULT_TIMEOUT_MS = 60_000;
+
+const SENSITIVE_QUERY_PARAM = /key|token|secret|auth/i;
+
+/**
+ * Redact credential-bearing query params (e.g. `exaApiKey`) so failed
+ * requests never write secrets to the persistent log file.
+ */
+export function redactUrlForLog(url: string): string {
+	try {
+		const parsed = new URL(url);
+		for (const name of parsed.searchParams.keys()) {
+			if (SENSITIVE_QUERY_PARAM.test(name)) parsed.searchParams.set(name, "[redacted]");
+		}
+		return parsed.toString();
+	} catch {
+		// Unparseable URL — drop the query string entirely rather than risk leaking it.
+		return url.split("?")[0];
+	}
+}
+
 /** Parse SSE response format (lines starting with "data: ") */
 export function parseSSE(text: string): unknown {
 	const lines = text.split("\n");
@@ -13,8 +35,12 @@ export function parseSSE(text: string): unknown {
 		if (line.startsWith("data: ")) {
 			const data = line.slice(6).trim();
 			if (data === "[DONE]") continue;
-			const result = JSON.parse(data) as unknown;
-			if (result) return result;
+			try {
+				const result = JSON.parse(data) as unknown;
+				if (result) return result;
+			} catch {
+				// Non-JSON data line (keep-alive/comment) — skip and keep scanning.
+			}
 		}
 	}
 	// Fallback: try parsing entire response as JSON
@@ -71,12 +97,12 @@ export async function callMCP<T = unknown>(
 			Accept: "application/json, text/event-stream",
 		},
 		body: JSON.stringify(body),
-		signal: options?.signal,
+		signal: options?.signal ?? AbortSignal.timeout(MCP_DEFAULT_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {
 		const errorMsg = `MCP request failed: ${response.status} ${response.statusText}`;
-		logger.error(errorMsg, { url, method, params });
+		logger.error(errorMsg, { url: redactUrlForLog(url), method, params });
 		throw new Error(errorMsg);
 	}
 
@@ -84,7 +110,11 @@ export async function callMCP<T = unknown>(
 	const result = parseSSE(text) as JsonRpcResponse<T> | null;
 
 	if (!result) {
-		logger.error("Failed to parse MCP response", { url, method, responseText: text.slice(0, 500) });
+		logger.error("Failed to parse MCP response", {
+			url: redactUrlForLog(url),
+			method,
+			responseText: text.slice(0, 500),
+		});
 		throw new Error("Failed to parse MCP response");
 	}
 

package/src/mcp/manager.ts

@@ -472,24 +472,25 @@ export class MCPManager {
 			const cachedTools = new Map<string, MCPToolDefinition[]>();
 			const pendingTasks = connectionTasks.filter(task => task.tracked.status === "pending");
 
-			if (pendingTasks.length > 0) {
-				if (this.toolCache) {
-					await Promise.all(
-						pendingTasks.map(async task => {
-							const cached = await this.toolCache?.get(task.name, task.config);
-							if (cached) {
-								cachedTools.set(task.name, cached);
-							}
-						}),
-					);
-				}
-
-				const pendingWithoutCache = pendingTasks.filter(task => !cachedTools.has(task.name));
-				if (pendingWithoutCache.length > 0) {
-					await Promise.allSettled(pendingWithoutCache.map(task => task.tracked.promise));
-				}
+			if (pendingTasks.length > 0 && this.toolCache) {
+				await Promise.all(
+					pendingTasks.map(async task => {
+						const cached = await this.toolCache?.get(task.name, task.config);
+						if (cached) {
+							cachedTools.set(task.name, cached);
+						}
+					}),
+				);
 			}
 
+			// Pending tasks without cached tools used to be awaited synchronously here,
+			// which gated the entire UI on the slowest server's per-request timeout
+			// (issue #2100: a single unresponsive MCP server blocked startup for the
+			// full 30 s `PROMETHEUS_MCP_TIMEOUT_MS`). Leave them in flight — the background
+			// `void toolsPromise.then(...)` chain above registers their tools and
+			// fires `#onToolsChanged` once the connect finishes, or logs the failure
+			// after `allowBackgroundLogging` flips below.
+
 			for (const task of connectionTasks) {
 				const { name } = task;
 				if (task.tracked.status === "fulfilled") {
@@ -642,6 +643,17 @@ export class MCPManager {
 		return this.#sources.get(name) ?? this.#connections.get(name)?._source;
 	}
 
+	/**
+	 * Get the preserved (pre-auth) config for a known server — whether currently
+	 * connected or merely discovered (a connect was attempted but may have failed,
+	 * e.g. an OAuth server that has not been authorized yet). Mirrors the
+	 * reconnect lookup at {@link reconnectServer} so callers like `/mcp reauth`
+	 * can recover a discovered server's config without re-reading config files.
+	 */
+	getServerConfig(name: string): MCPServerConfig | undefined {
+		return this.#connections.get(name)?.config ?? this.#serverConfigs.get(name);
+	}
+
 	/**
 	 * Wait for a connection to complete (or fail).
 	 */
@@ -1173,12 +1185,15 @@ export class MCPManager {
 					const shouldRefresh =
 						forceRefresh || (credential.expires && Date.now() >= credential.expires - REFRESH_BUFFER_MS);
 					if (shouldRefresh && credential.refresh && auth.tokenUrl) {
+						const resource =
+							auth.resource ?? (config.type === "http" || config.type === "sse" ? config.url : undefined);
 						try {
 							const refreshed = await refreshMCPOAuthToken(
 								auth.tokenUrl,
 								credential.refresh,
 								auth.clientId,
 								auth.clientSecret,
+								resource,
 							);
 							const refreshedCredential = { type: "oauth" as const, ...refreshed };
 							await this.#authStorage.set(credentialId, refreshedCredential);

package/src/mcp/oauth-discovery.ts

@@ -4,12 +4,14 @@
  * Automatically detects OAuth requirements from MCP server responses
  * and extracts authentication endpoints.
  */
+import type { FetchImpl } from "@prometheus-ai/ai/types";
 
 export interface OAuthEndpoints {
 	authorizationUrl: string;
 	tokenUrl: string;
 	clientId?: string;
 	scopes?: string;
+	resource?: string;
 }
 
 export interface AuthDetectionResult {
@@ -93,7 +95,12 @@ export function extractOAuthEndpoints(error: Error): OAuthEndpoints | null {
 			(obj.default_client_id as string | undefined) ||
 			(obj.public_client_id as string | undefined);
 
-		return { authorizationUrl, tokenUrl, clientId, scopes };
+		const resource =
+			(obj.resource as string | undefined) ||
+			(obj.resource_uri as string | undefined) ||
+			(obj.resourceUri as string | undefined);
+
+		return { authorizationUrl, tokenUrl, clientId, scopes, resource };
 	};
 
 	const clientIdFromAuthUrl = (authorizationUrl: string): string | undefined => {
@@ -160,6 +167,7 @@ export function extractOAuthEndpoints(error: Error): OAuthEndpoints | null {
 			challengeValues.get("realm");
 		const tokenUrl =
 			challengeValues.get("token_url") || challengeValues.get("token_uri") || challengeValues.get("token_endpoint");
+		const resource = challengeValues.get("resource") || challengeValues.get("resource_uri");
 
 		if (authorizationUrl && tokenUrl) {
 			return {
@@ -167,6 +175,7 @@ export function extractOAuthEndpoints(error: Error): OAuthEndpoints | null {
 				tokenUrl,
 				clientId: challengeValues.get("client_id") || clientIdFromAuthUrl(authorizationUrl),
 				scopes: challengeValues.get("scope") || challengeValues.get("scopes") || scopeFromAuthUrl(authorizationUrl),
+				resource,
 			};
 		}
 	}
@@ -249,7 +258,9 @@ export async function discoverOAuthEndpoints(
 	serverUrl: string,
 	authServerUrl?: string,
 	resourceMetadataUrl?: string,
+	opts?: { fetch?: FetchImpl; protectedResource?: string },
 ): Promise<OAuthEndpoints | null> {
+	const fetchImpl: FetchImpl = opts?.fetch ?? fetch;
 	const wellKnownPaths = [
 		"/.well-known/oauth-authorization-server",
 		"/.well-known/openid-configuration",
@@ -261,18 +272,23 @@ export async function discoverOAuthEndpoints(
 	const urlsToQuery: string[] = [];
 	const visitedAuthServers = new Set<string>();
 
+	let protectedResource = opts?.protectedResource;
+
 	// Step 1: If a resource_metadata URL was provided, fetch it to discover auth servers.
 	// This follows the RFC 9728 chain: resource_metadata → authorization_servers.
 	if (resourceMetadataUrl && !visitedAuthServers.has(resourceMetadataUrl)) {
 		visitedAuthServers.add(resourceMetadataUrl);
 		try {
-			const metaResp = await fetch(resourceMetadataUrl, {
+			const metaResp = await fetchImpl(resourceMetadataUrl, {
 				method: "GET",
 				headers: { Accept: "application/json" },
 				redirect: "follow",
 			});
 			if (metaResp.ok) {
 				const meta = (await metaResp.json()) as Record<string, unknown>;
+				if (typeof meta.resource === "string" && meta.resource.trim() !== "") {
+					protectedResource = meta.resource;
+				}
 				const authServers = Array.isArray(meta.authorization_servers)
 					? meta.authorization_servers.filter((entry): entry is string => typeof entry === "string")
 					: [];
@@ -301,6 +317,8 @@ export async function discoverOAuthEndpoints(
 			const scopesSupported = Array.isArray(metadata.scopes_supported)
 				? metadata.scopes_supported.filter((scope): scope is string => typeof scope === "string").join(" ")
 				: undefined;
+			const resource = typeof metadata.resource === "string" ? metadata.resource : protectedResource;
+
 			return {
 				authorizationUrl: String(metadata.authorization_endpoint),
 				tokenUrl: String(metadata.token_endpoint),
@@ -321,12 +339,15 @@ export async function discoverOAuthEndpoints(
 						: typeof metadata.scope === "string"
 							? metadata.scope
 							: undefined),
+				resource,
 			};
 		}
 
 		if (metadata.oauth || metadata.authorization || metadata.auth) {
 			const oauthData = (metadata.oauth || metadata.authorization || metadata.auth) as Record<string, unknown>;
 			if (typeof oauthData.authorization_url === "string" && typeof oauthData.token_url === "string") {
+				const resource = typeof oauthData.resource === "string" ? oauthData.resource : protectedResource;
+
 				return {
 					authorizationUrl: oauthData.authorization_url || String(oauthData.authorizationUrl),
 					tokenUrl: oauthData.token_url || String(oauthData.tokenUrl),
@@ -346,6 +367,7 @@ export async function discoverOAuthEndpoints(
 							: typeof oauthData.scope === "string"
 								? oauthData.scope
 								: undefined,
+					resource,
 				};
 			}
 		}
@@ -359,7 +381,7 @@ export async function discoverOAuthEndpoints(
 			const urlsToTry = buildWellKnownUrls(path, baseUrl);
 			for (const url of urlsToTry) {
 				try {
-					const response = await fetch(url.toString(), {
+					const response = await fetchImpl(url.toString(), {
 						method: "GET",
 						headers: { Accept: "application/json" },
 						redirect: "follow",
@@ -375,11 +397,19 @@ export async function discoverOAuthEndpoints(
 								? metadata.authorization_servers.filter((entry): entry is string => typeof entry === "string")
 								: [];
 
+							const discoveredProtectedResource =
+								typeof metadata.resource === "string" && metadata.resource.trim() !== ""
+									? metadata.resource
+									: protectedResource;
+
 							for (const discoveredAuthServer of authServers) {
 								if (visitedAuthServers.has(discoveredAuthServer)) {
 									continue;
 								}
-								const discovered = await discoverOAuthEndpoints(serverUrl, discoveredAuthServer);
+								const discovered = await discoverOAuthEndpoints(serverUrl, discoveredAuthServer, undefined, {
+									fetch: fetchImpl,
+									protectedResource: discoveredProtectedResource,
+								});
 								if (discovered) return discovered;
 							}
 						}

package/src/mcp/oauth-flow.ts

@@ -5,9 +5,10 @@
  * by providing authorization URL, token URL, and client credentials.
  */
 
-import type { OAuthCallbackFlowOptions } from "@prometheus-ai/ai/utils/oauth/callback-server";
-import { OAuthCallbackFlow } from "@prometheus-ai/ai/utils/oauth/callback-server";
-import type { OAuthController, OAuthCredentials } from "@prometheus-ai/ai/utils/oauth/types";
+import type { OAuthCallbackFlowOptions } from "@prometheus-ai/ai/oauth/callback-server";
+import { OAuthCallbackFlow } from "@prometheus-ai/ai/oauth/callback-server";
+import type { OAuthController, OAuthCredentials } from "@prometheus-ai/ai/oauth/types";
+import type { FetchImpl } from "@prometheus-ai/ai/types";
 
 const DEFAULT_PORT = 3000;
 const CALLBACK_PATH = "/callback";
@@ -97,6 +98,23 @@ function resolveCallbackOptions(config: MCPOAuthConfig): OAuthCallbackFlowOption
 	};
 }
 
+function resolveResourceUri(resource: string | undefined): string | undefined {
+	const trimmed = resource?.trim();
+	if (!trimmed) return undefined;
+	if (trimmed !== resource) {
+		throw new Error("OAuth resource URI must not include surrounding whitespace");
+	}
+
+	const parsed = new URL(trimmed);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error("OAuth resource URI must use http or https");
+	}
+	if (parsed.hash) {
+		throw new Error("OAuth resource URI must not include a fragment");
+	}
+	return trimmed;
+}
+
 export interface MCPOAuthConfig {
 	/** Authorization endpoint URL */
 	authorizationUrl: string;
@@ -114,6 +132,10 @@ export interface MCPOAuthConfig {
 	callbackPort?: number;
 	/** Custom callback path (default: /callback or redirectUri pathname) */
 	callbackPath?: string;
+	/** MCP resource URI for RFC 8707 resource indicators */
+	resource?: string;
+	/** Fetch implementation for token exchange and discovery requests. */
+	fetch?: FetchImpl;
 }
 
 /**
@@ -124,6 +146,8 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 	#resolvedClientId?: string;
 	#registeredClientSecret?: string;
 	#codeVerifier?: string;
+	#fetch: FetchImpl;
+	#resource?: string;
 
 	constructor(
 		private config: MCPOAuthConfig,
@@ -131,6 +155,10 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 	) {
 		super(ctrl, resolveCallbackOptions(config));
 		this.#resolvedClientId = this.#resolveClientId(config);
+		this.#fetch = config.fetch ?? ctrl.fetch ?? fetch;
+		this.#resource = resolveResourceUri(
+			config.resource ?? this.#resourceFromAuthorizationUrl(config.authorizationUrl),
+		);
 	}
 
 	/**
@@ -152,6 +180,9 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 	get registeredClientSecret(): string | undefined {
 		return this.#registeredClientSecret;
 	}
+	get resource(): string | undefined {
+		return this.#resource;
+	}
 
 	async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> {
 		if (!this.#resolvedClientId) {
@@ -171,6 +202,12 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		if (this.config.scopes && !params.get("scope")) {
 			params.set("scope", this.config.scopes);
 		}
+		const existingResource = params.get("resource")?.trim();
+		if (existingResource) {
+			this.#resource = resolveResourceUri(existingResource);
+		} else if (this.#resource) {
+			params.set("resource", this.#resource);
+		}
 		params.set("redirect_uri", redirectUri);
 		params.set("state", state);
 
@@ -207,12 +244,15 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		this.#codeVerifier = undefined;
 
 		// Add client secret if provided
+		if (this.#resource) {
+			params.set("resource", this.#resource);
+		}
 		const clientSecret = this.config.clientSecret ?? this.#registeredClientSecret;
 		if (clientSecret) {
 			params.set("client_secret", clientSecret);
 		}
 
-		const response = await fetch(this.config.tokenUrl, {
+		const response = await this.#fetch(this.config.tokenUrl, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/x-www-form-urlencoded",
@@ -280,6 +320,13 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 			return undefined;
 		}
 	}
+	#resourceFromAuthorizationUrl(authorizationUrl: string): string | undefined {
+		try {
+			return new URL(authorizationUrl).searchParams.get("resource") ?? undefined;
+		} catch {
+			return undefined;
+		}
+	}
 
 	/**
 	 * Try OAuth dynamic client registration when provider requires a client_id.
@@ -289,7 +336,7 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		if (!registrationEndpoint) return;
 
 		try {
-			const response = await fetch(registrationEndpoint, {
+			const response = await this.#fetch(registrationEndpoint, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -357,7 +404,7 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 
 	async #tryWellKnownForRegistration(wellKnownUrl: string): Promise<string | null> {
 		try {
-			const response = await fetch(wellKnownUrl, {
+			const response = await this.#fetch(wellKnownUrl, {
 				method: "GET",
 				headers: { Accept: "application/json" },
 			});
@@ -374,7 +421,7 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 
 	async #assertClientIdNotRequired(authorizationUrl: string): Promise<void> {
 		try {
-			const response = await fetch(authorizationUrl, {
+			const response = await this.#fetch(authorizationUrl, {
 				method: "GET",
 				redirect: "manual",
 				headers: { Accept: "text/plain,text/html,application/json" },
@@ -402,15 +449,21 @@ export async function refreshMCPOAuthToken(
 	refreshToken: string,
 	clientId?: string,
 	clientSecret?: string,
+	resourceOrOpts?: string | { fetch?: FetchImpl },
+	opts?: { fetch?: FetchImpl },
 ): Promise<OAuthCredentials> {
+	const fetchImpl: FetchImpl = (typeof resourceOrOpts === "string" ? opts?.fetch : resourceOrOpts?.fetch) ?? fetch;
+	const resource = typeof resourceOrOpts === "string" ? resourceOrOpts : undefined;
 	const params = new URLSearchParams({
 		grant_type: "refresh_token",
 		refresh_token: refreshToken,
 	});
 	if (clientId) params.set("client_id", clientId);
+	const resolvedResource = resolveResourceUri(resource);
+	if (resolvedResource) params.set("resource", resolvedResource);
 	if (clientSecret) params.set("client_secret", clientSecret);
 
-	const response = await fetch(tokenUrl, {
+	const response = await fetchImpl(tokenUrl, {
 		method: "POST",
 		headers: { "Content-Type": "application/x-www-form-urlencoded" },
 		body: params.toString(),

package/src/mcp/render.ts

@@ -53,7 +53,13 @@ export function renderMCPResult(
 	const lines: string[] = [];
 	const isError = result.isError ?? result.details?.isError ?? false;
 	const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
-	lines.push(renderStatusLine({ icon: isError ? "error" : "success", title }, theme));
+	const success = !isError;
+	lines.push(
+		renderStatusLine(
+			success ? { iconOverride: theme.styledSymbol("tool.mcp", "accent"), title } : { icon: "error", title },
+			theme,
+		),
+	);
 
 	// Args section (when expanded)
 	if (expanded && args && typeof args === "object" && Object.keys(args).length > 0) {

package/src/mcp/startup-events.ts

@@ -0,0 +1,21 @@
+export const MCP_CONNECTING_EVENT_CHANNEL = "mcp:connecting";
+
+export type McpConnectingEvent = { serverNames: string[] };
+
+export function formatMCPConnectingMessage(serverNames: string[]): string {
+	return `Connecting to MCP servers: ${serverNames.join(", ")}…`;
+}
+
+/**
+ * Runtime validator for the cross-module event payload. The event bus is
+ * untyped at runtime, so the subscriber verifies the shape before formatting
+ * rather than trusting a cast — a malformed emit is ignored instead of throwing.
+ */
+export function isMcpConnectingEvent(data: unknown): data is McpConnectingEvent {
+	return (
+		typeof data === "object" &&
+		data !== null &&
+		Array.isArray((data as { serverNames?: unknown }).serverNames) &&
+		(data as { serverNames: unknown[] }).serverNames.every(name => typeof name === "string")
+	);
+}

package/src/mcp/tool-bridge.ts

@@ -220,6 +220,7 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly mcpToolName: string;
 	/** Server name */
 	readonly mcpServerName: string;
+	readonly approval = "write" as const;
 	/** Render completed MCP calls with the result header replacing the pending call header. */
 	readonly mergeCallAndResult = true;
 
@@ -305,6 +306,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly mcpToolName: string;
 	/** Server name */
 	readonly mcpServerName: string;
+	readonly approval = "write" as const;
 	/** Render completed MCP calls with the result header replacing the pending call header. */
 	readonly mergeCallAndResult = true;