@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/agent/goals/state.js

@@ -1,80 +0,0 @@
-import { CHECKLIST_ITEM_PENDING, TERMINAL_CHECKLIST_STATUSES } from "./checklist-types.js";
-//#region src/agent/goals/state.ts
-function defaultMaxTurns(cfg) {
-	const n = cfg?.maxTurns;
-	if (typeof n === "number" && Number.isFinite(n)) return Math.max(1, Math.min(500, Math.floor(n)));
-	return 20;
-}
-/** Render checklist for continuation prompt (Hermes-style, no numbers in body). */
-function renderChecklistPlain(items) {
-	if (!items.length) return "(empty)";
-	const lines = [];
-	for (const it of items) {
-		let line = `${it.status === "completed" ? "[x]" : it.status === "impossible" ? "[!]" : "[ ]"} ${it.text}`;
-		if (it.status === "impossible" && it.evidence) line += ` (impossible: ${it.evidence})`;
-		lines.push(line);
-	}
-	return lines.join("\n");
-}
-/** Numbered checklist for judge user prompts (1-based indices). */
-function renderChecklistNumbered(items) {
-	if (!items.length) return "(empty)";
-	const lines = [];
-	for (let i = 0; i < items.length; i++) {
-		const it = items[i];
-		let line = `${i + 1}. ${it.status === "completed" ? "[x]" : it.status === "impossible" ? "[!]" : "[ ]"} ${it.text}`;
-		if (it.status === "impossible" && it.evidence) line += ` (impossible: ${it.evidence})`;
-		lines.push(line);
-	}
-	return lines.join("\n");
-}
-/**
-* After LLM decomposition, keep existing checklist rows (e.g. user-added acceptance criteria)
-* and append judge-generated items, skipping duplicate text (case-insensitive trim).
-*/
-function mergeDecomposedChecklistItems(existing, decomposedTexts) {
-	const now = Date.now();
-	const next = existing.map((it) => ({ ...it }));
-	const seen = new Set(next.map((it) => it.text.trim().toLowerCase()));
-	for (const row of decomposedTexts) {
-		const t = row.text.trim();
-		if (!t) continue;
-		const key = t.toLowerCase();
-		if (seen.has(key)) continue;
-		seen.add(key);
-		next.push({
-			text: t,
-			status: CHECKLIST_ITEM_PENDING,
-			addedBy: "judge",
-			addedAt: now
-		});
-	}
-	return next;
-}
-function applyJudgeChecklistUpdates(items, parsed) {
-	const next = items.map((it) => ({ ...it }));
-	const now = Date.now();
-	for (const upd of parsed.updates) {
-		const idx = upd.index;
-		if (idx < 0 || idx >= next.length) continue;
-		const item = next[idx];
-		if (TERMINAL_CHECKLIST_STATUSES.has(item.status)) continue;
-		if (!TERMINAL_CHECKLIST_STATUSES.has(upd.status)) continue;
-		item.status = upd.status;
-		item.completedAt = now;
-		if (upd.evidence?.trim()) item.evidence = upd.evidence.trim();
-	}
-	for (const ni of parsed.newItems) {
-		const t = ni.text.trim();
-		if (!t) continue;
-		next.push({
-			text: t,
-			status: CHECKLIST_ITEM_PENDING,
-			addedBy: "judge",
-			addedAt: now
-		});
-	}
-	return next;
-}
-//#endregion
-export { applyJudgeChecklistUpdates, defaultMaxTurns, mergeDecomposedChecklistItems, renderChecklistNumbered, renderChecklistPlain };

package/dist/src/agent/lifecycle/progress.d.ts

