@gajae-code/coding-agent 0.7.10 → 0.8.0

package/src/web/search/providers/duckduckgo.ts

@@ -196,7 +196,7 @@ async function fetchAndParse(
 			"Accept-Language": "en-US,en;q=0.9",
 		},
 		body,
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	// DuckDuckGo signals soft blocks with 202 (which is still response.ok).

package/src/web/search/providers/exa.ts

@@ -115,7 +115,7 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 			"x-api-key": apiKey,
 		},
 		body: JSON.stringify(body),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/gemini.ts

@@ -29,7 +29,11 @@ const ANTIGRAVITY_ENDPOINT_FALLBACKS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_
 const DEFAULT_MODEL = "gemini-2.5-flash";
 const MAX_RETRIES = 3;
 const BASE_DELAY_MS = 1000;
-const RATE_LIMIT_BUDGET_MS = 5 * 60 * 1000;
+// Retry-delay ceiling for 429/5xx. The web_search chain always terminates in
+// the keyless DuckDuckGo fallback, so a rate-limited Gemini should fail
+// through in seconds instead of parking the chain behind long server-provided
+// retry delays (previously a 5-minute budget).
+const RATE_LIMIT_BUDGET_MS = 30 * 1000;
 
 const GEMINI_PROVIDERS = ["google-gemini-cli", "google-antigravity"] as const;
 type GeminiProviderId = (typeof GEMINI_PROVIDERS)[number];
@@ -230,7 +234,7 @@ async function callGeminiSearch(
 			...headers,
 		},
 		body: JSON.stringify(requestBody),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "llm"),
 	});
 	const urlFor = (attempt: number) =>
 		`${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`;
@@ -466,7 +470,7 @@ async function searchGeminiViaGenerativeLanguage(params: SearchParams): Promise<
 		method: "POST",
 		headers: { ...(ctx.headers ?? {}), "x-goog-api-key": apiKey, "Content-Type": "application/json" },
 		body: JSON.stringify(body),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "llm"),
 	});
 	const text = await response.text();
 	if (!response.ok) {

package/src/web/search/providers/jina.ts

@@ -41,7 +41,7 @@ async function callJinaSearch(apiKey: string, query: string, signal?: AbortSigna
 			Accept: "application/json",
 			Authorization: `Bearer ${apiKey}`,
 		},
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/kimi.ts

@@ -19,6 +19,11 @@ const KIMI_SEARCH_URL = "https://api.kimi.com/coding/v1/search";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 20;
 const DEFAULT_TIMEOUT_SECONDS = 30;
+// Local hard ceiling aligned with the upstream `timeout_seconds` request budget
+// (plus transport headroom) instead of the generic 15s "api" class: Kimi
+// legitimately runs search + page crawling up to its advertised 30s window,
+// and aborting earlier would discard valid in-budget responses.
+const KIMI_HARD_TIMEOUT_MS = (DEFAULT_TIMEOUT_SECONDS + 5) * 1000;
 
 export interface KimiSearchParams {
 	query: string;
@@ -87,7 +92,7 @@ async function callKimiSearch(
 			enable_page_crawling: params.includeContent,
 			timeout_seconds: DEFAULT_TIMEOUT_SECONDS,
 		}),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, KIMI_HARD_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/openai-compatible.ts

@@ -134,7 +134,7 @@ export class OpenAICompatibleSearchProvider extends SearchProvider {
 				method: "POST",
 				headers,
 				body: JSON.stringify(payload),
-				signal: withHardTimeout(params.signal),
+				signal: withHardTimeout(params.signal, "llm"),
 			});
 
 		// Web search is a Responses-API capability: many OpenAI-compatible

package/src/web/search/providers/parallel.ts

