nolo-cli 0.1.39 → 0.1.41

package/ai/tools/uiAskChoiceTool.ts

@@ -0,0 +1,104 @@
+// 文件: ai/tools/uiAskChoiceTool.ts
+
+export const uiAskChoiceFunctionSchema = {
+    name: "ui_ask_choice",
+    description: [
+        "当你需要让用户在几个互斥的选项之间做选择时，使用本工具。",
+        "",
+        "这是一个通用的“出选项”工具，适用于多种场景，例如：",
+        "1）用户的需求比较宽泛或模糊，你可以给出 2～5 个不同方向的候选方案，让 TA 先选一个方向；",
+        "2）一个计划 / 流程到了分支节点，需要用户决定下一步做什么；",
+        "3）你想为用户设计一组练习题、测试题或问卷题（如出题练习、人格测试等单选题）；",
+        "4）在新阶段/新会话中，根据系统提示或用户画像，给出若干“接下来可以尝试的事情”（例如功能导航或使用技巧）。",
+        "",
+        "使用建议：",
+        "- 当你判断“先给出 2～5 个明确选项能显著帮用户理清下一步要做什么”时，可以主动调用本工具；",
+        "- 如果用户的目标已经非常具体、清晰，并且你可以直接给出高质量答案，优先直接回答，而不是再弹出选择菜单；",
+        "- 默认情况下，不要在完全没有有效上下文的场景（例如用户只说“你好”）立刻调用本工具，除非系统提示中已经明确要求你在新会话开头用它来生成欢迎菜单或功能导航；",
+        "- 请把给用户看的问题写在 question 字段中，不要在同一轮 assistant 普通文本里重复这句话；",
+        "- 每个选项的 userMessage 建议写成完整的一句话，方便后续理解上下文；如果留空，将自动使用 label 作为 userMessage。",
+        "",
+        "在代码协作场景下的推荐用法：",
+        "- 如果你已经在本轮 assistant 的 content 中给出了分析、说明或多个备选方案，可以在同一轮消息的结尾调用本工具，请用户选择“是否根据上述方案开始实际修改代码”或“优先执行哪一个方案/步骤”。",
+        "- 在这种情况下，question 字段通常是一个简短的问题（例如：“接下来你希望我按哪个方案来具体修改代码？”），而详细的解释和方案描述放在 content 中。",
+        "- 如果当前对话只需要一个简单的选择，而不需要额外解释，你也可以不输出额外的 content，而只调用本工具，由 question 字段直接向用户提问。"
+    ].join("\n"),
+    parameters: {
+        type: "object",
+        properties: {
+            question: {
+                type: "string",
+                description:
+                    "展示给用户的问题文案，用一句话说明要做什么选择。例如：“接下来你更希望我帮你做哪件事？”。不要在同一轮 assistant 普通文本里重复这句话。"
+            },
+            choices: {
+                type: "array",
+                description:
+                    "备选项列表。每个选项会渲染成一个按钮，供用户点击选择。",
+                items: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description:
+                                "选项内部标识（用于后续逻辑或调试，不会直接展示给用户）。"
+                        },
+                        label: {
+                            type: "string",
+                            description:
+                                "显示给用户看的按钮文字。例如：“生成本周周报”。"
+                        },
+                        userMessage: {
+                            type: "string",
+                            description: [
+                                "用户点击此选项后，你希望作为下一条 user 消息发送给模型的自然语言内容。",
+                                "建议写成完整的一句话，例如：“帮我生成一份本周的工作周报”。",
+                                "如果留空，将使用 label 作为 userMessage。"
+                            ].join(" ")
+                        }
+                    },
+                    required: ["id", "label"]
+                }
+            },
+            blocking: {
+                type: "boolean",
+                description: [
+                    "是否需要等待用户选择之后，再继续当前流程（例如 Plan）。",
+                    "默认 true：即发出问题后，等待用户点击某个选项再继续。"
+                ].join(" "),
+                default: true
+            }
+        },
+        required: ["question", "choices"]
+    }
+};
+export async function uiAskChoiceFunc(
+    args: any,
+    _thunkApi: AppThunkApi
+): Promise<{
+    rawData: {
+        type: "ui_ask_choice";
+        question: string;
+        choices: any[];
+        blocking: boolean;
+    };
+    displayData: string;
+}> {
+    const question = String(args?.question ?? "").trim();
+    const choices = Array.isArray(args?.choices) ? args.choices : [];
+    const blocking = args?.blocking !== false;
+
+    if (!question || choices.length === 0) {
+        throw new Error("ui_ask_choice 需要 question 和至少一个 choice。");
+    }
+
+    return {
+        rawData: {
+            type: "ui_ask_choice",
+            question,
+            choices,
+            blocking,
+        },
+        displayData: question,
+    };
+}

