u-foo 2.2.4 → 2.3.0

package/src/agent/loopObservability.js

@@ -135,6 +135,10 @@ function readRecentLoopSummary(projectRoot, options = {}) {
     output_tokens: 0,
     cache_read_tokens: 0,
     cache_creation_tokens: 0,
+    cache_semistatic_hit: 0,
+    cache_semistatic_miss: 0,
+    memory_prefix_tokens: 0,
+    dynamic_memory_tokens: 0,
     total_tokens: 0,
     total_latency_ms: 0,
     first_token_ms: 0,
@@ -154,18 +158,24 @@ function readRecentLoopSummary(projectRoot, options = {}) {
       summary.output_tokens += Number(row.output_tokens) || 0;
       summary.cache_read_tokens += Number(row.cache_read_tokens) || 0;
       summary.cache_creation_tokens += Number(row.cache_creation_tokens) || 0;
+      summary.cache_semistatic_hit += Number(row.cache_semistatic_hit) || 0;
+      summary.cache_semistatic_miss += Number(row.cache_semistatic_miss) || 0;
+      summary.memory_prefix_tokens += Number(row.memory_prefix_tokens) || 0;
+      summary.dynamic_memory_tokens += Number(row.dynamic_memory_tokens) || 0;
       summary.total_latency_ms += Number(row.latency_ms) || 0;
       summary.first_token_ms += Number(row.first_token_ms) || 0;
     } else if (row.event === "tool_call") {
       summary.tool_calls += 1;
       const name = String(row.tool_name || "").trim() || "unknown";
       toolCounts.set(name, (toolCounts.get(name) || 0) + 1);
+      summary.dynamic_memory_tokens += Number(row.dynamic_memory_tokens) || 0;
     } else if (row.event === "loop_terminal") {
       summary.terminal_reason = String(row.terminal_reason || "").trim();
       if ((Number(row.rounds) || 0) > 0) summary.rounds = Number(row.rounds) || summary.rounds;
       if ((Number(row.tool_calls) || 0) >= 0) summary.tool_calls = Number(row.tool_calls) || summary.tool_calls;
       if ((Number(row.total_tokens) || 0) > 0) summary.total_tokens = Number(row.total_tokens) || 0;
       if ((Number(row.total_latency_ms) || 0) > 0) summary.total_latency_ms = Number(row.total_latency_ms) || 0;
+      if ((Number(row.dynamic_memory_tokens) || 0) > 0) summary.dynamic_memory_tokens = Number(row.dynamic_memory_tokens) || summary.dynamic_memory_tokens;
     }
   }
 

package/src/agent/loopRuntime.js

@@ -58,6 +58,10 @@ function extractModelMetrics(result) {
     output_tokens: toNonNegativeInt(source.output_tokens),
     cache_read_tokens: toNonNegativeInt(source.cache_read_tokens),
     cache_creation_tokens: toNonNegativeInt(source.cache_creation_tokens),
+    cache_semistatic_hit: toNonNegativeInt(source.cache_semistatic_hit),
+    cache_semistatic_miss: toNonNegativeInt(source.cache_semistatic_miss),
+    memory_prefix_tokens: toNonNegativeInt(source.memory_prefix_tokens),
+    dynamic_memory_tokens: toNonNegativeInt(source.dynamic_memory_tokens),
     latency_ms: toNonNegativeInt(source.latency_ms),
     first_token_ms: toNonNegativeInt(source.first_token_ms),
     stop_reason: String(source.stop_reason || "").trim(),
@@ -168,6 +172,7 @@ function buildTerminalPayload(reason, lastPayload, rounds, toolCalls, toolErrors
     fallback_used: normalizeFallbackUsed(totals.fallback_used),
     total_tokens: toNonNegativeInt(totals.total_tokens),
     total_latency_ms: toNonNegativeInt(totals.total_latency_ms),
+    dynamic_memory_tokens: toNonNegativeInt(totals.dynamic_memory_tokens),
   };
   return payload;
 }
