@xopcai/xopc 0.0.187 → 0.0.189

package/dist/src/agent/feedback/feedback-coordinator.d.ts

@@ -1,73 +0,0 @@
-/**
- * Feedback Coordinator - Coordinates all feedback mechanisms
- *
- * Unifies progress feedback, stream updates, and direct messages
- * into a single coherent feedback system.
- */
-import type { MessageBus } from '../../infra/bus/index.js';
-import type { SessionContext } from '../session/session-context.js';
-import type { ProgressFeedbackManager, ProgressStage } from '../lifecycle/progress.js';
-import type { StreamHandle } from '../messaging/stream-manager.js';
-export interface FeedbackCoordinatorConfig {
-    progressManager: ProgressFeedbackManager;
-    bus: MessageBus;
-}
-export declare class FeedbackCoordinator {
-    private progressManager;
-    private bus;
-    private currentStreamHandle;
-    private currentContext;
-    constructor(config: FeedbackCoordinatorConfig);
-    /**
-     * Set the current context for feedback
-     */
-    setContext(context: SessionContext): void;
-    /**
-     * Clear the current context
-     */
-    clearContext(): void;
-    /**
-     * Start a task and initialize feedback
-     */
-    startTask(): void;
-    /**
-     * End a task and cleanup feedback
-     */
-    endTask(): void;
-    /**
-     * Set the stream handle for progress updates
-     */
-    setStreamHandle(handle: StreamHandle): void;
-    /**
-     * Clear the stream handle
-     */
-    clearStreamHandle(): void;
-    /**
-     * Send progress message via stream or direct message
-     */
-    private sendProgressMessage;
-    /**
-     * Send heartbeat for long-running tasks
-     */
-    private sendHeartbeat;
-    /**
-     * Map tool name to progress stage
-     */
-    private getToolStage;
-    /**
-     * Update progress via stream
-     */
-    updateProgress(text: string, stage: ProgressStage, detail?: string): void;
-    /**
-     * Set progress stage
-     */
-    setProgress(stage: ProgressStage, detail?: string): void;
-    /**
-     * Send a direct message to the current context
-     */
-    sendMessage(content: string): Promise<void>;
-    /**
-     * Get the progress manager instance
-     */
-    getProgressManager(): ProgressFeedbackManager;
-}

package/dist/src/agent/feedback/feedback-coordinator.js

