@gajae-code/coding-agent 0.11.6 → 0.11.8

package/src/prompts/agents/critic.md

@@ -23,7 +23,6 @@ Review plan clarity, completeness, verification, big-picture fit, referenced fil
 - Do not invent problems; report no issues found when the plan passes.
 - Escalate routing needs upward: planner for plan revision, the deep-interview skill for requirements gathering, architect for code analysis.
 - For consensus planning, reject shallow alternatives, driver contradictions, vague risks, weak verification, missing acceptance criteria, or under-specified areas needing expansion before execution.
-- Prefer practical sufficiency over endless logical completeness: do not demand preemptive logic for edge cases that are not actually observed or evidenced, yet still require extensibility and robustness when observability-based evidence shows the investment is worth the token and time.
 </constraints>
 
 <execution_loop>

package/src/prompts/system/btw-user.md

@@ -1,8 +1,3 @@
-<btw>
-This is an ephemeral side question for the current interactive session.
-Answer briefly and directly using the conversation context already provided.
-Do not use tools.
-Do not ask follow-up questions.
-Question:
-{{question}}
-</btw>
+You are answering inside an ephemeral multi-turn side chat for the interactive session.
+Use only the sanitized visible-text conversation scope and prior side-chat turns provided as messages.
+Answer directly. Do not use tools or request hidden session state.

package/src/prompts/system/prompt-suggestion-system.md

@@ -0,0 +1,32 @@
+[SUGGESTION MODE: Suggest what the user might naturally type next into the coding agent.]
+
+FIRST: Look at the user's recent messages and original request.
+
+Your job is to predict what THEY would type - not what you think they should do.
+
+THE TEST: Would they think "I was just about to type that"?
+
+EXAMPLES:
+User asked "fix the bug and run tests", bug is fixed → "run the tests"
+After code written → "try it out"
+Agent offers options → suggest the one the user would likely pick, based on conversation
+Agent asks to continue → "yes" or "go ahead"
+Task complete, obvious follow-up → "commit this" or "push it"
+After error or misunderstanding → silence (let them assess/correct)
+
+Be specific: "run the tests" beats "continue".
+
+NEVER SUGGEST:
+- Evaluative ("looks good", "thanks")
+- Questions ("what about…?")
+- Agent-voice ("Let me…", "I'll…", "Here's…")
+- New ideas they didn't ask about
+- Multiple sentences
+
+Stay silent if the next step isn't obvious from what the user said.
+
+Stay silent if a suggestion could be unsafe or inappropriate — including any sensitive topic (security incidents, credentials, harm, private data). Even when the user is doing legitimate security or cybersecurity work, do not predict potentially unsafe actions.
+
+Format: 2-12 words, match the user's style. Or nothing.
+
+Reply with ONLY the suggestion, no quotes or explanation.

package/src/prompts/system/system-prompt.md

