nolo-cli 0.1.40 → 0.1.41

package/ai/agent/cleanAgentMessages.ts

@@ -0,0 +1,140 @@
+// 文件路径: ai/agent/cleanAgentMessages.ts
+
+import type { Message } from "../../chat/messages/types";
+
+/**
+ * 判断消息的文本内容是否“为空”（对人没意义）
+ */
+const isEmptyContent = (content: unknown): boolean => {
+    if (content == null) return true;
+
+    if (typeof content === "string") {
+        return content.trim().length === 0;
+    }
+
+    if (Array.isArray(content)) {
+        return content.length === 0;
+    }
+
+    return false;
+};
+
+/**
+ * 为指定 Agent 构造“安全”的消息视图:
+ *
+ * 分层目标：
+ * - 这一层是「对话视角清洗」，不直接关心 OpenAI/Azure 精确协议，只关心：
+ *   1）当前 Agent 能看到什么历史；
+ *   2）哪些内部 plumbing 信息需要隐藏。
+ *
+ * 约定：
+ * - 所有 Agent：
+ *   - 丢弃「assistant 且 content 为空 且 没有 tool 调用」的消息（通常是 streaming 占位，没实际内容）
+ *
+ * - 当前 Agent（cybotKey 匹配）：
+ *   - user / assistant / tool 消息：原样保留（保证自己工具链完整）
+ *   - 特别地：即使 assistant 只有 tool 调用、没有文本，也要保留
+ *
+ * - 其它 Agent：
+ *   - assistant 消息：
+ *       - 删除所有 tool 调用字段（tool_calls / toolCalls），避免跨 Agent 的 call_id 冲突；
+ *       - 使用 agentName 作为前缀，生成可读文本：
+ *         - 有原始文本：`【AgentName】 原文...`
+ *         - 没有原始文本：`【AgentName】（使用了工具生成回复）`
+ *   - tool 消息：直接丢弃（内部 plumbing，对当前 Agent 没意义）
+ *
+ * - 其它角色（system 等）：原样保留
+ */
+export const buildAgentViewMessages = (
+    allMessages: Message[],
+    currentCybotKey: string
+): Message[] => {
+    const result: Message[] = [];
+
+    for (const msg of allMessages) {
+        if (!msg) continue;
+
+        const role = (msg as any).role;
+        if (!role) continue;
+
+        // 同时兼容内部字段 toolCalls 和 OpenAI 标准字段 tool_calls
+        const hasToolCalls =
+            (Array.isArray((msg as any).tool_calls) &&
+                (msg as any).tool_calls.length > 0) ||
+            (Array.isArray((msg as any).toolCalls) &&
+                (msg as any).toolCalls.length > 0);
+
+        const empty = isEmptyContent((msg as any).content);
+
+        // 1. 统一丢弃“空 assistant 且没有 tool 调用”的消息
+        //    - 对所有 Agent 一视同仁，这类通常是 streaming 中途写入的占位，没实际内容
+        if (role === "assistant" && empty && !hasToolCalls) {
+            continue;
+        }
+
+        const isCurrentAgent = (msg as any).cybotKey === currentCybotKey;
+
+        // ---- 用户消息：所有 Agent 都需要完整历史 ----
+        if (role === "user") {
+            result.push(msg);
+            continue;
+        }
+
+        // ---- 助手消息 ----
+        if (role === "assistant") {
+            if (isCurrentAgent) {
+                // 当前 Agent 自己的历史回复：原样保留（包含 toolCalls / tool_calls）
+                result.push(msg);
+            } else {
+                // 其它 Agent 的回复：降级为纯文本 + 前缀，不再携带任何 tool 调用字段
+                const cloned: Message = { ...(msg as any) } as Message;
+
+                // 删掉所有工具调用字段，避免跨 Agent 的 call_id 污染
+                if ((cloned as any).tool_calls) {
+                    delete (cloned as any).tool_calls;
+                }
+                if ((cloned as any).toolCalls) {
+                    delete (cloned as any).toolCalls;
+                }
+
+                const rawAgentName = (cloned as any).agentName;
+                const agentName =
+                    rawAgentName && String(rawAgentName).trim()
+                        ? String(rawAgentName).trim()
+                        : "其他 Agent";
+
+                if (typeof cloned.content === "string") {
+                    const trimmed = cloned.content.trim();
+                    if (trimmed) {
+                        cloned.content = `【${agentName}】 ${trimmed}`;
+                    } else {
+                        cloned.content = `【${agentName}】（使用了工具生成回复）`;
+                    }
+                } else {
+                    // 非字符串内容（理论上很少见），同样给一个占位说明
+                    cloned.content = `【${agentName}】（使用了工具生成回复）`;
+                }
+
+                result.push(cloned);
+            }
+            continue;
+        }
+
+        // ---- 工具消息 ----
+        if (role === "tool") {
+            if (isCurrentAgent) {
+                // 当前 Agent 自己的 tool 消息：保留，保证工具调用链可用
+                result.push(msg);
+            } else {
+                // 其它 Agent 的 tool 消息：全部丢弃，避免跨 Agent / 跨 provider 的 call_id 冲突
+                continue;
+            }
+            continue;
+        }
+
+        // ---- 其它角色（system 等） ----
+        result.push(msg);
+    }
+
+    return result;
+};

