jeopi-cli 16.6.12 → 16.6.13

package/src/messenger/activity.ts

@@ -0,0 +1,24 @@
+import type { AgentSessionEvent } from "../session/agent-session";
+import type { MessengerActivityReporter } from "./types";
+
+/**
+ * Derive one-line progress from session events: the model's declared tool intent (falling back to the
+ * tool name) and long-running lifecycle notices. Raw tool arguments, results and errors never surface.
+ */
+export function createMessengerActivityTracker(report: MessengerActivityReporter): (event: AgentSessionEvent) => void {
+	let step = 0;
+	return event => {
+		switch (event.type) {
+			case "tool_execution_start":
+				step++;
+				report(`Step ${step} · ${event.intent ?? `Using ${event.toolName}`}`);
+				return;
+			case "auto_compaction_start":
+				report("Compacting context");
+				return;
+			case "auto_retry_start":
+				report(`Retrying after a provider error (${event.attempt}/${event.maxAttempts})`);
+				return;
+		}
+	};
+}

package/src/messenger/discord.ts

@@ -14,6 +14,8 @@ const PERMANENT_CLOSE_CODES = new Set([4004, 4010, 4011, 4012, 4013, 4014]);
 // they are part of the delivered text, and consume one UTF-16 unit each.
 const DISCORD_WHITESPACE = /^[\s\u0085\u001c-\u001f]$/u;
 const DISCORD_BOUNDARY_GUARD = "\u200b";
+// SUPPRESS_EMBEDS | SUPPRESS_NOTIFICATIONS: a status line never unfurls links or pings on creation.
+const DISCORD_ACTIVITY_FLAGS = (1 << 2) | (1 << 12);
 
 function splitDiscordText(text: string): { chunks: string[]; needsAttachment: boolean } {
 	const chunks: string[] = [];
@@ -333,6 +335,7 @@ export function createDiscordAdapter(
 			if (oldest !== undefined) createdThreads.delete(oldest);
 		}
 	};
+	const activityMessages = new Map<string, string>();
 	const headers = (): Record<string, string> => {
 		if (!token) throw new DiscordConfigurationError("Discord bot token is missing");
 		return { Authorization: `Bot ${token}`, "Content-Type": "application/json" };
@@ -504,6 +507,61 @@ export function createDiscordAdapter(
 				deps.fetch,
 			);
 		},
