nolo-cli 0.1.7 → 0.1.9

package/ai/agent/cliPrompt.ts

@@ -0,0 +1,10 @@
+/**
+ * 构建包含 system prompt 的完整 prompt。
+ *
+ * CLI agent 与普通 model 共用 prompt / model / 最近文本上下文这些能力面，
+ * 但 CLI 不走本地 tool-calls 协议，因此这里只做文本级结构化拼接。
+ */
+export function buildCliPrompt(systemPrompt: string | undefined, taskPrompt: string): string {
+  if (!systemPrompt?.trim()) return taskPrompt;
+  return `[角色设定]\n${systemPrompt.trim()}\n\n[当前任务]\n${taskPrompt.trim()}`;
+}

package/ai/agent/contextCompiler.ts

@@ -0,0 +1,107 @@
+// Simple deterministic hash for cache-key purposes (browser + server compatible)
+function createHash(_algo: string) {
+  let buf = "";
+  return {
+    update(s: string) { buf += s; return this; },
+    digest(_enc: string) {
+      // FNV-1a 32-bit, hex-padded to 8 chars
+      let h = 0x811c9dc5;
+      for (let i = 0; i < buf.length; i++) {
+        h ^= buf.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+      }
+      return h.toString(16).padStart(8, "0");
+    },
+  };
+}
+
+export type ContextLayerOwner =
+  | "platform"
+  | "agent"
+  | "user"
+  | "runtime";
+
+export type ContextLayerCacheScope = "static" | "session" | "turn";
+
+export type ContextLayer = {
+  id: string;
+  owner: ContextLayerOwner;
+  content?: string | null;
+  tokenBudget?: number;
+  cacheScope?: ContextLayerCacheScope;
+};
+
+export type CompiledContextLayer = {
+  id: string;
+  owner: ContextLayerOwner;
+  content: string;
+  cacheScope: ContextLayerCacheScope;
+  charCount: number;
+  estimatedTokens: number;
+  tokenBudget?: number;
+  budgetStatus?: "within-budget" | "over-budget";
+};
+
+export type CompiledContext = {
+  content: string;
+  layers: CompiledContextLayer[];
+  cacheProfile: {
+    stablePrefixHash: string;
+    stablePrefixLayerIds: string[];
+    stablePrefixCharCount: number;
+    stablePrefixEstimatedTokens: number;
+  };
+};
+
+const hasLayerContent = (
+  layer: ContextLayer
+): layer is ContextLayer & { content: string } => Boolean(layer.content);
+
+export const estimateContextTokens = (content: string): number =>
+  Math.ceil(content.length / 4);
+
+export const compileContextLayers = (
+  layers: ContextLayer[]
+): CompiledContext => {
+  const compiledLayers = layers
+    .filter(hasLayerContent)
+    .map((layer): CompiledContextLayer => {
+      const estimatedTokens = estimateContextTokens(layer.content);
+      return {
+        id: layer.id,
+        owner: layer.owner,
+        content: layer.content,
+        cacheScope: layer.cacheScope ?? "turn",
+        charCount: layer.content.length,
+        estimatedTokens,
+        tokenBudget: layer.tokenBudget,
+        budgetStatus:
+          typeof layer.tokenBudget === "number"
+            ? estimatedTokens <= layer.tokenBudget
+              ? "within-budget"
+              : "over-budget"
+            : undefined,
+      };
+    });
+  const stablePrefixLayers: CompiledContextLayer[] = [];
+  for (const layer of compiledLayers) {
+    if (layer.cacheScope === "turn") break;
+    stablePrefixLayers.push(layer);
+  }
+  const stablePrefixContent = stablePrefixLayers
+    .map((layer) => layer.content)
+    .join("\n\n");
+
+  return {
+    content: compiledLayers.map((layer) => layer.content).join("\n\n"),
+    layers: compiledLayers,
+    cacheProfile: {
+      stablePrefixHash: createHash("sha256")
+        .update(stablePrefixContent)
+        .digest("hex"),
+      stablePrefixLayerIds: stablePrefixLayers.map((layer) => layer.id),
+      stablePrefixCharCount: stablePrefixContent.length,
+      stablePrefixEstimatedTokens: estimateContextTokens(stablePrefixContent),
+    },
+  };
+};