package/ai/tools/updateContentTitleTool.ts

@@ -0,0 +1,84 @@
+import { updateContentTitle } from "../../create/space/spaceSlice"; // 假设有一个对应的 action
+import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
+
+// Tool definition
+export const updateContentTitleTool = {
+  type: "function",
+  function: {
+    name: "update_content_title",
+    description: "更新当前空间中某个内容的标题",
+    parameters: {
+      type: "object",
+      properties: {
+        contentId: {
+          type: "string",
+          description: "要更新的内容ID",
+        },
+        title: {
+          type: "string",
+          description: "新的页面标题",
+        },
+      },
+      required: ["contentId", "title"],
+    },
+  },
+};
+
+/**
+ * 更新当前空间中某个内容标题的实现
+ * @param args 工具参数 { contentId: string, title: string }
+ * @param thunkApi Redux Thunk API { dispatch, getState }
+ * @returns Promise<{ success: true, id: string, title: string } | never> - 成功时返回包含 id 和新标题的对象，失败时抛出错误
+ */
+export const updateContentTitleFunc = async (
+  args: { contentId: string; title: string },
+  thunkApi: any /* Replace 'any' with your actual ThunkApi type */
+) => {
+  const { dispatch, getState } = thunkApi;
+  const state = getState(); // Assuming getState returns RootState
+  const spaceId = selectCurrentSpaceId(state); // 获取当前空间ID
+  const { contentId, title } = args;
+
+  console.log(
+    `[updateContentTitleFunc] spaceId: ${spaceId}, contentId: ${contentId}, title: ${title}`
+  );
+
+  if (!spaceId) {
+    console.error("[updateContentTitleFunc] 更新标题失败：未找到当前空间ID");
+    throw new Error("无法更新标题，因为当前空间未设定。");
+  }
+
+  if (!contentId) {
+    console.error("[updateContentTitleFunc] 更新标题失败：未提供内容ID");
+    throw new Error("无法更新标题，因为内容ID未提供。");
+  }
+
+  try {
+    // 调用 updateContentTitle action (直接从 spaceSlice 中导入)
+    console.log(
+      "[updateContentTitleFunc] Dispatching updateContentTitle action..."
+    );
+    const updatedContentId = await dispatch(
+      updateContentTitle({
+        spaceId,
+        contentId,
+        title: title.trim(), // 确保标题去除首尾空格
+      })
+    ).unwrap(); // unwrap 会在失败时抛出错误
+
+    console.log(
+      `[updateContentTitleFunc] Content title updated successfully. contentId: ${updatedContentId}`
+    );
+
+    // 返回结构化数据
+    return {
+      success: true, // 明确表示成功
+      id: updatedContentId, // 返回内容ID
+      title: title, // 返回使用的新标题
+    };
+  } catch (error: any) {
+    console.error("[updateContentTitleFunc] 更新标题失败:", error);
+    const errorMessage = error?.message || JSON.stringify(error) || "未知错误";
+    throw new Error(`更新标题时出错: ${errorMessage}`);
+  }
+};

package/ai/tools/updateDocTool.ts

