u-foo 2.5.13 → 2.5.15

package/src/code/nativeRunner.js

@@ -6,12 +6,26 @@ const {
 } = require("../agents/providers/credentials/kimi");
 const { runToolCall } = require("./dispatch");
 const { appendUsageRecord } = require("./usageStore");
+const { isContextV2Enabled } = require("./context/featureFlag");
+const {
+  persistToolResultToContext,
+  sanitizeModelMessages,
+} = require("./context/assembler");
+const { systemBlocksToAnthropicPayload } = require("./context/promptLayers");
+const { parseStructuredSideEffects } = require("./context/stateCommit");
+const {
+  parseExecutionSegment,
+  executeExecutionSegment,
+  formatSegmentResultMessage,
+  emptyExecutionState,
+} = require("./context/executionSegment");
+const { stableStringify } = require("./context/stableJson");
 const { getReadToolDescription } = require("../agents/prompts/native/toolDescriptions/read");
 const { getWriteToolDescription } = require("../agents/prompts/native/toolDescriptions/write");
 const { getEditToolDescription } = require("../agents/prompts/native/toolDescriptions/edit");
 const { getBashToolDescription } = require("../agents/prompts/native/toolDescriptions/bash");
 
-const CORE_TOOL_NAMES = new Set(["read", "write", "edit", "bash"]);
+const CORE_TOOL_NAMES = new Set(["read", "write", "edit", "bash", "artifact_read"]);
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
 const DEFAULT_KIMI_BASE_URL = "https://api.kimi.com/coding/v1";
@@ -20,12 +34,18 @@ const DEFAULT_KIMI_MODEL = "k3";
 // to 200 (fork). We count individual tool calls (not turns), so 100 leaves headroom
 // for non-trivial tasks while still catching runaway loops. Override via env.
 const DEFAULT_MAX_NATIVE_TOOL_CALLS = 100;
-const DEFAULT_MAX_NATIVE_TOOL_ERRORS = 5;
+const DEFAULT_MAX_NATIVE_TOOL_ERRORS = 20;
+const DEFAULT_NATIVE_TIMEOUT_MS = 43200000; // 12 hours
 // Anthropic Messages rejects max_tokens above the model's real cap (64K on
 // current models), so the transports use different defaults. Override either
 // via UFOO_UCODE_MAX_TOKENS (positive integer).
 const DEFAULT_OPENAI_MAX_TOKENS = 131072;
 const DEFAULT_ANTHROPIC_MAX_TOKENS = 64000;
+// Extended thinking is on by default for the anthropic transport; the budget
+// stays well below the 64K max_tokens cap as the Messages API requires.
+// UFOO_UCODE_THINKING_BUDGET_TOKENS overrides; 0 or a non-numeric value
+// disables thinking (the payload then omits the field entirely).
+const DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS = 10000;
 // Prompt caching is GA on the current Messages API: cache_control blocks need
 // no anthropic-beta header. Kept as a constant so the marker shape stays in
 // one place (system block + last history message, 2 of the 4 allowed
@@ -38,7 +58,7 @@ function nowMs() {
 
 function normalizeTimeoutMs(value) {
   const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return 300000;
+  if (!Number.isFinite(parsed)) return DEFAULT_NATIVE_TIMEOUT_MS;
   return Math.max(1000, Math.floor(parsed));
 }
 
@@ -59,6 +79,16 @@ function resolveMaxTokens(fallback) {
   return normalizePositiveInt(process.env.UFOO_UCODE_MAX_TOKENS, fallback);
 }
 
+function resolveThinkingBudgetTokens() {
+  const raw = process.env.UFOO_UCODE_THINKING_BUDGET_TOKENS;
+  if (raw === undefined || raw === null || String(raw).trim() === "") {
+    return DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS;
+  }
+  const parsed = Number.parseInt(String(raw), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return 0;
+  return Math.floor(parsed);
+}
+
 function toUsageInt(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) return 0;
@@ -128,7 +158,7 @@ function enforceNativeToolBudget({
   }
 }
 
-function createGuards({ signal = null, timeoutMs = 300000 } = {}) {
+function createGuards({ signal = null, timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS } = {}) {
   const startedAt = nowMs();
   const budgetMs = normalizeTimeoutMs(timeoutMs);
 
@@ -349,6 +379,25 @@ function buildCoreToolSpecs() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "artifact_read",
+        description: "Load a stored artifact by artifactId. Use selectors startLine/endLine, maxChars, or tailLines to read a slice.",
+        parameters: {
+          type: "object",
+          properties: {
+            artifactId: { type: "string" },
+            sessionId: { type: "string" },
+            startLine: { type: "integer" },
+            endLine: { type: "integer" },
+            maxChars: { type: "integer" },
+            tailLines: { type: "integer" },
+          },
+          required: ["artifactId"],
+        },
+      },
+    },
   ];
 }
 