package/ai/agent/contextLayerContract.ts

@@ -0,0 +1,44 @@
+type ContextLayerContractOptions = {
+  hasRememberMemoryTool?: boolean;
+  hasDocTools?: boolean;
+};
+
+export const buildContextLayerContractBlock = (
+  options: ContextLayerContractOptions = {}
+): string => {
+  const lines = [
+    "--- 上下文分层约定 ---",
+    "不要把所有信息都塞进同一层。优先利用已有的 memory / knowledge / doc，而不是把它们混成一段长对话。",
+    "",
+    "层次边界：",
+    "1. memory layer：放短到中期、可复用但不必永久挂载的偏好、近期共识和压缩后的经验；要短、可检索、可替换。",
+    "2. knowledge layer：放稳定规则、长期有效事实和每轮都会反复依赖的说明；优先通过 prompt / references 自动加载。",
+    "3. doc layer：放需要跨轮次持续维护的外部工作台，例如 runbook、mission、incident、checkpoint、idea backlog、experiment log；需要时显式读取和更新。",
+    "",
+    "写入原则：",
+    "- 临时步骤、原始长日志、一次性思路，不要直接写进 memory 或 knowledge。",
+    "- 稳定行为规则、长期固定约束，优先沉淀到 knowledge layer。",
+    "- 用户偏好、最近形成的协作共识、近期反复有用的经验，优先沉淀到 memory layer。",
+    "- 需要跨轮次接力的任务状态、运行手册、事故记录、检查点，优先写入 doc layer。",
+    "",
+    "读取原则：",
+    "- 先用 knowledge layer 解决稳定规则问题。",
+    "- 再用 memory layer 补充近期偏好和延续性。",
+    "- 需要真实运行现场、任务状态或可共享工作台时，再读 doc layer。",
+    "- 当前用户输入始终高于 recent memory；recent memory 高于过旧的 doc 推断。",
+  ];
+
+  if (options.hasRememberMemoryTool) {
+    lines.push(
+      "- 当某条偏好、近期共识或复用经验对未来明显有帮助时，可以调用 rememberMemory，但要写成简洁可复用的一句话；只有当前 dialog 明确绑定了 space，且内容属于共享协作规则时才写 space memory。"
+    );
+  }
+
+  if (options.hasDocTools) {
+    lines.push(
+      "- 当任务需要 24h 连续运行、跨 dialog 接力或人工与 agent 共读时，优先把 mission / runbook / incident / checkpoint / idea backlog / experiment log 写入 doc layer。"
+    );
+  }
+
+  return lines.join("\n");
+};

package/ai/agent/createAgentSchema.ts