@@ -1,90 +0,0 @@
-/**
- * Progress Feedback Manager
- *
- * Manages real-time progress feedback for long-running agent tasks.
- * Provides:
- * - Tool/end notifications execution start
- * - Thinking indicators
- * - Progress stage updates
- * - Stream integration for real-time display
- */
-export type ProgressStage = 'thinking' | 'searching' | 'reading' | 'writing' | 'executing' | 'analyzing' | 'idle';
-export interface ProgressUpdate {
-    stage: ProgressStage;
-    detail?: string;
-    toolName?: string;
-    toolArgs?: Record<string, unknown>;
-    timestamp: number;
-}
-export interface ProgressFeedbackConfig {
-    level: 'minimal' | 'normal' | 'verbose';
-    showThinking: boolean;
-    streamToolProgress: boolean;
-    heartbeatEnabled: boolean;
-    heartbeatIntervalMs: number;
-    longTaskThresholdMs: number;
-    showErrorAccumulation: boolean;
-    showRequestLimitWarning: boolean;
-}
-export interface ProgressMessage {
-    type: 'start' | 'update' | 'complete' | 'error' | 'warning' | 'thinking';
-    stage: ProgressStage;
-    message: string;
-    detail?: string;
-    toolName?: string;
-    toolArgs?: Record<string, unknown>;
-}
-export interface ProgressCallbacks {
-    onProgress?: (msg: ProgressMessage) => void;
-    onStreamStart?: (toolName: string, toolArgs: Record<string, unknown>) => void;
-    onStreamUpdate?: (toolName: string, partialResult: string) => void;
-    onStreamEnd?: (toolName: string, result: string, isError: boolean) => void;
-    onThinking?: (thinking: string) => void;
-    onHeartbeat?: (elapsedMs: number, currentStage: ProgressStage) => void;
-}
-export declare class ProgressFeedbackManager {
-    private config;
-    private callbacks;
-    private currentStage;
-    private currentTool;
-    private taskStartTime;
-    private heartbeatTimer?;
-    private streamActive;
-    constructor(config?: Partial<ProgressFeedbackConfig>);
-    setCallbacks(callbacks: ProgressCallbacks): void;
-    startTask(): void;
-    endTask(): void;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private mapToolToStage;
-    private formatToolName;
-    onToolStart(toolName: string, toolArgs?: Record<string, unknown>): void;
-    onToolUpdate(toolName: string, partialResult: unknown): void;
-    onToolEnd(toolName: string, result: unknown, isError?: boolean): void;
-    onThinking(thinking: string): void;
-    onTurnStart(): void;
-    onMessageStart(): void;
-    onMessageUpdate(_content: string): void;
-    onAgentEnd(): void;
-    getCurrentState(): {
-        stage: ProgressStage;
-        tool: string | null;
-        elapsedMs: number;
-    };
-    setConfig(config: Partial<ProgressFeedbackConfig>): void;
-    getStageEmoji(stage: ProgressStage): string;
-    getStageLabel(stage: ProgressStage): string;
-    /**
-     * Notify about accumulated tool errors
-     * Enhanced feedback for tool failures
-     */
-    onToolErrorAccumulated(toolName: string, failureCount: number, maxFailures: number, remainingAttempts?: number): void;
-    /**
-     * Notify about request limit status
-     * Enhanced feedback for approaching/ reaching request limits
-     */
-    onRequestLimitStatus(count: number, limit: number, remaining: number, isWarning: boolean, shouldStop: boolean): void;
-}
-export declare const progressFeedbackManager: ProgressFeedbackManager;
-export declare function formatProgressMessage(msg: ProgressMessage, parseMode?: 'Markdown' | 'HTML'): string;
-export declare function formatHeartbeatMessage(elapsedMs: number, stage: ProgressStage, detail?: string): string;

package/dist/src/agent/lifecycle/progress.js