@@ -1,156 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { formatHeartbeatMessage, formatProgressMessage } from "../lifecycle/progress.js";
-//#region src/agent/feedback/feedback-coordinator.ts
-init_logger();
-const log = createLogger("FeedbackCoordinator");
-var FeedbackCoordinator = class {
-	progressManager;
-	bus;
-	currentStreamHandle = null;
-	currentContext = null;
-	constructor(config) {
-		this.progressManager = config.progressManager;
-		this.bus = config.bus;
-	}
-	/**
-	* Set the current context for feedback
-	*/
-	setContext(context) {
-		this.currentContext = context;
-	}
-	/**
-	* Clear the current context
-	*/
-	clearContext() {
-		this.currentContext = null;
-	}
-	/**
-	* Start a task and initialize feedback
-	*/
-	startTask() {
-		this.progressManager.startTask();
-	}
-	/**
-	* End a task and cleanup feedback
-	*/
-	endTask() {
-		this.progressManager.endTask();
-		this.clearStreamHandle();
-	}
-	/**
-	* Set the stream handle for progress updates
-	*/
-	setStreamHandle(handle) {
-		this.currentStreamHandle = handle;
-		if (handle) this.progressManager.setCallbacks({
-			onProgress: (msg) => this.sendProgressMessage(msg),
-			onStreamStart: (toolName, toolArgs) => {
-				const stage = this.getToolStage(toolName);
-				if (this.currentStreamHandle?.setProgress) {
-					let detail;
-					if (toolArgs.path) detail = String(toolArgs.path);
-					else if (toolArgs.command) {
-						const cmd = String(toolArgs.command);
-						detail = cmd.length > 30 ? cmd.slice(0, 30) + "..." : cmd;
-					}
-					this.currentStreamHandle.setProgress(stage, detail);
-				}
-			},
-			onStreamEnd: () => {
-				if (this.currentStreamHandle?.setProgress) this.currentStreamHandle.setProgress("idle");
-			},
-			onHeartbeat: (elapsedMs, stage) => {
-				this.sendHeartbeat(elapsedMs, stage);
-			}
-		});
-	}
-	/**
-	* Clear the stream handle
-	*/
-	clearStreamHandle() {
-		this.currentStreamHandle = null;
-	}
-	/**
-	* Send progress message via stream or direct message
-	*/
-	async sendProgressMessage(msg) {
-		if (!this.currentContext) return;
-		if (this.currentStreamHandle?.updateProgress && msg.stage !== "idle") this.currentStreamHandle.updateProgress("", msg.stage, msg.message);
-		else if (msg.type === "error") {
-			const formatted = formatProgressMessage(msg);
-			await this.bus.publishOutbound({
-				channel: this.currentContext.channel,
-				chat_id: this.currentContext.chatId,
-				content: formatted,
-				type: "message"
-			});
-		}
-	}
-	/**
-	* Send heartbeat for long-running tasks
-	*/
-	async sendHeartbeat(elapsedMs, stage) {
-		if (!this.currentContext) return;
-		log.info({
-			elapsedMs,
-			stage
-		}, "Progress heartbeat");
-		const formatted = formatHeartbeatMessage(elapsedMs, stage);
-		await this.bus.publishOutbound({
-			channel: this.currentContext.channel,
-			chat_id: this.currentContext.chatId,
-			content: formatted,
-			type: "message"
-		});
-	}
-	/**
-	* Map tool name to progress stage
-	*/
-	getToolStage(toolName) {
-		const name = toolName.toLowerCase();
-		if (name.includes("read") || name.includes("file")) return "reading";
-		if (name.includes("search") || name.includes("grep") || name.includes("web")) return "searching";
-		if (name.includes("write") || name.includes("edit")) return "writing";
-		if (name.includes("bash") || name.includes("shell") || name.includes("exec")) return "executing";
-		return "executing";
-	}
-	/**
-	* Update progress via stream
-	*/
-	updateProgress(text, stage, detail) {
-		if (this.currentStreamHandle?.updateProgress) this.currentStreamHandle.updateProgress(text, stage, detail);
-	}
-	/**
-	* Set progress stage
-	*/
-	setProgress(stage, detail) {
-		if (this.currentStreamHandle?.setProgress) this.currentStreamHandle.setProgress(stage, detail);
-	}
-	/**
-	* Send a direct message to the current context
-	*/
-	async sendMessage(content) {
-		if (!this.currentContext) {
-			log.warn({
-				hasStreamHandle: Boolean(this.currentStreamHandle),
-				contentPreview: content.slice(0, 80)
-			}, "Outbound message skipped: no session context (setContext not called or cleared)");
-			return;
-		}
-		await this.bus.publishOutbound({
-			channel: this.currentContext.channel,
-			chat_id: this.currentContext.chatId,
-			content,
-			type: "message"
-		});
-	}
-	/**
-	* Get the progress manager instance
-	*/
-	getProgressManager() {
-		return this.progressManager;
-	}
-};
-//#endregion
-export { FeedbackCoordinator };

package/dist/src/agent/feedback/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Feedback Layer - Exports all feedback-related modules
- */
-export { FeedbackCoordinator, type FeedbackCoordinatorConfig } from './feedback-coordinator.js';

package/dist/src/agent/feedback/index.js

@@ -1,2 +0,0 @@
-import { FeedbackCoordinator } from "./feedback-coordinator.js";
-export { FeedbackCoordinator };

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,339 +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",
-	"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 };