@@ -0,0 +1,234 @@
+// 路径: ai/agent/createAgentSchema.ts
+
+import { ReferenceItem } from "app/types"; // 确保 app/types 里有 ReferenceItem 定义
+import { TFunction } from "i18next";
+import { z } from "zod";
+
+// --- 常量 ---
+export const DEFAULT_TEMPERATURE = 0.7;
+export const DEFAULT_TOP_P = 1;
+export const DEFAULT_FREQUENCY_PENALTY = 0.0;
+export const DEFAULT_PRESENCE_PENALTY = 0.0;
+export const DEFAULT_MAX_TOKENS = 4096;
+export const DEFAULT_REASONING_EFFORT = "medium";
+
+export const REASONING_EFFORT_OPTIONS = ["low", "medium", "high"] as const;
+const greetingMenuItemSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  userMessage: z.string().optional(),
+});
+
+const greetingConfigSchema = z.object({
+  text: z.string().trim().optional(),
+  menu: z.array(greetingMenuItemSchema).optional(),
+});
+
+const referenceItemSchema = z
+  .object({
+    dbKey: z.string(),
+    title: z.string(),
+    type: z.enum(["knowledge", "instruction", "page"]),
+  })
+  .transform((data) => ({
+    ...data,
+    type: data.type === "page" ? "knowledge" : data.type,
+  }));
+
+// --- 核心 schema ---
+export const getCreateAgentSchema = (t: TFunction) =>
+  z
+    .object({
+      name: z
+        .string()
+        .trim()
+        .min(1, t("validation.nameRequired"))
+        .max(50, t("validation.nameTooLong")),
+
+      /**
+       * provider 不再必填：只是一个可选的标识字段
+       */
+      provider: z.string().trim().optional().or(z.string().length(0)),
+
+      /**
+       * 模型：所有模式下必须选择（通过 refine 条件校验）
+       */
+      model: z.string().trim().optional().or(z.string().length(0)),
+
+      /**
+       * 模型是否支持图像（来自模型元数据，方便持久化 / 服务端快速判断）
+       */
+      hasVision: z.boolean().optional().default(false),
+
+      /**
+       * API 来源：平台 / 自定义 / CLI
+       */
+      apiSource: z.enum(["platform", "custom", "cli"]).default("platform"),
+
+      /**
+       * CLI provider（apiSource=cli 时有效）：支持 "copilot" | "gemini" | "codex" | "claude"
+       */
+      cliProvider: z
+        .enum(["copilot", "gemini", "codex", "claude"])
+        .optional()
+        .or(z.literal("")),
+
+      /**
+       * Optional machine binding for CLI agents. Empty means use the server/local
+       * CLI runtime; a value means dispatch the CLI run to a connected machine.
+       */
+      machineId: z.string().trim().optional().or(z.string().length(0)),
+
+      customProviderUrl: z
+        .string()
+        .trim()
+        .optional()
+        .or(z.string().length(0))
+        .refine((val) => !val || z.string().url().safeParse(val).success, {
+          message: t("validation.invalidUrl"),
+        }),
+
+      /**
+       * API Key：完全可选（本地 / 无鉴权的自定义接口不需要）
+       */
+      apiKey: z.string().trim().optional().or(z.string().length(0)),
+
+      useServerProxy: z.boolean().default(true),
+
+      prompt: z.string().trim().optional().or(z.string().length(0)),
+
+      tools: z.array(z.string()).default([]),
+
+      isPublic: z.boolean().default(false),
+
+      greeting: z
+        .union([z.string(), greetingConfigSchema])
+        .optional(),
+
+
+      introduction: z.string().trim().optional().or(z.string().length(0)),
+
+      inputPrice: z.number().min(0, t("validation.priceMin")).default(0),
+
+      outputPrice: z.number().min(0, t("validation.priceMin")).default(0),
+
+      avatarFileId: z.string().optional().or(z.string().length(0)),
+
+      tags: z.string().trim().optional().or(z.string().length(0)),
+
+      references: z
+        .array(referenceItemSchema)
+        .optional()
+        .default([])
+        .refine(
+          (refs) => {
+            const dbKeys = refs?.map((ref) => ref.dbKey) || [];
+            return dbKeys.length === new Set(dbKeys).size;
+          },
+          { message: t("validation.duplicateReferences") }
+        ),
+
+      temperature: z
+        .number()
+        .min(0, t("validation.temperatureRange"))
+        .max(2, t("validation.temperatureRange"))
+        .optional(),
+
+      top_p: z
+        .number()
+        .min(0, t("validation.topPRange"))
+        .max(1, t("validation.topPRange"))
+        .optional(),
+
+      frequency_penalty: z
+        .number()
+        .min(-2, t("validation.frequencyPenaltyRange"))
+        .max(2, t("validation.frequencyPenaltyRange"))
+        .optional(),
+
+      presence_penalty: z
+        .number()
+        .min(-2, t("validation.presencePenaltyRange"))
+        .max(2, t("validation.presencePenaltyRange"))
+        .optional(),
+
+      max_tokens: z
+        .number()
+        .min(1, t("validation.maxTokensMin"))
+        .max(500000, t("validation.maxTokensMax"))
+        .optional(),
+
+      reasoning_effort: z
+        .enum(REASONING_EFFORT_OPTIONS, {
+          errorMap: () => ({ message: t("validation.reasoningEffortInvalid") }),
+        })
+        .default(DEFAULT_REASONING_EFFORT)
+        .optional(),
+
+      /**
+       * enableThinking：是否开启模型思考模式
+       * - Ollama/Qwen3: delta.reasoning 字段会流式返回思考过程
+       * - Anthropic Claude: 注入 thinking: { type:"enabled", budget_tokens }
+       * - DeepSeek: delta.reasoning_content
+       */
+      enableThinking: z.boolean().optional().default(false),
+
+      /**
+       * thinkingBudget：思考 token 预算（仅对支持 budget_tokens 的 provider 生效，如 Anthropic）
+       * Ollama/DeepSeek 等不支持 budget_tokens 的 provider 忽略此字段
+       */
+      thinkingBudget: z
+        .number()
+        .min(1024, t("validation.thinkingBudgetMin"))
+        .max(32000, t("validation.thinkingBudgetMax"))
+        .optional(),
+
+      /**
+       * whitelist：白名单
+       */
+      whitelist: z.array(z.string().trim().min(1)).optional().default([]),
+
+      /**
+       * linkedSpaces：关联的其他 Space ID 列表
+       * Agent 可以访问这些 Space 的目录结构作为粗略上下文
+       */
+      linkedSpaces: z.array(z.string().trim().min(1)).optional().default([]),
+    })
+    // --- refine 逻辑 ---
+    // 1) 自定义 URL 必填：
+    //    - 只要 apiSource === "custom"，必须填写 customProviderUrl
+    .refine(
+      (data) => {
+        if (data.apiSource === "custom") {
+          return !!data.customProviderUrl;
+        }
+        return true;
+      },
+      {
+        message: t("validation.customUrlRequired"),
+        path: ["customProviderUrl"],
+      }
+    )
+    // 2) model 必填规则：
+    //    - platform / custom 模式必填；cli 模式有默认值，不强制
+    .refine(
+      (data) => {
+        if (data.apiSource === "cli") return true;
+        return !!data.model?.trim();
+      },
+      {
+        message: t("validation.modelRequired"),
+        path: ["model"],
+      }
+    );
+
+export type FormData = z.infer<ReturnType<typeof getCreateAgentSchema>>;
+
+export const normalizeReferences = (references: any[]): ReferenceItem[] => {
+  if (!Array.isArray(references)) return [];
+  return references.map((ref) => ({
+    dbKey: ref.dbKey || "",
+    title: ref.title || "",
+    type: ref.type === "page" ? "knowledge" : ref.type || "knowledge",
+  }));
+};