@@ -1,340 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-//#region src/agent/lifecycle/progress.ts
-init_logger();
-const log = createLogger("ProgressFeedback");
-const DEFAULT_CONFIG = {
-	level: "normal",
-	showThinking: true,
-	streamToolProgress: true,
-	heartbeatEnabled: true,
-	heartbeatIntervalMs: 2e4,
-	longTaskThresholdMs: 3e4,
-	showErrorAccumulation: true,
-	showRequestLimitWarning: true
-};
-const TOOL_STAGE_MAP = {
-	"read": "reading",
-	"read_file": "reading",
-	"read_multiple": "reading",
-	"glob": "reading",
-	"find": "reading",
-	"list_dir": "reading",
-	"ls": "reading",
-	"memory_get": "reading",
-	"curated_memory": "writing",
-	"grep": "searching",
-	"web_search": "searching",
-	"search": "searching",
-	"memory_search": "searching",
-	"session_search": "searching",
-	"find_files": "searching",
-	"web_fetch": "reading",
-	"fetch": "reading",
-	"curl": "reading",
-	"wget": "reading",
-	"write": "writing",
-	"write_file": "writing",
-	"write_multiple": "writing",
-	"edit": "writing",
-	"apply_patch": "writing",
-	"patch": "writing",
-	"create": "writing",
-	"mkdir": "writing",
-	"delete": "writing",
-	"remove": "writing",
-	"bash": "executing",
-	"exec_command": "executing",
-	"update_plan": "thinking",
-	"exec": "executing",
-	"run": "executing",
-	"command": "executing",
-	"node": "executing",
-	"python": "executing",
-	"npm": "executing",
-	"pnpm": "executing",
-	"git": "executing",
-	"docker": "executing",
-	"kubectl": "executing",
-	"message": "idle",
-	"send": "idle",
-	"reply": "idle",
-	"analyze": "analyzing",
-	"compare": "analyzing",
-	"diff": "analyzing",
-	"summarize": "analyzing"
-};
-const STAGE_EMOJI = {
-	"thinking": "🤔",
-	"searching": "🔍",
-	"reading": "📖",
-	"writing": "✍️",
-	"executing": "⚙️",
-	"analyzing": "📊",
-	"idle": "💬"
-};
-const STAGE_LABEL = {
-	"thinking": "Thinking",
-	"searching": "Searching",
-	"reading": "Reading",
-	"writing": "Writing",
-	"executing": "Executing",
-	"analyzing": "Analyzing",
-	"idle": "Ready"
-};
-var ProgressFeedbackManager = class {
-	config;
-	callbacks = {};
-	currentStage = "idle";
-	currentTool = null;
-	taskStartTime = 0;
-	heartbeatTimer;
-	streamActive = false;
-	constructor(config = {}) {
-		this.config = {
-			...DEFAULT_CONFIG,
-			...config
-		};
-	}
-	setCallbacks(callbacks) {
-		this.callbacks = {
-			...this.callbacks,
-			...callbacks
-		};
-	}
-	startTask() {
-		this.taskStartTime = Date.now();
-		if (this.config.heartbeatEnabled) this.startHeartbeat();
-	}
-	endTask() {
-		this.stopHeartbeat();
-		this.currentStage = "idle";
-		this.currentTool = null;
-		this.taskStartTime = 0;
-		this.streamActive = false;
-	}
-	startHeartbeat() {
-		this.stopHeartbeat();
-		this.heartbeatTimer = setInterval(() => {
-			const elapsed = Date.now() - this.taskStartTime;
-			if (elapsed >= this.config.longTaskThresholdMs) this.callbacks.onHeartbeat?.(elapsed, this.currentStage);
-		}, this.config.heartbeatIntervalMs);
-	}
-	stopHeartbeat() {
-		if (this.heartbeatTimer) {
-			clearInterval(this.heartbeatTimer);
-			this.heartbeatTimer = void 0;
-		}
-	}
-	mapToolToStage(toolName) {
-		const normalizedName = toolName.toLowerCase();
-		const toCheck = [normalizedName, normalizedName.replace(/_/g, "")];
-		const sortedKeys = Object.keys(TOOL_STAGE_MAP).sort((a, b) => b.length - a.length);
-		for (const name of toCheck) for (const key of sortedKeys) if (name.includes(key)) return TOOL_STAGE_MAP[key];
-		return "executing";
-	}
-	formatToolName(toolName) {
-		return toolName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-	}
-	onToolStart(toolName, toolArgs = {}) {
-		if (this.config.level === "minimal") return;
-		this.currentTool = toolName;
-		this.currentStage = this.mapToolToStage(toolName);
-		this.streamActive = true;
-		const formattedName = this.formatToolName(toolName);
-		const emoji = STAGE_EMOJI[this.currentStage];
-		const label = STAGE_LABEL[this.currentStage];
-		let detail = "";
-		if (toolArgs.path) detail = `📁 ${toolArgs.path}`;
-		else if (toolArgs.query) detail = `🔎 ${toolArgs.query}`;
-		else if (toolArgs.command) {
-			const cmd = String(toolArgs.command);
-			detail = `⚡ ${cmd.length > 50 ? cmd.slice(0, 50) + "..." : cmd}`;
-		}
-		const message = {
-			type: "start",
-			stage: this.currentStage,
-			message: `${emoji} ${label}: ${formattedName}`,
-			detail: detail || void 0,
-			toolName,
-			toolArgs
-		};
-		if (this.config.level === "verbose" || this.config.streamToolProgress) this.callbacks.onProgress?.(message);
-		this.callbacks.onStreamStart?.(toolName, toolArgs);
-		log.debug({
-			toolName,
-			stage: this.currentStage
-		}, "Tool execution started");
-	}
-	onToolUpdate(toolName, partialResult) {
-		if (this.config.level === "minimal") return;
-		if (!this.streamActive || !this.config.streamToolProgress) return;
-		let displayResult = "";
-		if (typeof partialResult === "string") displayResult = partialResult.slice(0, 200);
-		else if (partialResult && typeof partialResult === "object") {
-			const result = partialResult;
-			if (result.output) displayResult = String(result.output).slice(0, 200);
-			else if (result.content) displayResult = String(result.content).slice(0, 200);
-			else if (result.text) displayResult = String(result.text).slice(0, 200);
-		}
-		this.callbacks.onStreamUpdate?.(toolName, displayResult);
-	}
-	onToolEnd(toolName, result, isError = false) {
-		if (this.config.level === "minimal" && !isError) return;
-		const wasActive = this.streamActive;
-		this.streamActive = false;
-		let resultSummary = "";
-		if (result && typeof result === "object") {
-			const res = result;
-			if (res.content && Array.isArray(res.content)) {
-				const textContent = res.content.find((c) => typeof c === "object" && c !== null && c.type === "text");
-				if (textContent) resultSummary = String(textContent.text || "").slice(0, 100);
-			}
-		}
-		const message = {
-			type: isError ? "error" : "complete",
-			stage: this.currentStage,
-			message: isError ? `❌ Tool failed: ${this.formatToolName(toolName)}` : `✅ Done: ${this.formatToolName(toolName)}`,
-			toolName
-		};
-		if (wasActive) this.callbacks.onStreamEnd?.(toolName, resultSummary, isError);
-		if (isError || this.config.level !== "minimal") this.callbacks.onProgress?.(message);
-		if (this.currentTool === toolName) {
-			this.currentTool = null;
-			this.currentStage = "idle";
-		}
-		log.debug({
-			toolName,
-			isError
-		}, "Tool execution ended");
-	}
-	onThinking(thinking) {
-		if (!this.config.showThinking || this.config.level === "minimal") return;
-		const displayThinking = thinking.length > 100 ? thinking.slice(0, 100) + "..." : thinking;
-		this.callbacks.onThinking?.(displayThinking);
-	}
-	onTurnStart() {
-		if (this.config.level === "minimal") return;
-		this.currentStage = "thinking";
-		this.taskStartTime = Date.now();
-		if (this.config.heartbeatEnabled && !this.heartbeatTimer) this.startHeartbeat();
-	}
-	onMessageStart() {}
-	onMessageUpdate(_content) {}
-	onAgentEnd() {
-		this.endTask();
-	}
-	getCurrentState() {
-		return {
-			stage: this.currentStage,
-			tool: this.currentTool,
-			elapsedMs: this.taskStartTime ? Date.now() - this.taskStartTime : 0
-		};
-	}
-	setConfig(config) {
-		this.config = {
-			...this.config,
-			...config
-		};
-	}
-	getStageEmoji(stage) {
-		return STAGE_EMOJI[stage] || "💬";
-	}
-	getStageLabel(stage) {
-		return STAGE_LABEL[stage] || "Unknown";
-	}
-	/**
-	* Notify about accumulated tool errors
-	* Enhanced feedback for tool failures
-	*/
-	onToolErrorAccumulated(toolName, failureCount, maxFailures, remainingAttempts) {
-		if (!this.config.showErrorAccumulation) return;
-		if (this.config.level === "minimal") return;
-		const remaining = remainingAttempts ?? maxFailures - failureCount;
-		const percentage = failureCount / maxFailures * 100;
-		let message;
-		let type = percentage >= 100 ? "error" : "warning";
-		if (percentage >= 100) message = `❌ ${this.formatToolName(toolName)} has reached maximum failures (${maxFailures}/${maxFailures})`;
-		else if (percentage >= 50) message = `⚠️ ${this.formatToolName(toolName)} failed ${failureCount}/${maxFailures} times`;
-		else message = `⚠️ ${this.formatToolName(toolName)} failed ${failureCount} time${failureCount > 1 ? "s" : ""}`;
-		const progressMsg = {
-			type,
-			stage: "executing",
-			message,
-			detail: remaining > 0 ? `Remaining attempts: ${remaining}` : "Stopping tool execution",
-			toolName
-		};
-		this.callbacks.onProgress?.(progressMsg);
-		const atCap = maxFailures > 0 && failureCount >= maxFailures;
-		const summary = atCap ? `Tool "${toolName}" reached max failures (${failureCount}/${maxFailures})` : `Tool "${toolName}" failures ${failureCount}/${maxFailures} (${remaining} attempt(s) left)`;
-		if (atCap) log.error({
-			toolName,
-			failureCount,
-			maxFailures,
-			remaining
-		}, summary);
-		else log.warn({
-			toolName,
-			failureCount,
-			maxFailures,
-			remaining
-		}, summary);
-	}
-	/**
-	* Notify about request limit status
-	* Enhanced feedback for approaching/ reaching request limits
-	*/
-	onRequestLimitStatus(count, limit, remaining, isWarning, shouldStop) {
-		if (!this.config.showRequestLimitWarning) return;
-		if (this.config.level === "minimal") return;
-		if (!isWarning && !shouldStop) return;
-		const percentage = count / limit * 100;
-		let message;
-		let type = shouldStop ? "error" : "warning";
-		if (shouldStop) message = `❌ Request limit reached (${count}/${limit})`;
-		else if (percentage >= 90) message = `⚠️ Request limit warning (${count}/${limit})`;
-		else message = `⚠️ Approaching request limit (${count}/${limit})`;
-		const progressMsg = {
-			type,
-			stage: "thinking",
-			message,
-			detail: remaining > 0 ? `Remaining requests: ${remaining}` : "Stopping execution"
-		};
-		this.callbacks.onProgress?.(progressMsg);
-		const summary = shouldStop ? `LLM request limit reached (${count}/${limit}); stopping turn` : `LLM request budget ${count}/${limit} (${remaining} left)`;
-		if (shouldStop) log.error({
-			count,
-			limit,
-			remaining,
-			shouldStop
-		}, summary);
-		else log.warn({
-			count,
-			limit,
-			remaining,
-			shouldStop
-		}, summary);
-	}
-};
-const progressFeedbackManager = new ProgressFeedbackManager();
-function formatProgressMessage(msg, parseMode = "HTML") {
-	const emoji = STAGE_EMOJI[msg.stage];
-	if (parseMode === "HTML") {
-		let html = `<b>${emoji} ${msg.message}</b>`;
-		if (msg.detail) html += `\n${msg.detail}`;
-		return html;
-	} else {
-		let md = `**${emoji} ${msg.message}**`;
-		if (msg.detail) md += `\n${msg.detail}`;
-		return md;
-	}
-}
-function formatHeartbeatMessage(elapsedMs, stage, detail) {
-	const seconds = Math.floor(elapsedMs / 1e3);
-	let message = `${STAGE_EMOJI[stage]} Still ${STAGE_LABEL[stage].toLowerCase()}...`;
-	if (detail) message += `\n${detail}`;
-	message += `\n⏱️ ${seconds}s elapsed`;
-	return message;
-}
-//#endregion
-export { ProgressFeedbackManager, formatHeartbeatMessage, formatProgressMessage, progressFeedbackManager };

