grok-telegram-bot 2.2.4 → 2.3.1

package/src/bot/session-runtime.ts

@@ -7,9 +7,10 @@
 import { basename } from "node:path";
 import { type Api, InlineKeyboard } from "grammy";
 import {
-  type GrokClient,
-  isAccountRotationError,
+  type GrokClient,
+  isAccountRotationError,
   isContextExhaustedError,
+  isSessionLifecycleError,
   isTransientError,
   type SessionMetadata,
 } from "../grok/client.js";
@@ -31,7 +32,8 @@ import { type FileOp, fileOpFromUpdate, mergeFileOp, summarizeFileOps, summarize
 import { isActiveStatus, renderSubagentTransition, statusKey } from "../render/subagent.js";
 import type { PendingStage, SubagentInfo } from "../grok/types.js";
 import { ResponseStreamer } from "../stream/streamer.js";
-import { extractImagePaths, sendImages } from "./image-return.js";
+import { IMAGE_OUTPUT_DIRECTIVE } from "../render/image-output.js";
+import { collectTurnImagePaths, sendImages } from "./image-return.js";
 import { buildContentBlocks, mergeInputs } from "./prompt-content.js";
 import {
   backoffSchedule,
@@ -99,10 +101,10 @@ export class SessionRuntime {
   private turnCount = 0;
   /** Telegram message id of the current turn's prompt, so replies thread to it. */
   private turnReplyTo: number | undefined;
-  private imageScanText = "";
-  private sentImagesThisTurn = new Set<string>();
-  /** Monotonic count used to reject ACP "success" responses with no turn updates. */
-  private sessionUpdateCount = 0;
+  private imageScanText = "";
+  private sentImagesThisTurn = new Set<string>();
+  /** Monotonic count used to reject ACP "success" responses with no turn updates. */
+  private sessionUpdateCount = 0;
   private readonly listener: (sessionId: string, update: SessionUpdate) => void;
   private primingContext: string | undefined;
   private watcher: TailWatcher | undefined;
@@ -216,8 +218,11 @@ export class SessionRuntime {
       this.typing.stop();
       this.stopWatch();
       if (this.streamer) {
-        await this.streamer.finalize().catch(() => {});
+        // Finalize off the critical path so project/session switches never wait
+        // on Telegram edits of the previous live stream.
+        const prev = this.streamer;
         this.streamer = undefined;
+        void prev.finalize().catch(() => {});
       }
     }
     this.changed();
@@ -252,6 +257,7 @@ export class SessionRuntime {
   // в”Ђв”Ђ sessions в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async startNewSession(cwd: string, projectName?: string): Promise<void> {
+    await this.accountRotator?.waitForIdle();
     if (this.busy) await this.cancel();
     await this.bindNewSession(cwd, projectName);
   }
@@ -426,6 +432,9 @@ export class SessionRuntime {
   }
 
   private async ensureSession(): Promise<void> {
+    // Account rotation restarts the process globally. Do not bind a new chat
+    // to a candidate account until the owner has finished probing it.
+    await this.accountRotator?.waitForIdle();
     if (this.rebindPending && this.sessionId) {
       // The ACP process is frequently mid-restart the first time we re-bind
       // (auto-restart after a crash, or a fresh bot boot), so a single attempt
@@ -514,14 +523,17 @@ export class SessionRuntime {
     const content = buildContentBlocks(input, {
       reasoning: reasoningDirective(this.reasoning),
       priming: this.primingContext,
+      imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
       progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
     });
     this.primingContext = undefined;
 
     try {
       const outcome = await this.runPromptWithRetries(content);
-      const recovered = await this.maybeAutoFork(input, outcome);
-      let final = recovered ?? outcome;
+      const rebound = await this.maybeRecoverAgentSession(input, outcome);
+      let final = rebound ?? outcome;
+      const recovered = await this.maybeAutoFork(input, final);
+      final = recovered ?? final;
       // Last resort: if the turn still failed, rotate through other saved
       // accounts (once) and retry on each until one works.
       const rotated = await this.maybeRotateAccount(input, final);
@@ -624,6 +636,51 @@ export class SessionRuntime {
     return pct !== undefined && pct >= threshold;
   }
 
+  /** A shared-process restart invalidates this runtime's ACP session binding,
+   * but says nothing about account health. Wait for any account probe to
+   * settle, re-bind/fork this chat on the selected account, and retry once. */
+  private async maybeRecoverAgentSession(
+    input: PromptInput,
+    outcome: { result?: PromptResult; error?: Error; attempts: number },
+  ): Promise<{ result?: PromptResult; error?: Error; attempts: number } | undefined> {
+    if (
+      !outcome.error ||
+      !isSessionLifecycleError(outcome.error) ||
+      this.cancelled ||
+      (this.streamer?.hasOutput ?? false)
+    ) {
+      return undefined;
+    }
+    try {
+      await this.accountRotator?.waitForIdle();
+      if (this.cancelled) return outcome;
+      const previousId = this.sessionId;
+      this.sessionLive = false;
+      this.rebindPending = Boolean(previousId);
+      await this.ensureSession();
+      this.shownToolIds = new Set();
+      this.subagentShown = new Map();
+      this.streamer?.setFooter(this.hashtags());
+      const retryContent = buildContentBlocks(input, {
+        reasoning: reasoningDirective(this.reasoning),
+        priming: this.primingContext,
+        imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
+        progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+      });
+      this.primingContext = undefined;
+      log.info(
+        `chat ${this.chatId} recovered lifecycle error on the active account` +
+          (previousId && this.sessionId !== previousId
+            ? ` with fresh session ${this.sessionId?.slice(0, 8)}`
+            : " by re-binding its session"),
+      );
+      return this.runPromptWithRetries(retryContent);
+    } catch (error) {
+      log.warn(`chat ${this.chatId} session recovery failed: ${(error as Error).message}`);
+      return { error: error as Error, attempts: outcome.attempts };
+    }
+  }
+
   /**
    * Auto-fork-on-error recovery. When a turn fails with a *transient* error (or
    * a context-exhaustion error) and nothing was streamed to the user, the
@@ -670,6 +727,7 @@ export class SessionRuntime {
     const forkContent = buildContentBlocks(input, {
       reasoning: reasoningDirective(this.reasoning),
       priming: transcript ? buildPriming(transcript) : undefined,
+      imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
       progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
     });
     return this.runPromptWithRetries(forkContent);
@@ -692,27 +750,59 @@ export class SessionRuntime {
     input: PromptInput,
     final: { result?: PromptResult; error?: Error; attempts: number },
   ): Promise<{ result?: PromptResult; error?: Error; attempts: number } | undefined> {
-    const rotator = this.accountRotator;
-    if (!rotator?.enabled() || !final.error || this.cancelled) return undefined;
-    // A quota-exhausted or access-denied response cannot be recovered by retrying
-    // this login. Quarantine it before choosing targets, so later rotations do not
-    // cycle back to a known-bad account. This intentionally happens before the
-    // partial-stream guard: we must not retry/rotate a partial reply, but its
-    // account still needs to be skipped during a future rotation.
-    if (isAccountRotationError(final.error)) {
-      await rotator.markFailed(undefined, final.error.message);
-    }
-    if (this.streamer?.hasOutput ?? false) return undefined;
-    const targets = await rotator.targets().catch(() => [] as { id: string; label: string }[]);
+    const rotator = this.accountRotator;
+    if (!rotator?.enabled() || !final.error || this.cancelled) return undefined;
+    if (isSessionLifecycleError(final.error)) return undefined;
+    const originalError = final.error;
+    const observed = rotator.state();
+    return rotator.withRotationLock(observed, async (changed) => {
+      if (this.cancelled) return final;
+      if (changed) {
+        if (this.streamer?.hasOutput ?? false) return undefined;
+        const current = rotator.state();
+        const transcript = this.sessionId ? recentTranscript(this.cfg.sessionsDir, this.sessionId) : undefined;
+        if (this.foreground) {
+          await this.notify(
+            `\u{1F504} Reusing ${current.activeLabel ?? "the account selected by another chat"} with a fresh session…`,
+            { replyTo: this.turnReplyTo },
+          );
+        }
+        log.info(`chat ${this.chatId} reusing account generation ${current.generation} selected by another chat`);
+        try {
+          await this.bindNewSession(this.cwd, this.projectName);
+        } catch (error) {
+          return { error: error as Error, attempts: final.attempts };
+        }
+        this.shownToolIds = new Set();
+        this.subagentShown = new Map();
+        this.streamer?.setFooter(this.hashtags());
+        const content = buildContentBlocks(input, {
+          reasoning: reasoningDirective(this.reasoning),
+          priming: transcript ? buildPriming(transcript) : undefined,
+          imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
+          progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+        });
+        return this.runPromptWithRetries(content);
+      }
+    // A quota-exhausted or access-denied response cannot be recovered by retrying
+    // this login. Quarantine it before choosing targets, so later rotations do not
+    // cycle back to a known-bad account. This intentionally happens before the
+    // partial-stream guard: we must not retry/rotate a partial reply, but its
+    // account still needs to be skipped during a future rotation.
+    if (isAccountRotationError(originalError)) {
+      await rotator.markFailed(observed.activeId, originalError.message);
+    }
+    if (this.streamer?.hasOutput ?? false) return undefined;
+    const targets = await rotator.targets().catch(() => [] as { id: string; label: string }[]);
     if (targets.length === 0) return undefined;
 
     const transcript = this.sessionId ? recentTranscript(this.cfg.sessionsDir, this.sessionId) : undefined;
-    const errors: string[] = [`\u2022 previous: ${final.error.message}`];
+    const errors: string[] = [`\u2022 previous: ${originalError.message}`];
     let last = final;
 
     for (const t of targets) {
       if (this.cancelled) return last;
-      const failReason = last.error ?? final.error;
+      const failReason = last.error ?? originalError;
       if (this.foreground) {
         await this.notify(formatAccountSwitchNotice(t.label, failReason), { replyTo: this.turnReplyTo });
       }
@@ -736,30 +826,32 @@ export class SessionRuntime {
       const content = buildContentBlocks(input, {
         reasoning: reasoningDirective(this.reasoning),
         priming: transcript ? buildPriming(transcript) : undefined,
-        progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+        imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
+      progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
       });
       log.info(
         `chat ${this.chatId} auto-rotating to account ${t.label}` +
-          (isAccountRotationError(failReason) ? " (previous account unavailable)" : ""),
+          (isAccountRotationError(failReason) ? " (previous account unavailable)" : ""),
       );
       // runPromptWithRetries already skips backoff for 402 / balance exhausted.
       last = await this.runPromptWithRetries(content);
-      if (last.result && !this.cancelled) {
+      if (last.result && !this.cancelled) {
         if (this.foreground) {
           await this.notify(`\u2705 Recovered on ${t.label}.`, { replyTo: this.turnReplyTo });
         }
         return last;
-      }
-      if (last.error && isAccountRotationError(last.error)) {
-        await rotator.markFailed(t.id, last.error.message);
-      }
-      if (this.cancelled || (this.streamer?.hasOutput ?? false)) return last;
-      errors.push(`\u2022 ${t.label}: ${last.error?.message ?? "failed"}`);
+      }
+      if (last.error && isAccountRotationError(last.error)) {
+        await rotator.markFailed(t.id, last.error.message);
+      }
+      if (this.cancelled || (this.streamer?.hasOutput ?? false)) return last;
+      errors.push(`\u2022 ${t.label}: ${last.error?.message ?? "failed"}`);
     }
 
     // One full cycle done and still failing — stop with a combined report.
     const combined = new Error(`Tried ${targets.length + 1} account(s), all failed:\n${errors.join("\n")}`);
     return { error: combined, attempts: last.attempts };
+    });
   }
 
   /**
@@ -776,21 +868,21 @@ export class SessionRuntime {
   ): Promise<{ result?: PromptResult; error?: Error; attempts: number }> {
     const delays = this.cfg.promptRetryAttempts > 0 ? backoffSchedule(this.cfg.promptRetryAttempts) : [];
     const totalAttempts = delays.length + 1;
-    let attempt = 0;
-    for (;;) {
-      attempt++;
-      try {
-        const updatesBeforePrompt = this.sessionUpdateCount;
-        const result = await this.acp.prompt(this.sessionId!, content);
-        // A healthy ACP turn emits at least one session/update (text, thought,
-        // or tool event) before resolving session/prompt. Grok can otherwise
-        // report a successful end-turn after an upstream model failure; never
-        // present that as a completed user request.
-        await sleep(0);
-        if (this.sessionUpdateCount === updatesBeforePrompt) {
-          throw new Error("Empty agent response — Grok ended the turn without any output or tool activity");
-        }
-        return { result, attempts: attempt };
+    let attempt = 0;
+    for (;;) {
+      attempt++;
+      try {
+        const updatesBeforePrompt = this.sessionUpdateCount;
+        const result = await this.acp.prompt(this.sessionId!, content);
+        // A healthy ACP turn emits at least one session/update (text, thought,
+        // or tool event) before resolving session/prompt. Grok can otherwise
+        // report a successful end-turn after an upstream model failure; never
+        // present that as a completed user request.
+        await sleep(0);
+        if (this.sessionUpdateCount === updatesBeforePrompt) {
+          throw new Error("Empty agent response — Grok ended the turn without any output or tool activity");
+        }
+        return { result, attempts: attempt };
       } catch (err) {
         const error = err as Error;
         const canRecover = !this.cancelled && !(this.streamer?.hasOutput ?? false);
@@ -803,7 +895,7 @@ export class SessionRuntime {
           attempt <= delays.length &&
           canRecover &&
           !forkInstead &&
-          !isAccountRotationError(error) &&
+          !isAccountRotationError(error) &&
           isTransientError(error);
         if (!willRetry) return { error, attempts: attempt };
         const waitMs = delays[attempt - 1]!;
@@ -859,6 +951,7 @@ export class SessionRuntime {
     const delays = this.cfg.promptRetryAttempts > 0 ? backoffSchedule(this.cfg.promptRetryAttempts) : [RETRY_BASE_MS];
     const resumeContent = buildContentBlocks(textPrompt(RESUME_INSTRUCTION), {
       reasoning: reasoningDirective(this.reasoning),
+      imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
       progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
     });
 
@@ -888,17 +981,26 @@ export class SessionRuntime {
     return last;
   }
 
-  /** Send any fresh images the agent produced this turn (screenshots, etc.). */
+  /** Send any fresh images the agent produced this turn (Imagine, screenshots…). */
   private async sendTurnImages(): Promise<void> {
-    if (!this.cfg.sendAgentImages || !this.imageScanText) return;
-    const paths = extractImagePaths(this.imageScanText, this.cwd);
+    if (!this.cfg.sendAgentImages) return;
+    // Always check session images/ + assets/ even when the agent never named a
+    // path in text — image_gen writes under ~/.grok/sessions/.../images/.
+    const paths = collectTurnImagePaths({
+      scanText: this.imageScanText,
+      cwd: this.cwd,
+      sessionId: this.sessionId,
+      since: this.turnStartedAt,
+    });
     if (paths.length === 0) return;
     try {
-      await sendImages(this.api, this.chatId, paths, {
+      const n = await sendImages(this.api, this.chatId, paths, {
         since: this.turnStartedAt,
         already: this.sentImagesThisTurn,
         max: this.cfg.agentImagesMax,
+        replyTo: this.turnReplyTo,
       });
+      if (n > 0) log.info(`chat ${this.chatId}: sent ${n} agent image file(s)`);
     } catch {
       /* non-fatal */
     }
@@ -980,10 +1082,10 @@ export class SessionRuntime {
     void this.runTurn(batch);
   }
 
-  private onUpdate(sessionId: string, update: SessionUpdate): void {
-    if (!this.busy || sessionId !== this.sessionId) return;
-    this.sessionUpdateCount++;
-    const kind = update.sessionUpdate;
+  private onUpdate(sessionId: string, update: SessionUpdate): void {
+    if (!this.busy || sessionId !== this.sessionId) return;
+    this.sessionUpdateCount++;
+    const kind = update.sessionUpdate;
 
     // Accumulate the turn's file-change summary + image-scan text even when this
     // session is in the background (its output isn't streamed here, but the
@@ -991,6 +1093,12 @@ export class SessionRuntime {
     if (kind === "tool_call" || kind === "tool_call_update") {
       if (update.rawInput) this.imageScanText += " " + JSON.stringify(update.rawInput);
       if (update.title) this.imageScanText += " " + update.title;
+      // Tool results often carry the saved path only in content_blocks (Imagine).
+      if (Array.isArray(update.content_blocks)) {
+        this.imageScanText += " " + JSON.stringify(update.content_blocks);
+      }
+      // Some agents put free-form result text on `content`.
+      if (update.content?.text) this.imageScanText += " " + update.content.text;
       const fo = fileOpFromUpdate(update);
       if (fo) this.fileOps.set(fo.path, mergeFileOp(this.fileOps.get(fo.path), fo.op));
     } else if (kind === "agent_message_chunk") {

package/src/grok/client.ts

@@ -15,6 +15,7 @@ import { EventEmitter } from "node:events";
 import { createLogger } from "../logger.js";
 import { hasLogin } from "../app/grok-credentials.js";
 import { contextWindowFor, DEFAULT_MODEL, KNOWN_MODELS } from "./models.js";
+import { IMAGE_OUTPUT_DIRECTIVE } from "../render/image-output.js";
 import { PROGRESS_DIRECTIVE } from "../render/progress.js";
 import { SessionLog } from "./session-log.js";
 import { JsonRpcTransport } from "./transport.js";
@@ -58,6 +59,11 @@ const ACCOUNT_EXHAUSTED_RE =
  * saved login may be permitted, while same-account retries cannot help. */
 const ACCOUNT_ACCESS_DENIED_RE =
   /\b403\b|forbidden|access denied/i;
+/** Process/session lifecycle failures are not evidence that the active login
+ * is bad. They require a session re-bind on the current process generation,
+ * never account rotation. */
+const SESSION_LIFECYCLE_RE =
+  /unknown session id|grok agent is restarting|grok agent stdio exited|grok agent (?:is )?not running|agent connection (?:is )?closed|authentication required.{0,80}no auth method id provided/i;
 
 export class GrokError extends Error {
   constructor(
@@ -122,7 +128,14 @@ export function isAccountRotationError(err: Error): boolean {
   return false;
 }
 
+export function isSessionLifecycleError(err: Error): boolean {
+  return SESSION_LIFECYCLE_RE.test(err.message);
+}
+
 export function isTransientError(err: Error): boolean {
+  // Retrying the same stale session cannot recover a process-generation
+  // mismatch. SessionRuntime owns the immediate re-bind + one safe retry.
+  if (isSessionLifecycleError(err)) return false;
   // Quota exhaustion and access denial are permanent for this login — rotate,
   // never back off and retry the same credentials.
   if (isAccountRotationError(err)) return false;
@@ -264,9 +277,10 @@ export class GrokClient extends EventEmitter {
     this.availableModels = KNOWN_MODELS.map((m) => ({ modelId: m.modelId, name: m.name, description: m.description }));
   }
 
-  async start(): Promise<void> {
+  async start(notifyRestarted = false): Promise<void> {
     this.stopped = false;
     await this.connect();
+    if (notifyRestarted) this.emit("restarted");
   }
 
   private async connect(): Promise<void> {
@@ -528,9 +542,7 @@ export class GrokClient extends EventEmitter {
     this.stopped = true;
     this.restartAttempts = 0;
     await this.killCurrent();
-    this.stopped = false;
-    await this.connect();
-    this.emit("restarted");
+    await this.start(true);
   }
 
   private killCurrent(): Promise<void> {
@@ -728,8 +740,12 @@ export class GrokClient extends EventEmitter {
    *  leading reasoning directive, fork/priming preamble) removed, for a clean log. */
   private cleanUserText(content: ContentBlock[]): string {
     let t = this.visibleText(content);
+    // Strip bot-injected appendices (image rules first, then progress — progress
+    // is always last when both are present).
     const pi = t.indexOf(PROGRESS_DIRECTIVE);
     if (pi !== -1) t = t.slice(0, pi).trimEnd();
+    const ii = t.indexOf(IMAGE_OUTPUT_DIRECTIVE);
+    if (ii !== -1) t = t.slice(0, ii).trimEnd();
     const marker = "User's new message:\n";
     const mi = t.lastIndexOf(marker);
     if (mi !== -1) t = t.slice(mi + marker.length);

package/src/grok/types.ts

@@ -26,12 +26,23 @@ export interface JsonRpcNotification {
 
 export type JsonRpcMessage = JsonRpcResponse & JsonRpcNotification & { method?: string };
 
-/** A content block in a prompt or message. */
+/** A content block in a prompt or message (ACP ContentBlock subset). */
 export interface ContentBlock {
-  type: "text" | "image" | "resource";
+  type: "text" | "image" | "audio" | "resource" | "resource_link";
   text?: string;
   data?: string;
   mimeType?: string;
+  /** resource_link */
+  uri?: string;
+  name?: string;
+  size?: number;
+  /** embedded resource */
+  resource?: {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+  };
   [k: string]: unknown;
 }
 
@@ -47,7 +58,11 @@ export interface InitializeResult {
   authMethods?: AuthMethod[];
   agentCapabilities?: {
     loadSession?: boolean;
-    promptCapabilities?: { image?: boolean };
+    promptCapabilities?: {
+      image?: boolean;
+      audio?: boolean;
+      embeddedContext?: boolean;
+    };
   };
   agentInfo?: { name?: string; version?: string };
 }

package/src/render/image-output.ts

@@ -0,0 +1,12 @@
+/**
+ * Prompt appendix so the agent keeps generated images in the session media
+ * folder and mentions absolute paths (the bot delivers those as Telegram files).
+ *
+ * Keep tidy-idempotent (no trailing spaces / 3+ blank lines) so
+ * `cleanStoredText` can strip it by exact match after extractProgress/tidy.
+ */
+export const IMAGE_OUTPUT_DIRECTIVE = [
+  "IMAGE OUTPUT RULES:",
+  "When generating images (image_gen / image_edit) or saving image files, write them under the current Grok session media folder (session images/ or assets/) or the project images/ directory — not random temp locations.",
+  "Always mention the absolute path of each image file you create in your reply so the client can deliver it as a downloadable Telegram file.",
+].join("\n");

package/src/sessions/history.ts

@@ -3,6 +3,7 @@
  * Reads only the tail of large logs to stay fast.
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { IMAGE_OUTPUT_DIRECTIVE } from "../render/image-output.js";
 import { extractProgress, PROGRESS_DIRECTIVE } from "../render/progress.js";
 import type { HistoryEntry, HistoryRole } from "./types.js";
 
@@ -161,6 +162,7 @@ function cleanStoredText(text: string): string {
   if (!text) return text;
   let t = extractProgress(text).cleaned;
   if (t.includes(PROGRESS_DIRECTIVE)) t = t.split(PROGRESS_DIRECTIVE).join("").trim();
+  if (t.includes(IMAGE_OUTPUT_DIRECTIVE)) t = t.split(IMAGE_OUTPUT_DIRECTIVE).join("").trim();
   return t;
 }