package/ai/agent/executeToolCall.ts

@@ -0,0 +1,58 @@
+// packages/ai/agent/executeToolCall.ts
+//
+// 提取自 runAgentClientLoop：非流式多轮循环中执行单次 tool_call 的公共逻辑。
+// streamAgentChatTurn 走 sendOpenAICompletionsRequest → toolThunks，不使用此函数。
+
+import { findToolExecutor } from "ai/tools";
+import { getToolResultErrorData } from "ai/tools/toolResultError";
+
+interface ToolCall {
+  id: string;
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+}
+
+/**
+ * 执行单次 tool_call，返回工具结果字符串（供追加到 messages）。
+ *
+ * @param tc            LLM 返回的单个 tool_call 对象
+ * @param thunkApi      Redux thunkApi（含 dispatch / getState）
+ * @param parentMessageId 父消息 ID（关联上下文）
+ */
+export async function executeToolCall(
+  tc: ToolCall,
+  thunkApi: any,
+  parentMessageId?: string
+): Promise<string> {
+  const toolName: string = tc.function?.name ?? "";
+  const toolArgs = (() => {
+    try {
+      return JSON.parse(tc.function?.arguments ?? "{}");
+    } catch {
+      return {};
+    }
+  })();
+
+  try {
+    const executor = findToolExecutor(toolName);
+    if (!executor) {
+      return `[工具 "${toolName}" 未找到]`;
+    }
+    const result = await executor(toolArgs, thunkApi, {
+      parentMessageId: parentMessageId ?? "",
+    });
+    // executor 返回 { rawData, displayData? } 或直接返回字符串
+    const raw = result?.rawData ?? result;
+    return typeof raw === "string" ? raw : JSON.stringify(raw);
+  } catch (err: any) {
+    console.error(`[executeToolCall] tool "${toolName}" 执行失败:`, err);
+    const structured = getToolResultErrorData(err);
+    if (structured?.rawData !== undefined) {
+      const raw = structured.rawData;
+      return typeof raw === "string" ? raw : JSON.stringify(raw);
+    }
+    return `[工具 "${toolName}" 执行失败: ${err?.message ?? err}]`;
+  }
+}