package/dist/src/agent/mcp/bundle-mcp-materialize.js

@@ -1,183 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_string_coerce, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "../../utils/string-coerce.js";
-import { buildSafeToolName, normalizeReservedToolNames } from "./bundle-mcp-names.js";
-import { setPluginToolMeta } from "./mcp-tool-meta.js";
-import crypto from "node:crypto";
-//#region src/agent/mcp/bundle-mcp-materialize.ts
-init_logger();
-init_string_coerce();
-const log = createLogger("Mcp:Bundle");
-function readMaterializedToolDescription(tool) {
-	const raw = tool;
-	return normalizeOptionalString(raw.description) ?? normalizeOptionalString(raw.label) ?? tool.name;
-}
-function mapBundleMcpToolsForGateway(tools, serverId) {
-	const prefix = `${serverId.trim()}__`;
-	return tools.filter((tool) => tool.name.startsWith(prefix)).map((tool) => ({
-		name: tool.name,
-		shortName: tool.name.slice(prefix.length),
-		description: readMaterializedToolDescription(tool)
-	}));
-}
-async function listBundleMcpServerToolsForGateway(params) {
-	const runtime = await createBundleMcpToolRuntime({
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	try {
-		return mapBundleMcpToolsForGateway(runtime.tools, params.serverId);
-	} finally {
-		await runtime.dispose();
-	}
-}
-function mapBundleMcpResourcesForGateway(resources, serverId) {
-	return resources.filter((resource) => resource.serverName === serverId).map((resource) => ({
-		uri: resource.uri,
-		name: resource.name,
-		title: resource.title,
-		description: resource.description,
-		mimeType: resource.mimeType
-	}));
-}
-function mapBundleMcpPromptsForGateway(prompts, serverId) {
-	return prompts.filter((prompt) => prompt.serverName === serverId).map((prompt) => ({
-		name: prompt.name,
-		title: prompt.title,
-		description: prompt.description,
-		argumentCount: prompt.argumentCount
-	}));
-}
-async function listBundleMcpServerCapabilitiesForGateway(params) {
-	const createRuntime = (await import("./bundle-mcp-runtime.js")).createSessionMcpRuntime;
-	const runtime = createRuntime({
-		sessionId: `bundle-mcp:${crypto.randomUUID()}`,
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	try {
-		const catalog = await runtime.getCatalog();
-		const tools = mapBundleMcpToolsForGateway(await materializeBundleMcpToolsForRun({ runtime }).then(async (toolRuntime) => {
-			try {
-				return toolRuntime.tools;
-			} finally {
-				await toolRuntime.dispose();
-			}
-		}), params.serverId);
-		const resources = mapBundleMcpResourcesForGateway(catalog.resources, params.serverId);
-		const prompts = mapBundleMcpPromptsForGateway(catalog.prompts, params.serverId);
-		return {
-			serverId: params.serverId,
-			toolCount: tools.length,
-			resourceCount: resources.length,
-			promptCount: prompts.length,
-			tools,
-			resources,
-			prompts
-		};
-	} finally {
-		await runtime.dispose();
-	}
-}
-function toAgentToolResult(params) {
-	const content = Array.isArray(params.result.content) ? params.result.content : [];
-	const normalizedContent = content.length > 0 ? content : params.result.structuredContent !== void 0 ? [{
-		type: "text",
-		text: JSON.stringify(params.result.structuredContent, null, 2)
-	}] : [{
-		type: "text",
-		text: JSON.stringify({
-			status: params.result.isError === true ? "error" : "ok",
-			server: params.serverName,
-			tool: params.toolName
-		}, null, 2)
-	}];
-	const details = {
-		mcpServer: params.serverName,
-		mcpTool: params.toolName
-	};
-	if (params.result.structuredContent !== void 0) details.structuredContent = params.result.structuredContent;
-	if (params.result.isError === true) details.status = "error";
-	return {
-		content: normalizedContent,
-		details
-	};
-}
-async function materializeBundleMcpToolsForRun(params) {
-	let disposed = false;
-	const releaseLease = params.runtime.acquireLease?.();
-	params.runtime.markUsed();
-	let catalog;
-	try {
-		catalog = await params.runtime.getCatalog();
-	} catch (error) {
-		releaseLease?.();
-		throw error;
-	}
-	const reservedNames = normalizeReservedToolNames(params.reservedToolNames);
-	const tools = [];
-	const sortedCatalogTools = [...catalog.tools].toSorted((a, b) => {
-		const serverOrder = a.safeServerName.localeCompare(b.safeServerName);
-		if (serverOrder !== 0) return serverOrder;
-		const toolOrder = a.toolName.localeCompare(b.toolName);
-		if (toolOrder !== 0) return toolOrder;
-		return a.serverName.localeCompare(b.serverName);
-	});
-	for (const tool of sortedCatalogTools) {
-		const originalName = tool.toolName.trim();
-		if (!originalName) continue;
-		const safeToolName = buildSafeToolName({
-			serverName: tool.safeServerName,
-			toolName: originalName,
-			reservedNames
-		});
-		if (safeToolName !== `${tool.safeServerName}__${originalName}`) log.warn(`bundle-mcp: tool "${tool.toolName}" from server "${tool.serverName}" registered as "${safeToolName}" to keep the tool name provider-safe.`);
-		reservedNames.add(normalizeLowercaseStringOrEmpty(safeToolName));
-		const agentTool = {
-			name: safeToolName,
-			label: tool.title ?? tool.toolName,
-			description: tool.description || tool.title || tool.fallbackDescription,
-			parameters: tool.inputSchema,
-			execute: async (_toolCallId, input, signal) => {
-				params.runtime.markUsed();
-				const result = await params.runtime.callTool(tool.serverName, tool.toolName, input, signal);
-				return toAgentToolResult({
-					serverName: tool.serverName,
-					toolName: tool.toolName,
-					result
-				});
-			}
-		};
-		setPluginToolMeta(agentTool, {
-			pluginId: "bundle-mcp",
-			optional: false
-		});
-		tools.push(agentTool);
-	}
-	tools.sort((a, b) => a.name.localeCompare(b.name));
-	return {
-		tools,
-		dispose: async () => {
-			if (disposed) return;
-			disposed = true;
-			releaseLease?.();
-			await params.disposeRuntime?.();
-		}
-	};
-}
-async function createBundleMcpToolRuntime(params) {
-	const runtime = (params.createRuntime ?? (await import("./bundle-mcp-runtime.js")).createSessionMcpRuntime)({
-		sessionId: `bundle-mcp:${crypto.randomUUID()}`,
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	return await materializeBundleMcpToolsForRun({
-		runtime,
-		reservedToolNames: params.reservedToolNames,
-		disposeRuntime: async () => {
-			await runtime.dispose();
-		}
-	});
-}
-//#endregion
-export { createBundleMcpToolRuntime, listBundleMcpServerCapabilitiesForGateway, listBundleMcpServerToolsForGateway, mapBundleMcpToolsForGateway, materializeBundleMcpToolsForRun };

package/dist/src/agent/mcp/mcp-tool-meta.d.ts

@@ -1,8 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-export type McpToolMeta = {
-    pluginId: string;
-    optional?: boolean;
-};
-export declare function setPluginToolMeta(tool: AgentTool, meta: McpToolMeta): void;
-export declare function getPluginToolMeta(tool: AgentTool): McpToolMeta | undefined;
-export declare function isBundleMcpTool(tool: AgentTool): boolean;