@@ -360,7 +409,7 @@ function buildAnthropicToolSpecs() {
   }));
 }
 
-function createRequestController({ signal = null, timeoutMs = 300000 } = {}) {
+function createRequestController({ signal = null, timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS } = {}) {
   const controller = new AbortController();
   let timedOut = false;
 
@@ -422,11 +471,7 @@ function normalizeToolName(value = "") {
 }
 
 function toJsonString(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value || "");
-  }
+  return stableStringify(value);
 }
 
 function parseSseBlocks(text = "") {
@@ -475,7 +520,15 @@ function normalizeToolCallArgs(raw = "") {
   return {};
 }
 
-function runCoreTool({ tool = "", args = {}, workspaceRoot = process.cwd(), onToolEvent = null } = {}) {
+function runCoreTool({
+  tool = "",
+  args = {},
+  workspaceRoot = process.cwd(),
+  onToolEvent = null,
+  sessionId = "",
+  contextV2 = false,
+  onArtifactPersisted = null,
+} = {}) {
   const normalizedTool = normalizeToolName(tool);
   if (!normalizedTool) {
     emitToolEvent(onToolEvent, {
@@ -491,6 +544,9 @@ function runCoreTool({ tool = "", args = {}, workspaceRoot = process.cwd(), onTo
   }
 
   const safeArgs = args && typeof args === "object" ? { ...args } : {};
+  if (normalizedTool === "artifact_read" && sessionId && !safeArgs.sessionId) {
+    safeArgs.sessionId = sessionId;
+  }
   emitToolEvent(onToolEvent, {
     tool: normalizedTool,
     phase: "start",
@@ -498,9 +554,13 @@ function runCoreTool({ tool = "", args = {}, workspaceRoot = process.cwd(), onTo
     error: "",
   });
 
+  const toolOptions = { workspaceRoot, cwd: workspaceRoot };
+  if (normalizedTool === "artifact_read" && sessionId) {
+    toolOptions.sessionId = sessionId;
+  }
   const result = runToolCall(
     { tool: normalizedTool, args: safeArgs },
-    { workspaceRoot, cwd: workspaceRoot }
+    toolOptions,
   );
 
   if (!result || result.ok === false) {
@@ -510,6 +570,26 @@ function runCoreTool({ tool = "", args = {}, workspaceRoot = process.cwd(), onTo
       args: safeArgs,
       error: String((result && result.error) || `${normalizedTool} failed`),
     });
+    return result;
+  }
+
+  const useContextV2 = contextV2 || isContextV2Enabled();
+  if (useContextV2 && normalizedTool !== "artifact_read") {
+    const persisted = persistToolResultToContext({
+      workspaceRoot,
+      sessionId,
+      tool: normalizedTool,
+      args: safeArgs,
+      rawResult: result,
+    });
+    if (typeof onArtifactPersisted === "function") {
+      try {
+        onArtifactPersisted(persisted);
+      } catch {
+        // ignore
+      }
+    }
+    return persisted.modelPayload || result;
   }
 
   return result;
@@ -533,7 +613,7 @@ async function runSseRequest({
   headers = {},
   payload = {},
   signal = null,
-  timeoutMs = 300000,
+  timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS,
   onPhase = null,
   onNonStream,
   onEvent,
@@ -625,7 +705,7 @@ async function runOpenAiLikeTurn({
   onThinkingDelta = null,
   onPhase = null,
   signal = null,
-  timeoutMs = 300000,
+  timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS,
 } = {}) {
   const payload = {
     model,
@@ -794,6 +874,13 @@ function normalizeAnthropicMessageContent(raw = []) {
           text: String(item.text || ""),
         };
       }
+      if (item.type === "thinking") {
+        return {
+          type: "thinking",
+          thinking: String(item.thinking || ""),
+          signature: String(item.signature || ""),
+        };
+      }
       if (item.type === "tool_use") {
         return {
           type: "tool_use",
@@ -868,12 +955,13 @@ async function runAnthropicTurn({
   apiKey = "",
   model = "",
   systemPrompt = "",
+  systemBlocks = null,
   messages = [],
   onTextDelta = null,
   onThinkingDelta = null,
   onPhase = null,
   signal = null,
-  timeoutMs = 300000,
+  timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS,
 } = {}) {
   const payload = {
     model,
@@ -882,17 +970,23 @@ async function runAnthropicTurn({
     tools: buildAnthropicToolSpecs(),
     stream: true,
   };
-  const systemText = String(systemPrompt || "").trim();
-  if (systemText) {
-    // Block form with a cache breakpoint; the system prompt is the most
-    // stable prefix of every request.
-    payload.system = [
-      {
-        type: "text",
-        text: systemText,
-        cache_control: { ...ANTHROPIC_CACHE_CONTROL },
-      },
-    ];
+  const thinkingBudget = resolveThinkingBudgetTokens();
+  if (thinkingBudget > 0) {
+    payload.thinking = { type: "enabled", budget_tokens: thinkingBudget };
+  }
+  if (Array.isArray(systemBlocks) && systemBlocks.length > 0) {
+    payload.system = systemBlocksToAnthropicPayload(systemBlocks);
+  } else {
+    const systemText = String(systemPrompt || "").trim();
+    if (systemText) {
+      payload.system = [
+        {
+          type: "text",
+          text: systemText,
+          cache_control: { ...ANTHROPIC_CACHE_CONTROL },
+        },
+      ];
+    }
   }
 
   const headers = {
@@ -994,6 +1088,7 @@ async function runAnthropicTurn({
             order: index,
             type: "thinking",
             text: String(contentBlock.thinking || ""),
+            signature: String(contentBlock.signature || ""),
           });
         } else if (contentBlock.type === "tool_use") {
           blockMap.set(index, {
@@ -1058,6 +1153,16 @@ async function runAnthropicTurn({
           return;
         }
 
+        if (delta.type === "signature_delta") {
+          // Signed thinking blocks must be replayed verbatim on later turns
+          // (tool-use continuation contract), so accumulate the signature
+          // alongside the thinking text.
+          current.type = "thinking";
+          current.signature = `${String(current.signature || "")}${String(delta.signature || "")}`;
+          blockMap.set(index, current);
+          return;
+        }
+
         if (delta.type === "input_json_delta") {
           current.type = "tool_use";
           current.inputJson = `${String(current.inputJson || "")}${String(delta.partial_json || "")}`;
@@ -1069,8 +1174,17 @@ async function runAnthropicTurn({
     buildResult: () => {
       const assistantContent = Array.from(blockMap.values())
         .sort((a, b) => a.order - b.order)
-        .filter((item) => item.type !== "thinking")
         .map((item) => {
+          if (item.type === "thinking") {
+            // Kept (with signature) so tool-use continuation turns can
+            // replay the thinking blocks the API requires.
+            return {
+              type: "thinking",
+              thinking: String(item.text || ""),
+              signature: String(item.signature || ""),
+            };
+          }
+
           if (item.type === "text") {
             return {
               type: "text",
@@ -1248,16 +1362,20 @@ async function runNativeLoop({
   workspaceRoot = process.cwd(),
   prompt = "",
   systemPrompt = "",
+  systemBlocks = null,
   historyMessages = [],
   model = "",
   baseUrl = "",
   apiKey = "",
   provider = "",
-  timeoutMs = 300000,
+  timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS,
   onStreamDelta = null,
   onThinkingDelta = null,
   onPhase = null,
   onToolEvent = null,
+  onArtifactPersisted = null,
+  sessionId = "",
+  contextV2 = false,
   signal = null,
   guards,
 } = {}) {
@@ -1271,13 +1389,14 @@ async function runNativeLoop({
     throw new Error("ucode baseUrl is not configured");
   }
 
-  const messages = cloneMessageList(historyMessages);
+  const messages = sanitizeModelMessages(cloneMessageList(historyMessages));
   transport.prepareMessages({ messages, systemPrompt, prompt });
 
   let aggregated = "";
   let streamed = false;
   let toolCallsExecuted = 0;
   let toolErrors = 0;
+  let executionState = emptyExecutionState();
   const toolBudget = resolveNativeToolBudget();
   const usage = createUsageTotals();
 
@@ -1290,6 +1409,7 @@ async function runNativeLoop({
       model: requestModel,
       provider,
       systemPrompt,
+      systemBlocks,
       messages,
       signal,
       timeoutMs,
@@ -1312,8 +1432,34 @@ async function runNativeLoop({
     const toolCalls = transport.getToolCalls(turnResult);
 
     if (toolCalls.length === 0) {
-      transport.appendFinalAssistantMessage({ messages, turnResult });
       const text = String(turnResult.text || "").trim();
+      if (contextV2) {
+        const sideEffects = parseStructuredSideEffects(text);
+        const segment = parseExecutionSegment(sideEffects);
+        if (segment && segment.steps && segment.steps.length > 0) {
+          transport.appendFinalAssistantMessage({ messages, turnResult });
+          const exec = executeExecutionSegment({
+            segment,
+            executionState,
+            runStep: ({ tool, args }) => runCoreTool({
+              tool,
+              args,
+              workspaceRoot,
+              onToolEvent,
+              sessionId,
+              contextV2,
+              onArtifactPersisted,
+            }),
+          });
+          executionState = exec.executionState;
+          messages.push({
+            role: "user",
+            content: formatSegmentResultMessage(exec),
+          });
+          continue;
+        }
+      }
+      transport.appendFinalAssistantMessage({ messages, turnResult });
       if (!aggregated.trim() && text) {
         aggregated = text;
       }
@@ -1344,6 +1490,9 @@ async function runNativeLoop({
         args: pending.args,
         workspaceRoot,
         onToolEvent,
+        sessionId,
+        contextV2,
+        onArtifactPersisted,
       });
       toolCallsExecuted += 1;
       if (!toolResult || toolResult.ok === false) {
@@ -1375,15 +1524,18 @@ async function runNativeAgentTask({
   workspaceRoot = process.cwd(),
   prompt = "",
   systemPrompt = "",
+  systemBlocks = null,
   provider = "",
   model = "",
   messages = [],
   sessionId = "",
-  timeoutMs = 300000,
+  timeoutMs = DEFAULT_NATIVE_TIMEOUT_MS,
   onStreamDelta = null,
   onThinkingDelta = null,
   onPhase = null,
   onToolEvent = null,
+  onArtifactPersisted = null,
+  contextV2 = false,
   signal = null,
 } = {}) {
   const guards = createGuards({ signal, timeoutMs });
@@ -1444,6 +1596,7 @@ async function runNativeAgentTask({
       workspaceRoot,
       prompt: promptText,
       systemPrompt,
+      systemBlocks,
       historyMessages: messages,
       model: runtime.model,
       baseUrl: runtime.baseUrl,
@@ -1454,6 +1607,9 @@ async function runNativeAgentTask({
       onThinkingDelta,
       onPhase,
       onToolEvent,
+      onArtifactPersisted,
+      sessionId: nextSessionId,
+      contextV2: contextV2 || isContextV2Enabled(),
       signal,
       guards,
     });

package/src/code/repl.js

@@ -21,7 +21,9 @@ const {
   getPendingBusCount,
   shouldAutoConsumeBus,
 } = require("./busConsumer");
-const { summarizeSessionUsage } = require("./usageStore");
+const { summarizeSessionUsage, formatSessionUsageStatus } = require("./usageStore");
+const { listUcodeCommandsForHelp } = require("./commands");
+const { applyUcodeModelCommand, suggestUcodeModels } = require("./modelCommand");
 
 function printPrompt(stdout = process.stdout) {
   stdout.write("> ");
@@ -75,40 +77,14 @@ function extractAgentNickname(agentId = "") {
   return base;
 }
 
-function formatSessionUsageStatus(summary = {}) {
-  const source = summary && typeof summary === "object" ? summary : {};
-  const input = Number(source.input) || 0;
-  const output = Number(source.output) || 0;
-  const cacheRead = Number(source.cacheRead) || 0;
-  const cacheCreation = Number(source.cacheCreation) || 0;
-  const denominator = cacheRead + input;
-  const hitRate = denominator > 0 ? (cacheRead / denominator) * 100 : 0;
-  return [
-    `Session tokens: input=${input} output=${output} cache_read=${cacheRead} cache_creation=${cacheCreation}`,
-    `Cache hit rate: ${hitRate.toFixed(1)}% (cache_read/(cache_read+input))`,
-  ].join("\n");
-}
-
 function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
   const text = normalizeLine(line);
   if (!text) return { kind: "empty" };
-  if (text === "exit" || text === "quit") return { kind: "exit" };
-  if (text === "help") {
+  if (text === "exit" || text === "quit" || text === "/exit" || text === "/quit") return { kind: "exit" };
+  if (text === "help" || text === "/help") {
     return {
       kind: "help",
-      output: [
-        "Commands:",
-        "  help",
-        "  exit|quit",
-        "  ubus|/ubus",
-        "  status|/status",
-        "  skills [list]",
-        "  skills show <name>",
-        "  bg|/bg <task>",
-        "  resume <session-id>",
-        "  tool <read|write|edit|bash> <args-json>",
-        "  run <read|write|edit|bash> <args-json>",
-      ].join("\n"),
+      output: listUcodeCommandsForHelp(),
     };
   }
   const legacyUfooMarker = parseLegacyUfooMarkerCommand(text);
@@ -128,6 +104,25 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
       kind: "status",
     };
   }
+  const modelMatch = text.match(/^(?:\/model|model)(?:\s+(.*))?$/i);
+  if (modelMatch) {
+    const nextModel = String(modelMatch[1] || "").trim();
+    if (!nextModel) {
+      return { kind: "model", action: "show" };
+    }
+    // Reject accidental multi-token garbage; model ids are single tokens.
+    if (/\s/.test(nextModel)) {
+      return {
+        kind: "error",
+        output: "usage: /model [model-id]",
+      };
+    }
+    return {
+      kind: "model",
+      action: "set",
+      model: nextModel,
+    };
+  }
   const skillsMatch = text.match(/^(?:\/skills|skills)(?:\s+(.*))?$/i);
   if (skillsMatch) {
     const args = String(skillsMatch[1] || "").trim().split(/\s+/).filter(Boolean);
@@ -187,13 +182,13 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
       task,
     };
   }
-  const resumeMatch = text.match(/^resume(?:\s+(.+))?$/i);
+  const resumeMatch = text.match(/^(?:\/resume|resume)(?:\s+(.+))?$/i);
   if (resumeMatch) {
     const session = String(resumeMatch[1] || "").trim();
     if (!session) {
       return {
         kind: "error",
-        output: "usage: resume <session-id>",
+        output: "usage: /resume <session-id>",
       };
     }
     return {
@@ -439,6 +434,13 @@ async function runUcodeCoreAgent({
         });
         stdout.write(`${formatSessionUsageStatus(usageSummary)}\n`);
       }
+      if (result.kind === "model") {
+        const applied = applyUcodeModelCommand(state, result);
+        stdout.write(`${applied.output}\n`);
+        if (applied.ok && result.action === "set") {
+          persistSessionState(state);
+        }
+      }
       if (result.kind === "ubus") {
         const ubusResult = await runUbusCommand(state, {
           workspaceRoot: runtimeWorkspace,
@@ -637,4 +639,6 @@ module.exports = {
   extractAgentNickname,
   parseAgentArgs,
   formatSessionUsageStatus,
+  applyUcodeModelCommand,
+  suggestUcodeModels,
 };