package/ai/agent/fetchAgentContexts.ts

@@ -0,0 +1,42 @@
+import { fetchReferenceContents } from "ai/context/buildReferenceContext";
+import { resolveReferenceAssets } from "ai/agent/referenceUtils";
+import type { ReferenceItem } from "app/types";
+
+export interface AgentContexts {
+  botInstructionsContext: string;
+  botKnowledgeContext: string;
+}
+
+/** 根据 agentConfig.references 拉取 instruction / knowledge */
+export async function fetchAgentContexts(
+  references: ReferenceItem[] | undefined,
+  dispatch: any
+): Promise<AgentContexts> {
+  if (!Array.isArray(references)) {
+    return { botInstructionsContext: "", botKnowledgeContext: "" };
+  }
+
+  const { references: normalizedRefs, contentByKey } =
+    await resolveReferenceAssets(references, dispatch);
+
+  const instructionKeys = new Set<string>();
+  const knowledgeKeys = new Set<string>();
+  normalizedRefs.forEach((ref) => {
+    if (!ref.dbKey) return;
+    ref.type === "instruction"
+      ? instructionKeys.add(ref.dbKey)
+      : knowledgeKeys.add(ref.dbKey);
+  });
+  const [instructionsMap, knowledgeMap] = await Promise.all([
+    fetchReferenceContents(Array.from(instructionKeys), dispatch, {
+      preloaded: contentByKey,
+    }),
+    fetchReferenceContents(Array.from(knowledgeKeys), dispatch, {
+      preloaded: contentByKey,
+    }),
+  ]);
+  return {
+    botInstructionsContext: Array.from(instructionsMap.values()).join(""),
+    botKnowledgeContext: Array.from(knowledgeMap.values()).join(""),
+  };
+}

package/ai/agent/generatePrompt.ts

@@ -0,0 +1,3 @@
+// 文件路径: ai/agent/generatePrompt.ts
+// 向后兼容转发层，请使用 buildSystemPrompt
+export { buildSystemPrompt as generatePrompt, buildSystemPrompt } from "./buildSystemPrompt";

package/ai/agent/getFullChatContextKeys.ts