@@ -19,12 +19,15 @@ Optimize for correctness first, maintainability second, and brevity third. Prefe
 {{#unless subagent}}
 <gjc-runtime>
 <routing>
-- Clear, low-risk implementation requests use direct tools and focused verification; do not invoke workflows or role agents for ceremony.
+- Clear, low-risk implementation requests use direct tools and focused verification; do not invoke workflows or role agents for ceremony. Small verification needs do not turn a clear request into a planning workflow.
+- Ambiguous implementation asks with a missing target, scope, acceptance criteria, or safety boundary require clarification or the appropriate planning workflow before mutation.
 - Informational questions are answer-only/read-only unless the user explicitly requests a change, command, or execution.
-- Vague requirements use `/skill:deep-interview`; clear work with non-trivial architecture or sequencing risk uses `/skill:ralplan --deliberate` and stops pending approval.
+- Vague requirements use `/skill:deep-interview`: a requirements-only workflow that must not mutate product code. Its spec hands off as deep-interview → ralplan consensus → pending approval → separately approved execution.
+- Clear work with non-trivial architecture or sequencing risk uses `/skill:ralplan --deliberate` and stops pending approval.
 - Use `/skill:ultragoal` for durable goal ledgers and `/skill:team` for approved coordinated persistent work.
 - Delegate large implementation slices to `executor`; use `planner`, `architect`, or `critic` for bounded planning and review.
-- Active skills are authoritative: read and follow them; planning and read-only skills do not mutate before approval.
+- Active skills are authoritative: never ignore an invoked skill; read the full skill text and follow it exactly.
+- Before explicit execution approval, planning and interview workflows NEVER edit product source, run mutating shell commands, commit, push, open PRs, or delegate implementation.
 </routing>
 </gjc-runtime>
 {{/unless}}
@@ -206,7 +209,6 @@ Guardrails? None. Restrictions? None. Freedom? Unlimited.
 - **Do your homework first** - Read the files, search, and understand the context before asking
 - **Don’t Stop at Analysis** - Once you’ve assessed the situation, take the next step (session, comment, merge, fix, cleanup) on your own
 - **No Inflating Operational/Meta Issues** - Just because the backlog is empty doesn’t mean you should force operational follow-ups, verifiability checks, or meta issues. Only raise issues for actual repository problems; otherwise, stop.
-- **Practical sufficiency over completeness** - Don’t add logic that preemptively handles edge cases you haven’t actually observed; endless logical completeness loses to practical sufficiency. Extensibility and robustness matter, but they must be observability-based and evidence-based—any engineering without underlying evidence that it’s worth the token and time is over-engineering.
 - **Always maintain execution** - Do not end your turn with just reporting, summarizing, or analyzing. If an action is possible, execute it immediately during the same turn.
 - **Always be in action mode** - The default stance is intervention, not observation. If you see something that needs cleaning up, clean it up; if you see a session that needs opening, open it; if you see a PR that needs blocking, block it; if you see a PR that needs merging, review it and merge it.
 - **No begging for permission** - For obvious follow-up actions (cleaning up sessions, marking items as stale, fixing routing, updating documentation to reflect Doctrine), don’t ask—just do it.

package/src/prompts/tools/cron.md

@@ -1,4 +1,6 @@
-Schedule a prompt to fire on a recurring cron schedule, or one-shot at the next match. Cron tasks let you re-run a prompt automatically on an interval — poll a deployment, babysit a PR, check back on a long-running build, or remind yourself to do something later in the session.
+Schedule a prompt to fire on a recurring cron schedule, or one-shot at the next match. Cron tasks re-run an agent prompt automatically on an interval when every firing is allowed to produce a normal assistant response, such as a reminder or a scheduled status report.
+
+Cron is not a silent polling primitive. Every firing starts an agent turn, and hiding the injected cron message does not hide that turn's assistant response. For ongoing logs, file watching, or PR/CI polling that should report only meaningful state changes, use `monitor` with a script that writes a line only when there is an event to process, and set `persistent: true` so the monitor survives the first emitted event. Do not schedule a cron prompt that asks the agent to suppress routine polls; prompt wording cannot make a cron-triggered assistant turn reliably silent.
 
 Use a single `op` field to select the operation:
 

package/src/prompts/tools/skill-discovery.md

@@ -3,6 +3,7 @@ Discover project and user runtime skills without loading full skill content.
 <instruction>
 - Searches only custom runtime skill locations: nearest project `.gjc/skills`; then, under the home directory, canonical `<config>/agent/skills`, configured legacy `<config>/skills`, and historical legacy `.gjc/skills`. `<config>` is the home-relative directory name from `GJC_CONFIG_DIR`, then `PI_CONFIG_DIR`, then `.gjc`; even an absolute-looking configured name is joined beneath `<home>`. Duplicate names use that exact precedence. Built-in, bundled, and internal workflow skills are intentionally excluded.
 - Returns thin metadata only: name, description, source scope, path, and use conditions when present.
+- When zero candidates are returned because discovery config is disabled (`skills.enabled`, `skills.enablePiProject`, `skills.enablePiUser`), the result carries a `notice` explaining which setting blocked the search — an empty result without a `notice` means the searched scopes genuinely contain no matching skills.
 - To load a selected skill's full `SKILL.md`, invoke it through the existing `skill` tool with the exact `name` returned here.
 </instruction>
 

package/src/runtime-mcp/client.ts

@@ -15,15 +15,12 @@ import type {
 	MCPInitializeParams,
 	MCPInitializeResult,
 	MCPPrompt,
-	MCPPromptsListResult,
 	MCPRequestOptions,
 	MCPResource,
 	MCPResourceReadParams,
 	MCPResourceReadResult,
 	MCPResourceSubscribeParams,
-	MCPResourcesListResult,
 	MCPResourceTemplate,
-	MCPResourceTemplatesListResult,
 	MCPServerCapabilities,
 	MCPServerConfig,
 	MCPServerConnection,
@@ -43,6 +40,9 @@ const PROTOCOL_VERSION = "2025-03-26";
 /** Default connection timeout in ms */
 const CONNECTION_TIMEOUT_MS = 30_000;
 
+const MAX_PAGINATION_PAGES = 100,
+	MAX_PAGINATION_ITEMS = 10_000;
+
 /** Client info sent during initialization */
 const CLIENT_INFO = {
 	name: "gjc-coding-agent",
@@ -109,6 +109,40 @@ function decodeToolsListResult(value: unknown): MCPToolsListResult {
 	return value.nextCursor === undefined ? { tools } : { tools, nextCursor: value.nextCursor };
 }
 
+async function collectPaginated<T>(
+	connection: MCPServerConnection,
+	options: MCPRequestOptions | undefined,
+	method: string,
+	itemKey: string,
+	items: T[],
+	decode?: (value: unknown) => unknown,
+): Promise<void> {
+	const seenCursors = new Set<string>();
+	const failure = (detail: string) => new MCPExpectedFailure(new Error(`MCP ${method} pagination ${detail}`));
+	let cursor: string | undefined;
+	for (let page = 1; page <= MAX_PAGINATION_PAGES; page++) {
+		const value = await connection.transport.request<unknown>(method, cursor ? { cursor } : {}, options);
+		const result = decode ? decode(value) : value;
+		if (
+			!isRecord(result) ||
+			!Array.isArray(result[itemKey]) ||
+			(result.nextCursor !== undefined && typeof result.nextCursor !== "string")
+		)
+			throw new MCPExpectedFailure();
+		const nextCursor = result.nextCursor as string | undefined;
+		if (nextCursor && seenCursors.has(nextCursor)) throw failure("repeated a cursor");
+		const pageItems = result[itemKey] as T[];
+		const itemCount = items.length + pageItems.length;
+		if (itemCount > MAX_PAGINATION_ITEMS || (itemCount === MAX_PAGINATION_ITEMS && nextCursor))
+			throw failure("did not complete within the 10000-item budget");
+		items.push(...pageItems);
+		if (!nextCursor) return;
+		if (page === MAX_PAGINATION_PAGES) throw failure("did not complete within the 100-page budget");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+}
+
 /**
  * Default handler for standard MCP server-to-client requests.
  * Handles `ping` and `roots/list`; rejects unknown methods with -32601.
@@ -292,18 +326,7 @@ export async function listTools(
 	}
 
 	const allTools: MCPToolDefinition[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = decodeToolsListResult(await connection.transport.request<unknown>("tools/list", params, options));
-		allTools.push(...result.tools);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "tools/list", "tools", allTools, decodeToolsListResult);
 
 	// Cache tools
 	connection.tools = allTools;
@@ -362,18 +385,7 @@ export async function listResources(
 	}
 
 	const allResources: MCPResource[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = await connection.transport.request<MCPResourcesListResult>("resources/list", params, options);
-		allResources.push(...result.resources);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "resources/list", "resources", allResources);
 
 	connection.resources = allResources;
 	return allResources;
@@ -395,22 +407,7 @@ export async function listResourceTemplates(
 	}
 
 	const allTemplates: MCPResourceTemplate[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = await connection.transport.request<MCPResourceTemplatesListResult>(
-			"resources/templates/list",
-			params,
-			options,
-		);
-		allTemplates.push(...result.resourceTemplates);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "resources/templates/list", "resourceTemplates", allTemplates);
 
 	connection.resourceTemplates = allTemplates;
 	return allTemplates;
@@ -514,18 +511,7 @@ export async function listPrompts(
 	}
 
 	const allPrompts: MCPPrompt[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = await connection.transport.request<MCPPromptsListResult>("prompts/list", params, options);
-		allPrompts.push(...result.prompts);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "prompts/list", "prompts", allPrompts);
 
 	connection.prompts = allPrompts;
 	return allPrompts;

package/src/runtime-mcp/content-limits.ts

@@ -0,0 +1,71 @@
+export const MCP_MAX_CONTENT_BYTES = 16 * 1024 * 1024;
+export const MCP_MAX_ERROR_BYTES = 16 * 1024;
+export const MCP_MAX_SSE_REQUEST_MESSAGES = 1024;
+export const MCP_MAX_SSE_BATCH_MESSAGES = 1024;
+export const MCP_HTTP_TIMEOUT_MS = 30_000;
+
+function ignoreCancellation(cancel: () => Promise<unknown>): void {
+	try {
+		void cancel().catch(() => {});
+	} catch {}
+}
+
+export function cancelMCPStream(stream: ReadableStream<Uint8Array> | null): void {
+	if (stream) ignoreCancellation(() => stream.cancel());
+}
+
+type ByteReader = Pick<ReadableStreamDefaultReader<Uint8Array>, "read">;
+
+async function readChunk(reader: ByteReader, signal?: AbortSignal) {
+	if (!signal) return reader.read();
+	signal.throwIfAborted();
+	const aborted = Promise.withResolvers<never>();
+	const onAbort = () => aborted.reject(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([reader.read(), aborted.promise]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+
+export async function readMCPResponseText(response: Response, limit: number, truncate = false, signal?: AbortSignal) {
+	const declared = response.headers.get("Content-Length");
+	if (!truncate && declared && /^\d+$/.test(declared) && Number(declared) > limit) {
+		cancelMCPStream(response.body);
+		throw new Error("MCP response exceeds size limit");
+	}
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	let buffer = new Uint8Array(Math.min(limit, 64 * 1024));
+	let total = 0;
+	try {
+		while (true) {
+			const { value, done } = await readChunk(reader, signal);
+			if (done) break;
+			if (value.length === 0) continue;
+			const remaining = limit - total;
+			if (value.length > remaining) {
+				if (truncate && remaining > 0) buffer.set(value.subarray(0, remaining), total);
+				ignoreCancellation(() => reader.cancel());
+				if (!truncate) throw new Error("MCP response exceeds size limit");
+				return `${new TextDecoder().decode(buffer)}\u2026`;
+			}
+			if (total + value.length > buffer.length) {
+				const grown = new Uint8Array(Math.min(limit, Math.max(total + value.length, buffer.length * 2)));
+				grown.set(buffer);
+				buffer = grown;
+			}
+			buffer.set(value, total);
+			total += value.length;
+		}
+		return new TextDecoder().decode(buffer.subarray(0, total));
+	} catch (error) {
+		ignoreCancellation(() => reader.cancel());
+		throw error;
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}

package/src/runtime-mcp/json-rpc.ts

@@ -4,6 +4,8 @@
  * Lightweight utilities for calling MCP servers directly via HTTP
  * without maintaining persistent connections.
  */
+// biome-ignore assist/source/organizeImports: Keep independent MCP security imports on separate merge anchors.
+import { cancelMCPStream, MCP_HTTP_TIMEOUT_MS, MCP_MAX_CONTENT_BYTES, readMCPResponseText } from "./content-limits";
 import { logger } from "@gajae-code/utils";
 
 /** Parse SSE response format (lines starting with "data: ") */
@@ -25,6 +27,15 @@ export function parseSSE(text: string): unknown {
 	}
 }
 
+async function translateMCPTimeout<T>(operation: Promise<T>, signal: AbortSignal): Promise<T> {
+	try {
+		return await operation;
+	} catch (error) {
+		if (signal.aborted && error === signal.reason) throw new Error("MCP request timed out");
+		throw error;
+	}
+}
+
 /** JSON-RPC 2.0 response structure */
 export interface JsonRpcResponse<T = unknown> {
 	jsonrpc: "2.0";
@@ -57,22 +68,25 @@ export async function callMCP<T = unknown>(
 		params: params ?? {},
 	};
 
-	const response = await fetch(url, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Accept: "application/json, text/event-stream",
-		},
-		body: JSON.stringify(body),
-	});
+	const signal = AbortSignal.timeout(MCP_HTTP_TIMEOUT_MS);
+	const response = await translateMCPTimeout(
+		fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+			body: JSON.stringify(body),
+			signal,
+		}),
+		signal,
+	);
 
 	if (!response.ok) {
+		cancelMCPStream(response.body);
 		const errorMsg = `MCP request failed: ${response.status} ${response.statusText}`;
 		logger.error(errorMsg, { url, method, params });
 		throw new Error(errorMsg);
 	}
 
-	const text = await response.text();
+	const text = await translateMCPTimeout(readMCPResponseText(response, MCP_MAX_CONTENT_BYTES, false, signal), signal);
 	const result = parseSSE(text) as JsonRpcResponse<T> | null;
 
 	if (!result) {

package/src/runtime-mcp/manager.ts

@@ -6,12 +6,12 @@
  */
 import * as path from "node:path";
 import * as url from "node:url";
-import type { TSchema } from "@gajae-code/ai";
+import { isCanonicalMCPOAuthBinding, resolveMCPOAuthResourceOrigin, type TSchema } from "@gajae-code/ai";
 import { logger } from "@gajae-code/utils";
 import type { SourceMeta } from "../capability/types";
 import * as configValue from "../config/resolve-config-value";
 import type { CustomTool } from "../extensibility/custom-tools/types";
-import type { AuthStorage } from "../session/auth-storage";
+import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
 import {
 	connectToServer,
 	disconnectServer,
@@ -27,7 +27,6 @@ import {
 	unsubscribeFromResources,
 } from "./client";
 import { loadAllMCPConfigs, validateServerConfig } from "./config";
-import { refreshMCPOAuthToken } from "./oauth-flow";
 import type { MCPToolDetails } from "./tool-bridge";
 import { DeferredMCPTool, MCPTool } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
@@ -1469,64 +1468,63 @@ export class MCPManager {
 		let resolved: MCPServerConfig = { ...config };
 
 		const auth = config.auth;
-		if (auth?.type === "oauth" && auth.credentialId && this.#authStorage) {
+		if (auth?.type === "oauth") {
+			if (!auth.credentialId || !this.#authStorage || (config.type !== "http" && config.type !== "sse")) {
+				throw new MCPExpectedFailure();
+			}
 			const credentialId = auth.credentialId;
 			let credential = this.#authStorage.get(credentialId);
-			if (credential?.type === "oauth") {
-				// Proactive refresh: 5-minute buffer before expiry
-				// Force refresh: on 401/403 auth errors (revoked tokens, clock skew, missing expires)
-				const REFRESH_BUFFER_MS = 5 * 60_000;
-				const shouldRefresh =
-					forceRefresh || (credential.expires && Date.now() >= credential.expires - REFRESH_BUFFER_MS);
-				let refreshedCredential:
-					| {
-							type: "oauth";
-							access: string;
-							refresh: string;
-							expires: number;
-					  }
-					| undefined;
-				if (shouldRefresh && credential.refresh && auth.tokenUrl) {
-					try {
-						const refreshed = await refreshMCPOAuthToken(
-							auth.tokenUrl,
-							credential.refresh,
-							auth.clientId,
-							auth.clientSecret,
-						);
-						refreshedCredential = { type: "oauth", ...refreshed };
-					} catch (error) {
-						if (!(error instanceof MCPExpectedFailure)) throw error;
-						if (this.#toolsOnly) {
-							logger.debug("MCP OAuth refresh failed");
-						} else {
-							logger.warn("MCP OAuth refresh failed, using existing token");
-						}
+			const binding = credential?.type === "oauth" ? credential.mcpBinding : undefined;
+			const endpointOrigin = resolveMCPOAuthResourceOrigin(config.url);
+			if (
+				credential?.type !== "oauth" ||
+				!binding ||
+				!isCanonicalMCPOAuthBinding(binding) ||
+				binding.resourceOrigin !== endpointOrigin ||
+				(auth.tokenUrl !== undefined && auth.tokenUrl !== binding.tokenEndpoint)
+			) {
+				throw new MCPExpectedFailure();
+			}
+
+			// Proactive refresh: 5-minute buffer before expiry
+			// Force refresh: on 401/403 auth errors (revoked tokens, clock skew, missing expires)
+			const REFRESH_BUFFER_MS = 5 * 60_000;
+			const shouldRefresh =
+				forceRefresh || (credential.expires && Date.now() >= credential.expires - REFRESH_BUFFER_MS);
+			if (shouldRefresh && credential.refresh) {
+				let refreshedCredential: OAuthCredential | undefined;
+				try {
+					refreshedCredential = await this.#authStorage.forceRefreshOAuthCredential(credentialId, credential, {
+						clientId: auth.clientId,
+						clientSecret: auth.clientSecret,
+					});
+				} catch {
+					if (forceRefresh) throw new MCPExpectedFailure();
+					if (this.#toolsOnly) {
+						logger.debug("MCP OAuth refresh failed");
+					} else {
+						logger.warn("MCP OAuth refresh failed, using existing token");
 					}
 				}
 				if (refreshedCredential) {
-					await this.#authStorage.set(credentialId, refreshedCredential);
+					const refreshedBinding = refreshedCredential.mcpBinding;
+					if (
+						!refreshedBinding ||
+						refreshedBinding.resourceOrigin !== binding.resourceOrigin ||
+						refreshedBinding.tokenEndpoint !== binding.tokenEndpoint
+					) {
+						throw new MCPExpectedFailure();
+					}
 					credential = refreshedCredential;
 				}
-
-				if (resolved.type === "http" || resolved.type === "sse") {
-					resolved = {
-						...resolved,
-						headers: {
-							...resolved.headers,
-							Authorization: `Bearer ${credential.access}`,
-						},
-					};
-				} else {
-					resolved = {
-						...resolved,
-						env: {
-							...resolved.env,
-							OAUTH_ACCESS_TOKEN: credential.access,
-						},
-					};
-				}
 			}
+			resolved = {
+				...config,
+				headers: {
+					...config.headers,
+					Authorization: `Bearer ${credential.access}`,
+				},
+			};
 		}
 		if (this.#toolsOnly && resolved.type === "stdio") {
 			resolved = { ...resolved, noInheritEnv: true };

package/src/runtime-mcp/oauth-flow.ts

@@ -8,29 +8,10 @@
 import type { OAuthCallbackFlowOptions } from "@gajae-code/ai/utils/oauth/callback-server";
 import { OAuthCallbackFlow } from "@gajae-code/ai/utils/oauth/callback-server";
 import type { OAuthController, OAuthCredentials } from "@gajae-code/ai/utils/oauth/types";
-import { MCPExpectedFailure } from "./types";
 
 const DEFAULT_PORT = 3000;
 const CALLBACK_PATH = "/callback";
 const CALLBACK_BIND_HOSTNAME = "127.0.0.1";
-type RefreshTokenResponse = {
-	access_token: string;
-	refresh_token?: string;
-	expires_in?: number;
-};
-
-function isRefreshTokenResponse(value: unknown): value is RefreshTokenResponse {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const payload = value as Record<string, unknown>;
-	return (
-		typeof payload.access_token === "string" &&
-		payload.access_token.length > 0 &&
-		(payload.refresh_token === undefined || typeof payload.refresh_token === "string") &&
-		(payload.expires_in === undefined ||
-			(typeof payload.expires_in === "number" && Number.isFinite(payload.expires_in) && payload.expires_in >= 0))
-	);
-}
-
 function isLoopbackHostname(hostname: string): boolean {
 	return hostname === "localhost" || hostname === "127.0.0.1";
 }
@@ -384,56 +365,3 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		}
 	}
 }
-
-/**
- * Refresh an MCP OAuth token using the standard refresh_token grant.
- * Returns updated credentials; preserves the old refresh token if the server doesn't rotate it.
- */
-export async function refreshMCPOAuthToken(
-	tokenUrl: string,
-	refreshToken: string,
-	clientId?: string,
-	clientSecret?: string,
-): Promise<OAuthCredentials> {
-	const params = new URLSearchParams({
-		grant_type: "refresh_token",
-		refresh_token: refreshToken,
-	});
-	if (clientId) params.set("client_id", clientId);
-	if (clientSecret) params.set("client_secret", clientSecret);
-
-	let response: Response;
-	try {
-		response = await fetch(tokenUrl, {
-			method: "POST",
-			headers: { "Content-Type": "application/x-www-form-urlencoded" },
-			body: params.toString(),
-		});
-	} catch (error) {
-		throw new MCPExpectedFailure(error);
-	}
-
-	if (!response.ok) {
-		let text: string;
-		try {
-			text = await response.text();
-		} catch (error) {
-			throw new MCPExpectedFailure(error);
-		}
-		throw new MCPExpectedFailure(new Error(`MCP OAuth refresh failed: ${response.status} ${text}`));
-	}
-
-	let data: unknown;
-	try {
-		data = await response.json();
-	} catch {
-		throw new MCPExpectedFailure();
-	}
-	if (!isRefreshTokenResponse(data)) throw new MCPExpectedFailure();
-	const expiresIn = data.expires_in ?? 3600;
-	return {
-		access: data.access_token,
-		refresh: data.refresh_token ?? refreshToken,
-		expires: Date.now() + expiresIn * 1000,
-	};
-}