+		async activity(message, text, signal) {
+			const channelId = message.threadId ?? message.channelId;
+			const key = JSON.stringify([channelId, message.messageId]);
+			const messages = `${API}/channels/${encodeURIComponent(channelId)}/messages`;
+			const statusId = activityMessages.get(key);
+			if (text === undefined) {
+				if (!statusId) return;
+				try {
+					await messengerFetchJson(
+						`${messages}/${encodeURIComponent(statusId)}`,
+						{ method: "DELETE", headers: headers() },
+						signal,
+						deps.fetch,
+					);
+				} catch (error) {
+					// Keep the ID so the caller can retry; a missing message is already removed.
+					if (!(error instanceof MessengerHttpError && error.status === 404)) throw error;
+				}
+				activityMessages.delete(key);
+				return;
+			}
+			const content = `⏳ ${text}`;
+			if (statusId) {
+				try {
+					// Edits re-parse mentions with default allowances unless allowed_mentions is repeated.
+					await messengerFetchJson(
+						`${messages}/${encodeURIComponent(statusId)}`,
+						{
+							method: "PATCH",
+							headers: headers(),
+							body: JSON.stringify({ content, allowed_mentions: { parse: [] } }),
+						},
+						signal,
+						deps.fetch,
+					);
+					return;
+				} catch (error) {
+					if (!(error instanceof MessengerHttpError && error.status === 404)) throw error;
+					activityMessages.delete(key);
+				}
+			}
+			const created = await messengerFetchJson(
+				messages,
+				{
+					method: "POST",
+					headers: headers(),
+					body: JSON.stringify({ content, allowed_mentions: { parse: [] }, flags: DISCORD_ACTIVITY_FLAGS }),
+				},
+				signal,
+				deps.fetch,
+			);
+			if (!isRecord(created) || typeof created.id !== "string" || !created.id)
+				throw new Error("Discord activity message returned no ID");
+			activityMessages.set(key, created.id);
+		},
 		async send(message, text, signal) {
 			let files: { name: string; data: Uint8Array }[] = [];
 			if (config.artifactDir) {

package/src/messenger/gateway.ts

@@ -1,5 +1,12 @@
 import { logger } from "jeopi-utils";
-import type { MessengerAdapter, MessengerConfig, MessengerMessage, MessengerReply } from "./types";
+import { MessengerHttpError } from "./http";
+import type {
+	MessengerActivityReporter,
+	MessengerAdapter,
+	MessengerConfig,
+	MessengerMessage,
+	MessengerReply,
+} from "./types";
 import { MessengerFatalError } from "./types";
 
 const MAX_MESSAGE_LENGTH = 32_000;
@@ -7,6 +14,157 @@ const MAX_QUEUED_MESSAGES = 100;
 const MAX_SEEN_MESSAGES = 10_000;
 const STATUS_TIMEOUT_MS = 1000;
 const MAX_STATUS_IN_FLIGHT = 8;
+const MAX_ACTIVITY_LENGTH = 120;
+// Status edits are cosmetic: keep them sparse so they never compete with reply delivery for rate limits.
+const ACTIVITY_INTERVAL_MS = 2_000;
+const ACTIVITY_TIMEOUT_MS = 3_000;
+
+/** Collapse to one bounded line: drop invisible format characters, fold control and whitespace runs. */
+function activityLine(text: string): string {
+	const line = text
+		.replace(/\p{Cf}/gu, "")
+		.replace(/[\p{Cc}\p{Z}\s]+/gu, " ")
+		.trim();
+	if (line.length <= MAX_ACTIVITY_LENGTH) return line;
+	let end = MAX_ACTIVITY_LENGTH - 1;
+	const last = line.charCodeAt(end - 1);
+	if (last >= 0xd800 && last <= 0xdbff) end--;
+	return `${line.slice(0, end).trimEnd()}…`;
+}
+
+interface ActivityReporter {
+	report: MessengerActivityReporter;
+	/** Stop updates and remove any shown line; idempotent and never rejects. */
+	close(): Promise<void>;
+}
+
+const NO_ACTIVITY: ActivityReporter = { report() {}, close: () => Promise.resolve() };
+
+/**
+ * Bound a cosmetic adapter call: a stalled provider request must not hold up the request queue. A timeout
+ * rejects so callers can retry; cancellation through `signal` resolves because the request is ending.
+ */
+async function boundedActivity(run: (signal: AbortSignal) => Promise<void>, signal?: AbortSignal): Promise<void> {
+	const timeout = new AbortController();
+	const callSignal = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
+	const stopped = Promise.withResolvers<void>();
+	const onStop = (): void => {
+		if (timeout.signal.aborted) stopped.reject(new Error("Messenger activity update timed out"));
+		else stopped.resolve();
+	};
+	callSignal.addEventListener("abort", onStop, { once: true });
+	const timer = setTimeout(() => timeout.abort(), ACTIVITY_TIMEOUT_MS);
+	try {
+		await Promise.race([Promise.resolve().then(() => run(callSignal)), stopped.promise]);
+	} finally {
+		clearTimeout(timer);
+		callSignal.removeEventListener("abort", onStop);
+	}
+}
+
+/**
+ * Coalesce a request's activity into one status line: show the first report at once, then at most the
+ * latest line per interval. Removal skips the request signal so an aborted request still retires its line.
+ */
+function createActivityReporter(
+	adapter: MessengerAdapter,
+	destination: MessengerMessage,
+	signal: AbortSignal,
+	intervalMs: number,
+): ActivityReporter {
+	const activity = adapter.activity;
+	if (!activity) return NO_ACTIVITY;
+	let latest: string | undefined;
+	let sent: string | undefined;
+	let shown = false;
+	let closed = false;
+	let pumping = false;
+	let pump = Promise.resolve();
+	let nextAt = 0;
+	let wake: (() => void) | undefined;
+	let closing: Promise<void> | undefined;
+	const update = (text: string | undefined, callSignal?: AbortSignal): Promise<void> =>
+		boundedActivity(bounded => activity.call(adapter, destination, text, bounded), callSignal);
+	const pause = async (ms: number): Promise<void> => {
+		const { promise, resolve } = Promise.withResolvers<void>();
+		const timer = setTimeout(resolve, ms);
+		wake = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		try {
+			await promise;
+		} finally {
+			wake = undefined;
+		}
+	};
+	const run = async (): Promise<void> => {
+		try {
+			while (!closed && !signal.aborted && latest !== sent) {
+				const delay = nextAt - Date.now();
+				if (delay > 0) {
+					await pause(delay);
+					continue;
+				}
+				const text = latest;
+				sent = text;
+				shown = true;
+				let spacing = intervalMs;
+				try {
+					await update(text, signal);
+				} catch (error) {
+					if (error instanceof MessengerHttpError && error.status === 429) {
+						// Keep the line pending: a rate-limited update is retried unless a newer line replaces it.
+						sent = undefined;
+						spacing = Math.max(spacing, error.retryAfterMs ?? 1_000);
+					} else if (!signal.aborted) {
+						logger.warn("Messenger activity update failed", { platform: destination.platform });
+					}
+				}
+				nextAt = Date.now() + spacing;
+			}
+		} finally {
+			pumping = false;
+		}
+	};
+	return {
+		report(text) {
+			if (closed || signal.aborted) return;
+			const line = activityLine(text);
+			if (!line) return;
+			latest = line;
+			if (pumping) return;
+			pumping = true;
+			pump = run();
+		},
+		close() {
+			closing ??= (async () => {
+				closed = true;
+				wake?.();
+				await pump;
+				if (!shown) return;
+				for (let attempt = 0; ; attempt++) {
+					try {
+						await update(undefined);
+						return;
+					} catch (error) {
+						const wait =
+							error instanceof MessengerHttpError && error.status === 429
+								? (error.retryAfterMs ?? 1_000)
+								: 1_000;
+						// One bounded retry: removal holds the request queue.
+						if (attempt > 0 || wait > ACTIVITY_TIMEOUT_MS) {
+							logger.warn("Messenger activity removal failed", { platform: destination.platform });
+							return;
+						}
+						await Bun.sleep(wait);
+					}
+				}
+			})();
+			return closing;
+		},
+	};
+}
 
 /** Include the sender even in shared threads: remote histories must not cross users. */
 export function messengerConversationKey(message: MessengerMessage): string {
@@ -50,11 +208,18 @@ export interface MessengerGateway {
 	handle(message: MessengerMessage, signal?: AbortSignal): Promise<void>;
 }
 
+export interface MessengerGatewayOptions {
+	/** Minimum spacing between in-place activity edits for one request. */
+	activityIntervalMs?: number;
+}
+
 export function createMessengerGateway(
 	config: MessengerConfig,
 	adapters: MessengerAdapter[],
 	reply: MessengerReply,
+	options: MessengerGatewayOptions = {},
 ): MessengerGateway {
+	const activityIntervalMs = Math.max(0, options.activityIntervalMs ?? ACTIVITY_INTERVAL_MS);
 	const byPlatform = new Map(adapters.map(adapter => [adapter.platform, adapter]));
 	if (byPlatform.size !== adapters.length) throw new Error("Duplicate messenger adapter");
 	for (const platform of Object.keys(config.platforms)) {
@@ -76,6 +241,7 @@ export function createMessengerGateway(
 			if (!pending) break;
 			const { message, adapter, signal, resolve } = pending;
 			let failed = false;
+			let activity = NO_ACTIVITY;
 			let statusChain = Promise.resolve();
 			const status = (state: "processing" | "success" | "failure"): void => {
 				if (!adapter.status) return;
@@ -111,9 +277,10 @@ export function createMessengerGateway(
 				if (signal.aborted) continue;
 				status("processing");
 				const destination = (await adapter.prepare?.(message, signal)) ?? message;
+				activity = createActivityReporter(adapter, destination, signal, activityIntervalMs);
 				let text: string;
 				try {
-					text = await reply(destination, signal);
+					text = await reply(destination, signal, activity.report);
 				} catch (error) {
 					failed = true;
 					if (error instanceof MessengerFatalError) {
@@ -125,6 +292,9 @@ export function createMessengerGateway(
 					if (signal.aborted) continue;
 					logger.warn("Messenger agent turn failed", { platform: message.platform });
 					text = "The request could not be completed. Please try again.";
+				} finally {
+					// Retire the status line alongside reply delivery rather than delaying the reply on it.
+					void activity.close();
 				}
 				if (!signal.aborted && text.trim()) {
 					// A failed send may already have delivered a chunk: never retry the entire reply.
@@ -137,6 +307,7 @@ export function createMessengerGateway(
 					status("failure");
 				}
 			} finally {
+				await activity.close();
 				resolve();
 			}
 		}

package/src/messenger/live-session.ts

@@ -1,5 +1,6 @@
 import type { AssistantMessage, UserMessage } from "jeopi-ai";
 import type { InteractiveModeContext } from "../modes/types";
+import { createMessengerActivityTracker } from "./activity";
 import { messengerArtifactPrompt } from "./artifacts";
 import { loadMessengerConfig, validateMessengerEnvironment } from "./config";
 import { createDiscordAdapter, type DiscordTransportDeps } from "./discord";
@@ -156,7 +157,7 @@ export function createLiveDiscordBridge(
 	let localCapture: object | undefined;
 	let close: () => Promise<void>;
 	let revoke: () => Promise<void>;
-	const reply: MessengerReply = async (message, signal) => {
+	const reply: MessengerReply = async (message, signal, onActivity) => {
 		if (closed || signal?.aborted) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
 		if (!sameSession(ctx, attachedSession, sessionId, sessionFile)) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
 		if (!isMessengerMessageAllowed(message, scopedConfig)) throw new Error(LIVE_UNAVAILABLE_MESSAGE);
@@ -190,8 +191,13 @@ export function createLiveDiscordBridge(
 			void revoke();
 		};
 		operationSignal.addEventListener("abort", onAbort, { once: true });
+		const track = onActivity && createMessengerActivityTracker(onActivity);
 		const unsubscribe = attachedSession.subscribe(event => {
-			if (event.type !== "message_end") return;
+			if (event.type !== "message_end") {
+				// Report only this Discord turn: its prompt event precedes the turn's tool and retry events.
+				if (capture.promptSeen && !capture.conflicted) track?.(event);
+				return;
+			}
 			if (event.message.role === "user") {
 				const text = userMessageText(event.message);
 				if (!capture.promptSeen && text === capture.promptText) {
@@ -265,6 +271,7 @@ export function createLiveDiscordBridge(
 	const adapterFactory = dependencies.createAdapter ?? createDiscordAdapter;
 	const gatewayFactory = dependencies.createGateway ?? createMessengerGateway;
 	const adapter = adapterFactory(discordConfig, dependencies.env, dependencies.transport);
+	const activity = adapter.activity;
 	const guardedAdapter: MessengerAdapter = {
 		...adapter,
 		send: async (message, text, signal) => {
@@ -277,6 +284,13 @@ export function createLiveDiscordBridge(
 			}
 			await adapter.send(message, text, sendSignal);
 		},
+		// New status text requires the attached session; removal must still retire a shown line after close.
+		activity:
+			activity &&
+			(async (message, text, signal) => {
+				if (text !== undefined && (closed || !sameSession(ctx, attachedSession, sessionId, sessionFile))) return;
+				await activity.call(adapter, message, text, signal);
+			}),
 	};
 	const setRelayDestination = (channelId: string | undefined): void => {
 		if (closed || !sameSession(ctx, attachedSession, sessionId, sessionFile))

package/src/messenger/session.ts

@@ -10,6 +10,7 @@ import type { AgentSession } from "../session/agent-session";
 import type { AuthStorage } from "../session/auth-storage";
 import { USER_INTERRUPT_LABEL } from "../session/messages";
 import { SessionManager } from "../session/session-manager";
+import { createMessengerActivityTracker } from "./activity";
 import { messengerArtifactPrompt } from "./artifacts";
 import { messengerConversationKey } from "./gateway";
 import { type MessengerConfig, MessengerFatalError, type MessengerReply } from "./types";
@@ -123,12 +124,13 @@ export function createMessengerSessionBridge(
 		activeRoute = route;
 	}
 
-	const reply: MessengerReply = async (message, signal) => {
+	const reply: MessengerReply = async (message, signal, onActivity) => {
 		if (closed || signal.aborted) throw new Error("Messenger session is closed");
 		if (activeTurn) throw new Error("Messenger turns must be serialized");
 		const finished = Promise.withResolvers<void>();
 		activeTurn = finished.promise;
 		let aborting: Promise<void> | undefined;
+		let unsubscribe: (() => void) | undefined;
 		const onAbort = (): void => {
 			if (session && !aborting) {
 				aborting = session.abort({ reason: USER_INTERRUPT_LABEL });
@@ -182,6 +184,8 @@ export function createMessengerSessionBridge(
 				const guidance = await messengerArtifactPrompt(artifactRoot, message, signal);
 				if (guidance) prompt += `\n\n${guidance}`;
 			}
+			// Turns are serialized, so every event until idle belongs to this request.
+			if (onActivity) unsubscribe = current.subscribe(createMessengerActivityTracker(onActivity));
 			const dispatched = await current.prompt(prompt, { expandPromptTemplates: false });
 			await current.waitForIdle();
 			await current.sessionManager.flush();
@@ -197,6 +201,7 @@ export function createMessengerSessionBridge(
 			if (!text.trim()) throw new Error("Messenger response is empty");
 			return text;
 		} finally {
+			unsubscribe?.();
 			signal.removeEventListener("abort", onAbort);
 			await aborting?.catch(() => {});
 			activeTurn = undefined;

package/src/messenger/types.ts

@@ -14,6 +14,9 @@ export interface MessengerMessage {
 	attachments?: { url: string; filename: string; size: number }[];
 }
 
+/** Report a short, human-readable description of the work in progress. */
+export type MessengerActivityReporter = (text: string) => void;
+
 export interface MessengerAdapter {
 	platform: MessengerPlatform;
 	start(onMessage: (message: MessengerMessage) => Promise<void>, signal: AbortSignal): Promise<void>;
@@ -24,6 +27,11 @@ export interface MessengerAdapter {
 		status: "processing" | "success" | "failure",
 		signal?: AbortSignal,
 	): Promise<void>;
+	/**
+	 * Show `text` (one sanitized line) as the request's single in-progress status, editing it in place on
+	 * later calls; `undefined` removes it. The gateway serializes and throttles calls per request.
+	 */
+	activity?(message: MessengerMessage, text: string | undefined, signal?: AbortSignal): Promise<void>;
 }
 
 export interface MessengerPlatformConfig {
@@ -47,7 +55,11 @@ export interface MessengerTransportDeps {
 	WebSocket?: typeof WebSocket;
 }
 
-export type MessengerReply = (message: MessengerMessage, signal: AbortSignal) => Promise<string>;
+export type MessengerReply = (
+	message: MessengerMessage,
+	signal: AbortSignal,
+	onActivity?: MessengerActivityReporter,
+) => Promise<string>;
 /** A partially initialized SDK must not be retried inside a live gateway. */
 export class MessengerFatalError extends Error {
 	constructor() {