@@ -0,0 +1,168 @@
+
+// packages/ai/agent/getFullChatContextKeys.ts
+import { RootState } from "app/store";
+import { selectAllMsgs } from "chat/messages/messageSlice";
+import type { DialogConfig } from "app/types";
+import { extractCustomId } from "core/prefix";
+
+/** 简单的数组差集工具：返回 arrA 中不在 arrB 里的元素 */
+const difference = <T>(arrA: T[], arrB: T[]): T[] => {
+  if (!arrA.length) return [];
+  if (!arrB.length) return [...arrA];
+
+  const exclude = new Set(arrB);
+  return arrA.filter((item) => !exclude.has(item));
+};
+
+/**
+ * Collect all possible reference keys for this chat turn:
+ * - botInstructionKeys: keys from agentConfig.references of type "instruction"
+ * - botKnowledgeKeys: keys from agentConfig.references (non-instruction)
+ * - currentInputKeys: keys referenced directly by the user's current input (array parts with pageKey)
+ * - historyKeys: keys from all previous messages' content parts
+ */
+export const getFullChatContextKeys = async (
+  state: RootState,
+  dispatch: any,
+  agentConfig: any,
+  userInput: string | any[],
+  dialogConfig?: DialogConfig
+): Promise<Record<string, Set<string>>> => {
+  const msgs = selectAllMsgs(
+    state,
+    dialogConfig?.dbKey
+      ? extractCustomId(dialogConfig.dbKey)
+      : dialogConfig?.id
+  );
+
+  const botInstructionKeys = new Set<string>();
+  const botKnowledgeKeys = new Set<string>();
+
+  if (Array.isArray(agentConfig.references)) {
+    for (const ref of agentConfig.references as Array<{
+      dbKey: string;
+      type: string;
+    }>) {
+      if (!ref?.dbKey) continue;
+      if (ref.type === "instruction") {
+        botInstructionKeys.add(ref.dbKey);
+      } else {
+        botKnowledgeKeys.add(ref.dbKey);
+      }
+    }
+  }
+
+  const currentInputKeys = new Set<string>();
+  if (Array.isArray(userInput)) {
+    for (const part of userInput) {
+      if (part?.pageKey) currentInputKeys.add(part.pageKey);
+      if (part?.dialogKey) currentInputKeys.add(part.dialogKey);
+    }
+  }
+
+  const historyKeys = new Set<string>();
+
+  // 1. 从 DialogConfig.referenceKeys 读取（这是主要的、持久化的引用来源）
+  // 即使消息被压缩，这里的 keys 也会保留
+  const savedKeys = dialogConfig?.referenceKeys;
+  if (Array.isArray(savedKeys)) {
+    savedKeys.forEach((k: string) => historyKeys.add(k));
+  }
+
+  // 2. 仅扫描尚未被压缩的近期消息
+  // 已压缩的消息（summarizedBeforeId 之前的部分，包含该条本身）的 keys
+  // 已在压缩时存入 dialogConfig.referenceKeys，步骤 1 已覆盖，无需重复扫描。
+  const scanContentParts = (msg: any) => {
+    if (!msg.content) return;
+    const contentParts = Array.isArray(msg.content) ? msg.content : [msg.content];
+    for (const part of contentParts) {
+      if (part && typeof part === 'object') {
+        if (part?.pageKey) historyKeys.add(part.pageKey);
+        if (part?.dialogKey) historyKeys.add(part.dialogKey);
+      }
+    }
+  };
+
+  if (msgs && msgs.length > 0) {
+    const summarizedBeforeId = dialogConfig?.summarizedBeforeId;
+
+    if (!summarizedBeforeId) {
+      // 无压缩记录，扫描全部消息
+      for (const msg of (msgs as any[])) scanContentParts(msg);
+    } else {
+      let foundMarker = false;
+      let startScan = false;
+
+      for (const msg of (msgs as any[])) {
+        if (!startScan) {
+          if (msg.id === summarizedBeforeId) {
+            foundMarker = true;
+            startScan = true;
+            // summarizedBeforeId 那条消息本身已被压缩，keys 在 referenceKeys 里，跳过
+          }
+          continue;
+        }
+        scanContentParts(msg);
+      }
+
+      // marker 找不到说明 Redux 中的消息都是新的，应该全扫
+      if (!foundMarker) {
+        console.warn(`[getFullChatContextKeys] marker ${summarizedBeforeId} not found, scanning all`);
+        for (const msg of (msgs as any[])) scanContentParts(msg);
+      }
+    }
+  }
+
+  return {
+    botInstructionKeys,
+    currentInputKeys,
+    historyKeys,
+    botKnowledgeKeys,
+  };
+};
+
+/**
+ * Deduplicate keys across priority levels.
+ * Priority order (high -> low):
+ * 1) botInstructionKeys
+ * 2) currentInputKeys
+ * 3) historyKeys
+ * 4) botKnowledgeKeys
+ *
+ * Return field names match context block identifiers expected downstream.
+ */
+export const deduplicateContextKeys = (
+  keys: Record<string, Set<string>>
+): Record<string, string[]> => {
+  const {
+    botInstructionKeys,
+    currentInputKeys,
+    historyKeys,
+    botKnowledgeKeys,
+  } = keys;
+
+  const finalBotInstructionKeys = Array.from(botInstructionKeys);
+
+  const finalCurrentInputKeys = difference(
+    Array.from(currentInputKeys),
+    finalBotInstructionKeys
+  );
+
+  const finalHistoryKeys = difference(Array.from(historyKeys), [
+    ...finalBotInstructionKeys,
+    ...finalCurrentInputKeys,
+  ]);
+
+  const finalBotKnowledgeKeys = difference(Array.from(botKnowledgeKeys), [
+    ...finalBotInstructionKeys,
+    ...finalCurrentInputKeys,
+    ...finalHistoryKeys,
+  ]);
+
+  return {
+    botInstructionsContext: finalBotInstructionKeys,
+    currentInputContext: finalCurrentInputKeys,
+    historyContext: finalHistoryKeys,
+    botKnowledgeContext: finalBotKnowledgeKeys,
+  };
+};