codex-to-im 1.0.18 → 1.0.19

package/dist/cli.mjs

@@ -22,6 +22,29 @@ function resolveDefaultCtiHome() {
 }
 var CTI_HOME = process.env.CTI_HOME || resolveDefaultCtiHome();
 var CONFIG_PATH = path.join(CTI_HOME, "config.env");
+function parseEnvFile(content) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    entries.set(key, value);
+  }
+  return entries;
+}
+function loadRawConfigEnv() {
+  try {
+    return parseEnvFile(fs.readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
 
 // src/service-manager.ts
 var moduleDir = path2.dirname(fileURLToPath(import.meta.url));
@@ -104,6 +127,24 @@ function getUiServerStatus() {
     port: status.port ?? uiPort
   };
 }
+function buildDaemonEnv() {
+  const env = { ...process.env };
+  env.CTI_HOME = CTI_HOME;
+  for (const [key, value] of loadRawConfigEnv()) {
+    env[key] = value;
+  }
+  delete env.CLAUDECODE;
+  return env;
+}
+async function waitForBridgeRunning(timeoutMs = 2e4) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const status = getBridgeStatus();
+    if (status.running) return status;
+    await sleep(500);
+  }
+  return getBridgeStatus();
+}
 async function waitForUiServer(timeoutMs = 15e3) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
@@ -119,6 +160,30 @@ async function waitForUiServer(timeoutMs = 15e3) {
   }
   return getUiServerStatus();
 }
