@ai-setting/roy-agent-cli 1.7.56 → 1.7.58

package/dist/bin/roy-agent.js

@@ -365,25 +365,46 @@ var exports_stream_output_service = {};
 __export(exports_stream_output_service, {
   streamAbortSignal: () => streamAbortSignal,
   resetStreamAbort: () => resetStreamAbort,
+  isStreamAborted: () => isStreamAborted,
   hasNumericUsage: () => hasNumericUsage,
   abortStream: () => abortStream,
+  __resetAllStreamAbortForTest: () => __resetAllStreamAbortForTest,
   StreamOutputService: () => StreamOutputService,
   COLORS: () => COLORS
 });
 import chalk2 from "chalk";
 import { createLogger as createLogger2, TracedAs as TracedAs2 } from "@ai-setting/roy-agent-core";
-function resetStreamAbort() {
-  streamAbortSignal.aborted = false;
+function resetStreamAbort(scope) {
+  if (scope === undefined) {
+    streamAbortSignal.aborted = false;
+    return;
+  }
+  abortedRuns.delete(scope);
+}
+function abortStream(scope) {
+  if (scope === undefined) {
+    streamAbortSignal.aborted = true;
+    return;
+  }
+  abortedRuns.add(scope);
+}
+function isStreamAborted(scope) {
+  if (streamAbortSignal.aborted)
+    return true;
+  if (scope === undefined)
+    return false;
+  return abortedRuns.has(scope);
 }
-function abortStream() {
-  streamAbortSignal.aborted = true;
+function __resetAllStreamAbortForTest() {
+  streamAbortSignal.aborted = false;
+  abortedRuns.clear();
 }
 function hasNumericUsage(usage) {
   if (!usage)
     return false;
   return typeof usage.promptTokens === "number" || typeof usage.completionTokens === "number" || typeof usage.totalTokens === "number" || typeof usage.cacheRead === "number" || typeof usage.cacheWrite === "number" || typeof usage.promptTokensTotal === "number";
 }
-var logger2, COLORS, streamAbortSignal, StreamOutputService;
+var logger2, COLORS, streamAbortSignal, abortedRuns, StreamOutputService;
 var init_stream_output_service = __esm(() => {
   init_markdown_renderer();
   logger2 = createLogger2("stream-output");
@@ -406,6 +427,7 @@ var init_stream_output_service = __esm(() => {
   streamAbortSignal = {
     aborted: false
   };
+  abortedRuns = new Set;
   StreamOutputService = class StreamOutputService {
     fullText = "";
     fullReasoning = "";
@@ -421,6 +443,9 @@ var init_stream_output_service = __esm(() => {
     reasoningClosedByText = false;
     chunkCallback = undefined;
     silent = false;
+    sessionFilter = undefined;
+    acceptsSidelessEvents = true;
+    runId = undefined;
     constructor(options = {}) {
       this.options = options;
       this.silent = options.silent ?? false;
@@ -435,6 +460,15 @@ var init_stream_output_service = __esm(() => {
     setChunkCallback(cb) {
       this.chunkCallback = cb;
     }
+    setSessionFilter(sessionId) {
+      this.sessionFilter = sessionId;
+    }
+    setAcceptsSidelessEvents(accepts) {
+      this.acceptsSidelessEvents = accepts;
+    }
+    setRunId(runId) {
+      this.runId = runId;
+    }
     emitChunk(event) {
       if (!this.chunkCallback)
         return;
@@ -455,7 +489,8 @@ var init_stream_output_service = __esm(() => {
       console.log(message);
     }
     checkAbort() {
-      if (streamAbortSignal.aborted) {
+      const aborted = this.runId !== undefined ? isStreamAborted(this.runId) : streamAbortSignal.aborted;
+      if (aborted) {
         this.logStdout(`
 ${COLORS.system("[已中断]")}
 `);
@@ -463,7 +498,25 @@ ${COLORS.system("[已中断]")}
       }
       return false;
     }
+    extractEventSessionId(event) {
+      const fromMeta = event?.metadata?.sessionId;
+      if (typeof fromMeta === "string" && fromMeta.length > 0)
+        return fromMeta;
+      const fromPayload = event?.payload?.metadata?.sessionId;
+      if (typeof fromPayload === "string" && fromPayload.length > 0)
+        return fromPayload;
+      return;
+    }
     handleEvent(event) {
+      if (this.sessionFilter !== undefined) {
+        const eventSessionId = this.extractEventSessionId(event);
+        if (eventSessionId === undefined) {
+          if (!this.acceptsSidelessEvents)
+            return;
+        } else if (eventSessionId !== this.sessionFilter) {
+          return;
+        }
+      }
       if (this.checkAbort()) {
         return;
       }
@@ -9586,7 +9639,7 @@ class CliQuietModeService {
 // package.json
 var package_default = {
   name: "@ai-setting/roy-agent-cli",
-  version: "1.7.56",
+  version: "1.7.58",
   type: "module",
   description: "CLI for roy-agent - Non-interactive command execution",
   main: "./dist/index.js",
@@ -11239,6 +11292,9 @@ class QueryExecutor {
     showToolResults: false
   };
   _pendingContextConfig = null;
+  _pendingSessionScope = undefined;
+  _pendingAcceptsSideless = undefined;
+  _sidelessPolicyExplicit = false;
   _pendingChunkCallback = undefined;
   failureNotifier;
   constructor(options) {
@@ -11277,6 +11333,14 @@ class QueryExecutor {
       this.streamService.setChunkCallback(this._pendingChunkCallback);
       this._pendingChunkCallback = undefined;
     }
+    if (this._pendingAcceptsSideless !== undefined) {
+      this.streamService.setAcceptsSidelessEvents(this._pendingAcceptsSideless);
+      this._pendingAcceptsSideless = undefined;
+    }
+    if (this._pendingSessionScope !== undefined) {
+      this.streamService.setSessionFilter(this._pendingSessionScope);
+      this.streamService.setRunId(this._pendingSessionScope);
+    }
     if (this._pendingContextConfig) {
       this.streamService.setContextInfo(this._pendingContextConfig.contextWindow, this._pendingContextConfig.contextWindow * this._pendingContextConfig.thresholdRatio);
       this._pendingContextConfig = null;
@@ -11302,6 +11366,18 @@ class QueryExecutor {
       this._pendingChunkCallback = cb;
     }
   }
+  setSessionScope(sessionId) {
+    this._pendingSessionScope = sessionId;
+    if (this.streamService) {
+      this.streamService.setSessionFilter(sessionId);
+      this.streamService.setRunId(sessionId);
+    }
+  }
+  setAcceptsSidelessEvents(accepts) {
+    this._pendingAcceptsSideless = accepts;
+    this._sidelessPolicyExplicit = true;
+    this.streamService?.setAcceptsSidelessEvents(accepts);
+  }
   handleEvent(event) {
     if (event.type === "context.threshold_exceeded" && !this.quiet) {
       const payload = event.payload;
@@ -11322,6 +11398,13 @@ class QueryExecutor {
       showToolResults: streamOptions?.showToolResults ?? this.streamOptions.showToolResults
     };
     this.subscribeToEvents(options);
+    if (sessionId) {
+      this.streamService?.setSessionFilter(sessionId);
+      this.streamService?.setRunId(sessionId);
+      if (!this._sidelessPolicyExplicit) {
+        this.streamService?.setAcceptsSidelessEvents(true);
+      }
+    }
     this.streamService?.reset();
     if (!this.quiet) {
       this.output.info(`执行: ${message}`);
@@ -11696,8 +11779,268 @@ import {
 } from "@ai-setting/roy-agent-core";
 
 // src/commands/shared/event-handler.ts
+import {
+  getEnvContext,
+  runWithEnvContextAsync
+} from "@ai-setting/roy-agent-core/env";
 import { TracedAs as TracedAs5 } from "@ai-setting/roy-agent-core";
 import { notifyReactFailure as notifyReactFailure2 } from "@ai-setting/roy-agent-core/env/error-reply";
+
+// src/commands/shared/telemetry-notice.ts
+import { spawn } from "node:child_process";
+import { normalizeLarkAtMentions } from "@ai-setting/roy-agent-core/env/lark-mention-utils";
+import { deriveIdempotencyKey } from "@ai-setting/roy-agent-core/env/event-source/idempotency-key";
+var TELEMETRY_EVENT_TYPES = new Set([
+  "task.background.started",
+  "task.background.progress"
+]);
+function isTelemetryEvent(type) {
+  if (!type)
+    return false;
+  return TELEMETRY_EVENT_TYPES.has(type);
+}
+var MAX_TITLE_CHARS = 40;
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function formatElapsed(ms) {
+  if (!Number.isFinite(ms) || ms <= 0)
+    return "0m";
+  const totalMin = Math.floor(ms / 60000);
+  if (totalMin < 60)
+    return `${totalMin}m`;
+  const totalHour = Math.floor(totalMin / 60);
+  const min = totalMin % 60;
+  if (totalHour < 24) {
+    return min === 0 ? `${totalHour}h` : `${totalHour}h${min}m`;
+  }
+  const day = Math.floor(totalHour / 24);
+  const hour = totalHour % 24;
+  return hour === 0 ? `${day}d` : `${day}d${hour}h`;
+}
+function formatClock(ts) {
+  const d = new Date(ts);
+  return `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+}
+function formatTimeoutLabel(ms) {
+  if (!Number.isFinite(ms) || ms <= 0)
+    return "0m";
+  return formatElapsed(ms);
+}
+function truncateTitle(raw) {
+  const s = raw.trim();
+  if (s.length <= MAX_TITLE_CHARS)
+    return s;
+  return `${s.slice(0, MAX_TITLE_CHARS)}…`;
+}
+function pickString(v) {
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+function pickNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+function buildTelemetryNoticeText(type, payload, now = Date.now()) {
+  const p = payload ?? {};
+  const taskId = pickNumber(p.associatedTaskId);
+  const bgId = pickString(p.backgroundTaskId);
+  const desc = truncateTitle(pickString(p.description) ?? "后台任务");
+  let label;
+  if (taskId !== undefined)
+    label = `Task #${taskId}`;
+  else if (bgId)
+    label = bgId;
+  else
+    label = "后台任务";
+  const head = type === "task.background.started" ? `\uD83D\uDD14 ${label}「${desc}」已启动` : `\uD83D\uDD04 ${label}「${desc}」后台运行中`;
+  const parts = [];
+  const startedAt = pickNumber(p.startedAt);
+  const timeoutMs = pickNumber(p.timeoutMs);
+  if (type !== "task.background.started" && startedAt !== undefined) {
+    parts.push(`已跑 ${formatElapsed(now - startedAt)}`);
+  }
+  if (startedAt !== undefined && timeoutMs !== undefined) {
+    parts.push(`预计 ${formatClock(startedAt + timeoutMs)} 超时（timeout ${formatTimeoutLabel(timeoutMs)}）`);
+  }
+  let text = head;
+  if (parts.length > 0)
+    text += `
+${parts.join("，")}`;
+  const progressMessage = pickString(p.progressMessage);
+  if (progressMessage)
+    text += `
+${progressMessage}`;
+  return text;
+}
+var DEFAULT_SEND_TIMEOUT_MS = 5000;
+var MAX_IDEMPOTENCY_KEY_LEN = 50;
+function deriveTelemetryIdempotencyKey(eventId, chatId) {
+  const anchor = pickString(eventId) ?? `ts-${Date.now()}-${Math.random()}`;
+  return deriveIdempotencyKey(["telemetry", anchor, chatId]);
+}
+function buildLarkSendArgs(input) {
+  const { chatId, text, profile, idempotencyKey } = input;
+  const args = [
+    "im",
+    "+messages-send",
+    "--chat-id",
+    chatId,
+    "--markdown",
+    normalizeLarkAtMentions(text),
+    "--as",
+    "bot"
+  ];
+  if (idempotencyKey) {
+    args.push("--idempotency-key", idempotencyKey.slice(0, MAX_IDEMPOTENCY_KEY_LEN));
+  }
+  if (profile)
+    args.unshift("--profile", profile);
+  return args;
+}
+function sendLarkChatMarkdown(options) {
+  const { chatId, text, profile, idempotencyKey } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
+  if (!chatId) {
+    return Promise.reject(new Error("sendLarkChatMarkdown: empty chatId"));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer;
+    const finish = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      if (err)
+        reject(err);
+      else
+        resolve();
+    };
+    const args = buildLarkSendArgs({ chatId, text, profile, idempotencyKey });
+    let proc;
+    try {
+      proc = spawn("lark-cli", args, {
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      finish(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    let stderr = "";
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      finish(new Error(`lark-cli timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    proc.on("close", (code) => {
+      if (code === 0)
+        finish();
+      else
+        finish(new Error(`lark-cli exited with code ${code}: ${stderr}`));
+    });
+    proc.on("error", (err) => finish(err));
+  });
+}
+function targetFromEventMetadata(metadata) {
+  if (!metadata)
+    return;
+  const replyChannel = metadata.replyChannel;
+  const chatId = pickString(replyChannel?.chatId) ?? pickString(metadata.chatId);
+  if (!chatId)
+    return;
+  const profile = pickString(replyChannel?.profile) ?? pickString(metadata.profile);
+  return profile ? { chatId, profile } : { chatId };
+}
+async function targetFromTriggerEvent(eventStore, triggerEventId) {
+  if (!eventStore || !triggerEventId)
+    return;
+  let persisted;
+  try {
+    persisted = await eventStore.getEventById(triggerEventId);
+  } catch {
+    return;
+  }
+  if (!persisted || typeof persisted !== "object")
+    return;
+  const metadata = persisted.metadata;
+  if (!metadata || typeof metadata !== "object")
+    return;
+  return targetFromEventMetadata(metadata);
+}
+
+// src/commands/shared/self-echo-filter.ts
+var BOT_SENDER_TYPES = new Set(["bot", "app"]);
+function pickString2(v) {
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+function extractSenderIdentity(event) {
+  if (!event)
+    return {};
+  const metadata = event.metadata;
+  const payload = event.payload;
+  const payloadMeta = payload?.metadata;
+  const rawEvent = payload?.rawEvent;
+  const innerEvent = rawEvent?.event;
+  const innerSender = innerEvent?.sender;
+  const topSender = rawEvent?.sender;
+  const senderType = pickString2(metadata?.senderType) ?? pickString2(payloadMeta?.senderType) ?? pickString2(rawEvent?.sender_type) ?? pickString2(innerSender?.sender_type) ?? pickString2(topSender?.sender_type) ?? pickString2(payload?.senderType);
+  const nestedSenderId = innerSender?.sender_id ?? topSender?.sender_id;
+  const senderId = pickString2(metadata?.senderId) ?? pickString2(payloadMeta?.senderId) ?? pickString2(payload?.senderId) ?? pickString2(rawEvent?.sender_id) ?? (typeof nestedSenderId === "string" ? pickString2(nestedSenderId) : pickString2(nestedSenderId?.open_id) ?? pickString2(nestedSenderId?.user_id) ?? pickString2(nestedSenderId?.union_id));
+  return {
+    ...senderType ? { senderType } : {},
+    ...senderId ? { senderId } : {}
+  };
+}
+function isSelfEchoEvent(event, options = {}) {
+  const { senderType, senderId } = extractSenderIdentity(event);
+  if (options.enabled === false) {
+    return {
+      skip: false,
+      reason: "disabled",
+      ...senderType ? { senderType } : {},
+      ...senderId ? { senderId } : {}
+    };
+  }
+  if (senderType && BOT_SENDER_TYPES.has(senderType.toLowerCase())) {
+    return {
+      skip: true,
+      reason: "bot-sender",
+      ...senderType ? { senderType } : {},
+      ...senderId ? { senderId } : {}
+    };
+  }
+  if (senderId && options.selfBotIds && options.selfBotIds.length > 0) {
+    if (options.selfBotIds.includes(senderId)) {
+      return {
+        skip: true,
+        reason: "self-bot-id",
+        ...senderType ? { senderType } : {},
+        senderId
+      };
+    }
+  }
+  return {
+    skip: false,
+    ...senderType ? { senderType } : {},
+    ...senderId ? { senderId } : {}
+  };
+}
+var SELF_ECHO_FILTER_ENABLED_ENV = "ROY_AGENT_SELF_ECHO_FILTER";
+function readSelfEchoFilterEnabled(env = process.env) {
+  const raw = env[SELF_ECHO_FILTER_ENABLED_ENV];
+  if (raw === undefined)
+    return true;
+  const v = raw.trim().toLowerCase();
+  return !(v === "0" || v === "false" || v === "off" || v === "no");
+}
+
+// src/commands/shared/event-handler.ts
 function parseLarkPerTaskChatId(contextJson) {
   if (!contextJson)
     return;
@@ -11717,6 +12060,8 @@ var NOTIFY_V2_TERMINAL_TYPES = new Set([
 ]);
 
 class EventHandler {
+  static DEFAULT_LANE_KEY = "__default__";
+  static DEFAULT_MAX_CONCURRENT_SESSIONS = 4;
   env;
   eventTypes;
   onEvent;
@@ -11724,15 +12069,39 @@ class EventHandler {
   formatter;
   isIdle;
   idleCheckInterval;
-  queue = [];
-  isProcessing = false;
+  isSessionIdleFn = null;
+  maxConcurrentSessions;
+  lanes = new Map;
+  runningLanes = new Set;
+  laneTails = new Map;
+  get isProcessing() {
+    return this.runningLanes.size > 0;
+  }
+  chatSessionCache = new Map;
+  inFlightCount = 0;
+  legacyQueue = [];
+  get queue() {
+    return this.legacyQueue;
+  }
   isStopped = false;
   unsubscribe = null;
+  activeSlots = 0;
+  slotWaiters = [];
+  sessionChains = new Map;
   sessionComponent = null;
   activeEventSessionId = null;
   resolvedSessionByTrigger = new Map;
   eventStore = null;
   getHandlerForEsType = null;
+  telemetrySender = (notice) => sendLarkChatMarkdown(notice);
+  selfEchoFilter = {
+    enabled: true,
+    selfBotIds: []
+  };
+  selfEchoDroppedCount = 0;
+  getSelfEchoDroppedCount() {
+    return this.selfEchoDroppedCount;
+  }
   constructor(options) {
     this.env = options.env;
     this.eventTypes = options.eventTypes;
@@ -11740,10 +12109,18 @@ class EventHandler {
     this.onEventWithEnv = options.onEventWithEnv;
     this.formatter = options.formatter ?? new EventMessageFormatter;
     this.isIdle = options.isIdle ?? (() => true);
+    this.isSessionIdleFn = options.isSessionIdle ?? null;
+    const maxSessions = options.maxConcurrentSessions;
+    this.maxConcurrentSessions = typeof maxSessions === "number" && Number.isFinite(maxSessions) && maxSessions >= 1 ? Math.floor(maxSessions) : EventHandler.DEFAULT_MAX_CONCURRENT_SESSIONS;
     this.idleCheckInterval = options.idleCheckInterval ?? 100;
     this.sessionComponent = options.sessionComponent ?? null;
     this.eventStore = options.eventStore ?? null;
     this.getHandlerForEsType = options.getHandlerForEsType ?? null;
+    this.telemetrySender = options.telemetrySender ?? ((notice) => sendLarkChatMarkdown(notice));
+    this.selfEchoFilter = {
+      enabled: options.selfEchoFilter?.enabled ?? readSelfEchoFilterEnabled(),
+      selfBotIds: options.selfEchoFilter?.selfBotIds ?? []
+    };
   }
   start() {
     this.isStopped = false;
@@ -11777,17 +12154,58 @@ class EventHandler {
       this.unsubscribe();
       this.unsubscribe = null;
     }
-    this.queue = [];
-    this.isProcessing = false;
+    this.lanes.clear();
+    this.legacyQueue = [];
+    this.laneTails.clear();
+    const waiters = this.slotWaiters.splice(0, this.slotWaiters.length);
+    for (const w of waiters)
+      w();
+    this.activeSlots = 0;
     this.clearActiveSession();
   }
   async handleEvent(event) {
     if (this.isStopped) {
       return;
     }
+    if (this.selfEchoFilter.enabled) {
+      const verdict = isSelfEchoEvent(event, {
+        selfBotIds: this.selfEchoFilter.selfBotIds
+      });
+      if (verdict.skip) {
+        this.selfEchoDroppedCount += 1;
+        console.error(`[EventHandler] self-echo event dropped (reason=${verdict.reason}` + `, senderType=${verdict.senderType ?? "-"}` + `, senderId=${verdict.senderId ?? "-"}` + `, type=${event.type})`);
+        return;
+      }
+    }
+    if (isTelemetryEvent(event.type)) {
+      this.sendTelemetryNotice(event);
+      return;
+    }
     const formatted = await this.formatEvent(event);
     this.enqueue(formatted);
   }
+  async sendTelemetryNotice(event) {
+    try {
+      const metadata = event.metadata;
+      let target = targetFromEventMetadata(metadata);
+      if (!target) {
+        const triggerEventId = typeof metadata?.triggerEventId === "string" ? metadata.triggerEventId : undefined;
+        target = await targetFromTriggerEvent(this.eventStore, triggerEventId);
+      }
+      if (!target) {
+        return;
+      }
+      const text = buildTelemetryNoticeText(event.type, event.payload);
+      await this.telemetrySender({
+        chatId: target.chatId,
+        ...target.profile ? { profile: target.profile } : {},
+        text,
+        idempotencyKey: deriveTelemetryIdempotencyKey(event.id, target.chatId)
+      });
+    } catch (err) {
+      console.error(`[EventHandler] telemetry notice failed (swallowed) type=${event.type}`, err);
+    }
+  }
   async formatEvent(event) {
     if (NOTIFY_V2_TERMINAL_TYPES.has(event.type) && event.metadata?.triggerEventId && this.eventStore && this.getHandlerForEsType) {
       try {
@@ -11900,77 +12318,218 @@ class EventHandler {
       await this.onEvent(formatted.message);
     }
   }
+  laneKeyFor(item) {
+    if (item.chatId)
+      return item.chatId;
+    if (item.triggerSessionId)
+      return `trigger:${item.triggerSessionId}`;
+    return EventHandler.DEFAULT_LANE_KEY;
+  }
   enqueue(formattedEvent) {
     if (this.isStopped) {
       return;
     }
-    this.queue.push(formattedEvent);
-    if (!this.isProcessing) {
-      this.processQueue();
+    const item = { ...formattedEvent };
+    if (!item.envContext) {
+      item.envContext = getEnvContext();
     }
+    const laneKey = this.laneKeyFor(item);
+    const lane = this.lanes.get(laneKey);
+    if (lane) {
+      lane.push(item);
+    } else {
+      this.lanes.set(laneKey, [item]);
+    }
+    this.scheduleLane(laneKey);
   }
   getQueueLength() {
-    return this.queue.length;
+    let total = this.legacyQueue.length + this.inFlightCount;
+    for (const lane of this.lanes.values()) {
+      total += lane.length;
+    }
+    return total;
   }
   isQueueEmpty() {
-    return this.queue.length === 0;
+    return this.getQueueLength() === 0;
   }
-  async processQueue() {
-    this.isProcessing = true;
-    const chatSessionCache = new Map;
-    while (!this.isStopped && this.queue.length > 0) {
-      await this.waitForIdle();
-      if (this.isStopped) {
-        break;
+  isSessionIdle(laneKey) {
+    return !this.runningLanes.has(laneKey);
+  }
+  getRunningLaneKeys() {
+    return Array.from(this.runningLanes);
+  }
+  scheduleLane(laneKey) {
+    if (this.isStopped)
+      return;
+    if (this.runningLanes.has(laneKey))
+      return;
+    this.runningLanes.add(laneKey);
+    const tail = this.runLane(laneKey).catch((err) => {
+      console.error(`[EventHandler] lane ${laneKey} 处理异常:`, err);
+    }).finally(() => {
+      this.runningLanes.delete(laneKey);
+      this.laneTails.delete(laneKey);
+      const rest = this.lanes.get(laneKey);
+      if (rest && rest.length > 0) {
+        this.scheduleLane(laneKey);
       }
-      const item = this.queue.shift();
-      if (!item) {
+    });
+    this.laneTails.set(laneKey, tail);
+  }
+  async runLane(laneKey) {
+    while (!this.isStopped) {
+      const lane = this.lanes.get(laneKey);
+      if (!lane || lane.length === 0) {
         break;
       }
-      let sessionId = null;
-      if (item.chatId && this.sessionComponent) {
-        const cached = chatSessionCache.get(item.chatId);
-        if (cached) {
-          sessionId = cached;
-        } else {
-          sessionId = await this.ensureChatSession(item.chatId);
-          if (sessionId) {
-            chatSessionCache.set(item.chatId, sessionId);
+      const head = lane[0];
+      const sessionId = await runWithEnvContextAsync(head.envContext, () => this.resolveSessionForItem(laneKey, head));
+      if (this.isStopped)
+        break;
+      const canonicalKey = sessionId ?? laneKey;
+      if (canonicalKey !== laneKey) {
+        const mine = this.lanes.get(laneKey) ?? [];
+        if (mine.length > 0) {
+          const target = this.lanes.get(canonicalKey);
+          if (target) {
+            target.push(...mine);
+          } else {
+            this.lanes.set(canonicalKey, mine);
           }
+          this.lanes.delete(laneKey);
+          this.scheduleLane(canonicalKey);
         }
-        if (!sessionId) {
-          console.warn(`[EventHandler] Failed to ensure chat-keyed session (chatId=${item.chatId}), ` + `falling back to trigger_session_id path`);
-          sessionId = await this.ensureActiveSession(item.triggerSessionId);
-        }
-      } else {
-        sessionId = await this.ensureActiveSession(item.triggerSessionId);
+        return;
       }
+      await this.waitForIdle(sessionId ?? laneKey);
+      if (this.isStopped)
+        break;
+      const claimKey = sessionId ?? laneKey;
+      const releaseClaim = await this.claimSession(claimKey);
       if (this.isStopped) {
+        releaseClaim();
         break;
       }
-      if (sessionId) {
-        item.eventSessionId = sessionId;
+      await this.acquireSlot();
+      if (this.isStopped) {
+        releaseClaim();
+        this.releaseSlot();
+        break;
       }
       try {
+        const item = lane.shift();
+        if (!item)
+          break;
+        this.inFlightCount++;
+        try {
+          await this.processItem(item, sessionId);
+        } finally {
+          this.inFlightCount--;
+        }
+      } finally {
+        releaseClaim();
+        this.releaseSlot();
+      }
+    }
+    const rest = this.lanes.get(laneKey);
+    if (!rest || rest.length === 0) {
+      this.lanes.delete(laneKey);
+    }
+  }
+  async resolveSessionForItem(laneKey, item) {
+    if (item.sessionResolved) {
+      return item.resolvedSessionId ?? null;
+    }
+    const resolved = await this.resolveSessionForItemUncached(laneKey, item);
+    item.sessionResolved = true;
+    item.resolvedSessionId = resolved;
+    return resolved;
+  }
+  async resolveSessionForItemUncached(laneKey, item) {
+    if (item.chatId && this.sessionComponent) {
+      const cached = this.chatSessionCache.get(item.chatId);
+      if (cached)
+        return cached;
+      let resolved = await this.ensureChatSession(item.chatId);
+      if (!resolved) {
+        console.warn(`[EventHandler] Failed to ensure chat-keyed session (chatId=${item.chatId}), ` + `falling back to trigger_session_id path`);
+        resolved = await this.ensureActiveSession(item.triggerSessionId);
+      } else {
+        this.chatSessionCache.set(item.chatId, resolved);
+      }
+      return resolved;
+    }
+    return this.ensureActiveSession(item.triggerSessionId);
+  }
+  async processItem(item, sessionId) {
+    if (sessionId) {
+      item.eventSessionId = sessionId;
+    }
+    try {
+      await runWithEnvContextAsync(item.envContext, async () => {
         if (this.onEventWithEnv) {
           await this.onEventWithEnv(item);
-          continue;
+          return;
         }
         await this.onEvent(item.message);
-      } catch (error) {
-        console.error(`[EventHandler] 处理事件失败:`, error);
-        try {
-          await notifyReactFailure2({
-            error,
-            envEvent: item.envEvent,
-            sessionId
-          });
-        } catch (notifyErr) {
-          console.error(`[EventHandler] 失败说明回飞书异常:`, notifyErr);
-        }
+      });
+    } catch (error) {
+      console.error(`[EventHandler] 处理事件失败:`, error);
+      try {
+        await notifyReactFailure2({
+          error,
+          envEvent: item.envEvent,
+          sessionId: sessionId ?? undefined
+        });
+      } catch (notifyErr) {
+        console.error(`[EventHandler] 失败说明回飞书异常:`, notifyErr);
       }
     }
-    this.isProcessing = false;
+  }
+  async processQueue() {
+    if (this.isStopped)
+      return;
+    if (this.legacyQueue.length > 0) {
+      const pending = this.legacyQueue.splice(0, this.legacyQueue.length);
+      for (const item of pending) {
+        if (!item.envContext) {
+          item.envContext = getEnvContext();
+        }
+        const laneKey = this.laneKeyFor(item);
+        const lane = this.lanes.get(laneKey);
+        if (lane)
+          lane.push(item);
+        else
+          this.lanes.set(laneKey, [item]);
+      }
+    }
+    for (const [laneKey, lane] of Array.from(this.lanes.entries())) {
+      if (lane.length > 0)
+        this.scheduleLane(laneKey);
+    }
+    const tails = Array.from(this.laneTails.values());
+    if (tails.length > 0) {
+      await Promise.all(tails.map((t) => t.catch(() => {
+        return;
+      })));
+    }
+  }
+  async acquireSlot() {
+    if (this.activeSlots < this.maxConcurrentSessions) {
+      this.activeSlots++;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.slotWaiters.push(resolve);
+    });
+    this.activeSlots++;
+  }
+  releaseSlot() {
+    if (this.activeSlots > 0)
+      this.activeSlots--;
+    const next = this.slotWaiters.shift();
+    if (next)
+      next();
   }
   async ensureActiveSession(triggerSessionIdOverride) {
     if (!this.sessionComponent)
@@ -12080,6 +12639,7 @@ class EventHandler {
   clearActiveSession() {
     this.activeEventSessionId = null;
     this.resolvedSessionByTrigger.clear();
+    this.chatSessionCache.clear();
   }
   cacheResolvedSession(triggerSessionIdOverride, sessionId) {
     if (triggerSessionIdOverride && sessionId) {
@@ -12089,11 +12649,38 @@ class EventHandler {
   getActiveEventSessionId() {
     return this.activeEventSessionId;
   }
-  async waitForIdle() {
-    while (!this.isStopped && !this.isIdle()) {
+  async waitForIdle(sessionId) {
+    while (!this.isStopped && !this.isLaneIdle(sessionId)) {
       await this.sleep(this.idleCheckInterval);
     }
   }
+  isLaneIdle(sessionId) {
+    if (this.isSessionIdleFn && sessionId) {
+      return this.isSessionIdleFn(sessionId);
+    }
+    return this.isIdle();
+  }
+  claimSession(sessionKey) {
+    const prev = this.sessionChains.get(sessionKey) ?? Promise.resolve();
+    let releaseFn;
+    const current = new Promise((resolve) => {
+      releaseFn = resolve;
+    });
+    const tail = prev.then(() => current);
+    this.sessionChains.set(sessionKey, tail);
+    return prev.then(() => {
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        releaseFn();
+        if (this.sessionChains.get(sessionKey) === tail) {
+          this.sessionChains.delete(sessionKey);
+        }
+      };
+    });
+  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -12106,6 +12693,14 @@ __legacyDecorateClassTS([
   ]),
   __legacyMetadataTS("design:returntype", typeof Promise === "undefined" ? Object : Promise)
 ], EventHandler.prototype, "handleEvent", null);
+__legacyDecorateClassTS([
+  TracedAs5("event_handler.telemetry_notice", { recordParams: true, recordResult: false }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof EnvEvent === "undefined" ? Object : EnvEvent
+  ]),
+  __legacyMetadataTS("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], EventHandler.prototype, "sendTelemetryNotice", null);
 __legacyDecorateClassTS([
   TracedAs5("cli.event-handler.formatEvent", { recordParams: true, recordResult: false }),
   __legacyMetadataTS("design:type", Function),
@@ -12188,12 +12783,24 @@ function createEventHandlerForInteractive(options) {
   const dbPath = options.dbPath ?? createDefaultEventStoreDbPath();
   const eventStore = getOrCreateEventStore(dbPath);
   const getHandlerForEsType = getHandlerForEsTypeForEnv(options.env);
+  const maxConcurrentSessions = options.maxConcurrentSessions ?? readMaxConcurrentSessionsFromEnv();
   return new EventHandler({
     ...options,
+    ...maxConcurrentSessions !== undefined ? { maxConcurrentSessions } : {},
     eventStore,
     getHandlerForEsType
   });
 }
+var MAX_CONCURRENT_SESSIONS_ENV = "ROY_AGENT_MAX_CONCURRENT_SESSIONS";
+function readMaxConcurrentSessionsFromEnv(env = process.env) {
+  const raw = env[MAX_CONCURRENT_SESSIONS_ENV];
+  if (raw === undefined || raw.trim() === "")
+    return;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1)
+    return;
+  return Math.max(1, Math.floor(parsed));
+}
 
 // src/commands/shared/esc-active-descendant.ts
 function hasActiveDescendants(env, parentSessionId) {
@@ -12866,7 +13473,8 @@ var USER_PROMPT = COLORS.accent("❯ ");
 class REPL {
   rl;
   options;
-  isExecuting = false;
+  executingSessions = new Map;
+  static LEGACY_SESSION_KEY = "__legacy_isExecuting__";
   replMode = "ready";
   statusBarCtx = {};
   isAltEnterPending = false;
@@ -13059,7 +13667,10 @@ ${COLORS.system("[正在中断...]")}`);
           }
         }
         abortStream();
-        this.isExecuting = false;
+        for (const sid of this.getExecutingSessionIds()) {
+          abortStream(sid);
+        }
+        this.abortAllExecutingSessions();
         console.log(`${COLORS.system("[已中断，可以继续输入]")}`);
       } else {
         console.log(`
@@ -13144,7 +13755,8 @@ ${COLORS.system("[没有正在执行的请求]")}`);
           this.inkApi = api;
         },
         onSubmit: async (input) => {
-          this.isExecuting = true;
+          const inkSessionId = this.options.sessionId;
+          this.markSessionExecuting(inkSessionId, true);
           inkApiRef?.setMode("executing");
           try {
             await this.options.onExecute(input);
@@ -13162,7 +13774,7 @@ ${COLORS.system("[没有正在执行的请求]")}`);
             inkApiRef?.appendMessage({ role: "system", content: `[Error] ${msg}` });
             throw err;
           } finally {
-            this.isExecuting = false;
+            this.markSessionExecuting(inkSessionId, false);
           }
         },
         onCommand: async (cmd) => {
@@ -13315,7 +13927,8 @@ ${COLORS.error("❓ 未知命令: /" + cmd + "}")}`);
     }
   }
   async handleMessage(message) {
-    if (this.isExecuting) {
+    const inputSessionId = this.options.sessionId;
+    if (!this.isSessionIdle(inputSessionId)) {
       console.log(`
 ${COLORS.system("⏳ 上一次请求尚未完成，请稍候...")}
 `);
@@ -13382,7 +13995,7 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
         };
       }
     }
-    this.currentAgentContext = {
+    const agentContext = {
       agentType: agentFromEvent,
       pluginEnabled,
       envEvent: envEventForAgent,
@@ -13390,9 +14003,12 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
       eventSessionId,
       systemPrompt: envEvent.metadata?.systemPrompt
     };
-    await this.executeInternal(message, { showPrompt: true });
+    await this.executeInternal(message, {
+      showPrompt: true,
+      sessionId: eventSessionId,
+      agentContext
+    });
   }
-  currentAgentContext = undefined;
   lastReplyChannel = undefined;
   lastReplyChannelByChat = new Map;
   static REPLY_CHANNEL_CHAT_CACHE_MAX = 100;
@@ -13411,7 +14027,56 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
     }
   }
   isIdle() {
-    return !this.isExecuting;
+    return !this.anySessionBusy();
+  }
+  anySessionBusy() {
+    for (const count of this.execSet().values()) {
+      if (count > 0)
+        return true;
+    }
+    return false;
+  }
+  execSet() {
+    if (!this.executingSessions)
+      this.executingSessions = new Map;
+    return this.executingSessions;
+  }
+  get isExecuting() {
+    return this.anySessionBusy();
+  }
+  set isExecuting(executing) {
+    if (!executing) {
+      this.execSet().clear();
+      return;
+    }
+    this.execSet().set(REPL.LEGACY_SESSION_KEY, 1);
+  }
+  markSessionExecuting(sessionId, executing) {
+    const counts = this.execSet();
+    if (executing) {
+      counts.set(sessionId, (counts.get(sessionId) ?? 0) + 1);
+      return;
+    }
+    const current = counts.get(sessionId) ?? 0;
+    if (current <= 1) {
+      counts.delete(sessionId);
+    } else {
+      counts.set(sessionId, current - 1);
+    }
+  }
+  isSessionIdle(sessionId) {
+    return (this.execSet().get(sessionId) ?? 0) <= 0;
+  }
+  getExecutingSessionIds() {
+    const ids = [];
+    for (const [sid, count] of this.execSet().entries()) {
+      if (count > 0)
+        ids.push(sid);
+    }
+    return ids;
+  }
+  abortAllExecutingSessions() {
+    this.execSet().clear();
   }
   setMode(mode, detail) {
     this.replMode = mode;
@@ -13434,30 +14099,37 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
     }));
   }
   async executeInternal(message, options) {
-    this.isExecuting = true;
-    this.setMode("executing");
-    const agentContext = this.currentAgentContext;
-    this.currentAgentContext = undefined;
+    const execSessionId = options.sessionId ?? this.options.sessionId;
+    const agentContext = {
+      ...options.agentContext,
+      eventSessionId: options.agentContext?.eventSessionId ?? execSessionId
+    };
     resetStreamAbort();
     const provider = getTracerProvider3();
     const tracer = provider.getTracer("roy-tracer");
-    const existingContext = provider.getGlobalContext();
+    const payloadTraceContext = agentContext?.envEvent?.metadata?.traceContext;
+    const existingContext = payloadTraceContext ?? provider.getGlobalContext();
     let rootSpan;
     let traceId;
-    if (existingContext) {
-      rootSpan = tracer.startSpan("interactive.execute", {
-        parent: existingContext
-      });
-      traceId = existingContext.traceId;
-    } else {
-      rootSpan = tracer.startSpan("interactive.execute");
-      traceId = rootSpan.spanContext.traceId;
-      provider.setGlobalContext(rootSpan.spanContext);
-    }
-    console.log(`${COLORS.system("[Trace] " + traceId)}`);
-    console.log(`${COLORS.progress("[thinking...]")}`);
+    let runTraceContext = existingContext;
     try {
-      await this.options.onExecute(message, traceId, agentContext);
+      this.markSessionExecuting(execSessionId, true);
+      this.setMode("executing");
+      await provider.withGlobalContext(runTraceContext, async () => {
+        if (existingContext) {
+          rootSpan = tracer.startSpan("interactive.execute", {
+            parent: existingContext
+          });
+          traceId = existingContext.traceId;
+        } else {
+          rootSpan = tracer.startSpan("interactive.execute");
+          traceId = rootSpan.spanContext.traceId;
+          runTraceContext = rootSpan.spanContext;
+        }
+        console.log(`${COLORS.system("[Trace] " + traceId)}`);
+        console.log(`${COLORS.progress("[thinking...]")}`);
+        await this.options.onExecute(message, traceId, agentContext);
+      });
       if (this.options.onAfterExecute) {
         try {
           await this.options.onAfterExecute(this.lastUsage);
@@ -13473,7 +14145,7 @@ ${COLORS.system("[通知2] ❯ " + message.replace(/\n/g, `
         console.error(`
 ${COLORS.error("❌ 执行失败: " + error)}
 `);
-        rootSpan.setAttribute("error", String(error));
+        rootSpan?.setAttribute("error", String(error));
         try {
           await notifyReactFailure3({
             error,
@@ -13485,14 +14157,15 @@ ${COLORS.error("❌ 执行失败: " + error)}
         }
       }
     } finally {
-      rootSpan.end();
-      if (existingContext) {
-        provider.setGlobalContext(existingContext);
-      } else {
-        provider.setGlobalContext(undefined);
+      try {
+        provider.runInGlobalContextSync(runTraceContext, () => rootSpan?.end());
+      } catch (endErr) {
+        logger6.warn("root span end failed (ignored)", { error: String(endErr) });
+      }
+      this.markSessionExecuting(execSessionId, false);
+      if (this.isIdle()) {
+        this.setMode("ready");
       }
-      this.isExecuting = false;
-      this.setMode("ready");
       if (options.showPrompt) {
         this.redrawInputArea();
         if (this.rl) {
@@ -13662,6 +14335,9 @@ ${COLORS.error("❌ 执行失败: " + error)}
       }
     }
     abortStream();
+    for (const sid of this.getExecutingSessionIds()) {
+      abortStream(sid);
+    }
     if (this.inkApi && typeof this.inkApi.finishAssistantStream === "function") {
       try {
         this.inkApi.finishAssistantStream();
@@ -13688,7 +14364,7 @@ ${COLORS.error("❌ 执行失败: " + error)}
       }
     }
     if (isExecuting) {
-      this.isExecuting = false;
+      this.abortAllExecutingSessions();
     }
     this.setMode("ready");
     if (this.rl) {
@@ -13891,6 +14567,57 @@ function createInteractiveCommand(externalEnvService) {
           quiet: true,
           silent: useInk
         });
+        const MAX_SESSION_EXECUTORS = 16;
+        const sessionExecutors = new Map;
+        const runningTurns = new Set;
+        let sessionChunkCallback = undefined;
+        const getSessionExecutor = (sid) => {
+          if (!sid)
+            return queryExecutor;
+          const cached = sessionExecutors.get(sid);
+          if (cached) {
+            sessionExecutors.delete(sid);
+            sessionExecutors.set(sid, cached);
+            return cached;
+          }
+          const created = new QueryExecutor({
+            env,
+            sessionComponent,
+            output,
+            quiet: true,
+            silent: true
+          });
+          created.initStreamOutput(llmComponent);
+          created.setSessionScope(sid);
+          created.setAcceptsSidelessEvents(false);
+          created.setChunkCallback(sessionChunkCallback);
+          sessionExecutors.set(sid, created);
+          while (sessionExecutors.size > MAX_SESSION_EXECUTORS) {
+            let victim;
+            for (const key of sessionExecutors.keys()) {
+              if (!runningTurns.has(key)) {
+                victim = key;
+                break;
+              }
+            }
+            if (victim === undefined)
+              break;
+            const evicted = sessionExecutors.get(victim);
+            sessionExecutors.delete(victim);
+            try {
+              evicted?.dispose();
+            } catch {}
+          }
+          return created;
+        };
+        const disposeSessionExecutors = () => {
+          for (const ex of sessionExecutors.values()) {
+            try {
+              ex.dispose();
+            } catch {}
+          }
+          sessionExecutors.clear();
+        };
         let currentAgentContext = undefined;
         if (args.agent && args.agent !== "default") {
           const agentComponent = env.getComponent("agent");
@@ -13993,7 +14720,8 @@ function createInteractiveCommand(externalEnvService) {
           version: getPackageVersion(),
           useInk,
           onExecute: async (message, traceId, agentContext) => {
-            resetStreamAbort();
+            const runSessionId = agentContext?.eventSessionId;
+            resetStreamAbort(runSessionId);
             const preloadedPrompts = eventSourceSystemPrompts;
             const eventSourceSystemPrompt = preloadedPrompts.length > 0 ? joinResolvedSystemPrompts(preloadedPrompts) : undefined;
             const mergedContext = {
@@ -14008,16 +14736,27 @@ function createInteractiveCommand(externalEnvService) {
               }
             };
             const effectiveSessionId = mergedContext.eventSessionId ?? sessionId;
-            const result = await queryExecutor.execute(message, effectiveSessionId, {
-              showReasoning: args.reasoning,
-              showToolCalls: args.toolCalls,
-              showToolResults: args.toolResults
-            }, traceId, mergedContext);
-            if (result && !queryExecutor.getFullText()) {
-              console.log(result);
+            const isEventDrivenTurn = !!runSessionId && runSessionId !== sessionId;
+            const exec2 = isEventDrivenTurn ? getSessionExecutor(effectiveSessionId) : queryExecutor;
+            runningTurns.add(effectiveSessionId);
+            try {
+              const result = await exec2.execute(message, effectiveSessionId, {
+                showReasoning: args.reasoning,
+                showToolCalls: args.toolCalls,
+                showToolResults: args.toolResults
+              }, traceId, mergedContext);
+              if (result && !exec2.getFullText()) {
+                console.log(result);
+              } else if (isEventDrivenTurn) {
+                const full = exec2.getFullText();
+                if (full)
+                  console.log(full);
+              }
+              repl.setLastUsage(exec2.getLastUsage());
+              return result;
+            } finally {
+              runningTurns.delete(effectiveSessionId);
             }
-            repl.setLastUsage(queryExecutor.getLastUsage());
-            return result;
           },
           onAfterExecute: (usage) => {
             if (useInk)
@@ -14042,6 +14781,7 @@ function createInteractiveCommand(externalEnvService) {
           onSwitchSession: async (newSessionId) => {
             const result = await sessionManager.switchSession(newSessionId);
             queryExecutor.dispose();
+            disposeSessionExecutors();
             return result;
           },
           onCompact: async () => {
@@ -14091,6 +14831,7 @@ function createInteractiveCommand(externalEnvService) {
           eventTypes: ["task.background.*", "event-source.event.*"],
           formatter: new EventMessageFormatter({ prefix: "[通知]" }),
           isIdle: () => repl.isIdle(),
+          isSessionIdle: (sid) => repl.isSessionIdle(sid),
           sessionComponent,
           onEvent: async (_message) => {},
           onEventWithEnv: async (formattedEvent) => {
@@ -14124,6 +14865,20 @@ function createInteractiveCommand(externalEnvService) {
         repl.sessionManager = sessionManager;
         repl.sessionComponent = sessionComponent;
         repl._queryExecutor = queryExecutor;
+        {
+          let inkCb = null;
+          Object.defineProperty(repl, "inkChunkCallback", {
+            configurable: true,
+            get: () => inkCb,
+            set: (cb) => {
+              inkCb = cb;
+              sessionChunkCallback = cb ?? undefined;
+              for (const ex of sessionExecutors.values()) {
+                ex.setChunkCallback(sessionChunkCallback);
+              }
+            }
+          });
+        }
         await repl.start();
         process.removeListener("SIGINT", sigintHandler);
         console.log("正在清理资源...");
@@ -14135,6 +14890,7 @@ function createInteractiveCommand(externalEnvService) {
         }
         eventHandler.stop();
         queryExecutor.dispose();
+        disposeSessionExecutors();
         const esComponent = env.getComponent("event-source");
         if (esComponent) {
           const sources = esComponent.list?.();
@@ -15502,6 +16258,7 @@ async function loadHandleQuery(options, hooks) {
   const llmComponent = envService.getLLM();
   queryExecutor.initStreamOutput(llmComponent ?? null);
   const handleQuery = async (message, envEvent) => {
+    const eventTraceContext = envEvent?.metadata?.traceContext;
     const mergedContext = {
       ...agentContext,
       model: options.model,
@@ -15516,7 +16273,7 @@ async function loadHandleQuery(options, hooks) {
       showReasoning: options.reasoning ?? true,
       showToolCalls: options.toolCalls ?? true,
       showToolResults: options.toolResults ?? false
-    }, undefined, mergedContext);
+    }, eventTraceContext?.traceId, mergedContext);
     return String(result ?? "");
   };
   const taskEventHandler = new TaskEventHandler({
@@ -15593,6 +16350,7 @@ function createStreamHandleQuery(queryExecutor, sessionId, options, agentContext
           break;
       }
     });
+    const eventTraceContext = envEvent?.metadata?.traceContext;
     const mergedContext = {
       ...agentContext,
       model: options.model,
@@ -15607,7 +16365,7 @@ function createStreamHandleQuery(queryExecutor, sessionId, options, agentContext
       showReasoning: options.reasoning ?? true,
       showToolCalls: true,
       showToolResults: true
-    }, undefined, mergedContext);
+    }, eventTraceContext?.traceId, mergedContext);
     return String(result ?? "");
   };
 }