nolo-cli 0.1.13 → 0.1.14

package/ai/agent/startParallelAgentStreams.ts

@@ -0,0 +1,424 @@
+import type { RootState } from "app/store";
+import type { DialogConfig } from "app/types";
+import { patch, read, write } from "database/dbSlice";
+import { DataType } from "create/types";
+import { createDialogMessageKeyAndId } from "database/keys";
+import { streamAgentChatTurn } from "ai/agent/agentSlice";
+import { createDialog } from "chat/dialog/dialogSlice";
+import { serializeMessageContent } from "chat/messages/messageContent";
+import { addToolMessage, selectAllMsgs } from "chat/messages/messageSlice";
+import type { Message } from "chat/messages/types";
+import { extractCustomId } from "core/prefix";
+import {
+  calculateParallelBranchPricing,
+  summarizeParallelBudget,
+  summarizeParallelCosts,
+  type ParallelBudgetSummary,
+} from "ai/tools/agent/parallelBudget";
+
+type ParallelDisplayMode = "inline" | "folded";
+
+function getBranchFinalContent(
+  messages: Message[],
+  options: {
+    agentKey: string;
+    parallelSessionId?: string;
+    parallelBranchId?: string;
+  }
+) {
+  const { agentKey, parallelSessionId, parallelBranchId } = options;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || message.role !== "assistant") continue;
+    if (parallelSessionId && message.parallelSessionId !== parallelSessionId) continue;
+    if (parallelBranchId && message.parallelBranchId !== parallelBranchId) continue;
+    if (message.agentKey !== agentKey && message.cybotKey !== agentKey) continue;
+
+    const content = serializeMessageContent(message.content);
+    if (content) {
+      return { content, messageId: message.id };
+    }
+  }
+
+  return null;
+}
+
+async function persistInlineBranchMessage(options: {
+  dispatch: any;
+  parentDialogId: string;
+  agentKey: string;
+  agentName: string;
+  content: string;
+  parallelSessionId: string;
+  parallelBranchId: string;
+  parallelLabel: string;
+  parallelIndex: number;
+}) {
+  const {
+    dispatch,
+    parentDialogId,
+    agentKey,
+    agentName,
+    content,
+    parallelSessionId,
+    parallelBranchId,
+    parallelLabel,
+    parallelIndex,
+  } = options;
+  const { key: dbKey, messageId } = createDialogMessageKeyAndId(parentDialogId);
+  const mirroredMessage: Message & { dialogId?: string } = {
+    id: messageId,
+    dbKey,
+    dialogId: parentDialogId,
+    role: "assistant",
+    content,
+    agentKey,
+    cybotKey: agentKey,
+    agentName,
+    isStreaming: false,
+    parallelSessionId,
+    parallelBranchId,
+    parallelLabel,
+    parallelIndex,
+  };
+
+  dispatch(addToolMessage(mirroredMessage));
+  await dispatch(
+    write({
+      data: {
+        ...mirroredMessage,
+        type: DataType.MSG,
+      },
+      customKey: dbKey,
+    })
+  );
+
+  return {
+    parentMessageId: messageId,
+    parentMessageKey: dbKey,
+  };
+}
+
+export async function startParallelAgentStreams(options: {
+  task: string;
+  agents: Array<{ agentKey: string; label?: string; branchId?: string; serverBase?: string }>;
+  dispatch: any;
+  getState: () => RootState;
+  dialogId?: string;
+  dialogKey?: string;
+  waitForCompletion?: boolean;
+  displayMode?: ParallelDisplayMode;
+  budgetCredits?: number;
+}) {
+  const {
+    task,
+    agents,
+    dispatch,
+    getState,
+    dialogId,
+    dialogKey,
+    waitForCompletion = false,
+    budgetCredits,
+  } = options;
+  const parallelSessionId = `parallel-${Date.now()}-${Math.random()
+    .toString(36)
+    .slice(2, 10)}`;
+  const parentDialogId = dialogKey ? extractCustomId(dialogKey) : null;
+  const effectiveDisplayMode: ParallelDisplayMode = "inline";
+
+  const branches = await Promise.all(
+    agents.map(async (agent, index) => {
+      const branchId = agent.branchId?.trim() || `branch-${index + 1}`;
+      const config = await dispatch(read({ dbKey: agent.agentKey })).unwrap();
+      const label =
+        agent.label?.trim() ||
+        (typeof config?.name === "string" && config.name.trim()) ||
+        `Agent ${index + 1}`;
+
+      return {
+        agentKey: agent.agentKey,
+        ...(typeof agent.serverBase === "string" && agent.serverBase.trim()
+          ? { serverBase: agent.serverBase.trim() }
+          : {}),
+        parallelBranchId: branchId,
+        parallelLabel: label,
+        parallelIndex: index,
+        agentRecordId: typeof config?.dbKey === "string" ? config.dbKey : agent.agentKey,
+        model: typeof config?.model === "string" ? config.model : null,
+        provider: typeof config?.provider === "string" ? config.provider : null,
+        inputPrice:
+          typeof config?.inputPrice === "number" && Number.isFinite(config.inputPrice)
+            ? config.inputPrice
+            : null,
+        outputPrice:
+          typeof config?.outputPrice === "number" && Number.isFinite(config.outputPrice)
+            ? config.outputPrice
+            : null,
+      };
+    })
+  );
+
+  const branchTaskPreview = task.replace(/\s+/g, " ").trim().slice(0, 36);
+  const useChildDialogs = waitForCompletion && !!dialogKey;
+
+  const branchesWithTargets = await Promise.all(
+    branches.map(async (branch) => {
+      if (!useChildDialogs) {
+        return branch;
+      }
+
+      const childTitle =
+        branchTaskPreview.length > 0
+          ? `${branch.parallelLabel} · ${branchTaskPreview}`
+          : branch.parallelLabel;
+
+      const created = (await dispatch(
+        createDialog({
+          cybots: [branch.agentKey],
+          title: childTitle,
+          inheritFromDialogKey: dialogKey,
+          skipGreeting: true,
+        })
+      ).unwrap()) as DialogConfig;
+
+      if (created?.dbKey && parentDialogId) {
+        await dispatch(
+          patch({
+            dbKey: created.dbKey,
+            changes: {
+              parentDialogId,
+            },
+          })
+        )
+          .unwrap()
+          .catch(() => null);
+      }
+
+      return {
+        ...branch,
+        childDialogKey: created?.dbKey,
+        childDialogId: created?.dbKey ? extractCustomId(created.dbKey) : undefined,
+        childSpaceId: created?.spaceId,
+      };
+    })
+  );
+
+  if (!waitForCompletion) {
+    for (const branch of branchesWithTargets) {
+      void dispatch(
+        streamAgentChatTurn({
+          agentKey: branch.agentKey,
+          userInput: task,
+          ...(branch.serverBase ? { serverBase: branch.serverBase } : {}),
+          ...(dialogKey ? { dialogKey } : {}),
+          runtimeOptions: {
+            parallelSessionId,
+            parallelBranchId: branch.parallelBranchId,
+            parallelLabel: branch.parallelLabel,
+            parallelIndex: branch.parallelIndex,
+          },
+        })
+      );
+    }
+
+    return {
+      displayMode: effectiveDisplayMode,
+      parallelSessionId,
+      branches: branchesWithTargets,
+    };
+  }
+
+  const results = await Promise.all(
+    branchesWithTargets.map(async (branch) => {
+      try {
+        const targetDialogKey = branch.childDialogKey || dialogKey;
+        const targetDialogId = branch.childDialogId || dialogId;
+        const branchTurn = await dispatch(
+          streamAgentChatTurn({
+            agentKey: branch.agentKey,
+            userInput: task,
+            ...(branch.serverBase ? { serverBase: branch.serverBase } : {}),
+            ...(targetDialogKey ? { dialogKey: targetDialogKey } : {}),
+            ...(!branch.childDialogKey
+              ? {
+                  runtimeOptions: {
+                    parallelSessionId,
+                    parallelBranchId: branch.parallelBranchId,
+                    parallelLabel: branch.parallelLabel,
+                    parallelIndex: branch.parallelIndex,
+                  },
+                }
+              : {}),
+          })
+        ).unwrap();
+
+        if (!targetDialogId) {
+          return {
+            ok: false,
+            label: branch.parallelLabel,
+            branchId: branch.parallelBranchId,
+            parallelSessionId,
+            parallelIndex: branch.parallelIndex,
+            agentKey: branch.agentKey,
+            dialogKey: targetDialogKey ?? null,
+            dialogId: targetDialogId ?? null,
+            model: branch.model,
+            error: "missing dialogId for parallel result collection",
+            spentCredits: null,
+          };
+        }
+
+        const finalMessage = getBranchFinalContent(
+          selectAllMsgs(getState(), targetDialogId) as Message[],
+          branch.childDialogKey
+            ? {
+                agentKey: branch.agentKey,
+              }
+            : {
+                parallelSessionId,
+                parallelBranchId: branch.parallelBranchId,
+                agentKey: branch.agentKey,
+              }
+        );
+
+        if (!finalMessage?.content) {
+          return {
+            ok: false,
+            label: branch.parallelLabel,
+            branchId: branch.parallelBranchId,
+            parallelSessionId,
+            parallelIndex: branch.parallelIndex,
+            agentKey: branch.agentKey,
+            dialogKey: targetDialogKey ?? null,
+            dialogId: targetDialogId ?? null,
+            spaceId: branch.childSpaceId ?? null,
+            model: branch.model,
+            error: "branch completed without assistant content",
+            spentCredits: null,
+          };
+        }
+
+        const inlineProjection =
+          effectiveDisplayMode === "inline" && parentDialogId
+            ? await persistInlineBranchMessage({
+                dispatch,
+                parentDialogId,
+                agentKey: branch.agentKey,
+                agentName: branch.parallelLabel,
+                content: finalMessage.content,
+                parallelSessionId,
+                parallelBranchId: branch.parallelBranchId,
+                parallelLabel: branch.parallelLabel,
+                parallelIndex: branch.parallelIndex,
+              })
+            : null;
+        const pricing = calculateParallelBranchPricing({
+          usage: branchTurn?.usage,
+          agentKey: branch.agentKey,
+          dialogId: targetDialogId ?? null,
+          agentConfig: {
+            id: branch.agentRecordId,
+            model: branch.model,
+            provider: branch.provider,
+            inputPrice: branch.inputPrice,
+            outputPrice: branch.outputPrice,
+          },
+        });
+
+        return {
+          ok: true,
+          label: branch.parallelLabel,
+          branchId: branch.parallelBranchId,
+          parallelSessionId,
+          parallelIndex: branch.parallelIndex,
+          agentKey: branch.agentKey,
+          agentName: branch.parallelLabel,
+          dialogKey: targetDialogKey ?? null,
+          dialogId: targetDialogId ?? null,
+          spaceId: branch.childSpaceId ?? null,
+          model: branch.model,
+          provider: branch.provider,
+          content: finalMessage.content,
+          messageId: finalMessage.messageId,
+          inlineMessageId: inlineProjection?.parentMessageId ?? null,
+          inlineMessageKey: inlineProjection?.parentMessageKey ?? null,
+          usage: branchTurn?.usage ?? null,
+          spentCredits: pricing.spentCredits,
+          billedModel: pricing.billedModel,
+          billedProvider: pricing.billedProvider,
+          billingServiceTier: pricing.billingServiceTier,
+          pricingError: pricing.pricingError,
+        };
+      } catch (error: any) {
+        return {
+          ok: false,
+          label: branch.parallelLabel,
+          branchId: branch.parallelBranchId,
+          parallelSessionId,
+          parallelIndex: branch.parallelIndex,
+          agentKey: branch.agentKey,
+          dialogKey: branch.childDialogKey ?? dialogKey ?? null,
+          dialogId: branch.childDialogId ?? dialogId ?? null,
+          spaceId: branch.childSpaceId ?? null,
+          model: branch.model,
+          provider: branch.provider,
+          error: error?.message || String(error),
+          spentCredits: null,
+        };
+      }
+    })
+  );
+
+  const successful = results.filter((item) => item.ok);
+  const failed = results.filter((item) => !item.ok);
+  const stats = {
+    total: results.length,
+    succeeded: successful.length,
+    failed: failed.length,
+  };
+  const costSummary = summarizeParallelCosts(results);
+  const budget = summarizeParallelBudget({
+    budgetCredits,
+    results,
+  }) as ParallelBudgetSummary | null;
+  const mergedContent = successful
+    .map((item) => `## ${item.label}\n\n${item.content || "(无内容)"}`)
+    .join("\n\n");
+  const failedSummary = failed
+    .map((item) => `- ${item.label}: ${item.error || "unknown error"}`)
+    .join("\n");
+  const llmContext = [
+    mergedContent ? `并行分支结果：\n${mergedContent}` : "",
+    failedSummary ? `失败分支：\n${failedSummary}` : "",
+    costSummary.pricedBranches > 0 || budget
+      ? [
+          `并行成本：本轮已花费 ${costSummary.spentCredits} 积分。`,
+          budget
+            ? `预算 ${budget.budgetCredits} 积分，剩余 ${budget.remainingCredits} 积分。`
+            : "",
+          costSummary.unpricedBranches > 0
+            ? `${costSummary.unpricedBranches} 个成功分支缺少精确定价。`
+            : "",
+          budget?.exhausted
+            ? "预算已耗尽，请不要再开启新的并行轮次，直接总结当前共识与分歧。"
+            : "",
+        ]
+          .filter(Boolean)
+          .join(" ")
+      : "",
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  return {
+    displayMode: effectiveDisplayMode,
+    parallelSessionId,
+    branches: branchesWithTargets,
+    results,
+    stats,
+    costSummary,
+    ...(budget ? { budget } : {}),
+    content: mergedContent,
+    llmContext,
+  };
+}

package/ai/agent/startupProtocol.ts

@@ -0,0 +1,53 @@
+type StartupProtocolOptions = {
+  hasCheckEnvTool?: boolean;
+  hasExecShellTool?: boolean;
+};
+
+export const buildStartupProtocolBlock = (
+  options: StartupProtocolOptions = {}
+): string => {
+  const lines = [
+    "--- 启动协议 ---",
+    "每次开始处理一个新请求时，先整理启动上下文，再决定是否调用工具。",
+    "",
+    "启动顺序：",
+    "1. 先读取 policy / knowledge：你的核心 prompt、自动加载的 references、以及用户策略约束。",
+    "2. 再提炼 current mission：优先从当前用户输入和当前输入上下文里确认本轮目标、交付物和停止条件。",
+    "3. 再吸收 recent memory：结合 Memory Overlay、历史摘要、最近工作记忆和必要的历史引用，只保留对本轮真正有帮助的部分。",
+    "",
+    "在第一次工具调用前，先形成一份内部 working state，至少包含：",
+    "- current_goal：这一轮真正要完成什么",
+    "- constraints：当前约束、偏好、边界条件",
+    "- missing_facts：还缺哪些事实才能安全行动",
+    "- next_action：下一步最小且高价值的动作",
+    "",
+    "决策规则：",
+    "- 如果 policy / knowledge 已经足够回答，就直接回答，不要为了显得忙而乱调用工具。",
+    "- 如果 recent memory 与当前用户输入冲突，以当前用户输入为准。",
+    "- 如果需要依赖环境、文件状态、运行时事实或外部真值，先验证，再行动。",
+    "- 优先小步推进；每一轮先做最能降低不确定性的动作。",
+  ];
+
+  if (options.hasCheckEnvTool || options.hasExecShellTool) {
+    lines.push(
+      "- 只要任务涉及命令执行、shell 语法、路径约定、运行平台或服务状态，并且这些事实还不够明确，就先确认环境。"
+    );
+  }
+
+  if (options.hasCheckEnvTool) {
+    lines.push(
+      "- 环境不明确时，优先调用 checkEnv({ check: 'context' })，再决定后续命令和工具路径。"
+    );
+  }
+
+  if (options.hasExecShellTool) {
+    lines.push(
+      "- 需要执行命令时，先根据已确认的环境选择 shell；Windows 默认 PowerShell，Linux/macOS 默认 bash。"
+    );
+    lines.push(
+      "- 如果只是收集多个只读环境事实，优先合并成一次 shell 调用或一条组合命令，避免拆成很多小探针。"
+    );
+  }
+
+  return lines.join("\n");
+};