lark-remote 0.1.13 → 0.2.1

package/dist/router/utils.d.ts

@@ -45,6 +45,12 @@ export declare function formatUsageStats(usage?: {
     cumulativeCacheReadTokens?: number;
     /** Session-cumulative cache creation tokens (all runs). */
     cumulativeCacheCreationTokens?: number;
+    /** 实际生效模型（system.init 携带）。非空字符串才显示。 */
+    model?: string;
+    /** 本次 run 花费（USD）。存在才显示。 */
+    costUsd?: number;
+    /** 推理 token（pi 提供）。> 0 才显示。 */
+    reasoningTokens?: number;
 }, options?: {
     showResult?: boolean;
     result?: string;

package/dist/router/utils.js

@@ -46,6 +46,10 @@ export function formatUsageStats(usage, options) {
     const lines = [];
     // 1. Success 状态（通用格式，无具体结果值）
     lines.push('✅ 已完成');
+    // 1.4. 实际生效模型（非空字符串才显示）
+    if (usage?.model) {
+        lines.push(`Model - ${usage.model}`);
+    }
     // 1.5. 可选的结果行（showResult 为 true 时显示）
     if (options?.showResult && options?.result) {
         lines.push(`结果 - ${options.result}`);
@@ -140,6 +144,14 @@ export function formatUsageStats(usage, options) {
             lines.push(`Total token - ${formatTokenK(totalTokens)}${withCumGuard(totalTokens)}`);
         }
     }
+    // 8. 本次 run 花费（USD）
+    if (usage?.costUsd !== undefined) {
+        lines.push(`Cost - $${usage.costUsd.toFixed(4)}`);
+    }
+    // 9. 推理 token（> 0 才显示，格式对齐既有 token 行）
+    if (usage?.reasoningTokens !== undefined && usage.reasoningTokens > 0) {
+        lines.push(`Reasoning token - ${formatTokenK(usage.reasoningTokens)}`);
+    }
     return lines.join('\n');
 }
 //# sourceMappingURL=utils.js.map

package/dist/runner/bash/runner.d.ts

@@ -1,3 +1,5 @@
+import { type ShellBackend } from '../../platform/shell.js';
+import { type Terminator } from '../../platform/terminator.js';
 interface BashOutputEvent {
     type: 'stdout' | 'stderr' | 'exit';
     content: string;
@@ -32,11 +34,16 @@ export declare class BashProcessRunner implements BashRunner {
      */
     private readonly queueHighWater;
     private readonly queueLowWater;
-    private stopper;
+    private readonly terminator;
+    private readonly shell;
     constructor(opts?: {
         stopGraceMs?: number;
         queueHighWater?: number;
         queueLowWater?: number;
+        /** shell 后端注入（测试用）；默认按平台分发 */
+        shell?: ShellBackend;
+        /** 终止器注入（测试用）；默认按平台分发 */
+        terminator?: Terminator;
     });
     get isRunning(): boolean;
     run(command: string, opts: {
@@ -45,7 +52,7 @@ export declare class BashProcessRunner implements BashRunner {
     /**
      * P1-22: called by the process-level exit dispatcher on SIGINT/SIGTERM/exit.
      * Kills the whole process group (leader + background children) via
-     * ProcessStopper, matching agent-runner cleanupOnExit semantics.
+     * Terminator, matching agent-runner cleanupOnExit semantics.
      */
     cleanupOnExit(): void;
     stop(opts?: {

package/dist/runner/bash/runner.js

@@ -1,6 +1,7 @@
-import { spawn } from 'node:child_process';
 import { getLogger } from '../../logger/index.js';
-import { ProcessStopper } from '../common/process-stopper.js';
+import { createShellBackend, ShellUnavailableError, } from '../../platform/shell.js';
+import { createTerminator } from '../../platform/terminator.js';
+import { useDetachedProcessGroup } from '../../platform/spawn.js';
 import { registerExitCleanup, unregisterExitCleanup } from '../common/spawning-runner.js';
 /**
  * Lightweight bash executor for `!` commands.
@@ -22,7 +23,8 @@ export class BashProcessRunner {
      */
     queueHighWater;
     queueLowWater;
-    stopper;
+    terminator;
+    shell;
     constructor(opts) {
         const stopGraceMs = opts?.stopGraceMs ?? 1000;
         this.queueHighWater = opts?.queueHighWater ?? 32;
@@ -30,7 +32,10 @@ export class BashProcessRunner {
         if (this.queueLowWater > this.queueHighWater) {
             this.queueLowWater = this.queueHighWater;
         }
-        this.stopper = new ProcessStopper({ graceMs: stopGraceMs });
+        // `!` bash 无协议停止通道（§3.3）：posix 走组杀（与原 ProcessStopper 同实现），
+        // win32 优雅段显式跳过后树杀。
+        this.terminator = opts?.terminator ?? createTerminator({ graceMs: stopGraceMs, agent: 'bash' });
+        this.shell = opts?.shell ?? createShellBackend();
     }
     get isRunning() {
         return (this.currentProcess !== null &&
@@ -43,13 +48,33 @@ export class BashProcessRunner {
             throw new Error('bash process already running');
         }
         getLogger().debug(`[bash-runner] spawning command="${command}" cwd=${opts.cwd}`);
-        const proc = spawn('bash', ['-c', command], {
-            cwd: opts.cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            // Spawn in new process group so we can kill the entire group
-            detached: true,
-        });
+        let proc;
+        try {
+            proc = this.shell.spawn(command, {
+                cwd: opts.cwd,
+                options: {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    // posix 建新进程组（负 PID 组杀）；win32 不 detached（`.cmd` 垫片丢 stdio）
+                    detached: useDetachedProcessGroup(),
+                    windowsHide: true,
+                },
+            });
+        }
+        catch (err) {
+            // win32 Git Bash 缺失（§7.2）：同步抛出，转成明确错误输出而非悬死。
+            if (err instanceof ShellUnavailableError) {
+                getLogger().warn(`[bash-runner] shell unavailable: ${err.message}`);
+                yield { type: 'stderr', content: `${err.message}\n` };
+                yield { type: 'exit', content: '', exitCode: 1 };
+                return;
+            }
+            throw err;
+        }
         this.currentProcess = proc;
+        // stdio 固定为 ['ignore','pipe','pipe']，两条流必为 pipe（backend 返回的
+        // 宽化 ChildProcess 类型丢掉了这一点，这里收窄一次）
+        const stdout = proc.stdout;
+        const stderr = proc.stderr;
         getLogger().info(`[bash-runner] spawn pid=${proc.pid} command="${command.slice(0, 50)}..." cwd=${opts.cwd}`);
         // P1-22: register with the process-level exit dispatcher while the process
         // is alive — bridge exit/restart (SIGINT/SIGTERM/exit) then kills the whole
@@ -66,25 +91,25 @@ export class BashProcessRunner {
         const maybePauseStdout = () => {
             if (!stdoutPaused && stdoutQueue.length > this.queueHighWater) {
                 stdoutPaused = true;
-                proc.stdout.pause();
+                stdout.pause();
             }
         };
         const maybeResumeStdout = () => {
             if (stdoutPaused && stdoutQueue.length <= this.queueLowWater) {
                 stdoutPaused = false;
-                proc.stdout.resume();
+                stdout.resume();
             }
         };
         const maybePauseStderr = () => {
             if (!stderrPaused && stderrQueue.length > this.queueHighWater) {
                 stderrPaused = true;
-                proc.stderr.pause();
+                stderr.pause();
             }
         };
         const maybeResumeStderr = () => {
             if (stderrPaused && stderrQueue.length <= this.queueLowWater) {
                 stderrPaused = false;
-                proc.stderr.resume();
+                stderr.resume();
             }
         };
         // Resolved by a `data` event to signal "more output may be available,
@@ -98,14 +123,14 @@ export class BashProcessRunner {
                 resolve();
             }
         };
-        proc.stdout?.on('data', (chunk) => {
+        stdout.on('data', (chunk) => {
             const text = chunk.toString('utf-8');
             getLogger().debug(`[bash-runner] stdout: ${text.slice(0, 100)}`);
             stdoutQueue.push(text);
             maybePauseStdout();
             notifyData();
         });
-        proc.stderr?.on('data', (chunk) => {
+        stderr.on('data', (chunk) => {
             const text = chunk.toString('utf-8');
             getLogger().debug(`[bash-runner] stderr: ${text.slice(0, 100)}`);
             stderrQueue.push(text);
@@ -186,14 +211,14 @@ export class BashProcessRunner {
     /**
      * P1-22: called by the process-level exit dispatcher on SIGINT/SIGTERM/exit.
      * Kills the whole process group (leader + background children) via
-     * ProcessStopper, matching agent-runner cleanupOnExit semantics.
+     * Terminator, matching agent-runner cleanupOnExit semantics.
      */
     cleanupOnExit() {
         const proc = this.currentProcess;
         if (!proc || proc.exitCode !== null || proc.signalCode !== null)
             return;
         try {
-            void this.stopper.stop(proc, { immediate: true });
+            this.terminator.cleanupOnExit(proc);
         }
         catch {
             // fire-and-forget: nothing else to do at process exit
@@ -205,8 +230,8 @@ export class BashProcessRunner {
             this.currentProcess = null;
             return;
         }
-        // Delegate to ProcessStopper for unified stop semantics
-        await this.stopper.stop(proc, { immediate: opts?.immediate });
+        // Delegate to Terminator for unified stop semantics
+        await this.terminator.stop(proc, { immediate: opts?.immediate === true });
         this.currentProcess = null;
     }
 }

package/dist/runner/claude/session.d.ts

@@ -151,7 +151,10 @@ export declare class ClaudeSession extends SpawningRunner {
      * 的 post-result drain 在长驻模式下无对应物）。
      */
     private consumeTurn;
-    /** 构造进程退出且无终态 result 时的统一错误结果（对齐 SpawningRunner 语义）。 */
+    /**
+     * 构造进程退出且无终态 result 时的统一错误结果（对齐原 SpawningRunner
+     * buildResultEvent 语义，含 §4.4 win32 command-not-found 双条件定性）。
+     */
     private buildStreamEndedError;
     private wakeWaiters;
     /**

package/dist/runner/claude/session.js

@@ -31,7 +31,6 @@ import { readFile } from 'node:fs/promises';
 import { silentlyUnlink } from '../../common/fs.js';
 import { getLogger } from '../../logger/index.js';
 import { SpawningRunner } from '../common/spawning-runner.js';
-import { pipeAllStdio } from '../common/runner-utils.js';
 import { authErrorEvent, syntheticInitEvent } from '../common/runner-utils.js';
 import { makeQuestionApprovalEvent } from '../question-common.js';
 /** 拒绝权限时的默认提示（进入 claude 上下文，中文用户可读）。 */
@@ -246,7 +245,8 @@ export class ClaudeSession extends SpawningRunner {
     // SpawningRunner hooks
     // =========================================================================
     getStdio() {
-        return pipeAllStdio();
+        // stdin 也要 pipe：长驻会话经 stdin 写用户消息/审批响应。
+        return ['pipe', 'pipe', 'pipe'];
     }
     buildArgv(opts) {
         const args = [
@@ -312,6 +312,8 @@ export class ClaudeSession extends SpawningRunner {
         this.cwd = opts.cwd;
         this.autoApprove = false;
         this.pendingToolInputs.clear();
+        // §4.4 win32 嗅探嫌疑标记每次 spawn 重置（spawnChild 置位，收尾双条件消费）。
+        this.commandNotFoundSeen = false;
         // 每次 run 独立：上次 run 会话内跟踪到的计划文件不得泄漏到本次
         // （否则本次 ExitPlanMode 无 plan/planFilePath 时 resolvePlanContent
         // 会误读上一次的计划文件当当前计划）。
@@ -421,7 +423,10 @@ export class ClaudeSession extends SpawningRunner {
             }
         }
     }
-    /** 构造进程退出且无终态 result 时的统一错误结果（对齐 SpawningRunner 语义）。 */
+    /**
+     * 构造进程退出且无终态 result 时的统一错误结果（对齐原 SpawningRunner
+     * buildResultEvent 语义，含 §4.4 win32 command-not-found 双条件定性）。
+     */
     async buildStreamEndedError() {
         // 进程已死但 proc 'close' 事件可能略晚于 stdout 关闭：等退出登记拿可靠
         // code/signal。stdout 关闭 = 进程退出（claude 独占 stdout），'close' 必然
@@ -436,7 +441,16 @@ export class ClaudeSession extends SpawningRunner {
             errorMessage = `${this.binary} killed by signal ${exited.signal}${stderrTail ? `: ${stderrTail}` : ''}`;
         }
         else if (exited.code !== null && exited.code !== 0) {
-            errorMessage = `${this.binary} exited code=${exited.code}${stderrTail ? `: ${stderrTail}` : ''}`;
+            // §4.4 双条件定性：本分支已保证「用户未停 + signal 为 null + 非零退出」，
+            // 这里只补嗅探嫌疑标记这第二个条件。
+            const commandNotFound = this.commandNotFoundSeen;
+            if (commandNotFound) {
+                getLogger().error(`[${this.logTag}] command not found confirmed (win32 shim): exit=${exited.code} stderr=${this.spawnStderr.slice(-500)}`);
+            }
+            const cause = commandNotFound
+                ? `${this.binary} 命令未找到（win32 垫片启动失败：未安装或不在 PATH）`
+                : `${this.binary} exited code=${exited.code}`;
+            errorMessage = `${cause}${stderrTail ? `: ${stderrTail}` : ''}`;
         }
         else {
             errorMessage = `${this.binary} 输出流已结束，但未收到 result 事件${stderrTail ? `: ${stderrTail}` : ''}`;

package/dist/runner/codex/app-server/protocol-types.d.ts

@@ -222,7 +222,33 @@ export interface DiffItem {
     diff: string;
     timestamp: number;
 }
-export type ThreadItem = AgentMessageItem | ReasoningItem | CommandExecutionItem | PlanItem | FileChangeItem | ObservationItem | DiffItem | {
+/** Web search item（来源：codex-rs ThreadItem::WebSearch / v2 schema）。 */
+export interface WebSearchItem {
+    type: 'webSearch';
+    id: string;
+    query: string;
+    action?: unknown;
+}
+/** MCP tool call item（来源：codex-rs ThreadItem::McpToolCall / v2 schema）。 */
+export interface McpToolCallItem {
+    type: 'mcpToolCall';
+    id: string;
+    server: string;
+    tool: string;
+    arguments?: Record<string, unknown>;
+    result?: unknown;
+    error?: unknown;
+    status?: string;
+}
+/** Dynamic (client-registered) tool call item（来源：ThreadItem::DynamicToolCall）。 */
+export interface DynamicToolCallItem {
+    type: 'dynamicToolCall';
+    id: string;
+    tool: string;
+    arguments?: Record<string, unknown>;
+    status?: string;
+}
+export type ThreadItem = AgentMessageItem | ReasoningItem | CommandExecutionItem | PlanItem | FileChangeItem | WebSearchItem | McpToolCallItem | DynamicToolCallItem | ObservationItem | DiffItem | {
     type: 'userMessage';
     id: string;
     content: unknown[];
@@ -430,6 +456,14 @@ export interface ModelReroutedNotification {
         timestamp?: string;
     };
 }
+export interface TurnPlanUpdatedNotification {
+    method: 'turn/plan/updated';
+    params: {
+        threadId: string;
+        turnId?: string;
+        plan: PlanStep[];
+    };
+}
 export declare const ServerRequestMethod: {
     readonly COMMAND_EXECUTION_APPROVAL: "item/commandExecution/requestApproval";
     readonly FILE_CHANGE_APPROVAL: "item/fileChange/requestApproval";

package/dist/runner/codex/app-server/translator.d.ts

@@ -25,6 +25,11 @@ export declare class CodexAppServerTranslator {
     private reasoningByItem;
     /** Full command output per item id (item-scoped snapshot). */
     private toolOutputByItem;
+    /**
+     * Tool identity per item id (信息保真 C2): recorded at item/started, spread
+     * into every toolOutput turn_diff, released at item/completed.
+     */
+    private toolItemMeta;
     /** Full plan text per item id (item-scoped snapshot). */
     private planByItem;
     /** commandExecution items that emitted item/started (tool block position anchor). */
@@ -79,6 +84,19 @@ export declare class CodexAppServerTranslator {
     private handleCommandOutputDelta;
     private handlePlanUpdated;
     private handleTokenUsageUpdated;
+    /**
+     * warning 通知 → notice 事件（信息保真 C2：运行期告警不再静默丢弃）。
+     */
+    private handleWarning;
+    /**
+     * model/rerouted 通知 → notice 事件（模型重路由必须用户可见）。
+     */
+    private handleModelRerouted;
+    /**
+     * turn/plan/updated 通知 → plan 事件（PlanStep[] 渲染为 markdown 清单）。
+     * status 缺省或未知一律按 pending 处理（防御 wire 枚举漂移）。
+     */
+    private handleTurnPlanUpdated;
     private handleError;
     private handleThreadCompacted;
     private handleServerRequestResolved;

package/dist/runner/codex/app-server/translator.js

@@ -26,6 +26,11 @@ export class CodexAppServerTranslator {
     reasoningByItem = new Map();
     /** Full command output per item id (item-scoped snapshot). */
     toolOutputByItem = new Map();
+    /**
+     * Tool identity per item id (信息保真 C2): recorded at item/started, spread
+     * into every toolOutput turn_diff, released at item/completed.
+     */
+    toolItemMeta = new Map();
     /** Full plan text per item id (item-scoped snapshot). */
     planByItem = new Map();
     /** commandExecution items that emitted item/started (tool block position anchor). */
@@ -63,6 +68,12 @@ export class CodexAppServerTranslator {
                 return this.handleTokenUsageUpdated(params);
             case NotificationMethod.TURN_COMPLETED:
                 return this.handleTurnCompleted(params);
+            case NotificationMethod.WARNING:
+                return this.handleWarning(params);
+            case NotificationMethod.MODEL_REROUTED:
+                return this.handleModelRerouted(params);
+            case NotificationMethod.TURN_PLAN_UPDATED:
+                return this.handleTurnPlanUpdated(params);
             case NotificationMethod.ERROR:
                 return this.handleError(params);
             case NotificationMethod.THREAD_COMPACTED:
@@ -214,6 +225,7 @@ export class CodexAppServerTranslator {
         this.textByItem.clear();
         this.reasoningByItem.clear();
         this.toolOutputByItem.clear();
+        this.toolItemMeta.clear();
         this.planByItem.clear();
         this.startedToolItems.clear();
         this.fileChangeItems.clear();
@@ -314,10 +326,14 @@ export class CodexAppServerTranslator {
                 return [];
             }
             this.toolOutputByItem.set(item.id, authoritative);
+            // 信息保真 C2：完成事件同样携带身份，并在发出后释放 meta。
+            const meta = this.toolItemMeta.get(item.id);
+            this.toolItemMeta.delete(item.id);
             return [
                 {
                     type: 'turn_diff',
                     toolOutput: authoritative,
+                    ...meta,
                     itemId: item.id,
                     complete: true,
                     toolStatus: commandExecutionStatusToToolStatus(item.status),
@@ -367,6 +383,26 @@ export class CodexAppServerTranslator {
                 ];
             }
         }
+        // 信息保真 C2：webSearch/mcpToolCall/dynamicToolCall 等无专属 completed 分支的
+        // 工具 item 也必须收尾——否则 run-state 侧工具块永挂 running（无 completedAt/终态），
+        // toolItemMeta 泄漏到下个 turn 的 clear() 才被释放。
+        if (this.startedToolItems.has(item.id)) {
+            const meta = this.toolItemMeta.get(item.id);
+            this.toolItemMeta.delete(item.id);
+            this.startedToolItems.delete(item.id);
+            return [
+                {
+                    type: 'turn_diff',
+                    toolOutput: this.toolOutputByItem.get(item.id) ?? '',
+                    ...meta,
+                    itemId: item.id,
+                    complete: true,
+                    threadId: params.threadId,
+                    turnId: params.turnId,
+                    timestamp: this.now(),
+                },
+            ];
+        }
         return [];
     }
     handleReasoningTextDelta(params) {
@@ -393,6 +429,7 @@ export class CodexAppServerTranslator {
             {
                 type: 'turn_diff',
                 toolOutput: next,
+                ...this.toolItemMeta.get(params.itemId),
                 itemId: params.itemId,
                 threadId: params.threadId,
                 turnId: params.turnId,
@@ -428,6 +465,48 @@ export class CodexAppServerTranslator {
         };
         return [];
     }
+    /**
+     * warning 通知 → notice 事件（信息保真 C2：运行期告警不再静默丢弃）。
+     */
+    handleWarning(params) {
+        return [
+            {
+                type: 'notice',
+                level: 'warn',
+                code: params.code,
+                text: params.message,
+                timestamp: this.now(),
+            },
+        ];
+    }
+    /**
+     * model/rerouted 通知 → notice 事件（模型重路由必须用户可见）。
+     */
+    handleModelRerouted(params) {
+        return [
+            {
+                type: 'notice',
+                level: 'warn',
+                code: 'model/rerouted',
+                text: `模型已切换为 ${params.model}${params.reason ? `：${params.reason}` : ''}`,
+                timestamp: this.now(),
+            },
+        ];
+    }
+    /**
+     * turn/plan/updated 通知 → plan 事件（PlanStep[] 渲染为 markdown 清单）。
+     * status 缺省或未知一律按 pending 处理（防御 wire 枚举漂移）。
+     */
+    handleTurnPlanUpdated(params) {
+        const ICON = { completed: '✅', in_progress: '🔄', pending: '⬜', error: '❌' };
+        const markdown = params.plan
+            .map((s) => {
+            const status = s.status && s.status in ICON ? s.status : 'pending';
+            return `${ICON[status]} ${s.title}${s.subtitle ? ` — ${s.subtitle}` : ''}`;
+        })
+            .join('\n');
+        return [{ type: 'plan', plan: markdown, timestamp: this.now() }];
+    }
     handleError(params) {
         if (params.willRetry) {
             // 非终态错误：服务端会重试该 turn。提前结束 run 会造成桥与 server
@@ -574,10 +653,77 @@ export class CodexAppServerTranslator {
             // item/started 锚定工具块位置（真实时序）：命令开始时即创建工具块，
             // 而不是等到首个输出 delta——否则后续 reasoning item 会插到 command 之前。
             this.startedToolItems.add(item.id);
+            // 信息保真 C2：记录工具身份，随 turn_diff 透传（run-state 首见时写入）。
+            this.toolItemMeta.set(item.id, {
+                toolName: 'Bash',
+                toolInput: { command: item.command, ...(item.cwd ? { cwd: item.cwd } : {}) },
+                toolHint: 'shell',
+            });
+            return [
+                {
+                    type: 'turn_diff',
+                    toolOutput: '',
+                    ...this.toolItemMeta.get(item.id),
+                    itemId: item.id,
+                    threadId: params.threadId,
+                    turnId: params.turnId,
+                    timestamp: this.now(),
+                },
+            ];
+        }
+        if (item.type === 'webSearch') {
+            this.startedToolItems.add(item.id);
+            this.toolItemMeta.set(item.id, {
+                toolName: 'WebSearch',
+                toolInput: { query: item.query },
+                toolHint: 'web',
+            });
+            return [
+                {
+                    type: 'turn_diff',
+                    toolOutput: '',
+                    ...this.toolItemMeta.get(item.id),
+                    itemId: item.id,
+                    threadId: params.threadId,
+                    turnId: params.turnId,
+                    timestamp: this.now(),
+                },
+            ];
+        }
+        if (item.type === 'mcpToolCall') {
+            // ThreadItem union 含 catch-all 成员，判别收窄会与泛型成员并集；
+            // 显式断言到具体 interface（字段名已经 v2 schema 确认）。
+            const mcpItem = item;
+            this.startedToolItems.add(item.id);
+            this.toolItemMeta.set(item.id, {
+                toolName: `mcp__${mcpItem.server}__${mcpItem.tool}`,
+                toolInput: mcpItem.arguments ?? {},
+                toolHint: 'search',
+            });
+            return [
+                {
+                    type: 'turn_diff',
+                    toolOutput: '',
+                    ...this.toolItemMeta.get(item.id),
+                    itemId: item.id,
+                    threadId: params.threadId,
+                    turnId: params.turnId,
+                    timestamp: this.now(),
+                },
+            ];
+        }
+        if (item.type === 'dynamicToolCall') {
+            const dynItem = item;
+            this.startedToolItems.add(item.id);
+            this.toolItemMeta.set(item.id, {
+                toolName: dynItem.tool,
+                toolInput: dynItem.arguments ?? {},
+            });
             return [
                 {
                     type: 'turn_diff',
                     toolOutput: '',
+                    ...this.toolItemMeta.get(item.id),
                     itemId: item.id,
                     threadId: params.threadId,
                     turnId: params.turnId,