package/ai/agent/cliChatClient.ts

@@ -0,0 +1,153 @@
+import { selectCurrentServer } from "../../app/settings/settingSlice";
+import { selectCurrentToken } from "../../auth/authSlice";
+import type { RootState } from "../../app/store";
+import type { CliProvider } from "./cliExecutor";
+
+type CliChatAction = "start" | "turn" | "get" | "close";
+
+type CliChatRequestBase = {
+  cliProvider?: CliProvider;
+  model?: string;
+  systemPrompt?: string;
+  reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+  temperature?: number;
+  topP?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  maxTokens?: number;
+  enableThinking?: boolean;
+  thinkingBudget?: number;
+};
+
+function getCliChatRequestConfig(thunkApi: any) {
+  const state = thunkApi.getState() as RootState;
+  const currentServer = selectCurrentServer(state);
+  const token = selectCurrentToken(state);
+  if (!currentServer) throw new Error("无法获取当前服务器地址。");
+  return { currentServer, token };
+}
+
+async function postCliChat(
+  thunkApi: any,
+  body: Record<string, any>,
+  signal?: AbortSignal,
+): Promise<Response> {
+  const { currentServer, token } = getCliChatRequestConfig(thunkApi);
+  return fetch(`${currentServer}/api/cli/chat`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+    body: JSON.stringify(body),
+    signal,
+  });
+}
+
+export async function startCliChatSession(
+  thunkApi: any,
+  args: CliChatRequestBase & { systemPrompt?: string; cliProvider?: CliProvider },
+) {
+  const response = await postCliChat(thunkApi, {
+    action: "start" satisfies CliChatAction,
+      cliProvider: args.cliProvider,
+      model: args.model,
+      systemPrompt: args.systemPrompt,
+      reasoningEffort: args.reasoningEffort,
+      temperature: args.temperature,
+      topP: args.topP,
+      frequencyPenalty: args.frequencyPenalty,
+      presencePenalty: args.presencePenalty,
+      maxTokens: args.maxTokens,
+      enableThinking: args.enableThinking,
+      thinkingBudget: args.thinkingBudget,
+    });
+  return response.json();
+}
+
+export async function getCliChatSession(
+  thunkApi: any,
+  args: { sessionId: string },
+) {
+  const response = await postCliChat(thunkApi, {
+    action: "get" satisfies CliChatAction,
+    sessionId: args.sessionId,
+  });
+  return response.json();
+}
+
+export async function closeCliChatSession(
+  thunkApi: any,
+  args: { sessionId: string },
+) {
+  const response = await postCliChat(thunkApi, {
+    action: "close" satisfies CliChatAction,
+    sessionId: args.sessionId,
+  });
+  return response.json();
+}
+
+export async function runCliChatTurnNonStreaming(
+  thunkApi: any,
+  args: CliChatRequestBase & {
+    prompt: string;
+    sessionId: string;
+  },
+  signal?: AbortSignal,
+) {
+  const response = await postCliChat(
+    thunkApi,
+    {
+      action: "turn" satisfies CliChatAction,
+      sessionId: args.sessionId,
+      prompt: args.prompt,
+      model: args.model,
+      stream: false,
+    },
+    signal,
+  );
+  return response.json();
+}
+
+export function createCliChatTurnStream(
+  thunkApi: any,
+  args: CliChatRequestBase & {
+    prompt: string;
+    sessionId?: string;
+  },
+  signal?: AbortSignal,
+) {
+  return postCliChat(
+    thunkApi,
+    args.sessionId
+      ? {
+          action: "turn" satisfies CliChatAction,
+          sessionId: args.sessionId,
+          prompt: args.prompt,
+          model: args.model,
+          reasoningEffort: args.reasoningEffort,
+          temperature: args.temperature,
+          topP: args.topP,
+          frequencyPenalty: args.frequencyPenalty,
+          presencePenalty: args.presencePenalty,
+          maxTokens: args.maxTokens,
+          enableThinking: args.enableThinking,
+          thinkingBudget: args.thinkingBudget,
+        }
+      : {
+          prompt: args.prompt,
+          model: args.model,
+          cliProvider: args.cliProvider,
+          systemPrompt: args.systemPrompt,
+          reasoningEffort: args.reasoningEffort,
+          temperature: args.temperature,
+          topP: args.topP,
+          frequencyPenalty: args.frequencyPenalty,
+          presencePenalty: args.presencePenalty,
+          maxTokens: args.maxTokens,
+          enableThinking: args.enableThinking,
+          thinkingBudget: args.thinkingBudget,
+        },
+    signal,
+  );
+}