@@ -139,7 +139,7 @@ async function searchWithAuthStorage(
 				max_chars_per_result: 10_000,
 			},
 		}),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 	if (!response.ok) {
 		throw parseParallelErrorResponse(response.status, await response.text());

package/src/web/search/providers/perplexity.ts

@@ -251,7 +251,7 @@ async function callPerplexityApi(
 			"Content-Type": "application/json",
 		},
 		body: JSON.stringify(request),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "llm"),
 	});
 
 	if (!response.ok) {
@@ -370,7 +370,7 @@ async function callPerplexityOAuth(
 				skip_search_enabled: true,
 			},
 		}),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "llm"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/searxng.ts

@@ -214,7 +214,7 @@ async function callSearXNGSearch(
 
 	const response = await fetch(url, {
 		headers,
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/synthetic.ts

@@ -47,7 +47,7 @@ async function callSyntheticSearch(
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify({ query }),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/tavily.ts

@@ -96,7 +96,7 @@ async function callTavilySearch(apiKey: string, params: TavilySearchParams): Pro
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify(buildRequestBody(params)),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/utils.ts

@@ -44,38 +44,81 @@ export function findCredential(
 }
 
 /**
- * Default hard ceiling for a single web-search round-trip. 300s tolerates
- * legitimate slow LLM-mediated responses (anthropic web_search_20250305,
- * perplexity, gemini, OpenAI code backend) while still guaranteeing the session unfreezes
- * if Bun's `AbortSignal` fails to propagate on Windows.
- *
- * Pure search APIs (brave, exa, jina, tavily, searxng, synthetic, zai)
- * settle far faster in practice; reusing the same ceiling keeps the wiring
- * uniform without compromising correctness.
+ * Legacy hard ceiling for a single web-search round-trip, retained as the
+ * fallback for call sites that do not declare a timeout class. 300s tolerates
+ * pathological cases while still guaranteeing the session unfreezes if Bun's
+ * `AbortSignal` fails to propagate on Windows.
  */
 export const SEARCH_HARD_TIMEOUT_MS = 300_000;
 
+/**
+ * Hard ceiling for pure search APIs (brave, exa, jina, tavily, kagi,
+ * parallel, searxng, synthetic, zai, duckduckgo). These settle in ~1-3s in
+ * practice; a hung TCP/TLS connection should fall through to the next
+ * provider in seconds, not minutes. Kimi is the exception: it declares an
+ * explicit ceiling aligned with its upstream 30s request budget.
+ */
+export const SEARCH_API_TIMEOUT_MS = 15_000;
+
+/**
+ * Hard ceiling for LLM-mediated search providers (anthropic, codex, gemini,
+ * perplexity, xai, openai-compatible). These legitimately take tens of
+ * seconds because a model performs the search and synthesizes an answer.
+ */
+export const SEARCH_LLM_TIMEOUT_MS = 120_000;
+
+/** Timeout class a provider declares for its outbound round-trips. */
+export type SearchTimeoutClass = "api" | "llm";
+
+const TIMEOUT_CLASS_MS: Record<SearchTimeoutClass, number> = {
+	api: SEARCH_API_TIMEOUT_MS,
+	llm: SEARCH_LLM_TIMEOUT_MS,
+};
+
 /**
  * Runtime-configurable hard timeout, seeded from the `web_search.timeout`
- * setting via {@link setSearchHardTimeoutMs}. Falls back to
- * {@link SEARCH_HARD_TIMEOUT_MS} when unset or invalid.
+ * setting via {@link setSearchHardTimeoutMs}. When set, it overrides every
+ * class default so users keep a single knob. Unset means class defaults apply.
  */
-let configuredHardTimeoutMs = SEARCH_HARD_TIMEOUT_MS;
+let configuredHardTimeoutMs: number | undefined;
 
 /**
  * Override the hard timeout applied to every web-search round-trip.
  *
  * @param ms - Hard timeout in milliseconds. Non-finite or non-positive
- *   values reset the timeout to {@link SEARCH_HARD_TIMEOUT_MS}.
+ *   values clear the override so per-class defaults apply.
  */
 export function setSearchHardTimeoutMs(ms: number | undefined): void {
-	configuredHardTimeoutMs = typeof ms === "number" && Number.isFinite(ms) && ms > 0 ? ms : SEARCH_HARD_TIMEOUT_MS;
+	configuredHardTimeoutMs = typeof ms === "number" && Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+
+/** Structural settings source for {@link applyConfiguredSearchTimeout}. */
+export interface SearchTimeoutSettingSource {
+	get(path: "web_search.timeout"): unknown;
+	has(path: "web_search.timeout"): boolean;
+}
+
+/**
+ * Install the `web_search.timeout` override from settings — but only when the
+ * user explicitly configured it. The settings schema ships a default value
+ * (300), and consuming that default via `get()` alone would reinstall a
+ * uniform 300s ceiling on every session, silently disabling the per-class
+ * timeout defaults. `has()` distinguishes loaded/overridden settings from
+ * schema defaults; unset clears any previous override so class defaults apply.
+ */
+export function applyConfiguredSearchTimeout(settings: SearchTimeoutSettingSource): void {
+	if (!settings.has("web_search.timeout")) {
+		setSearchHardTimeoutMs(undefined);
+		return;
+	}
+	const value = settings.get("web_search.timeout");
+	setSearchHardTimeoutMs(typeof value === "number" && Number.isFinite(value) && value > 0 ? value * 1000 : undefined);
 }
 
 /**
  * Compose a caller-supplied {@link AbortSignal} with a hard timeout so an
- * outbound `fetch()` is guaranteed to settle within `ms` even when the
- * runtime fails to propagate cancellation to the underlying transport.
+ * outbound `fetch()` is guaranteed to settle even when the runtime fails to
+ * propagate cancellation to the underlying transport.
  *
  * Bun's WinHTTP backend on Windows is known to ignore `AbortSignal` once a
  * TCP/TLS connection stalls (oven-sh/bun#15275, oven-sh/bun#18536); without
@@ -83,9 +126,16 @@ export function setSearchHardTimeoutMs(ms: number | undefined): void {
  * because the user's Esc is never delivered to the native layer.
  *
  * @param signal - Caller cancellation signal, if any.
- * @param ms - Hard timeout in milliseconds. Defaults to the configured value.
+ * @param msOrClass - Explicit timeout in milliseconds, or a
+ *   {@link SearchTimeoutClass} resolved to its class default. Omitted falls
+ *   back to the legacy {@link SEARCH_HARD_TIMEOUT_MS} ceiling. A user-set
+ *   `web_search.timeout` overrides class defaults (but not explicit ms).
  */
-export function withHardTimeout(signal: AbortSignal | undefined, ms: number = configuredHardTimeoutMs): AbortSignal {
+export function withHardTimeout(signal: AbortSignal | undefined, msOrClass?: number | SearchTimeoutClass): AbortSignal {
+	const ms =
+		typeof msOrClass === "number"
+			? msOrClass
+			: (configuredHardTimeoutMs ?? (msOrClass ? TIMEOUT_CLASS_MS[msOrClass] : SEARCH_HARD_TIMEOUT_MS));
 	const timeout = AbortSignal.timeout(ms);
 	return signal ? AbortSignal.any([signal, timeout]) : timeout;
 }

package/src/web/search/providers/xai.ts

@@ -441,7 +441,7 @@ export async function searchXai(params: XaiSearchParams): Promise<SearchResponse
 				noInlineCitations: params.no_inline_citations,
 			}),
 		),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "llm"),
 	});
 
 	const text = await response.text();