@@ -0,0 +1,105 @@
+// ai/tools/updateDocTool.ts
+
+import { readAction } from "../../database/actions/read";
+import { write } from "../../database/dbSlice";
+import { markdownToSlate } from "../../create/editor/transforms/markdownToSlate";
+import { slateToRenderMarkdown } from "../../create/editor/transforms/slateToRenderMarkdown";
+import { extractMentionsFromSlate } from "../../create/editor/utils/slateUtils";
+import type { PageData } from "../../render/page/types";
+import { parseSkillDocProtocol } from "../skills/skillDocProtocol";
+
+export const updateDocFunctionSchema = {
+    name: "updateDoc",
+    description: "更新指定页面/文档的内容。支持全量覆盖或在末尾追加内容。",
+    parameters: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "页面/文档的 dbKey，通常以 page- 开头，例如 page-user-01ABC...",
+            },
+            content: {
+                type: "string",
+                description: "要更新或追加的 Markdown 格式内容。",
+            },
+            mode: {
+                type: "string",
+                enum: ["replace", "append"],
+                description: "更新模式：'replace' 表示全量覆盖（默认），'append' 表示在页面末尾追加。",
+                default: "replace",
+            },
+        },
+        required: ["id", "content"],
+    },
+};
+
+/**
+ * [Executor] 'updateDoc' 工具的执行函数。
+ */
+export async function updateDocFunc(
+    args: { id: string; content: string; mode?: "replace" | "append" },
+    thunkApi: any
+): Promise<{ rawData: any; displayData: string }> {
+    const { id, content, mode = "replace" } = args;
+    const { dispatch } = thunkApi;
+
+    if (!id.toLowerCase().startsWith("page-")) {
+        throw new Error("updateDoc 工具仅支持更新页面 (page-xxx)。");
+    }
+    try {
+        // 1. 读取原页面数据
+        const originalData = (await readAction({ dbKey: id }, thunkApi)) as PageData;
+        if (!originalData) {
+            throw new Error(`未找到 ID 为 ${id} 的页面。`);
+        }
+
+        const currentMarkdown =
+            typeof originalData.content === "string" && originalData.content.trim()
+                ? originalData.content
+                : slateToRenderMarkdown(
+                    Array.isArray(originalData.slateData) ? originalData.slateData : [],
+                );
+
+        const mergedMarkdown = mode === "append"
+            ? [currentMarkdown, content].filter(Boolean).join("\n\n")
+            : content;
+        const parsedProtocol = parseSkillDocProtocol(
+            mergedMarkdown,
+            originalData.meta,
+            originalData.tools,
+        );
+        const finalSlateData = markdownToSlate(parsedProtocol.content);
+        const tools = extractMentionsFromSlate(finalSlateData as any);
+
+        // 3. 构造更新后的数据
+        const updatedPageData: PageData = {
+            ...originalData,
+            slateData: finalSlateData,
+            content: parsedProtocol.content,
+            tools,
+            ...(parsedProtocol.meta ? { meta: parsedProtocol.meta } : {}),
+            updated_at: new Date().toISOString(),
+        };
+
+        // 4. 写入数据库
+        // 4. 写入数据库
+        await (dispatch as any)(write({ data: updatedPageData, customKey: id })).unwrap();
+
+        const displayData = mode === "append"
+            ? `已成功在页面《${originalData.title}》末尾追加了内容。`
+            : `页面《${originalData.title}》的内容已成功更新。`;
+
+        return {
+            rawData: { success: true, id, title: originalData.title },
+            displayData,
+        };
+    } catch (error: any) {
+        console.error("执行 updateDoc 工具时出错:", error);
+        throw new Error(`更新页面失败：${error?.message || String(error)}`);
+    }
+}
+// ── 向后兼容别名（旧名 updatePage / update_page）────────────────────────────
+/** @deprecated 使用 updateDocFunctionSchema */
+export const updatePageFunctionSchema = updateDocFunctionSchema;
+/** @deprecated 使用 updateDocFunc */
+export const updatePageFunc = updateDocFunc;

package/ai/tools/updateUserPreferenceProfileTool.ts

