nolo-cli 0.1.13 → 0.1.14

package/ai/tools/agent/callAgentTool.ts

@@ -0,0 +1,139 @@
+// 文件路径: ai/tools/agent/callAgentTool.ts
+
+import type { RootState } from "app/store";
+import { runAgent } from "ai/agent/agentSlice";
+import { runAgentBackground } from "ai/agent/runAgentBackground";
+
+
+/**
+ * callAgent 工具 Schema
+ *
+ * 用于开展一个子对话（sub-dialog），只关心执行结果。支持两种执行模式：
+ * - "server"（默认）：通过服务端 agent run 接口后台异步执行，结果写回 DB 并通过 SSE 回传，
+ *   适合大多数子任务，也能复用服务端 runtime auto-routing。
+ * - "client"：客户端同步执行，在当前 Redux 上下文中直接调用 runAgent，
+ *   适合确认只需本地轻量执行的子任务。
+ *
+ * 若需要用户立刻看到流式回复，请改用 runStreamingAgent。
+ */
+export const callAgentFunctionSchema = {
+    name: "callAgent",
+    description:
+        "调用一个指定的 Agent 执行一次子任务并返回结果。" +
+        "通常用于：将复杂子问题委托给其他 Agent，例如自动评测、多 Agent 对比、抓取结果的结构化处理等。",
+    parameters: {
+        type: "object",
+        properties: {
+            agentKey: {
+                type: "string",
+                description:
+                    "要调用的 Agent 的唯一 ID。",
+            },
+            task: {
+                type: "string",
+                description:
+                    "委托给该 Agent 的子任务描述（自然语言）。建议在此包含必要的上下文说明（例如当前表结构、题库说明等）。",
+            },
+            input: {
+                description:
+                    "可选。JSON 或字符串，将作为本次子任务的附加输入。通常用于传递抓取到的原始数据、题库、上下文片段等。",
+            },
+            mode: {
+                type: "string",
+                enum: ["client", "server"],
+                description:
+                    "执行模式：'server'（默认）为服务端后台异步执行，能复用 runtime auto-routing；" +
+                    "'client' 为客户端同步执行，适合明确只需本地轻量完成的任务。",
+                default: "server",
+            },
+            serverBase: {
+                type: "string",
+                description:
+                    "可选。目标 Agent 所在的 nolo server origin，例如 Windows 机器通过 Cloudflare 暴露的 https://win.example.com。" +
+                    "仅 server 模式使用；跨域目标必须由服务端 AGENT_TOOL_ALLOWED_SERVER_BASES 明确放行。" +
+                    "如果目标 Agent 记录声明了 delegation.serverBase / runtimeServerBase，服务端会在未显式传入时自动路由。",
+            },
+        },
+        required: ["agentKey", "task"],
+    },
+};
+
+interface CallAgentArgs {
+    agentKey: string;
+    task: string;
+    input?: any;
+    mode?: "client" | "server";
+    serverBase?: string;
+}
+
+/**
+ * callAgent 工具执行函数
+ * @param args - { agentKey, task, input, mode }
+ * @param thunkApi - Redux thunkApi
+ * @param context - { parentMessageId }，用于关联父消息
+ */
+export async function callAgentFunc(
+    args: CallAgentArgs,
+    thunkApi: any,
+    context?: { parentMessageId: string }
+): Promise<{ rawData: any; displayData?: string }> {
+    const { agentKey, task, input, mode = "server", serverBase } = args;
+    const { dispatch, getState } = thunkApi;
+    const state = getState() as RootState;
+
+    if (!agentKey) {
+        throw new Error("callAgent: 缺少 agentKey 参数。");
+    }
+    if (!task || typeof task !== "string") {
+        throw new Error("callAgent: 缺少有效的 task 文本描述。");
+    }
+
+    // 组装 content：统一用「指令 + 输入」的简单文本协议
+    let content: string;
+    if (input === undefined || input === null) {
+        content = task;
+    } else if (typeof input === "string") {
+        content = `${task}\n\n--- INPUT (text) ---\n${input}`;
+    } else {
+        const jsonStr = JSON.stringify(input, null, 2);
+        content = `${task}\n\n--- INPUT (json) ---\n${jsonStr}`;
+    }
+
+    const parentMessageId = context?.parentMessageId;
+
+    try {
+        if (mode === "server") {
+            // 服务端后台执行：适合耗时/计算密集型任务
+            // 通过 /api/agent/run?background=true 派发到服务端，SSE 监听结果
+            const result = await dispatch(
+                runAgentBackground({
+                    agentKey,
+                    userInput: content,
+                    ...(serverBase ? { serverBase } : {}),
+                })
+            ).unwrap();
+
+            return {
+                rawData: result.content ?? result,
+                displayData: `✅ callAgent(服务端) 执行完成，dialogId: ${result.dialogId}`,
+            };
+        }
+
+        // client 模式（默认）：客户端同步执行，结果直接返回给调用方
+        const result = await dispatch(
+            runAgent({
+                agentKey,
+                content,
+                parentMessageId,
+            })
+        ).unwrap();
+
+        return {
+            rawData: result,
+            displayData: "✅ callAgent(客户端) 子任务执行完成。",
+        };
+    } catch (e: any) {
+        const msg = e?.message || String(e);
+        throw new Error(`callAgent 调用 Agent [${agentKey}] 时出错: ${msg}`);
+    }
+}