package/ai/agent/cliExecutor.ts

@@ -41,7 +41,7 @@ export interface CliImageInput {
 
 export interface CliExecuteOptions {
   model?: string;
-  timeout?: number;   // ms，默认 120_000
+  timeout?: number;   // ms；各 CLI executor 可按任务类型设置自己的默认值
   cwd?: string;
   env?: Record<string, string | undefined>;
   yolo?: boolean;     // 允许所有工具，默认 true（后台任务常用）
@@ -70,6 +70,8 @@ type CliSessionMessage = {
   content: string;
 };
 
+const DEFAULT_AGY_TIMEOUT_MS = 600_000;
+
 export interface CliSessionHandle {
   sessionId: string;
   provider: CliProvider;
@@ -758,12 +760,49 @@ function formatCliTimeout(timeoutMs: number) {
   return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
 }
 
+function tailText(value: string, maxChars = 1200): string {
+  if (value.length <= maxChars) return value;
+  return value.slice(value.length - maxChars);
+}
+
+function terminateCliProcessGroup(
+  proc: ReturnType<typeof spawn>,
+  signal: NodeJS.Signals
+) {
+  const pid = typeof proc.pid === "number" ? proc.pid : 0;
+  if (pid > 0 && process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+      // Fall back to the child process if the group is unavailable.
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+    // Best effort cleanup only.
+  }
+}
+
+function buildAgyTimeoutError(timeout: number, stdout: string, stderr: string) {
+  const parts = [
+    `Antigravity CLI timed out after ${timeout}ms.`,
+    "agy print mode is agentic and can keep waiting for the conversation to become fully idle; prefer shorter scoped prompts or split the task into multiple turns.",
+  ];
+  const stdoutTail = tailText(stdout).trim();
+  const stderrTail = tailText(stderr).trim();
+  if (stdoutTail) parts.push(`stdout tail:\n${stdoutTail}`);
+  if (stderrTail) parts.push(`stderr tail:\n${stderrTail}`);
+  return new Error(parts.join("\n"));
+}
+
 function executeAgy(
   prompt: string,
   options: CliExecuteOptions
 ): Promise<CliExecuteResult> {
   const {
-    timeout = 120_000,
+    timeout = DEFAULT_AGY_TIMEOUT_MS,
     cwd = process.cwd(),
     yolo = true,
   } = options;
@@ -786,15 +825,28 @@ function executeAgy(
       cwd,
       env: buildCliProcessEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
     });
     let stdout = "";
     let stderr = "";
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let forceTimer: ReturnType<typeof setTimeout> | undefined;
+    let settled = false;
+
+    const clearTimers = () => {
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+    };
 
     if (timeout > 0) {
       timer = setTimeout(() => {
-        proc.kill("SIGTERM");
-        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
+        if (settled) return;
+        settled = true;
+        terminateCliProcessGroup(proc, "SIGTERM");
+        forceTimer = setTimeout(() => {
+          terminateCliProcessGroup(proc, "SIGKILL");
+        }, 3_000);
+        reject(buildAgyTimeoutError(timeout, stdout, stderr));
       }, timeout + 1_000);
     }
 
@@ -807,7 +859,12 @@ function executeAgy(
     });
 
     proc.on("close", (code) => {
-      if (timer) clearTimeout(timer);
+      if (settled) {
+        clearTimers();
+        return;
+      }
+      settled = true;
+      clearTimers();
       if (code !== 0 && code !== null) {
         reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
         return;
@@ -821,7 +878,9 @@ function executeAgy(
     });
 
     proc.on("error", (err) => {
-      if (timer) clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      clearTimers();
       reject(err);
     });
   });

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");
+};