+async function startBridge() {
+  ensureDirs();
+  const current = getBridgeStatus();
+  if (current.running) return current;
+  const daemonEntry = path2.join(packageRoot, "dist", "daemon.mjs");
+  if (!fs2.existsSync(daemonEntry)) {
+    throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
+  }
+  const stdoutFd = fs2.openSync(path2.join(logsDir, "bridge-launcher.out.log"), "a");
+  const stderrFd = fs2.openSync(path2.join(logsDir, "bridge-launcher.err.log"), "a");
+  const child = spawn(process.execPath, [daemonEntry], {
+    cwd: packageRoot,
+    detached: true,
+    env: buildDaemonEnv(),
+    stdio: ["ignore", stdoutFd, stderrFd],
+    ...WINDOWS_HIDE
+  });
+  child.unref();
+  const status = await waitForBridgeRunning();
+  if (!status.running) {
+    throw new Error(status.lastExitReason || "Bridge failed to report running=true.");
+  }
+  return status;
+}
 async function stopBridge() {
   const status = getBridgeStatus();
   if (!status.pid || !isProcessAlive(status.pid)) {
@@ -238,8 +303,19 @@ async function main() {
       const status = await ensureUiServerRunning();
       const url = getUiServerUrl(status.port);
       openBrowser(url);
-      process.stdout.write(`Codex to IM is available at ${url}
+      try {
+        await startBridge();
+        process.stdout.write(`Codex to IM is available at ${url}
 `);
+      } catch (error) {
+        process.stdout.write(`Codex to IM UI is available at ${url}
+`);
+        process.stderr.write(
+          `Bridge failed to start. Open the UI and check logs/config first: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+        process.exitCode = 1;
+      }
       return;
     }
     case "url": {
@@ -260,14 +336,6 @@ async function main() {
       process.exitCode = 1;
       return;
     }
-    case "share-feishu": {
-      const status = await ensureUiServerRunning();
-      const url = `${getUiServerUrl(status.port)}/#desktop`;
-      openBrowser(url);
-      process.stdout.write(`Opened Feishu handoff entry at ${url}
-`);
-      return;
-    }
     case "stop": {
       const bridge = await stopBridge();
       const ui = await stopUiServer();
@@ -290,7 +358,7 @@ async function main() {
       return;
     }
     default:
-      process.stdout.write("Usage: codex-to-im [open|url|share-feishu|stop|status]\n");
+      process.stdout.write("Usage: codex-to-im [open|url|stop|status]\n");
   }
 }
 main().catch((error) => {

package/dist/daemon.mjs

@@ -4047,7 +4047,9 @@ var init_codex_provider = __esm({
                   }
                   let sawAnyEvent = false;
                   try {
-                    const { events } = await thread.runStreamed(input);
+                    const { events } = await thread.runStreamed(input, {
+                      signal: params.abortController?.signal
+                    });
                     for await (const event of events) {
                       sawAnyEvent = true;
                       if (params.abortController?.signal.aborted) {
@@ -5271,15 +5273,18 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   lastIncomingMessageId = /* @__PURE__ */ new Map();
   /** Track active typing reaction IDs per chat for cleanup. */
   typingReactions = /* @__PURE__ */ new Map();
-  /** Active streaming card state per chatId. */
+  /** Active streaming card state per stream key. */
   activeCards = /* @__PURE__ */ new Map();
-  /** In-flight card creation promises per chatId — prevents duplicate creation. */
+  /** In-flight card creation promises per stream key — prevents duplicate creation. */
   cardCreatePromises = /* @__PURE__ */ new Map();
   /** Cached tenant token for upload APIs. */
   tenantTokenCache = null;
   isStreamingEnabled() {
     return getBridgeContext().store.getSetting("bridge_feishu_streaming_enabled") !== "false";
   }
+  resolveStreamKey(chatId, streamKey) {
+    return streamKey?.trim() || chatId;
+  }
   // ── Lifecycle ───────────────────────────────────────────────
   async start() {
     if (this.running) return;
@@ -5384,10 +5389,10 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Add a "Typing" emoji reaction to the user's message and create streaming card.
    * Called by bridge-manager via onMessageStart().
    */
-  onMessageStart(chatId) {
+  onMessageStart(chatId, streamKey) {
     const messageId = this.lastIncomingMessageId.get(chatId);
     if (messageId && this.isStreamingEnabled()) {
-      this.createStreamingCard(chatId, messageId).catch(() => {
+      this.createStreamingCard(chatId, messageId, streamKey).catch(() => {
       });
     }
     if (!messageId || !this.restClient) return;
@@ -5410,8 +5415,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Remove the "Typing" emoji reaction and clean up card state.
    * Called by bridge-manager via onMessageEnd().
    */
-  onMessageEnd(chatId) {
-    this.cleanupCard(chatId);
+  onMessageEnd(chatId, streamKey) {
+    this.cleanupCard(chatId, streamKey);
     const reactionId = this.typingReactions.get(chatId);
     const messageId = this.lastIncomingMessageId.get(chatId);
     if (!reactionId || !messageId || !this.restClient) return;
@@ -5462,17 +5467,19 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Create a new streaming card and send it as a message.
    * Returns true if card was created successfully.
    */
-  createStreamingCard(chatId, replyToMessageId) {
-    if (!this.restClient || this.activeCards.has(chatId)) return Promise.resolve(false);
-    const existing = this.cardCreatePromises.get(chatId);
+  createStreamingCard(chatId, replyToMessageId, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.restClient || this.activeCards.has(cardKey)) return Promise.resolve(false);
+    const existing = this.cardCreatePromises.get(cardKey);
     if (existing) return existing;
-    const promise = this._doCreateStreamingCard(chatId, replyToMessageId);
-    this.cardCreatePromises.set(chatId, promise);
-    promise.finally(() => this.cardCreatePromises.delete(chatId));
+    const promise = this._doCreateStreamingCard(chatId, replyToMessageId, cardKey);
+    this.cardCreatePromises.set(cardKey, promise);
+    promise.finally(() => this.cardCreatePromises.delete(cardKey));
     return promise;
   }
-  async _doCreateStreamingCard(chatId, replyToMessageId) {
+  async _doCreateStreamingCard(chatId, replyToMessageId, streamKey) {
     if (!this.restClient) return false;
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.card) {
       console.warn("[feishu-adapter] CardKit v1 API is unavailable in the current Feishu SDK client");
@@ -5526,7 +5533,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         console.warn("[feishu-adapter] Card message send returned no message_id");
         return false;
       }
-      this.activeCards.set(chatId, {
+      this.activeCards.set(cardKey, {
+        chatId,
         cardId,
         messageId,
         sequence: 0,
@@ -5537,7 +5545,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         lastUpdateAt: 0,
         throttleTimer: null
       });
-      console.log(`[feishu-adapter] Streaming card created: cardId=${cardId}, msgId=${messageId}`);
+      console.log(`[feishu-adapter] Streaming card created: streamKey=${cardKey}, cardId=${cardId}, msgId=${messageId}`);
       return true;
     } catch (err) {
       console.warn("[feishu-adapter] Failed to create streaming card:", err instanceof Error ? err.message : err);
@@ -5547,8 +5555,9 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   /**
    * Update streaming card content with throttling.
    */
-  updateCardContent(chatId, text2) {
-    const state = this.activeCards.get(chatId);
+  updateCardContent(chatId, text2, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const state = this.activeCards.get(cardKey);
     if (!state || !this.restClient) return;
     if (state.thinking && text2.trim()) {
       state.thinking = false;
@@ -5559,7 +5568,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       if (!state.throttleTimer) {
         state.throttleTimer = setTimeout(() => {
           state.throttleTimer = null;
-          this.flushCardUpdate(chatId);
+          this.flushCardUpdate(cardKey);
         }, CARD_THROTTLE_MS - elapsed);
       }
       return;
@@ -5568,13 +5577,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
     }
-    this.flushCardUpdate(chatId);
+    this.flushCardUpdate(cardKey);
   }
   /**
    * Flush pending card update to Feishu API.
    */
-  flushCardUpdate(chatId) {
-    const state = this.activeCards.get(chatId);
+  flushCardUpdate(streamKey) {
+    const state = this.activeCards.get(streamKey);
     if (!state || !this.restClient) return;
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.cardElement?.content) return;
@@ -5594,24 +5603,26 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   /**
    * Update tool progress in the streaming card.
    */
-  updateToolProgress(chatId, tools) {
-    const state = this.activeCards.get(chatId);
+  updateToolProgress(chatId, tools, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const state = this.activeCards.get(cardKey);
     if (!state) return;
     state.toolCalls = tools;
-    this.updateCardContent(chatId, state.pendingText || "");
+    this.updateCardContent(chatId, state.pendingText || "", cardKey);
   }
   /**
    * Finalize the streaming card: close streaming mode, update with final content + footer.
    */
-  async finalizeCard(chatId, status, responseText) {
-    const pending = this.cardCreatePromises.get(chatId);
+  async finalizeCard(chatId, status, responseText, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const pending = this.cardCreatePromises.get(cardKey);
     if (pending) {
       try {
         await pending;
       } catch {
       }
     }
-    const state = this.activeCards.get(chatId);
+    const state = this.activeCards.get(cardKey);
     if (!state || !this.restClient) return false;
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.card?.settings || !cardkit?.card?.update) return false;
@@ -5647,63 +5658,66 @@ var FeishuAdapter = class extends BaseChannelAdapter {
           sequence: state.sequence
         }
       });
-      console.log(`[feishu-adapter] Card finalized: cardId=${state.cardId}, status=${status}, elapsed=${formatElapsed(elapsedMs)}`);
+      console.log(`[feishu-adapter] Card finalized: streamKey=${cardKey}, cardId=${state.cardId}, status=${status}, elapsed=${formatElapsed(elapsedMs)}`);
       return true;
     } catch (err) {
       console.warn("[feishu-adapter] Card finalize failed:", err instanceof Error ? err.message : err);
       return false;
     } finally {
-      this.activeCards.delete(chatId);
+      this.activeCards.delete(cardKey);
     }
   }
   /**
    * Clean up card state without finalizing (e.g. on unexpected errors).
    */
-  cleanupCard(chatId) {
-    this.cardCreatePromises.delete(chatId);
-    const state = this.activeCards.get(chatId);
+  cleanupCard(chatId, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    this.cardCreatePromises.delete(cardKey);
+    const state = this.activeCards.get(cardKey);
     if (!state) return;
     if (state.throttleTimer) {
       clearTimeout(state.throttleTimer);
     }
-    this.activeCards.delete(chatId);
+    this.activeCards.delete(cardKey);
   }
   /**
    * Check if there is an active streaming card for a given chat.
    */
-  hasActiveCard(chatId) {
-    return this.activeCards.has(chatId);
+  hasActiveCard(chatId, streamKey) {
+    return this.activeCards.has(this.resolveStreamKey(chatId, streamKey));
   }
   // ── Streaming adapter interface ────────────────────────────────
   /**
    * Called by bridge-manager on each text SSE event.
    * Creates streaming card on first call, then updates content.
    */
-  onStreamText(chatId, fullText) {
+  onStreamText(chatId, fullText, streamKey) {
     if (!this.isStreamingEnabled()) return;
-    if (!this.activeCards.has(chatId)) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.activeCards.has(cardKey)) {
       const messageId = this.lastIncomingMessageId.get(chatId);
-      this.createStreamingCard(chatId, messageId).then((ok) => {
-        if (ok) this.updateCardContent(chatId, fullText);
+      this.createStreamingCard(chatId, messageId, cardKey).then((ok) => {
+        if (ok) this.updateCardContent(chatId, fullText, cardKey);
       }).catch(() => {
       });
       return;
     }
-    this.updateCardContent(chatId, fullText);
+    this.updateCardContent(chatId, fullText, cardKey);
   }
-  onMirrorStreamStart(chatId) {
+  onMirrorStreamStart(chatId, streamKey) {
     if (!this.isStreamingEnabled()) return;
-    if (this.activeCards.has(chatId)) return;
-    this.createStreamingCard(chatId, void 0).catch(() => {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (this.activeCards.has(cardKey)) return;
+    this.createStreamingCard(chatId, void 0, cardKey).catch(() => {
     });
   }
-  onToolEvent(chatId, tools) {
+  onToolEvent(chatId, tools, streamKey) {
     if (!this.isStreamingEnabled()) return;
-    this.updateToolProgress(chatId, tools);
+    this.updateToolProgress(chatId, tools, streamKey);
   }
-  async onStreamEnd(chatId, status, responseText) {
+  async onStreamEnd(chatId, status, responseText, streamKey) {
     if (!this.isStreamingEnabled()) return false;
-    return this.finalizeCard(chatId, status, responseText);
+    return this.finalizeCard(chatId, status, responseText, streamKey);
   }
   // ── Send ────────────────────────────────────────────────────
   async send(message) {
@@ -16818,8 +16832,6 @@ function resolveCommandAlias(rawCommand, args) {
       return "/help";
     case "/t":
       return !args ? "/threads" : /^(all|n\b)/i.test(args.trim()) ? "/threads" : "/thread";
-    case "/s":
-      return args ? "/use" : "/sessions";
     case "/n":
       return "/new";
     case "/m":
@@ -16890,6 +16902,12 @@ function getSessionDisplayName(session, fallbackDirectory) {
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function buildInteractiveStreamKey(sessionId, messageId) {
+  return `im:${sessionId}:${messageId}`;
+}
+function buildMirrorStreamKey(sessionId, turnId, startedAt) {
+  return `mirror:${sessionId}:${turnId || startedAt}`;
+}
 function getWorkspaceRoot() {
   const { store } = getBridgeContext();
   return store.getSetting("bridge_default_workspace_root") || DEFAULT_WORKSPACE_ROOT;
@@ -17829,6 +17847,16 @@ function formatMirrorMessage(threadTitle, userText, assistantText, markdown = fa
   sections.unshift(buildMirrorTitle(threadTitle, markdown));
   return sections.join("\n\n").trim();
 }
+function buildMirrorTimeoutNotice(markdown = false) {
+  return markdown ? "> \u8D85\u65F6\u63D0\u9192\uFF1A\u957F\u65F6\u95F4\u6CA1\u6709\u6536\u5230\u65B0\u7684\u684C\u9762\u4F1A\u8BDD\u8F93\u51FA\uFF0C\u672C\u6B21\u6D41\u5F0F\u540C\u6B65\u5DF2\u5148\u7ED3\u675F\uFF1B\u5982\u679C\u684C\u9762\u540E\u7EED\u7EE7\u7EED\u4EA7\u51FA\u5185\u5BB9\uFF0C\u4F1A\u91CD\u65B0\u5F00\u59CB\u65B0\u4E00\u8F6E\u540C\u6B65\u3002" : "\u8D85\u65F6\u63D0\u9192\uFF1A\u957F\u65F6\u95F4\u6CA1\u6709\u6536\u5230\u65B0\u7684\u684C\u9762\u4F1A\u8BDD\u8F93\u51FA\uFF0C\u672C\u6B21\u6D41\u5F0F\u540C\u6B65\u5DF2\u5148\u7ED3\u675F\uFF1B\u5982\u679C\u684C\u9762\u540E\u7EED\u7EE7\u7EED\u4EA7\u51FA\u5185\u5BB9\uFF0C\u4F1A\u91CD\u65B0\u5F00\u59CB\u65B0\u4E00\u8F6E\u540C\u6B65\u3002";
+}
+function appendMirrorTimeoutNotice(text2, markdown = false) {
+  const notice = buildMirrorTimeoutNotice(markdown);
+  const normalized = text2.trim();
+  return normalized ? `${normalized}
+
+${notice}` : notice;
+}
 function getMirrorStreamingAdapter(subscription) {
   const state = getState();
   const adapter = state.adapters.get(subscription.channelType);
@@ -17855,9 +17883,9 @@ function startMirrorStreaming(subscription, turnState) {
   const adapter = getMirrorStreamingAdapter(subscription);
   if (!adapter || turnState.streamStarted) return;
   try {
-    adapter.onMirrorStreamStart?.(subscription.chatId);
+    adapter.onMirrorStreamStart?.(subscription.chatId, turnState.streamKey);
     if (!adapter.onMirrorStreamStart) {
-      adapter.onStreamText?.(subscription.chatId, "");
+      adapter.onStreamText?.(subscription.chatId, "", turnState.streamKey);
     }
     turnState.streamStarted = true;
   } catch {
@@ -17873,7 +17901,7 @@ function updateMirrorStreaming(subscription, turnState) {
   );
   if (!text2) return;
   try {
-    adapter.onStreamText?.(subscription.chatId, text2);
+    adapter.onStreamText?.(subscription.chatId, text2, turnState.streamKey);
   } catch {
   }
 }
@@ -17882,7 +17910,7 @@ function updateMirrorToolProgress(subscription, turnState) {
   if (!adapter || typeof adapter.onToolEvent !== "function") return;
   startMirrorStreaming(subscription, turnState);
   try {
-    adapter.onToolEvent(subscription.chatId, Array.from(turnState.toolCalls.values()));
+    adapter.onToolEvent(subscription.chatId, Array.from(turnState.toolCalls.values()), turnState.streamKey);
   } catch {
   }
 }
@@ -17894,7 +17922,7 @@ function stopMirrorStreaming(subscription, status = "interrupted") {
     subscription.channelType,
     getMirrorStreamingText(subscription, pendingTurn)
   );
-  void adapter.onStreamEnd(subscription.chatId, status, text2).catch(() => {
+  void adapter.onStreamEnd(subscription.chatId, status, text2, pendingTurn.streamKey).catch(() => {
   });
 }
 async function deliverMirrorTurn(subscription, turn) {
@@ -17904,8 +17932,10 @@ async function deliverMirrorTurn(subscription, turn) {
   const title = getDesktopThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
   const responseParseMode = getFeedbackParseMode(subscription.channelType);
   const markdown = responseParseMode === "Markdown";
-  const renderedText = formatMirrorMessage(title, turn.userText, turn.text, markdown);
-  const renderedStreamText = formatMirrorMessage(title, turn.userText, turn.text, markdown, true);
+  const renderedTextBase = formatMirrorMessage(title, turn.userText, turn.text, markdown);
+  const renderedStreamTextBase = formatMirrorMessage(title, turn.userText, turn.text, markdown, true);
+  const renderedText = turn.timedOut ? appendMirrorTimeoutNotice(renderedTextBase || buildMirrorTitle(title, markdown), markdown) : renderedTextBase;
+  const renderedStreamText = turn.timedOut ? appendMirrorTimeoutNotice(renderedStreamTextBase || buildMirrorTitle(title, markdown), markdown) : renderedStreamTextBase;
   const text2 = renderedText ? renderFeedbackText(renderedText, responseParseMode) : "";
   const streamText = renderFeedbackText(
     renderedStreamText || buildMirrorTitle(title, markdown),
@@ -17916,7 +17946,8 @@ async function deliverMirrorTurn(subscription, turn) {
       const finalized = await adapter.onStreamEnd(
         subscription.chatId,
         turn.status,
-        streamText
+        streamText,
+        turn.streamKey
       );
       if (finalized) {
         subscription.lastDeliveredAt = turn.timestamp || nowIso();
@@ -17948,10 +17979,11 @@ async function deliverMirrorTurns(subscription, turns) {
     await deliverMirrorTurn(subscription, turn);
   }
 }
-function createMirrorTurnState(timestamp, turnId) {
+function createMirrorTurnState(sessionId, timestamp, turnId) {
   const safeTimestamp = timestamp || nowIso();
   return {
     turnId: turnId || null,
+    streamKey: buildMirrorStreamKey(sessionId, turnId || null, safeTimestamp),
     startedAt: safeTimestamp,
     lastActivityAt: safeTimestamp,
     userText: null,
@@ -17985,7 +18017,7 @@ ${normalized}` : normalized;
 }
 function ensureMirrorTurnState(subscription, record) {
   if (!subscription.pendingTurn) {
-    subscription.pendingTurn = createMirrorTurnState(record.timestamp, record.turnId);
+    subscription.pendingTurn = createMirrorTurnState(subscription.sessionId, record.timestamp, record.turnId);
     return subscription.pendingTurn;
   }
   if (!subscription.pendingTurn.turnId && record.turnId) {
@@ -18008,11 +18040,13 @@ function finalizeMirrorTurn(subscription, signature, timestamp, status, preferre
   const userText = pendingTurn.userText?.trim() || null;
   if (!text2 && !userText && pendingTurn.toolCalls.size === 0) return null;
   return {
+    streamKey: pendingTurn.streamKey,
     userText,
     text: text2,
     signature,
     timestamp: timestamp || pendingTurn.lastActivityAt || nowIso(),
-    status
+    status,
+    ...signature.startsWith("timeout:") ? { timedOut: true } : {}
   };
 }
 function consumeMirrorRecords(subscription, records) {
@@ -18026,7 +18060,7 @@ function consumeMirrorRecords(subscription, records) {
         if (superseded) finalized.push(superseded);
       }
       if (!subscription.pendingTurn) {
-        subscription.pendingTurn = createMirrorTurnState(record.timestamp, record.turnId);
+        subscription.pendingTurn = createMirrorTurnState(subscription.sessionId, record.timestamp, record.turnId);
       } else {
         if (!subscription.pendingTurn.turnId && record.turnId) {
           subscription.pendingTurn.turnId = record.turnId;
@@ -18305,11 +18339,21 @@ async function reconcileMirrorSubscription(subscription) {
       subscription.bufferedRecords.push(...filteredRecords);
     }
   }
+  const timedOutTurn = flushTimedOutMirrorTurn(subscription);
   if (getState().activeTasks.has(subscription.sessionId) || isMirrorSuppressed(subscription.sessionId)) {
+    if (timedOutTurn) {
+      try {
+        await deliverMirrorTurns(subscription, [timedOutTurn]);
+      } catch (error) {
+        subscription.dirty = true;
+        console.warn("[bridge-manager] Mirror delivery failed:", error instanceof Error ? error.message : error);
+      }
+    }
     syncMirrorSessionState(subscription.sessionId);
     return;
   }
-  const finalizedTurns = consumeBufferedMirrorTurns(subscription);
+  const finalizedTurns = timedOutTurn ? [timedOutTurn] : [];
+  finalizedTurns.push(...consumeBufferedMirrorTurns(subscription));
   if (finalizedTurns.length === 0) {
     syncMirrorSessionState(subscription.sessionId);
     return;
@@ -18712,7 +18756,8 @@ async function handleMessage(adapter, msg) {
     return;
   }
   const binding = resolve(msg.address);
-  adapter.onMessageStart?.(msg.address.chatId);
+  const streamKey = buildInteractiveStreamKey(binding.codepilotSessionId, msg.messageId);
+  adapter.onMessageStart?.(msg.address.chatId, streamKey);
   const taskAbort = new AbortController();
   const state = getState();
   resetMirrorSessionForInteractiveRun(binding.codepilotSessionId);
@@ -18773,7 +18818,7 @@ async function handleMessage(adapter, msg) {
       stripOutboundArtifactBlocksForStreaming(fullText)
     );
     try {
-      adapter.onStreamText(msg.address.chatId, rendered);
+      adapter.onStreamText(msg.address.chatId, rendered, streamKey);
     } catch {
     }
   } : void 0;
@@ -18785,7 +18830,7 @@ async function handleMessage(adapter, msg) {
       if (existing) existing.status = status;
     }
     try {
-      adapter.onToolEvent(msg.address.chatId, Array.from(toolCallTracker.values()));
+      adapter.onToolEvent(msg.address.chatId, Array.from(toolCallTracker.values()), streamKey);
     } catch {
     }
   } : void 0;
@@ -18818,7 +18863,8 @@ async function handleMessage(adapter, msg) {
         cardFinalized = await adapter.onStreamEnd(
           msg.address.chatId,
           status,
-          renderFeedbackTextForChannel(adapter.channelType, result.responseText)
+          renderFeedbackTextForChannel(adapter.channelType, result.responseText),
+          streamKey
         );
       } catch (err) {
         console.warn("[bridge-manager] Card finalize failed:", err instanceof Error ? err.message : err);
@@ -18863,7 +18909,7 @@ async function handleMessage(adapter, msg) {
     }
     if (hasStreamingCards && adapter.onStreamEnd && taskAbort.signal.aborted) {
       try {
-        await adapter.onStreamEnd(msg.address.chatId, "interrupted", "");
+        await adapter.onStreamEnd(msg.address.chatId, "interrupted", "", streamKey);
       } catch {
       }
     }
@@ -18872,7 +18918,7 @@ async function handleMessage(adapter, msg) {
     }
     state.activeTasks.delete(binding.codepilotSessionId);
     syncSessionRuntimeState(binding.codepilotSessionId);
-    adapter.onMessageEnd?.(msg.address.chatId);
+    adapter.onMessageEnd?.(msg.address.chatId, streamKey);
     ack();
   }
 }
@@ -18930,8 +18976,6 @@ async function handleCommand(adapter, msg, text2) {
         const oldTask = st.activeTasks.get(currentBinding.codepilotSessionId);
         if (oldTask) {
           oldTask.abort();
-          st.activeTasks.delete(currentBinding.codepilotSessionId);
-          syncSessionRuntimeState(currentBinding.codepilotSessionId);
         }
       }
       const workDir = resolved.workDir;
@@ -19377,8 +19421,6 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
       const taskAbort = st.activeTasks.get(binding.codepilotSessionId);
       if (taskAbort) {
         taskAbort.abort();
-        st.activeTasks.delete(binding.codepilotSessionId);
-        syncSessionRuntimeState(binding.codepilotSessionId);
         response = "\u6B63\u5728\u505C\u6B62\u5F53\u524D\u4EFB\u52A1...";
       } else {
         response = "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\u3002";

package/dist/ui-server.mjs

@@ -5045,7 +5045,9 @@ var CodexProvider = class {
               }
               let sawAnyEvent = false;
               try {
-                const { events } = await thread.runStreamed(input);
+                const { events } = await thread.runStreamed(input, {
+                  signal: params.abortController?.signal
+                });
                 for await (const event of events) {
                   sawAnyEvent = true;
                   if (params.abortController?.signal.aborted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-to-im",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "Installable Codex-to-IM bridge with local setup UI and background service",
   "license": "MIT",
   "homepage": "https://github.com/zhangle1987/codex-to-im#readme",