package/ai/tools/agent/createAgentTool.ts

@@ -0,0 +1,512 @@
+// 文件路径: ai/tools/agent/createAgentTool.ts
+
+import type { RootState } from "app/store";
+import type { Agent } from "app/types";
+import { createAgent } from "ai/agent/agentSlice";
+import { selectAllMemberSpaces, addContentToSpace } from "create/space/spaceSlice";
+import { ContentType } from "app/types";
+import { createAgentKey, } from "database/keys";
+import type { FormData as AgentFormData } from "ai/agent/createAgentSchema";
+import { selectCurrentUserBalance, selectUserId } from "auth/authSlice";
+import type { ModelWithProvider } from "ai/llm/models";
+import i18n from "app/i18n";
+
+type ReasoningEffort = "low" | "medium" | "high";
+
+type ReferenceArg = {
+    dbKey: string;
+    title?: string;
+    type?: "knowledge" | "instruction" | "page";
+};
+
+// 与 GreetingMenuEditor / greetingMenuItemSchema 对齐
+export type GreetingMenuItemArg = {
+    id: string;
+    label: string;
+    userMessage?: string;
+};
+
+export type GreetingConfigArg = {
+    text?: string;
+    menu?: GreetingMenuItemArg[];
+};
+
+export type CreateAgentToolArgs = {
+    name: string;
+    model: string;
+    provider: string; // 必填
+    prompt?: string;
+    introduction?: string;
+    greeting?: string | GreetingConfigArg; // 支持纯文本或带 menu 的对象
+    isPublic?: boolean;
+    tags?: string[] | string;
+    tools?: string[];
+    references?: ReferenceArg[];
+    linkedSpaces?: string[];
+    temperature?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    max_tokens?: number;
+    reasoning_effort?: ReasoningEffort;
+};
+
+const toTrimmed = (v: unknown): string =>
+    typeof v === "string"
+        ? v.trim()
+        : v == null
+            ? ""
+            : String(v).trim();
+
+/**
+ * 根据 model + 可选 provider 找到唯一的模型配置
+ *
+ * 规则：
+ * - 如果传了 provider，则优先按 (name, provider) 精确匹配；
+ * - 否则按 name 匹配：
+ *    - 找到 1 个 => 返回
+ *    - 找到 0 或 >1 个 => 返回 null（>1 说明有歧义）
+ */
+const findModelConfig = async (
+    modelName: string,
+    provider?: string
+): Promise<ModelWithProvider | null> => {
+    const { ALL_MODELS } = await import("ai/llm/models");
+    const name = toTrimmed(modelName);
+    const prov = toTrimmed(provider ?? "");
+    if (!name) return null;
+
+    if (prov) {
+        const exact = ALL_MODELS.find(
+            (m) => m.name === name && m.provider === prov
+        );
+        if (exact) return exact;
+    }
+
+    const matches = ALL_MODELS.filter((m) => m.name === name);
+    if (matches.length === 1) return matches[0];
+
+    if (matches.length > 1 && !prov) {
+        console.warn(
+            "[createAgentTool] findModelConfig: duplicate model names without provider",
+            {
+                modelName: name,
+                providers: matches.map((m) => m.provider),
+            }
+        );
+    }
+
+    return null;
+};
+
+/**
+ * [Schema] createAgent 工具定义：供 LLM 规划时调用
+ * - name / model / provider 必填：保证创建出来的 Agent 配置完整且无歧义
+ * - 其余字段可选：用于进一步定制 Agent 行为
+ */
+export const createAgentToolFunctionSchema = {
+    name: "createAgent",
+    description: i18n.t("tools.createAgent.description"),
+    parameters: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: i18n.t("tools.createAgent.params.name"),
+            },
+            model: {
+                type: "string",
+                description: i18n.t("tools.createAgent.params.model"),
+            },
+            provider: {
+                type: "string",
+                description: i18n.t("tools.createAgent.params.provider"),
+            },
+            prompt: {
+                type: "string",
+                description: i18n.t("tools.createAgent.params.prompt"),
+            },
+            introduction: {
+                type: "string",
+                description: i18n.t("tools.createAgent.params.introduction"),
+            },
+            greeting: {
+                description: i18n.t("tools.createAgent.params.greeting.desc"),
+                anyOf: [
+                    {
+                        type: "string",
+                        description: i18n.t(
+                            "tools.createAgent.params.greeting.stringDesc"
+                        ),
+                    },
+                    {
+                        type: "object",
+                        description: i18n.t(
+                            "tools.createAgent.params.greeting.objectDesc"
+                        ),
+                        properties: {
+                            text: {
+                                type: "string",
+                                description: i18n.t(
+                                    "tools.createAgent.params.greeting.texts.text"
+                                ),
+                            },
+                            menu: {
+                                type: "array",
+                                description: i18n.t(
+                                    "tools.createAgent.params.greeting.menu.desc"
+                                ),
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        id: {
+                                            type: "string",
+                                            description: i18n.t(
+                                                "tools.createAgent.params.greeting.menu.id"
+                                            ),
+                                        },
+                                        label: {
+                                            type: "string",
+                                            description: i18n.t(
+                                                "tools.createAgent.params.greeting.menu.label"
+                                            ),
+                                        },
+                                        userMessage: {
+                                            type: "string",
+                                            description: i18n.t(
+                                                "tools.createAgent.params.greeting.menu.userMessage"
+                                            ),
+                                        },
+                                    },
+                                    required: ["id", "label"],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            isPublic: {
+                type: "boolean",
+                description: i18n.t("tools.createAgent.params.isPublic"),
+            },
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description: i18n.t("tools.createAgent.params.tags"),
+            },
+            tools: {
+                type: "array",
+                items: { type: "string" },
+                description: i18n.t("tools.createAgent.params.tools"),
+            },
+            references: {
+                type: "array",
+                description: i18n.t("tools.createAgent.params.references.desc"),
+                items: {
+                    type: "object",
+                    properties: {
+                        dbKey: {
+                            type: "string",
+                            description: i18n.t(
+                                "tools.createAgent.params.references.dbKey"
+                            ),
+                        },
+                        title: {
+                            type: "string",
+                            description: i18n.t(
+                                "tools.createAgent.params.references.title"
+                            ),
+                        },
+                        type: {
+                            type: "string",
+                            enum: ["knowledge", "instruction", "page"],
+                            description: i18n.t(
+                                "tools.createAgent.params.references.type"
+                            ),
+                        },
+                    },
+                    required: ["dbKey"],
+                },
+            },
+            linkedSpaces: {
+                type: "array",
+                items: { type: "string" },
+                description: i18n.t("tools.createAgent.params.linkedSpaces"),
+            },
+            temperature: {
+                type: "number",
+                description: i18n.t("tools.createAgent.params.temperature"),
+            },
+            top_p: {
+                type: "number",
+                description: i18n.t("tools.createAgent.params.top_p"),
+            },
+            frequency_penalty: {
+                type: "number",
+                description: i18n.t(
+                    "tools.createAgent.params.frequency_penalty"
+                ),
+            },
+            presence_penalty: {
+                type: "number",
+                description: i18n.t(
+                    "tools.createAgent.params.presence_penalty"
+                ),
+            },
+            max_tokens: {
+                type: "number",
+                description: i18n.t("tools.createAgent.params.max_tokens"),
+            },
+            reasoning_effort: {
+                type: "string",
+                enum: ["low", "medium", "high"],
+                description: i18n.t(
+                    "tools.createAgent.params.reasoning_effort"
+                ),
+            },
+        },
+        // provider 必填
+        required: ["name", "model", "provider"],
+    },
+};
+
+const normalizeTags = (tags?: string[] | string): string => {
+    if (!tags) return "";
+    if (Array.isArray(tags)) {
+        return tags
+            .map((t) => String(t || "").trim())
+            .filter(Boolean)
+            .join(", ");
+    }
+    return String(tags);
+};
+
+/**
+ * 将工具入参转换为 Agent 表单数据结构（AgentFormData）
+ * - 默认使用平台 API（apiSource: 'platform'）
+ * - 不暴露自定义 API 字段（customProviderUrl / apiKey 等）
+ * - 根据 (model, provider) 自动补 hasVision 等能力字段
+ */
+const buildFormDataFromArgs = async (args: CreateAgentToolArgs): Promise<AgentFormData> => {
+    const {
+        name,
+        model,
+        provider,
+        prompt,
+        introduction,
+        greeting,
+        isPublic = false,
+        tags,
+        tools,
+        references,
+        linkedSpaces,
+        temperature,
+        top_p,
+        frequency_penalty,
+        presence_penalty,
+        max_tokens,
+        reasoning_effort,
+    } = args;
+
+    const trimmedName = toTrimmed(name);
+    const trimmedModel = toTrimmed(model);
+    const trimmedProvider = toTrimmed(provider);
+
+    // 用 (model, provider) 查模型元数据，顺便拿 hasVision 等能力
+    const modelConfig = await findModelConfig(trimmedModel, trimmedProvider);
+    const { getModelPricing } = await import("ai/llm/getPricing");
+
+    const formData: AgentFormData = {
+        name: trimmedName,
+        model: trimmedModel,
+        provider: modelConfig?.provider || trimmedProvider,
+
+        apiSource: "platform",
+        useServerProxy: true,
+
+        // 根据模型配置自动赋值 hasVision（支持图片 / 多模态）
+        hasVision: Boolean(modelConfig?.hasVision),
+
+        prompt: prompt ?? "",
+        introduction: introduction ?? "",
+        greeting, // 直接透传：string 或 { text, menu }
+        isPublic: !!isPublic,
+        tags: normalizeTags(tags),
+
+        tools: tools ?? [],
+        references: (references as any) ?? [],
+        linkedSpaces: linkedSpaces ?? [], // Leave raw inputs, resolve in executor
+
+        customProviderUrl: "",
+        apiKey: "",
+
+        // 从模型列表查真实价格，保证 AgentCard 和 useSendPermission 能正确显示
+        ...(() => {
+          const pricing = getModelPricing(modelConfig?.provider || trimmedProvider, trimmedModel);
+          return {
+            inputPrice: pricing?.inputPrice ?? 0,
+            outputPrice: pricing?.outputPrice ?? 0,
+          };
+        })(),
+
+        temperature,
+        top_p,
+        frequency_penalty,
+        presence_penalty,
+        max_tokens,
+        reasoning_effort,
+
+        whitelist: [],
+    };
+
+    return formData;
+};
+
+/**
+ * [Helper] 根据 Space 名称或 ID 查找 Space
+ */
+const findSpaceConfig = (
+    nameOrId: string,
+    allSpaces: any[]
+): { spaceId: string; name: string } | null => {
+    const query = toTrimmed(nameOrId).toLowerCase();
+    if (!query) return null;
+
+    // 1. 精确匹配 ID
+    const byId = allSpaces.find((s) => s.spaceId === nameOrId); // ID 区分大小写
+    if (byId) return { spaceId: byId.spaceId, name: byId.spaceName };
+
+    // 2. 匹配名称 (忽略大小写)
+    const byName = allSpaces.find(
+        (s) =>
+            (s.spaceName || "").toLowerCase() === query ||
+            (s.spaceId || "").toLowerCase() === query
+    );
+    if (byName) return { spaceId: byName.spaceId, name: byName.spaceName };
+
+    return null;
+};
+
+/**
+ * [Executor] createAgent 工具执行函数
+ */
+export async function createAgentToolFunc(
+    args: CreateAgentToolArgs,
+    thunkApi: any
+): Promise<{ rawData: Agent; displayData: string }> {
+    const state = thunkApi.getState() as RootState;
+    const currentUserId = selectUserId(state);
+    const currentBalance = selectCurrentUserBalance(state);
+
+    // 获取当前用户的所有 Space (from create/space/spaceSlice)
+    const allSpaces = selectAllMemberSpaces(state);
+
+    if (!currentUserId) {
+        throw new Error("创建 Agent 失败：当前未登录或缺少 userId。");
+    }
+
+    const { name, model, provider, linkedSpaces } =
+        args || ({} as CreateAgentToolArgs);
+
+    if (!name || typeof name !== "string" || !name.trim()) {
+        throw new Error("创建 Agent 失败：必须提供非空的 name 字段。");
+    }
+    if (!model || typeof model !== "string" || !model.trim()) {
+        throw new Error("创建 Agent 失败：必须提供非空的 model 字段。");
+    }
+    if (!provider || typeof provider !== "string" || !provider.trim()) {
+        throw new Error("创建 Agent 失败：必须提供非空的 provider 字段。");
+    }
+
+    // --- 处理 Space ID / Name 解析 ---
+    const resolvedLinkedSpaces: string[] = [];
+    if (Array.isArray(linkedSpaces) && linkedSpaces.length > 0) {
+        const notFound: string[] = [];
+        for (const input of linkedSpaces) {
+            const found = findSpaceConfig(input, allSpaces);
+            if (found) {
+                resolvedLinkedSpaces.push(found.spaceId);
+            } else {
+                notFound.push(input);
+            }
+        }
+
+        if (notFound.length > 0) {
+            // 如果有找不到的 Space，生成详细错误提示，列出可用 Space
+            const availableList = allSpaces
+                .map((s) => `- ${s.spaceName} (ID: ${s.spaceId})`)
+                .join("\n");
+            throw new Error(
+                `无法找到以下 Space: ${notFound.join(", ")}。\n` +
+                `请检查名称拼写或使用 'listUserSpaces' 获取最新列表。\n` +
+                `当前可用 Space:\n${availableList}`
+            );
+        }
+    }
+
+    const formData = await buildFormDataFromArgs(args);
+    // 覆盖为解析后的 ID 列表
+    formData.linkedSpaces = resolvedLinkedSpaces;
+
+    try {
+        const agent: Agent = await thunkApi
+            .dispatch(
+                createAgent({
+                    userId: currentUserId,
+                    formData,
+                    spaceId: state.space.currentSpaceId || undefined,
+                })
+            )
+            .unwrap();
+
+        // 自动添加到当前空间侧边栏
+        const currentSpaceId = state.space.currentSpaceId;
+        if (currentSpaceId) {
+            // 新创建的 Agent 统一使用 createAgentKey (agent- 前缀)
+            const agentDbKey = agent.isPublic
+                ? createAgentKey.public(agent.id)
+                : createAgentKey.private(currentUserId, agent.id);
+
+            try {
+                await thunkApi.dispatch((addContentToSpace as any)({
+                    spaceId: currentSpaceId,
+                    title: agent.name || "未命名智能体",
+                    type: ContentType.AGENT, // 统一使用 ContentType.AGENT
+                    contentKey: agentDbKey,
+                })).unwrap();
+            } catch (err) {
+                console.error("[createAgentTool] Failed to add to space:", err);
+            }
+        }
+
+        const lines: string[] = [
+            `✅ 已创建 Agent：${agent.name}`,
+            `- ID: ${agent.id}`,
+            `- 模型: ${agent.model || "(未指定)"}`,
+            `- Provider: ${agent.provider || "(未指定)"}`,
+            `- 是否公开: ${agent.isPublic ? "是" : "否"}`,
+        ];
+
+        if (Array.isArray(agent.tags) && agent.tags.length > 0) {
+            lines.push(`- 标签: ${agent.tags.join(", ")}`);
+        }
+        if (Array.isArray(agent.tools) && agent.tools.length > 0) {
+            lines.push(`- 启用工具: ${agent.tools.join(", ")}`);
+        }
+        if (typeof agent.temperature === "number") {
+            lines.push(`- temperature: ${agent.temperature}`);
+        }
+        if (typeof currentBalance === "number") {
+            lines.push(`- 当前余额: ${currentBalance}`);
+        }
+
+        return {
+            rawData: agent,
+            displayData: lines.join("\n"),
+        };
+    } catch (error: any) {
+        throw new Error(
+            `创建 Agent 失败：${error?.message || "未知错误，请稍后重试。"}`
+        );
+    }
+}