@@ -205,6 +210,7 @@ async function runPromptWithControllerLoop({
   let toolErrors = 0;
   let totalTokens = 0;
   let totalLatencyMs = 0;
+  let dynamicMemoryTokens = 0;
   const toolResults = [];
 
   const checkCancellation = () => {
@@ -220,6 +226,7 @@ async function runPromptWithControllerLoop({
     fallback_used: FALLBACK_USED_VALUES.NONE,
     total_tokens: totalTokens,
     total_latency_ms: totalLatencyMs,
+    dynamic_memory_tokens: dynamicMemoryTokens,
   });
 
   const terminate = (reason, payloadBase, roundsCount) => {
@@ -304,6 +311,10 @@ async function runPromptWithControllerLoop({
       output_tokens: metrics.output_tokens,
       cache_read_tokens: metrics.cache_read_tokens,
       cache_creation_tokens: metrics.cache_creation_tokens,
+      cache_semistatic_hit: metrics.cache_semistatic_hit,
+      cache_semistatic_miss: metrics.cache_semistatic_miss,
+      memory_prefix_tokens: metrics.memory_prefix_tokens,
+      dynamic_memory_tokens: metrics.dynamic_memory_tokens,
       latency_ms: modelLatency,
       first_token_ms: metrics.first_token_ms,
       tool_call_count: toolCall ? 1 : 0,
@@ -339,6 +350,7 @@ async function runPromptWithControllerLoop({
           fallback_used: FALLBACK_USED_VALUES.NONE,
           total_tokens: totalTokens,
           total_latency_ms: totalLatencyMs,
+          dynamic_memory_tokens: dynamicMemoryTokens,
         },
       };
       observer.emit("loop_terminal", finalPayload.loop);
@@ -382,13 +394,19 @@ async function runPromptWithControllerLoop({
     const toolDuration = Math.max(0, now() - toolStartedAt);
 
     let toolResultSize = 0;
+    let toolDynamicMemoryTokens = 0;
     try {
       toolResultSize = toolResult && toolResult.result !== undefined
         ? JSON.stringify(toolResult.result).length
         : 0;
+      toolDynamicMemoryTokens = toolResult && toolResult.result && Number.isFinite(Number(toolResult.result.dynamic_memory_tokens))
+        ? Math.max(0, Math.floor(Number(toolResult.result.dynamic_memory_tokens)))
+        : 0;
     } catch {
       toolResultSize = 0;
+      toolDynamicMemoryTokens = 0;
     }
+    dynamicMemoryTokens += toolDynamicMemoryTokens;
 
     observer.emit("tool_call", {
       round,
@@ -397,6 +415,7 @@ async function runPromptWithControllerLoop({
       turn_id: toolResult && toolResult.turn_id ? String(toolResult.turn_id) : `loop-round-${round}`,
       duration_ms: toolDuration,
       result_size: toolResultSize,
+      dynamic_memory_tokens: toolDynamicMemoryTokens,
       retry_count: 0,
       final_status: toolResult && toolResult.ok === true ? "ok" : "error",
     });

package/src/agent/ufooAgent.js

@@ -5,8 +5,9 @@ const { normalizeCliOutput } = require("./normalizeOutput");
 const { buildStatus } = require("../daemon/status");
 const { getUfooPaths } = require("../ufoo/paths");
 const { normalizeGateRouterResult } = require("../controller/gateRouter");
-const { sendUpstreamPrompt } = require("./upstreamTransport");
+const { normalizeProvider, sendUpstreamPrompt } = require("./upstreamTransport");
 const { normalizeAgentTypeAlias } = require("../bus/utils");
+const { buildCachedMemoryPrefix } = require("../memory");
 const { listProjectRuntimes, isGlobalControllerProjectRoot } = require("../projects");
 const {
   CONTROLLER_MODES,
@@ -522,6 +523,14 @@ function buildSystemPrompt(context, options = {}) {
   ].join("\n");
 }
 
+function buildMemoryPrefixResult(projectRoot, limit = 50) {
+  try {
+    return buildCachedMemoryPrefix(projectRoot, { limit });
+  } catch {
+    return { prefix: "", estimated_tokens: 0, cache_hit: false, cache_semistatic_hit: 0, cache_semistatic_miss: 0 };
+  }
+}
+
 function loadHistory(projectRoot, maxTurns = 6) {
   const file = path.join(getUfooPaths(projectRoot).agentDir, "ufoo-agent.history.jsonl");
   try {
@@ -594,9 +603,9 @@ function extractNickname(prompt) {
   return "";
 }
 
-function isUcodeProvider(value = "") {
-  const text = String(value || "").trim().toLowerCase();
-  return text === "ucode" || text === "ufoo" || text === "ufoo-code";
+function shouldUseDirectProvider(value = "") {
+  const provider = normalizeProvider(value);
+  return provider === "ucode" || provider === "codex" || provider === "claude";
 }
 
 function stripMarkdownFence(text = "") {
@@ -644,32 +653,42 @@ async function runUfooAgent({
   const bus = routingContext || (mode === "global-router"
     ? buildGlobalProjectRouterContext(projectRoot)
     : loadBusSummary(projectRoot));
-  const systemPrompt = buildSystemPrompt(bus, {
+  let systemPrompt = buildSystemPrompt(bus, {
     routingMode: mode,
     loopRuntime,
     controllerMode: resolvedControllerMode,
   });
+  const memoryPrefixResult = buildMemoryPrefixResult(projectRoot);
+  const memoryPrefix = String(memoryPrefixResult.prefix || "").trim();
+  if (memoryPrefix) {
+    systemPrompt = `${systemPrompt}\n\n${memoryPrefix}`;
+  }
   const history = loadHistory(projectRoot);
   const historyPrompt = buildHistoryPrompt(history);
   const fullPrompt = historyPrompt ? `${historyPrompt}User: ${prompt}` : prompt;
 
   let res;
 
-  if (isUcodeProvider(provider)) {
-    // Native path: direct HTTP to LLM API, no CLI binary needed
+  const useDirectProvider = shouldUseDirectProvider(provider);
+  let usedDirectProvider = false;
+
+  if (useDirectProvider) {
     res = await runNativeRouterCall({
       projectRoot,
       prompt: fullPrompt,
       systemPrompt,
+      provider,
       model,
     });
     if (!res.ok) {
       return { ok: false, error: res.error };
+    } else {
+      usedDirectProvider = true;
+      res = { ok: true, output: res.output, sessionId: "", provider: res.provider, model: res.model };
     }
-    // Native path returns { ok, output } where output is raw text
-    res = { ok: true, output: res.output, sessionId: "" };
-  } else {
-    // CLI path: spawn codex/claude binary
+  }
+
+  if (!useDirectProvider) {
     res = await runCliAgent({
       provider,
       model,
@@ -700,7 +719,7 @@ async function runUfooAgent({
     }
   }
 
-  const rawText = isUcodeProvider(provider)
+  const rawText = usedDirectProvider
     ? String(res.output || "").trim()
     : normalizeCliOutput(res.output);
   const text = stripMarkdownFence(rawText);
@@ -733,7 +752,18 @@ async function runUfooAgent({
 
   appendHistory(projectRoot, { prompt, reply: payload.reply || "" });
 
-  return { ok: true, payload };
+  return {
+    ok: true,
+    payload,
+    meta: {
+      memory_prefix_tokens: memoryPrefixResult.estimated_tokens || 0,
+      cache_semistatic_hit: memoryPrefixResult.cache_semistatic_hit || 0,
+      cache_semistatic_miss: memoryPrefixResult.cache_semistatic_miss || 0,
+      memory_prefix_truncated: memoryPrefixResult.truncated === true,
+      memory_prefix_entries: memoryPrefixResult.entry_count || 0,
+      memory_prefix_emitted: memoryPrefixResult.emitted_count || 0,
+    },
+  };
 }
 
 async function runUfooRouteAgent({

package/src/agent/upstreamTransport.js

@@ -16,7 +16,7 @@ function normalizeProvider(value = "") {
   if (!text) return "ucode";
   if (text === "codex-cli" || text === "codex-code" || text === "codex" || text === "openai") return "codex";
   if (text === "claude-cli" || text === "claude-code" || text === "claude" || text === "anthropic") return "claude";
-  if (text === "ucode") return "ucode";
+  if (text === "ucode" || text === "ufoo" || text === "ufoo-code") return "ucode";
   return text;
 }
 
@@ -200,6 +200,7 @@ async function resolveUpstreamRuntime({
   provider = "",
   model = "",
   env = process.env,
+  fetchImpl = global.fetch,
   loadConfigImpl = loadConfig,
 } = {}) {
   const normalizedProvider = normalizeProvider(provider);
@@ -208,6 +209,8 @@ async function resolveUpstreamRuntime({
   if (normalizedProvider === "codex") {
     const credential = await resolveCodexUpstreamCredentials({
       authPath: config.codexAuthPath,
+      refreshWindowMs: Number(config.codexOauthRefreshWindowSec || 300) * 1000,
+      fetchImpl,
       env,
     });
     const useCodexResponses = credential.credentialKind === "oauth" && Boolean(credential.accessToken);
@@ -408,13 +411,25 @@ async function sendUpstreamPrompt({
   env = process.env,
   loadConfigImpl = loadConfig,
 } = {}) {
-  const runtime = await resolveUpstreamRuntime({
-    projectRoot,
-    provider,
-    model,
-    env,
-    loadConfigImpl,
-  });
+  let runtime;
+  try {
+    runtime = await resolveUpstreamRuntime({
+      projectRoot,
+      provider,
+      model,
+      env,
+      fetchImpl,
+      loadConfigImpl,
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "upstream runtime resolution failed",
+      errorCode: err && err.code ? err.code : "UPSTREAM_RUNTIME_RESOLUTION_FAILED",
+      provider: normalizeProvider(provider),
+      model: String(model || "").trim(),
+    };
+  }
 
   const requestModel = String(runtime.model || "").trim();
   const request = runtime.transport === "anthropic-messages"

package/src/bus/index.js

@@ -65,7 +65,12 @@ class EventBus {
     this.messageManager = new MessageManager(
       this.busDir,
       this.busData,
-      this.queueManager
+      this.queueManager,
+      {
+        projectRoot: this.projectRoot,
+        enableGroupPolicyHook: true,
+        warn: logWarn,
+      }
     );
 
     // 自动清理不活跃的 agents

package/src/bus/message.js

@@ -8,9 +8,11 @@ const {
   readLastLine,
   isPidAlive,
   normalizeAgentTypeAlias,
+  logWarn,
 } = require("./utils");
 const NicknameManager = require("./nickname");
 const { buildMessageData } = require("./messageMeta");
+const { getUfooPaths } = require("../ufoo/paths");
 
 const SEQ_LOCK_TIMEOUT_MS = 5000;
 const SEQ_LOCK_POLL_MS = 25;
@@ -20,13 +22,21 @@ const SEQ_LOCK_STALE_MS = 30000;
  * 消息管理器
  */
 class MessageManager {
-  constructor(busDir, busData, queueManager) {
+  constructor(busDir, busData, queueManager, options = {}) {
     this.busDir = busDir;
     this.busData = busData;
     this.queueManager = queueManager;
     this.eventsDir = path.join(busDir, "events");
     this.seqFile = path.join(busDir, "seq.counter");
     this.seqLockFile = path.join(busDir, "seq.counter.lock");
+    this.projectRoot = typeof options.projectRoot === "string" && options.projectRoot.trim()
+      ? options.projectRoot
+      : "";
+    this.warn = typeof options.warn === "function" ? options.warn : logWarn;
+    this.preSendHooks = Array.isArray(options.preSendHooks) ? options.preSendHooks.slice() : [];
+    if (options.enableGroupPolicyHook === true && this.projectRoot) {
+      this.preSendHooks.push((context) => this.checkGroupSoftPolicy(context));
+    }
   }
 
   /**
@@ -255,6 +265,131 @@ class MessageManager {
     return false;
   }
 
+  readActiveGroupStates() {
+    if (!this.projectRoot) return [];
+    const groupsDir = getUfooPaths(this.projectRoot).groupsDir;
+    if (!fs.existsSync(groupsDir)) return [];
+
+    const groups = [];
+    let files = [];
+    try {
+      files = fs.readdirSync(groupsDir, { withFileTypes: true })
+        .filter((item) => item.isFile() && item.name.endsWith(".json"))
+        .map((item) => path.join(groupsDir, item.name))
+        .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }));
+    } catch {
+      return [];
+    }
+
+    for (const filePath of files) {
+      try {
+        const runtime = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        const status = typeof runtime.status === "string" ? runtime.status : "";
+        if (status === "active" || status === "starting") {
+          groups.push(runtime);
+        }
+      } catch {
+        // Ignore malformed runtime files; policy warnings must never block send.
+      }
+    }
+    return groups;
+  }
+
+  findGroupMember(runtime = {}, subscriberId = "") {
+    const members = Array.isArray(runtime.members) ? runtime.members : [];
+    const target = typeof subscriberId === "string" ? subscriberId.trim() : "";
+    if (!target) return null;
+
+    return members.find((member) => {
+      if (!member || typeof member !== "object") return false;
+      return member.subscriber_id === target
+        || member.bootstrapped_subscriber_id === target
+        || member.nickname === target
+        || member.scoped_nickname === target
+        || member.runtime_nickname === target;
+    }) || null;
+  }
+
+  checkGroupSoftPolicy({ publisher, targets } = {}) {
+    const resolvedTargets = Array.isArray(targets) ? targets : [];
+    if (!publisher || resolvedTargets.length === 0) return [];
+
+    const groups = this.readActiveGroupStates();
+    if (groups.length === 0) return [];
+
+    const warnings = [];
+    const seen = new Set();
+
+    for (const runtime of groups) {
+      const publisherMember = this.findGroupMember(runtime, publisher);
+      if (!publisherMember) continue;
+
+      const publisherNickname = publisherMember.nickname
+        || publisherMember.scoped_nickname
+        || publisherMember.runtime_nickname
+        || publisher;
+      for (const targetSubscriber of resolvedTargets) {
+        const targetMember = this.findGroupMember(runtime, targetSubscriber);
+        if (!targetMember || targetMember === publisherMember) continue;
+
+        const acceptFrom = Array.isArray(targetMember.accept_from)
+          ? targetMember.accept_from.filter((item) => typeof item === "string" && item.trim())
+          : [];
+        const allowed = acceptFrom.includes(publisherNickname)
+          || acceptFrom.includes(publisherMember.scoped_nickname)
+          || acceptFrom.includes(publisherMember.runtime_nickname)
+          || acceptFrom.includes(publisher);
+
+        if (allowed) continue;
+
+        const groupId = runtime.group_id || "unknown-group";
+        const targetNickname = targetMember.nickname
+          || targetMember.scoped_nickname
+          || targetMember.runtime_nickname
+          || targetSubscriber;
+        const key = `${groupId}:${publisherNickname}:${targetNickname}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+
+        const allowedText = acceptFrom.length > 0 ? acceptFrom.join(", ") : "none";
+        warnings.push(
+          `group policy warning: ${publisherNickname} -> ${targetNickname} violates accept_from for group ${groupId}; allowed: ${allowedText}`
+        );
+      }
+    }
+
+    return warnings;
+  }
+
+  async runPreSendHooks(context) {
+    if (!Array.isArray(this.preSendHooks) || this.preSendHooks.length === 0) {
+      return [];
+    }
+
+    const warnings = [];
+    for (const hook of this.preSendHooks) {
+      if (typeof hook !== "function") continue;
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const result = await hook(context);
+        if (Array.isArray(result)) {
+          warnings.push(...result.filter(Boolean).map((item) => String(item)));
+        } else if (typeof result === "string" && result) {
+          warnings.push(result);
+        } else if (result && typeof result.message === "string") {
+          warnings.push(result.message);
+        }
+      } catch (err) {
+        warnings.push(`preSendHook failed: ${err && err.message ? err.message : err}`);
+      }
+    }
+
+    for (const warning of warnings) {
+      this.warn(warning);
+    }
+    return warnings;
+  }
+
   /**
    * 发送消息
    */
@@ -269,6 +404,16 @@ class MessageManager {
       throw new Error(`Target "${target}" not found`);
     }
 
+    const warnings = await this.runPreSendHooks({
+      publisher,
+      target,
+      targets,
+      message,
+      options,
+      busData: this.busData,
+      projectRoot: this.projectRoot,
+    });
+
     const data = buildMessageData(message, options);
 
     // 构建事件
@@ -295,7 +440,7 @@ class MessageManager {
       }
     }
 
-    return { seq, targets };
+    return { seq, targets, warnings };
   }
 
   /**
@@ -421,12 +566,15 @@ class MessageManager {
 
         return false;
       })
-      .map(([id, meta]) => ({
-        id,
-        nickname: meta.nickname || meta.scoped_nickname || "",
-        agent_type: meta.agent_type,
-        last_seen: meta.last_seen,
-      }));
+      .map(([id, meta]) => {
+        const nickname = meta.nickname || meta.scoped_nickname;
+        return {
+          id,
+          ...(nickname ? { nickname } : {}),
+          agent_type: meta.agent_type,
+          last_seen: meta.last_seen,
+        };
+      });
 
     // 如果只有一个候选者，直接返回
     if (candidates.length === 1) {