@@ -0,0 +1,153 @@
+import type {
+  KnowledgeCaptureLevel,
+  SpaceContextLevel,
+  TonePreset,
+} from "../policy/types";
+import {
+  normalizeAgentUpdateFieldList,
+  type AgentUpdateField,
+} from "../policy/selfUpdateFields";
+
+async function dispatchSetSettings(thunkApi: any, changes: Record<string, unknown>) {
+  const injectedSetSettings = thunkApi?.extra?.setSettings;
+  const setSettings =
+    typeof injectedSetSettings === "function"
+      ? injectedSetSettings
+      : (await import("../../app/settings/settingSlice")).setSettings;
+  await thunkApi.dispatch(setSettings(changes as any)).unwrap();
+}
+
+export interface UpdateUserPreferenceProfileArgs {
+  userTonePreset?: TonePreset;
+  knowledgeCaptureLevel?: KnowledgeCaptureLevel;
+  spaceContextLevel?: SpaceContextLevel;
+  autoApproveSelfUpdateFields?: AgentUpdateField[];
+  globalPrompt?: string;
+  defaultAgentId?: string;
+  summary?: string;
+}
+
+export const updateUserPreferenceProfileFunctionSchema = {
+  name: "updateUserPreferenceProfile",
+  description: [
+    "当你已经明确收集到用户的个性化偏好时，使用本工具把这些偏好保存到用户设置里。",
+    "适用于保存 tone、knowledge capture、space context，以及用户的 global prompt / 自我介绍摘要。",
+    "只有在用户已经明确表达或确认后才调用；不要在信息不充分时猜测。",
+    "调用后，你应当用自然语言简要总结已保存的设置，并说明用户之后可以继续调整。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      userTonePreset: {
+        type: "string",
+        enum: ["default", "direct", "pragmatic", "friendly", "professional"],
+        description: "用户偏好的交流语气。",
+      },
+      knowledgeCaptureLevel: {
+        type: "integer",
+        enum: [1, 2, 3, 4],
+        description: "知识沉淀级别：1 不主动创建；2 先问再创建；3 回答后建议；4 高价值结果可自动创建。",
+      },
+      spaceContextLevel: {
+        type: "integer",
+        enum: [1, 2, 3, 4],
+        description: "空间上下文级别：1 不自动读取；2 只看结构和标题；3 轻量读取；4 自适应读取。",
+      },
+      autoApproveSelfUpdateFields: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: [
+            "name",
+            "model",
+            "provider",
+            "prompt",
+            "introduction",
+            "greeting",
+            "isPublic",
+            "tags",
+            "tools",
+            "references",
+            "temperature",
+            "top_p",
+            "frequency_penalty",
+            "presence_penalty",
+            "max_tokens",
+            "reasoning_effort",
+          ],
+        },
+        description: "哪些 updateSelf 字段以后不再询问用户，直接自动通过。",
+      },
+      globalPrompt: {
+        type: "string",
+        description: "可选：用户希望长期保留的一小段通用偏好说明。未明确确认时不要写。",
+      },
+      defaultAgentId: {
+        type: "string",
+        description: "可选：用户明确要求切换首页默认 agent 时才填写。",
+      },
+      summary: {
+        type: "string",
+        description: "给开发和日志看的简短总结，不会影响设置本身。",
+      },
+    },
+  } as const,
+};
+
+export async function updateUserPreferenceProfileFunc(
+  args: UpdateUserPreferenceProfileArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  const changes: Record<string, unknown> = {};
+
+  if (args.userTonePreset) {
+    changes.userTonePreset = args.userTonePreset;
+  }
+  if (typeof args.knowledgeCaptureLevel === "number") {
+    changes.knowledgeCaptureLevel = args.knowledgeCaptureLevel;
+  }
+  if (typeof args.spaceContextLevel === "number") {
+    changes.spaceContextLevel = args.spaceContextLevel;
+    changes.enableReadCurrentSpace = args.spaceContextLevel > 1;
+  }
+  if (Array.isArray(args.autoApproveSelfUpdateFields)) {
+    changes.autoApproveSelfUpdateFields = normalizeAgentUpdateFieldList(
+      args.autoApproveSelfUpdateFields,
+      []
+    );
+  }
+  if (typeof args.globalPrompt === "string" && args.globalPrompt.trim()) {
+    changes.globalPrompt = args.globalPrompt.trim();
+  }
+  if (typeof args.defaultAgentId === "string" && args.defaultAgentId.trim()) {
+    changes.defaultAgentId = args.defaultAgentId.trim();
+  }
+
+  if (Object.keys(changes).length === 0) {
+    throw new Error("没有可保存的用户偏好设置。");
+  }
+
+  await dispatchSetSettings(thunkApi, changes);
+
+  const rawData = {
+    success: true,
+    updated: changes,
+    summary: args.summary?.trim() || null,
+  };
+
+  const labels: string[] = [];
+  if (changes.userTonePreset) labels.push(`语气=${changes.userTonePreset}`);
+  if (changes.knowledgeCaptureLevel)
+    labels.push(`知识沉淀=${changes.knowledgeCaptureLevel}`);
+  if (changes.spaceContextLevel)
+    labels.push(`空间读取=${changes.spaceContextLevel}`);
+  if (changes.autoApproveSelfUpdateFields)
+    labels.push("自我更新免询问字段已更新");
+  if (changes.defaultAgentId) labels.push("默认助手已更新");
+  if (changes.globalPrompt) labels.push("通用提示词已更新");
+
+  return {
+    rawData,
+    displayData: `已保存用户偏好：${labels.join("，")}`,
+  };
+}