package/src/web/search/providers/zai.ts

@@ -79,7 +79,7 @@ async function callZaiTool(apiKey: string, args: Record<string, unknown>, signal
 				arguments: args,
 			},
 		}),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/workflow/workflow-intent-diff.ts

@@ -0,0 +1,199 @@
+export const WORKFLOW_INTENT_DIFF_CUSTOM_TYPE = "workflow-intent-diff";
+
+export type WorkflowIntentRoute = "direct" | "deep-interview" | "ralplan" | "ultragoal" | "team";
+export type DirectTrackingMode = "custom-entry-only" | "not-direct";
+export type RootCausePhaseStatus = "active" | "inactive";
+
+export interface WorkflowIntentDiff {
+	readonly version: 1;
+	readonly route: WorkflowIntentRoute;
+	readonly reason: string;
+	readonly directTracking: DirectTrackingMode;
+	readonly recommendedSkill?: Exclude<WorkflowIntentRoute, "direct">;
+	readonly recommendedInvocation?: string;
+	readonly triggers: readonly string[];
+	readonly rootCausePhase: {
+		readonly status: RootCausePhaseStatus;
+		readonly triggers: readonly string[];
+	};
+	readonly promptPreview: string;
+}
+
+interface RouteMatch {
+	readonly route: WorkflowIntentRoute;
+	readonly reason: string;
+	readonly recommendedInvocation?: string;
+	readonly triggers: readonly string[];
+}
+
+const PROMPT_PREVIEW_LIMIT = 240;
+
+const DURABLE_TRACKING_PATTERNS = [
+	/\bultragoal\b/i,
+	/\bdurable (?:goal|tracking|ledger|plan)\b/i,
+	/\b(?:goal|tracking|plan) ledger\b/i,
+	/\bcheckpoint(?:ed|ing)? (?:goal|plan|workflow|release|work)\b/i,
+	/\bcheckpoint (?:this|the) (?:goal|plan|workflow|release|work)\b/i,
+] as const;
+
+const AMBIGUOUS_REQUIREMENT_PATTERNS = [
+	/\bambiguous (?:requirement|requirements|request|requests|scope)\b/i,
+	/\bdeep[- ]interview\b/i,
+	/\binterview me\b/i,
+	/\bdon't assume\b/i,
+	/\bnot sure\b/i,
+	/\bunclear\b/i,
+	/\bvague\b/i,
+] as const;
+
+const ARCHITECTURE_SEQUENCE_PATTERNS = [
+	/\barchitecture\b/i,
+	/\barchitectural\b/i,
+	/\bsequence\b/i,
+	/\bmigrate\b/i,
+	/\bmigration\b/i,
+	/\bauth(?:entication|orization)? (?:migration|sequence|rollout|release|refactor|rewrite|transition)\b/i,
+	/\bsecurity\b/i,
+	/\bcompliance\b/i,
+	/\bPII\b/i,
+	/\bproduction (?:release|rollout|deployment|migration|incident|data|change|cutover)\b/i,
+	/\bdeploy(?:ing)? to production\b/i,
+	/\bbreaking change\b/i,
+	/\bdata loss\b/i,
+	/\bdestructive\b/i,
+] as const;
+
+const TEAM_PATTERNS = [
+	/\buse (?:a )?team\b/i,
+	/\bcoordinated (?:persistent )?workers\b/i,
+	/\bpersistent workers\b/i,
+	/\bworker coordination\b/i,
+] as const;
+
+const ROOT_CAUSE_TRIGGERS = [
+	{ name: "contradiction", pattern: /\bcontradict(?:ion|s|ory)?\b/i },
+	{ name: "regression", pattern: /\bregression\b/i },
+	{
+		name: "high-risk transition",
+		pattern:
+			/\b(?:migrate|migration|auth(?:entication|orization)? (?:migration|sequence|rollout|release|refactor|rewrite|transition)|security|breaking change|data loss|destructive|production (?:release|rollout|deployment|migration|incident|data|change|cutover)|deploy(?:ing)? to production|compliance|PII)\b/i,
+	},
+] as const;
+
+function matchesAny(text: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some(pattern => pattern.test(text));
+}
+
+function withGlobal(pattern: RegExp): RegExp {
+	const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+	return new RegExp(pattern.source, flags);
+}
+
+function isNegatedAt(text: string, index: number): boolean {
+	const prefix = text.slice(Math.max(0, index - 48), index).toLowerCase();
+	const boundary = Math.max(
+		prefix.lastIndexOf("."),
+		prefix.lastIndexOf(","),
+		prefix.lastIndexOf(";"),
+		prefix.lastIndexOf(":"),
+		prefix.lastIndexOf("?"),
+		prefix.lastIndexOf("!"),
+		prefix.lastIndexOf("\n"),
+		prefix.lastIndexOf(" but "),
+		prefix.lastIndexOf(" however "),
+		prefix.lastIndexOf(" yet "),
+		prefix.lastIndexOf(" then "),
+	);
+	const localPrefix = boundary >= 0 ? prefix.slice(boundary + 1) : prefix;
+	return /(?:^|[\s([{])(?:no|not|without|excluding|exclude|absent|absence of|avoid)\b[^.,!?;:\n]{0,48}$/.test(
+		localPrefix,
+	);
+}
+
+function matchesAnyNonNegated(text: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some(pattern => {
+		for (const match of text.matchAll(withGlobal(pattern))) {
+			if (!isNegatedAt(text, match.index ?? 0)) return true;
+		}
+		return false;
+	});
+}
+
+function collectRootCauseTriggers(text: string): readonly string[] {
+	return ROOT_CAUSE_TRIGGERS.filter(trigger => matchesAnyNonNegated(text, [trigger.pattern])).map(
+		trigger => trigger.name,
+	);
+}
+
+function buildPromptPreview(text: string): string {
+	const compact = text.replace(/\s+/g, " ").trim();
+	return compact.length > PROMPT_PREVIEW_LIMIT ? `${compact.slice(0, PROMPT_PREVIEW_LIMIT - 3)}...` : compact;
+}
+
+function classifyRoute(text: string): RouteMatch {
+	if (matchesAny(text, AMBIGUOUS_REQUIREMENT_PATTERNS)) {
+		return {
+			route: "deep-interview",
+			reason: "ambiguous requirements need clarification",
+			recommendedInvocation: "/skill:deep-interview",
+			triggers: ["ambiguous requirements"],
+		};
+	}
+
+	if (matchesAny(text, DURABLE_TRACKING_PATTERNS)) {
+		return {
+			route: "ultragoal",
+			reason: "durable tracking requested",
+			recommendedInvocation: "/skill:ultragoal",
+			triggers: ["durable tracking"],
+		};
+	}
+
+	if (matchesAnyNonNegated(text, ARCHITECTURE_SEQUENCE_PATTERNS)) {
+		return {
+			route: "ralplan",
+			reason: "architecture or sequence risk requires deliberate planning",
+			recommendedInvocation: "/skill:ralplan --deliberate",
+			triggers: ["architecture/sequence risk"],
+		};
+	}
+
+	if (matchesAny(text, TEAM_PATTERNS)) {
+		return {
+			route: "team",
+			reason: "coordinated persistent workers requested",
+			recommendedInvocation: "/skill:team",
+			triggers: ["coordinated workers"],
+		};
+	}
+
+	return {
+		route: "direct",
+		reason: "clear low-risk prompt stays on direct implementation path",
+		triggers: ["low-risk direct"],
+	};
+}
+
+export function buildWorkflowIntentDiff(text: string): WorkflowIntentDiff | null {
+	const promptPreview = buildPromptPreview(text);
+	if (!promptPreview) return null;
+
+	const route = classifyRoute(text);
+	const rootCauseTriggers = collectRootCauseTriggers(text);
+	const rootCauseActive = rootCauseTriggers.length > 0;
+	const direct = route.route === "direct";
+
+	return {
+		version: 1,
+		route: route.route,
+		reason: route.reason,
+		directTracking: direct ? "custom-entry-only" : "not-direct",
+		...(direct ? {} : { recommendedSkill: route.route, recommendedInvocation: route.recommendedInvocation }),
+		triggers: route.triggers,
+		rootCausePhase: {
+			status: rootCauseActive ? "active" : "inactive",
+			triggers: rootCauseTriggers,
+		},
+		promptPreview,
+	};
+}

package/dist/types/discovery/vscode.d.ts

@@ -1 +0,0 @@
-export {};

package/src/discovery/vscode.ts

@@ -1,105 +0,0 @@
-/**
- * VS Code Provider
- *
- * Loads config from `.vscode` directory (project-only).
- * Supports MCP server discovery from `mcp.json` with nested `mcp.servers` structure.
- */
-import { tryParseJson } from "@gajae-code/utils";
-import { registerProvider } from "../capability";
-import { readFile } from "../capability/fs";
-import { type MCPServer, mcpCapability } from "../capability/mcp";
-import type { LoadContext, LoadResult } from "../capability/types";
-import { createSourceMeta, expandEnvVarsDeep, getProjectPath } from "./helpers";
-
-const PROVIDER_ID = "vscode";
-const DISPLAY_NAME = "VS Code";
-const PRIORITY = 20;
-
-// =============================================================================
-// MCP Servers
-// =============================================================================
-
-registerProvider<MCPServer>(mcpCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load MCP servers from .vscode/mcp.json",
-	priority: PRIORITY,
-	async load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
-		const items: MCPServer[] = [];
-		const warnings: string[] = [];
-
-		// Project-only (VS Code doesn't support user-level MCP config)
-		const projectPath = getProjectPath(ctx, "vscode", "mcp.json");
-		if (projectPath) {
-			const result = await loadMCPConfig(ctx, projectPath, "project");
-			items.push(...result.items);
-			if (result.warnings) warnings.push(...result.warnings);
-		}
-
-		return { items, warnings };
-	},
-});
-
-/**
- * Load MCP servers from a mcp.json file.
- * VS Code uses nested structure: { "mcp": { "servers": { ... } } }
- */
-async function loadMCPConfig(
-	_ctx: LoadContext,
-	path: string,
-	level: "user" | "project",
-): Promise<LoadResult<MCPServer>> {
-	const items: MCPServer[] = [];
-	const warnings: string[] = [];
-
-	const content = await readFile(path);
-	if (!content) {
-		warnings.push(`Failed to read ${path}`);
-		return { items, warnings };
-	}
-
-	const parsed = tryParseJson<{ mcp?: { servers?: Record<string, unknown> } }>(content);
-	if (!parsed) {
-		warnings.push(`Invalid JSON in ${path}`);
-		return { items, warnings };
-	}
-
-	// VS Code uses nested structure: mcp.servers
-	const servers = parsed.mcp?.servers;
-	if (!servers || typeof servers !== "object") {
-		return { items, warnings };
-	}
-
-	for (const [name, config] of Object.entries(servers)) {
-		if (!config || typeof config !== "object") {
-			warnings.push(`Invalid config for server "${name}" in ${path}`);
-			continue;
-		}
-
-		const raw = config as Record<string, unknown>;
-
-		// Expand environment variables
-		const expanded = expandEnvVarsDeep(raw);
-
-		const server: MCPServer = {
-			name,
-			command: typeof expanded.command === "string" ? expanded.command : undefined,
-			args: Array.isArray(expanded.args) ? (expanded.args as string[]) : undefined,
-			env: expanded.env && typeof expanded.env === "object" ? (expanded.env as Record<string, string>) : undefined,
-			url: typeof expanded.url === "string" ? expanded.url : undefined,
-			headers:
-				expanded.headers && typeof expanded.headers === "object"
-					? (expanded.headers as Record<string, string>)
-					: undefined,
-			transport: ["stdio", "sse", "http"].includes(expanded.transport as string)
-				? (expanded.transport as "stdio" | "sse" | "http")
-				: undefined,
-			timeout: typeof expanded.timeout === "number" ? expanded.timeout : undefined,
-			_source: createSourceMeta(PROVIDER_ID, path, level),
-		};
-
-		items.push(server);
-	}
-
-	return { items, warnings };
-}