@ai-zen/agents-sdk 0.5.7 → 0.7.0

package/dist/capabilities/implements/builtin/LsTool.d.ts

@@ -1,6 +1,8 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS } from "@ai-zen/agents-core";
 export declare class LsTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         path: string;

package/dist/capabilities/implements/builtin/LsTool.js

@@ -1,25 +1,23 @@
 import * as fsp from "fs/promises";
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class LsTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "ls",
-                description: "列出目录",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: {
-                            type: "string",
-                            description: "目录路径",
-                        },
-                    },
-                    required: ["path"],
-                    additionalProperties: false,
+    function = {
+        name: "ls",
+        description: "列出目录",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "目录路径",
                 },
             },
-            env,
-        });
+            required: ["path"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
     async call(input) {
         try {

package/dist/capabilities/implements/builtin/MkdirTool.d.ts

@@ -1,6 +1,8 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS } from "@ai-zen/agents-core";
 export declare class MkdirTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         path: string;

package/dist/capabilities/implements/builtin/MkdirTool.js

@@ -1,29 +1,27 @@
 import * as fsp from "fs/promises";
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class MkdirTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "mkdir",
-                description: "创建目录",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: {
-                            type: "string",
-                            description: "目录路径",
-                        },
-                        recursive: {
-                            type: "boolean",
-                            description: "是否递归创建子目录",
-                        },
-                    },
-                    required: ["path"],
-                    additionalProperties: false,
+    function = {
+        name: "mkdir",
+        description: "创建目录",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "目录路径",
+                },
+                recursive: {
+                    type: "boolean",
+                    description: "是否递归创建子目录",
                 },
             },
-            env,
-        });
+            required: ["path"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
     async call(input) {
         try {

package/dist/capabilities/implements/builtin/ReadFileTool.d.ts

@@ -1,6 +1,8 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS } from "@ai-zen/agents-core";
 export declare class ReadFileTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         path: string;

package/dist/capabilities/implements/builtin/ReadFileTool.js

@@ -1,25 +1,23 @@
 import * as fsp from "fs/promises";
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class ReadFileTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "readFile",
-                description: "读取文件",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: {
-                            type: "string",
-                            description: "文件路径",
-                        },
-                    },
-                    required: ["path"],
-                    additionalProperties: false,
+    function = {
+        name: "readFile",
+        description: "读取文件",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "文件路径",
                 },
             },
-            env,
-        });
+            required: ["path"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
     async call(input) {
         try {

package/dist/capabilities/implements/builtin/RenameTool.d.ts

@@ -1,6 +1,8 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS } from "@ai-zen/agents-core";
 export declare class RenameTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         oldPath: string;

package/dist/capabilities/implements/builtin/RenameTool.js

@@ -1,29 +1,27 @@
 import * as fsp from "fs/promises";
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class RenameTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "rename",
-                description: "重命名或移动文件/目录（相当于 mv 命令）",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        oldPath: {
-                            type: "string",
-                            description: "原路径",
-                        },
-                        newPath: {
-                            type: "string",
-                            description: "新路径",
-                        },
-                    },
-                    required: ["oldPath", "newPath"],
-                    additionalProperties: false,
+    function = {
+        name: "rename",
+        description: "重命名或移动文件/目录（相当于 mv 命令）",
+        parameters: {
+            type: "object",
+            properties: {
+                oldPath: {
+                    type: "string",
+                    description: "原路径",
+                },
+                newPath: {
+                    type: "string",
+                    description: "新路径",
                 },
             },
-            env,
-        });
+            required: ["oldPath", "newPath"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
     async call(input) {
         try {

package/dist/capabilities/implements/builtin/RmTool.d.ts

@@ -1,6 +1,8 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS } from "@ai-zen/agents-core";
 export declare class RmTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         path: string;

package/dist/capabilities/implements/builtin/RmTool.js

@@ -1,29 +1,27 @@
 import * as fsp from "fs/promises";
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class RmTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "rm",
-                description: "删除文件或目录",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: {
-                            type: "string",
-                            description: "文件或目录路径",
-                        },
-                        recursive: {
-                            type: "boolean",
-                            description: "是否递归删除子目录",
-                        },
-                    },
-                    required: ["path"],
-                    additionalProperties: false,
+    function = {
+        name: "rm",
+        description: "删除文件或目录",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "文件或目录路径",
+                },
+                recursive: {
+                    type: "boolean",
+                    description: "是否递归删除子目录",
                 },
             },
-            env,
-        });
+            required: ["path"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
     async call(input) {
         try {

package/dist/capabilities/implements/builtin/SleepTool.d.ts

@@ -1,8 +1,10 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS, ToolCallContext } from "@ai-zen/agents-core";
 export declare class SleepTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         ms: number;
-    }): Promise<string>;
+    }, ctx?: ToolCallContext): Promise<string>;
 }