package/ai/tools/wereadGatewayTool.ts

@@ -0,0 +1,152 @@
+import { callToolApi } from "./toolApiClient";
+
+export const WEREAD_DEFAULT_SKILL_VERSION = "1.0.3";
+export const WEREAD_GATEWAY_URL = "https://i.weread.qq.com/api/agent/gateway";
+
+export interface WereadGatewayArgs {
+  api_name?: string;
+  skill_version?: string;
+  params?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface WereadGatewayRunOptions {
+  apiKey: string;
+  fetchImpl?: typeof fetch;
+}
+
+export const wereadGatewayFunctionSchema = {
+  name: "wereadGateway",
+  description:
+    "调用微信读书 Agent API Gateway。用于搜索书籍、查看书架、阅读统计、笔记划线、书评和推荐。业务参数必须平铺在请求体顶层。",
+  parameters: {
+    type: "object",
+    properties: {
+      api_name: {
+        type: "string",
+        description: "微信读书接口名，例如 /store/search、/shelf/sync、/user/notebooks。",
+      },
+      skill_version: {
+        type: "string",
+        description: "微信读书 skill 版本；未传时使用当前内置版本。",
+      },
+      params: {
+        type: "object",
+        description: "业务参数对象。工具会自动把字段平铺到请求体顶层，不会以 params 包裹转发。",
+        additionalProperties: true,
+      },
+    },
+    required: ["api_name"],
+  } as const,
+};
+
+const RESERVED_ARG_KEYS = new Set(["api_name", "skill_version", "params"]);
+
+function normalizeApiName(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeSkillVersion(value: unknown): string {
+  return typeof value === "string" && value.trim()
+    ? value.trim()
+    : WEREAD_DEFAULT_SKILL_VERSION;
+}
+
+function normalizeParams(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value as Record<string, unknown>;
+}
+
+export function buildWereadGatewayRequestBody(args: WereadGatewayArgs): Record<string, unknown> {
+  const apiName = normalizeApiName(args.api_name);
+  if (!apiName) {
+    throw new Error("wereadGateway 需要 api_name。");
+  }
+
+  const flattened: Record<string, unknown> = {
+    ...normalizeParams(args.params),
+  };
+  for (const [key, value] of Object.entries(args)) {
+    if (!RESERVED_ARG_KEYS.has(key)) {
+      flattened[key] = value;
+    }
+  }
+
+  return {
+    api_name: apiName,
+    ...flattened,
+    skill_version: normalizeSkillVersion(args.skill_version),
+  };
+}
+
+function extractUpgradeMessage(data: unknown): string | null {
+  const upgradeInfo = (data as any)?.upgrade_info;
+  return typeof upgradeInfo?.message === "string" && upgradeInfo.message.trim()
+    ? upgradeInfo.message.trim()
+    : null;
+}
+
+function extractErrcode(data: unknown): number {
+  const raw = (data as any)?.errcode;
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+}
+
+function extractErrorMessage(data: unknown): string {
+  const record = data as any;
+  return (
+    (typeof record?.errmsg === "string" && record.errmsg.trim()) ||
+    (typeof record?.message === "string" && record.message.trim()) ||
+    "微信读书接口返回错误"
+  );
+}
+
+export async function runWereadGatewayRequest(
+  args: WereadGatewayArgs,
+  options: WereadGatewayRunOptions
+): Promise<{ rawData: unknown; displayData: string }> {
+  const apiKey = options.apiKey.trim();
+  if (!apiKey) {
+    throw new Error("缺少 WEREAD_API_KEY。请先在设置 -> 密钥中保存 WEREAD_API_KEY。");
+  }
+
+  const body = buildWereadGatewayRequestBody(args);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const response = await fetchImpl(WEREAD_GATEWAY_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data = await response.json().catch(async () => ({
+    errmsg: await response.text().catch(() => ""),
+  }));
+  if (!response.ok) {
+    throw new Error(`微信读书接口请求失败：HTTP ${response.status}`);
+  }
+
+  const upgradeMessage = extractUpgradeMessage(data);
+  if (upgradeMessage) {
+    throw new Error(`微信读书 Skill 需要升级：${upgradeMessage}`);
+  }
+
+  const errcode = extractErrcode(data);
+  if (errcode !== 0) {
+    throw new Error(`微信读书接口返回错误 ${errcode}：${extractErrorMessage(data)}`);
+  }
+
+  const apiName = String(body.api_name);
+  return {
+    rawData: data,
+    displayData: `微信读书接口 ${apiName} 调用成功。\n\n${JSON.stringify(data, null, 2)}`,
+  };
+}
+
+export async function wereadGatewayFunc(
+  args: WereadGatewayArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  return callToolApi(thunkApi, "/api/weread/gateway", args, { withAuth: true });
+}

package/ai/tools/whisperTool.ts

@@ -0,0 +1,76 @@
+import { callToolApi } from "./toolApiClient";
+
+const SHARED_PARAMS = {
+  type: "object",
+  properties: {
+    audioUrl: {
+      type: "string",
+      description:
+        "音频来源：内部文件 ID (file-... 或 ULID)、公开 http/https URL，或 base64 data URI（data:audio/...;base64,...）。支持 mp3、wav、m4a、ogg、flac 等常见格式。",
+    },
+    language: {
+      type: "string",
+      description:
+        "可选，指定音频语言以提升精度（如 'zh'、'en'、'ja'）。不指定则自动检测。",
+    },
+  },
+  required: ["audioUrl"],
+};
+
+// ── whisper-large-v3-turbo（快速、便宜）──────────────────
+
+export const whisperTurboSchema = {
+  name: "whisper_turbo",
+  description:
+    "使用 openai/whisper-large-v3-turbo 对音频进行语音转文字（ASR）。速度快、价格低（$0.0002/min），适合大多数场景的实时或批量转录。",
+  parameters: SHARED_PARAMS,
+};
+
+export const whisperTurboFunc = async (
+  input: any,
+  thunkApi: any
+): Promise<any> => {
+  const { audioUrl, language } = input;
+  const data = await callToolApi(
+    thunkApi,
+    "/api/whisper-turbo",
+    { audioUrl, language },
+    { withAuth: true }
+  );
+  return {
+    summary: "Transcription completed",
+    text: data.text || "",
+    language: data.language,
+    duration: data.duration,
+    rawData: data,
+  };
+};
+
+// ── whisper-large-v3（高精度）────────────────────────────
+
+export const whisperV3Schema = {
+  name: "whisper_v3",
+  description:
+    "使用 openai/whisper-large-v3 对音频进行高精度语音转文字（ASR）。精度更高（尤其多语言/中文），价格稍高（$0.00045/min），适合对准确率要求严格的场景。",
+  parameters: SHARED_PARAMS,
+};
+
+export const whisperV3Func = async (
+  input: any,
+  thunkApi: any
+): Promise<any> => {
+  const { audioUrl, language } = input;
+  const data = await callToolApi(
+    thunkApi,
+    "/api/whisper-v3",
+    { audioUrl, language },
+    { withAuth: true }
+  );
+  return {
+    summary: "Transcription completed",
+    text: data.text || "",
+    language: data.language,
+    duration: data.duration,
+    rawData: data,
+  };
+};