package/dist/capabilities/implements/builtin/SleepTool.js

@@ -1,26 +1,24 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class SleepTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "sleep",
-                description: "等待指定的时间（毫秒）。用于需要延迟执行的场景，例如等待其他操作完成、操作间隔控制等。注意：过长的等待时间会影响响应速度，建议不超过 30000 毫秒（30 秒）。",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        ms: {
-                            type: "number",
-                            description: "等待的毫秒数（1 秒 = 1000 毫秒）。建议不超过 30000（30 秒）。",
-                        },
-                    },
-                    required: ["ms"],
-                    additionalProperties: false,
+    function = {
+        name: "sleep",
+        description: "等待指定的时间（毫秒）。用于需要延迟执行的场景，例如等待其他操作完成、操作间隔控制等。注意：过长的等待时间会影响响应速度，建议不超过 30000 毫秒（30 秒）。",
+        parameters: {
+            type: "object",
+            properties: {
+                ms: {
+                    type: "number",
+                    description: "等待的毫秒数（1 秒 = 1000 毫秒）。建议不超过 30000（30 秒）。",
                 },
             },
-            env,
-        });
+            required: ["ms"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
-    async call(input) {
+    async call(input, ctx) {
         const ms = input.ms;
         if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) {
             return JSON.stringify({
@@ -35,7 +33,29 @@ export class SleepTool extends SdkCallbackTool {
                 error: `等待时间 ${ms}ms 过长，建议不超过 300000ms（5 分钟）。如需长时间等待请分段执行。`,
             });
         }
-        await new Promise((resolve) => setTimeout(resolve, ms));
+        // 若 signal 已处于 aborted，直接返回中断结果，避免不必要的等待
+        const signal = ctx?.signal;
+        // 等待 ms 毫秒，中断（abort）时提前结束
+        await new Promise((resolve) => {
+            if (signal?.aborted) {
+                resolve();
+                return;
+            }
+            const timer = setTimeout(resolve, ms);
+            if (signal) {
+                signal.addEventListener("abort", () => {
+                    clearTimeout(timer);
+                    resolve();
+                }, { once: true });
+            }
+        });
+        if (signal?.aborted) {
+            return JSON.stringify({
+                success: false,
+                aborted: true,
+                error: "等待被中断（aborted）",
+            });
+        }
         return JSON.stringify({
             success: true,
             waitedMs: ms,

package/dist/capabilities/implements/builtin/ViewImageTool.d.ts

@@ -0,0 +1,24 @@
+import type { AgentNS, ToolCallContext } from "@ai-zen/agents-core";
+import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
+import type { AgentDefinition, AppConfig, ToolEnv } from "../../../types/index.js";
+/**
+ * 查看图片工具 — 让 Agent 主动查看/分析一张图片。**仅对视觉模型可用**：
+ * 由 `isAvailable(config, definition)` 声明（从 definition.modelId 解析模型，检查 Model.vision），
+ * buildTools 阶段按声明过滤——非视觉模型不会拿到该工具，故无需运行时重复校验。
+ *
+ * 输入 `path_or_url`：
+ *   - http(s) URL → 直接以 `image_url` 内容块返回，模型直接查看；
+ *   - 本地路径 → 自动通过 Files API（DeepSeek）上传，以 `file` 内容块（file_id）返回。
+ *
+ * 不使用 base64 内联（本地图片走 Files API，符合 DeepSeek 推荐与 48 MiB 请求体限制）。
+ * 依赖配置中的 deepseek 端点（Files API 能力）；URL 场景不依赖上传。
+ */
+export declare class ViewImageTool extends SdkCallbackTool {
+    /** 仅视觉模型可用：从 definition.modelId 解析当前模型，非视觉模型由 buildTools 过滤 */
+    isAvailable(config: AppConfig, definition: AgentDefinition): boolean;
+    function: AgentNS.FunctionDefine;
+    constructor(env: ToolEnv);
+    call(input: {
+        path_or_url?: string;
+    }, ctx?: ToolCallContext): Promise<AgentNS.MessageContent>;
+}

package/dist/capabilities/implements/builtin/ViewImageTool.js

@@ -0,0 +1,109 @@
+import OpenAI, { toFile } from "openai";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
+const SUPPORTED_EXT = [".jpg", ".jpeg", ".png", ".gif", ".webp"];
+/**
+ * 查看图片工具 — 让 Agent 主动查看/分析一张图片。**仅对视觉模型可用**：
+ * 由 `isAvailable(config, definition)` 声明（从 definition.modelId 解析模型，检查 Model.vision），
+ * buildTools 阶段按声明过滤——非视觉模型不会拿到该工具，故无需运行时重复校验。
+ *
+ * 输入 `path_or_url`：
+ *   - http(s) URL → 直接以 `image_url` 内容块返回，模型直接查看；
+ *   - 本地路径 → 自动通过 Files API（DeepSeek）上传，以 `file` 内容块（file_id）返回。
+ *
+ * 不使用 base64 内联（本地图片走 Files API，符合 DeepSeek 推荐与 48 MiB 请求体限制）。
+ * 依赖配置中的 deepseek 端点（Files API 能力）；URL 场景不依赖上传。
+ */
+export class ViewImageTool extends SdkCallbackTool {
+    /** 仅视觉模型可用：从 definition.modelId 解析当前模型，非视觉模型由 buildTools 过滤 */
+    isAvailable(config, definition) {
+        const modelId = definition.modelId ?? config.defaultModel;
+        const model = (config.models ?? []).find((m) => m.id === modelId);
+        return model?.vision === true;
+    }
+    function = {
+        name: "viewImage",
+        description: "查看一张图片并分析其内容。传入本地图片路径或 http(s) 图片 URL。本地图片会自动上传（Files API）后引用，网络图片直接引用。适合识别图片文字、描述图片内容、分析图表等。",
+        parameters: {
+            type: "object",
+            properties: {
+                path_or_url: {
+                    type: "string",
+                    description: "本地图片路径（相对/绝对）或 http(s) 图片 URL。支持的格式：JPEG、PNG、GIF、WebP。",
+                },
+            },
+            required: ["path_or_url"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
+    }
+    async call(input, ctx) {
+        const signal = ctx?.signal;
+        const target = input?.path_or_url;
+        if (!target || !target.trim()) {
+            return "viewImage 需要提供 path_or_url 参数（本地图片路径或 http(s) URL）。";
+        }
+        const value = target.trim();
+        try {
+            // 网络图片：直接返回 image_url 内容块（无需上传）
+            if (/^https?:\/\//i.test(value)) {
+                return [
+                    {
+                        type: "text",
+                        text: `已获取网络图片：${value}`,
+                    },
+                    { type: "image_url", image_url: { url: value } },
+                ];
+            }
+            // 本地图片：解析路径 + 校验 + Files API 上传
+            const absPath = path.isAbsolute(value)
+                ? value
+                : path.join(this.env.cwd, value);
+            let stat;
+            try {
+                stat = await fs.stat(absPath);
+            }
+            catch {
+                return `本地图片不存在: ${absPath}`;
+            }
+            if (!stat.isFile()) {
+                return `"${absPath}" 不是文件。`;
+            }
+            const ext = path.extname(absPath).toLowerCase();
+            if (!SUPPORTED_EXT.includes(ext)) {
+                return `不支持的图片格式 "${ext || "(无扩展名)"}"。支持的格式：JPEG、PNG、GIF、WebP。`;
+            }
+            // 上传端点：deepseek（Files API 能力）
+            const endpoint = (this.env.config.endpoints ?? []).find((e) => e.id === "deepseek");
+            if (!endpoint) {
+                return "未配置 deepseek 端点，无法上传本地图片（Files API）。如需查看本地图片，请先配置 deepseek 端点；网络图片 URL 可直接使用。";
+            }
+            if (!endpoint.apiKey) {
+                return `端点 "${endpoint.name}" 的 API Key 未设置，无法上传本地图片。`;
+            }
+            const client = new OpenAI({
+                apiKey: endpoint.apiKey,
+                baseURL: endpoint.baseUrl,
+            });
+            const file = await toFile(await fs.readFile(absPath), path.basename(absPath));
+            const uploaded = await client.files.create({ file, purpose: "user_data" }, { signal });
+            return [
+                {
+                    type: "text",
+                    text: `图片已上传（${path.basename(absPath)}），file_id: ${uploaded.id}`,
+                },
+                { type: "file", file_id: uploaded.id },
+            ];
+        }
+        catch (error) {
+            // 中断（abort）时返回明确的中断结果
+            if (signal?.aborted) {
+                return "图片查看被中断（aborted）";
+            }
+            return `查看图片失败: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+}

package/dist/capabilities/implements/builtin/WriteFileTool.d.ts

@@ -1,6 +1,8 @@
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 import type { ToolEnv } from "../../../types/index.js";
+import type { AgentNS } from "@ai-zen/agents-core";
 export declare class WriteFileTool extends SdkCallbackTool {
+    function: AgentNS.FunctionDefine;
     constructor(env: ToolEnv);
     call(input: {
         path: string;

package/dist/capabilities/implements/builtin/WriteFileTool.js

@@ -2,29 +2,27 @@ import * as fsp from "fs/promises";
 import * as path from "path";
 import { SdkCallbackTool } from "../../../runtime/SdkCallbackTool.js";
 export class WriteFileTool extends SdkCallbackTool {
-    constructor(env) {
-        super({
-            function: {
-                name: "writeFile",
-                description: "写入文件",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: {
-                            type: "string",
-                            description: "文件路径",
-                        },
-                        content: {
-                            type: "string",
-                            description: "文件内容",
-                        },
-                    },
-                    required: ["path", "content"],
-                    additionalProperties: false,
+    function = {
+        name: "writeFile",
+        description: "写入文件",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "文件路径",
+                },
+                content: {
+                    type: "string",
+                    description: "文件内容",
                 },
             },
-            env,
-        });
+            required: ["path", "content"],
+            additionalProperties: false,
+        },
+    };
+    constructor(env) {
+        super({ env });
     }
     async call(input) {
         try {

package/dist/capabilities/implements/builtin/index.d.ts

@@ -17,13 +17,15 @@ import { BatchEditTool } from "./BatchEditTool.js";
 import { EditTool } from "./EditTool.js";
 import { ExecAsyncTool } from "./ExecAsyncTool.js";
 import { SleepTool } from "./SleepTool.js";
+import { ViewImageTool } from "./ViewImageTool.js";
 import { GenerateImageTool } from "./GenerateImageTool.js";
 /**
- * 17 个无条件注册的内置工具类。
+ * 全部内置工具类（19 个）。
  * 工具类由 Provider 用 ToolEnv 实例化（每个 Provider 一套实例，注入其 cwd）。
  *
- * 注意：GenerateImageTool 依赖图片模型配置（defaultImageModel），
- * 由 discoverBuiltinTools 按条件实例化，不在此静态注册表中。
+ * 发现层不做任何过滤——工具的可用性由各工具自行声明（SdkCallbackTool.isAvailable，
+ * 入参含完整 config + 模型信息），在 buildTools/filter 阶段按声明过滤。
+ * 如 GenerateImageTool 依赖 defaultImageModel、ViewImageTool 仅视觉模型可用。
  */
 export declare const BUILTIN_TOOL_CLASSES: Array<new (env: ToolEnv) => SdkCallbackTool>;
-export { CwdTool, ReadFileTool, WriteFileTool, ExecTool, MkdirTool, RmTool, GlobTool, LsTool, ExistTool, FindTextTool, DownloadFileTool, RenameTool, CopyTool, BatchEditTool, EditTool, ExecAsyncTool, SleepTool, GenerateImageTool, };
+export { CwdTool, ReadFileTool, WriteFileTool, ExecTool, MkdirTool, RmTool, GlobTool, LsTool, ExistTool, FindTextTool, DownloadFileTool, RenameTool, CopyTool, BatchEditTool, EditTool, ExecAsyncTool, SleepTool, ViewImageTool, GenerateImageTool, };

package/dist/capabilities/implements/builtin/index.js

@@ -15,13 +15,15 @@ import { BatchEditTool } from "./BatchEditTool.js";
 import { EditTool } from "./EditTool.js";
 import { ExecAsyncTool } from "./ExecAsyncTool.js";
 import { SleepTool } from "./SleepTool.js";
+import { ViewImageTool } from "./ViewImageTool.js";
 import { GenerateImageTool } from "./GenerateImageTool.js";
 /**
- * 17 个无条件注册的内置工具类。
+ * 全部内置工具类（19 个）。
  * 工具类由 Provider 用 ToolEnv 实例化（每个 Provider 一套实例，注入其 cwd）。
  *
- * 注意：GenerateImageTool 依赖图片模型配置（defaultImageModel），
- * 由 discoverBuiltinTools 按条件实例化，不在此静态注册表中。
+ * 发现层不做任何过滤——工具的可用性由各工具自行声明（SdkCallbackTool.isAvailable，
+ * 入参含完整 config + 模型信息），在 buildTools/filter 阶段按声明过滤。
+ * 如 GenerateImageTool 依赖 defaultImageModel、ViewImageTool 仅视觉模型可用。
  */
 export const BUILTIN_TOOL_CLASSES = [
     CwdTool,
@@ -41,5 +43,7 @@ export const BUILTIN_TOOL_CLASSES = [
     EditTool,
     ExecAsyncTool,
     SleepTool,
+    ViewImageTool,
+    GenerateImageTool,
 ];
-export { CwdTool, ReadFileTool, WriteFileTool, ExecTool, MkdirTool, RmTool, GlobTool, LsTool, ExistTool, FindTextTool, DownloadFileTool, RenameTool, CopyTool, BatchEditTool, EditTool, ExecAsyncTool, SleepTool, GenerateImageTool, };
+export { CwdTool, ReadFileTool, WriteFileTool, ExecTool, MkdirTool, RmTool, GlobTool, LsTool, ExistTool, FindTextTool, DownloadFileTool, RenameTool, CopyTool, BatchEditTool, EditTool, ExecAsyncTool, SleepTool, ViewImageTool, GenerateImageTool, };

package/dist/capabilities/implements/mcpTools.js

@@ -81,7 +81,7 @@ export function createCallMcpTool(mcpManager) {
                 additionalProperties: false,
             },
         },
-        callback: async (input) => {
+        callback: async (input, ctx) => {
             const serverName = input.server;
             const state = mcpManager.getState(serverName);
             if (state !== "connected") {
@@ -96,7 +96,7 @@ export function createCallMcpTool(mcpManager) {
                 const result = await client.callTool({
                     name: input.tool,
                     arguments: input.arguments,
-                });
+                }, undefined, { signal: ctx?.signal });
                 const contents = result.content ?? [];
                 const textParts = contents
                     .filter((c) => c.type === "text")
@@ -131,7 +131,7 @@ export function createReadMcpResourceTool(mcpManager) {
                 additionalProperties: false,
             },
         },
-        callback: async (input) => {
+        callback: async (input, ctx) => {
             const serverName = input.server;
             const state = mcpManager.getState(serverName);
             if (state !== "connected") {
@@ -143,9 +143,7 @@ export function createReadMcpResourceTool(mcpManager) {
             }
             try {
                 mcpManager.touch(serverName);
-                const result = await client.readResource({
-                    uri: input.uri,
-                });
+                const result = await client.readResource({ uri: input.uri }, { signal: ctx?.signal });
                 const contents = result?.contents ?? [];
                 const textParts = contents
                     .filter((c) => c.text)