u-foo 3.0.0 → 3.0.2

package/src/code/providers/anthropicMessagesTransport.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const { assertTransport } = require("./transportContract");
+
+/**
+ * Anthropic Messages API transport adapter.
+ * @param {{
+ *   resolveUrl: Function,
+ *   runTurn: Function,
+ *   toJsonString: Function,
+ *   clipText: Function,
+ * }} deps
+ */
+function createAnthropicMessagesTransport(deps = {}) {
+  const {
+    resolveUrl,
+    runTurn,
+    toJsonString,
+    clipText,
+  } = deps;
+
+  const transport = {
+    name: "anthropic-messages",
+    resolveUrl,
+    prepareMessages({ messages, prompt }) {
+      messages.push({
+        role: "user",
+        content: String(prompt || ""),
+      });
+    },
+    runTurn,
+    getToolCalls(turnResult) {
+      return Array.isArray(turnResult.toolCalls) ? turnResult.toolCalls : [];
+    },
+    appendFinalAssistantMessage({ messages, turnResult }) {
+      const assistantContent = Array.isArray(turnResult.assistantContent)
+        ? turnResult.assistantContent
+        : [];
+      if (assistantContent.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: assistantContent,
+        });
+      } else if (String(turnResult.text || "").trim()) {
+        messages.push({
+          role: "assistant",
+          content: [
+            {
+              type: "text",
+              text: String(turnResult.text || ""),
+            },
+          ],
+        });
+      }
+    },
+    prepareToolCalls({ messages, turnResult, toolCalls }) {
+      const assistantContent = Array.isArray(turnResult.assistantContent)
+        ? turnResult.assistantContent
+        : [];
+
+      messages.push({
+        role: "assistant",
+        content: assistantContent,
+      });
+
+      return toolCalls.map((call) => ({
+        name: call.name,
+        args: call.args,
+        source: call,
+      }));
+    },
+    appendToolResult({ collected, call, toolResult }) {
+      collected.push({
+        type: "tool_result",
+        tool_use_id: String(call.source.id || ""),
+        content: clipText(toJsonString(toolResult), 12000),
+        is_error: Boolean(!toolResult || toolResult.ok === false),
+      });
+    },
+    flushToolResults({ messages, collected }) {
+      messages.push({
+        role: "user",
+        content: collected,
+      });
+    },
+  };
+
+  return assertTransport(transport, "anthropic-messages");
+}
+
+module.exports = {
+  createAnthropicMessagesTransport,
+};

package/src/code/providers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+module.exports = {
+  ...require("./transportContract"),
+  ...require("./openaiChatTransport"),
+  ...require("./anthropicMessagesTransport"),
+  ...require("./modelsCatalog"),
+};

package/src/code/providers/modelsCatalog.js

@@ -0,0 +1,304 @@
+"use strict";
+
+/**
+ * Live provider model catalog via the OpenAI-compatible / Anthropic models route.
+ *
+ * Used by /model suggestions and settings validation so ucode only offers
+ * (and preferably accepts) models the configured endpoint actually lists.
+ */
+
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const DEFAULT_TIMEOUT_MS = 8000;
+const CACHE_TTL_MS = 60_000;
+
+/** @type {Map<string, { at: number, result: object }>} */
+const modelsCache = new Map();
+
+function clipText(value = "", maxChars = 400) {
+  const text = String(value || "");
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}…`;
+}
+
+function resolveOpenAiModelsUrl(baseUrl = "") {
+  const raw = String(baseUrl || "").trim();
+  if (!raw) return "";
+  const normalized = raw.replace(/\/+$/, "");
+  if (/\/models$/i.test(normalized)) return normalized;
+  if (/\/chat\/completions$/i.test(normalized)) {
+    return normalized.replace(/\/chat\/completions$/i, "/models");
+  }
+  if (/\/v1$/i.test(normalized)) return `${normalized}/models`;
+  if (/\/api$/i.test(normalized)) return `${normalized}/v1/models`;
+  return `${normalized}/models`;
+}
+
+function resolveAnthropicModelsUrl(baseUrl = "") {
+  const raw = String(baseUrl || "").trim() || DEFAULT_ANTHROPIC_BASE_URL;
+  const normalized = raw.replace(/\/+$/, "");
+  if (/\/models$/i.test(normalized)) return normalized;
+  if (/\/messages$/i.test(normalized)) {
+    return normalized.replace(/\/messages$/i, "/models");
+  }
+  if (/\/v1$/i.test(normalized)) return `${normalized}/models`;
+  if (/\/api$/i.test(normalized)) return `${normalized}/v1/models`;
+  return `${normalized}/models`;
+}
+
+function resolveModelsUrl({ transport = "", baseUrl = "" } = {}) {
+  if (String(transport || "") === "anthropic-messages") {
+    return resolveAnthropicModelsUrl(baseUrl);
+  }
+  return resolveOpenAiModelsUrl(baseUrl);
+}
+
+function cacheKey({ transport = "", baseUrl = "", apiKey = "", provider = "" } = {}) {
+  const keyTail = apiKey ? String(apiKey).slice(-8) : "";
+  return `${provider}|${transport}|${baseUrl}|${keyTail}`;
+}
+
+function extractModelIds(payload) {
+  const ids = [];
+  const seen = new Set();
+  const push = (value) => {
+    const id = String(value || "").trim();
+    if (!id || seen.has(id)) return;
+    seen.add(id);
+    ids.push(id);
+  };
+
+  if (!payload || typeof payload !== "object") return ids;
+
+  if (Array.isArray(payload.data)) {
+    for (const item of payload.data) {
+      if (!item) continue;
+      if (typeof item === "string") push(item);
+      else push(item.id || item.model || item.name);
+    }
+  }
+
+  if (Array.isArray(payload.models)) {
+    for (const item of payload.models) {
+      if (!item) continue;
+      if (typeof item === "string") push(item);
+      else push(item.id || item.model || item.name);
+    }
+  }
+
+  return ids;
+}
+
+function buildListHeaders({ transport = "", apiKey = "" } = {}) {
+  const headers = {
+    Accept: "application/json",
+  };
+  const key = String(apiKey || "").trim();
+  if (!key) return headers;
+
+  if (String(transport || "") === "anthropic-messages") {
+    headers["x-api-key"] = key;
+    headers["anthropic-version"] = "2023-06-01";
+  } else {
+    headers.Authorization = `Bearer ${key}`;
+  }
+  return headers;
+}
+
+/**
+ * Fetch the provider's models catalog.
+ * @returns {Promise<{
+ *   ok: boolean,
+ *   models: string[],
+ *   url: string,
+ *   error: string,
+ *   status: number,
+ *   cached: boolean,
+ * }>}
+ */
+async function listProviderModels(options = {}) {
+  const transport = String(options.transport || "openai-chat").trim() || "openai-chat";
+  const baseUrl = String(options.baseUrl || "").trim();
+  const apiKey = String(options.apiKey || "").trim();
+  const provider = String(options.provider || "").trim();
+  const timeoutMs = Math.max(1000, Number(options.timeoutMs) || DEFAULT_TIMEOUT_MS);
+  const fetchImpl = typeof options.fetchImpl === "function" ? options.fetchImpl : fetch;
+  const skipCache = options.skipCache === true;
+  const url = resolveModelsUrl({ transport, baseUrl });
+
+  if (!url) {
+    return {
+      ok: false,
+      models: [],
+      url: "",
+      error: "models url unavailable (set ucode base url)",
+      status: 0,
+      cached: false,
+    };
+  }
+
+  const key = cacheKey({ transport, baseUrl, apiKey, provider });
+  if (!skipCache) {
+    const hit = modelsCache.get(key);
+    if (hit && (Date.now() - hit.at) < CACHE_TTL_MS) {
+      return { ...hit.result, cached: true };
+    }
+  }
+
+  const controller = typeof AbortController === "function" ? new AbortController() : null;
+  const timer = controller
+    ? setTimeout(() => {
+      try { controller.abort(); } catch { /* ignore */ }
+    }, timeoutMs)
+    : null;
+  if (timer && typeof timer.unref === "function") timer.unref();
+
+  try {
+    const response = await fetchImpl(url, {
+      method: "GET",
+      headers: buildListHeaders({ transport, apiKey }),
+      signal: controller ? controller.signal : undefined,
+    });
+    const status = Number(response && response.status) || 0;
+    const bodyText = await response.text().catch(() => "");
+    let payload = null;
+    try {
+      payload = bodyText ? JSON.parse(bodyText) : null;
+    } catch {
+      payload = null;
+    }
+
+    if (!response.ok) {
+      const result = {
+        ok: false,
+        models: [],
+        url,
+        error: `models route failed (${status}): ${clipText(bodyText || response.statusText || "unknown")}`,
+        status,
+        cached: false,
+      };
+      return result;
+    }
+
+    const models = extractModelIds(payload);
+    const result = {
+      ok: true,
+      models,
+      url,
+      error: models.length === 0 ? "models route returned an empty catalog" : "",
+      status,
+      cached: false,
+    };
+    // Cache successful responses even when empty — avoids hammering a broken gateway.
+    modelsCache.set(key, { at: Date.now(), result: { ...result, cached: false } });
+    return result;
+  } catch (err) {
+    const message = err && err.name === "AbortError"
+      ? `models route timed out after ${timeoutMs}ms`
+      : (err && err.message ? err.message : String(err || "models route failed"));
+    return {
+      ok: false,
+      models: [],
+      url,
+      error: message,
+      status: 0,
+      cached: false,
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+function modelSupported(model = "", models = []) {
+  const needle = String(model || "").trim();
+  if (!needle) return false;
+  const list = Array.isArray(models) ? models : [];
+  return list.some((id) => String(id || "").trim() === needle);
+}
+
+/**
+ * Validate a model id against the live catalog.
+ * Soft mode: when the catalog cannot be fetched, allow with a warning.
+ */
+async function confirmModelSupported(options = {}) {
+  const model = String(options.model || "").trim();
+  if (!model) {
+    return {
+      ok: false,
+      allowed: false,
+      model: "",
+      models: [],
+      error: "model id is empty",
+      warning: "",
+      catalog: null,
+    };
+  }
+
+  const catalog = await listProviderModels(options);
+  if (!catalog.ok) {
+    return {
+      ok: false,
+      allowed: options.strict === true ? false : true,
+      model,
+      models: [],
+      error: catalog.error || "models route unavailable",
+      warning: options.strict === true
+        ? ""
+        : `could not confirm model via models route (${catalog.error || "unavailable"}); accepting ${model}`,
+      catalog,
+    };
+  }
+
+  if (catalog.models.length === 0) {
+    return {
+      ok: false,
+      allowed: options.strict === true ? false : true,
+      model,
+      models: [],
+      error: catalog.error || "empty models catalog",
+      warning: options.strict === true
+        ? ""
+        : `models route returned no models; accepting ${model}`,
+      catalog,
+    };
+  }
+
+  if (!modelSupported(model, catalog.models)) {
+    const sample = catalog.models.slice(0, 8).join(", ");
+    const more = catalog.models.length > 8 ? ` (+${catalog.models.length - 8} more)` : "";
+    return {
+      ok: false,
+      allowed: false,
+      model,
+      models: catalog.models,
+      error: `model "${model}" is not in the provider catalog${sample ? ` (available: ${sample}${more})` : ""}`,
+      warning: "",
+      catalog,
+    };
+  }
+
+  return {
+    ok: true,
+    allowed: true,
+    model,
+    models: catalog.models,
+    error: "",
+    warning: "",
+    catalog,
+  };
+}
+
+function clearModelsCache() {
+  modelsCache.clear();
+}
+
+module.exports = {
+  resolveOpenAiModelsUrl,
+  resolveAnthropicModelsUrl,
+  resolveModelsUrl,
+  listProviderModels,
+  confirmModelSupported,
+  modelSupported,
+  extractModelIds,
+  clearModelsCache,
+  CACHE_TTL_MS,
+};

package/src/code/providers/openaiChatTransport.js

@@ -0,0 +1,98 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+const { assertTransport } = require("./transportContract");
+
+/**
+ * OpenAI-compatible chat-completions transport adapter.
+ * @param {{
+ *   resolveUrl: Function,
+ *   runTurn: Function,
+ *   normalizeToolName: Function,
+ *   normalizeToolCallArgs: Function,
+ *   toJsonString: Function,
+ *   clipText: Function,
+ * }} deps
+ */
+function createOpenAiChatTransport(deps = {}) {
+  const {
+    resolveUrl,
+    runTurn,
+    normalizeToolName,
+    normalizeToolCallArgs,
+    toJsonString,
+    clipText,
+  } = deps;
+
+  const transport = {
+    name: "openai-chat",
+    resolveUrl,
+    prepareMessages({ messages, systemPrompt, prompt }) {
+      const systemText = String(systemPrompt || "").trim();
+      const hasSystem = messages.some((entry) => String(entry.role || "").trim() === "system");
+      if (systemText && !hasSystem) {
+        messages.unshift({ role: "system", content: systemText });
+      }
+      messages.push({ role: "user", content: String(prompt || "") });
+    },
+    runTurn,
+    getToolCalls(turnResult) {
+      return Array.isArray(turnResult.toolCalls)
+        ? turnResult.toolCalls.filter((call) => call && call.function && typeof call.function === "object")
+        : [];
+    },
+    appendFinalAssistantMessage({ messages, turnResult }) {
+      const text = String(turnResult.text || "").trim();
+      if (text) {
+        messages.push({
+          role: "assistant",
+          content: text,
+        });
+      }
+    },
+    prepareToolCalls({ messages, toolCalls }) {
+      const assistantToolCalls = [];
+      for (const call of toolCalls) {
+        const callId = String(call.id || `call_${randomUUID()}`);
+        const name = normalizeToolName(call.function.name || "");
+        const args = normalizeToolCallArgs(call.function.arguments || "");
+
+        assistantToolCalls.push({
+          id: callId,
+          type: "function",
+          function: {
+            name: name || String(call.function.name || ""),
+            arguments: toJsonString(args),
+          },
+        });
+      }
+
+      if (assistantToolCalls.length === 0) return null;
+
+      messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: assistantToolCalls,
+      });
+
+      return assistantToolCalls.map((toolCall) => ({
+        name: toolCall.function.name,
+        args: normalizeToolCallArgs(toolCall.function.arguments),
+        source: toolCall,
+      }));
+    },
+    appendToolResult({ messages, call, toolResult }) {
+      messages.push({
+        role: "tool",
+        tool_call_id: call.source.id,
+        content: clipText(toJsonString(toolResult), 12000),
+      });
+    },
+  };
+
+  return assertTransport(transport, "openai-chat");
+}
+
+module.exports = {
+  createOpenAiChatTransport,
+};

package/src/code/providers/transportContract.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * Transport contract for native Agent Loop Provider adapters.
+ *
+ * Transports own wire-format conversion and turn execution only.
+ * They must not decide Plan Mode, write leases, or tool batch policy.
+ *
+ * Required methods:
+ * - resolveUrl(baseUrl) → string
+ * - prepareMessages({ messages, systemPrompt?, prompt })
+ * - runTurn(params) → Promise<turnResult>
+ * - getToolCalls(turnResult) → array
+ * - appendFinalAssistantMessage({ messages, turnResult })
+ * - prepareToolCalls({ messages, turnResult?, toolCalls }) → pendingCalls|null
+ * - appendToolResult({ messages?, collected?, call, toolResult })
+ * - flushToolResults?({ messages, collected })  // Anthropic-style batch
+ */
+
+const TRANSPORT_NAMES = Object.freeze(["openai-chat", "anthropic-messages"]);
+
+function assertTransport(transport = null, name = "") {
+  if (!transport || typeof transport !== "object") {
+    throw new Error(`missing transport${name ? `: ${name}` : ""}`);
+  }
+  const required = [
+    "resolveUrl",
+    "prepareMessages",
+    "runTurn",
+    "getToolCalls",
+    "appendFinalAssistantMessage",
+    "prepareToolCalls",
+    "appendToolResult",
+  ];
+  for (const key of required) {
+    if (typeof transport[key] !== "function") {
+      throw new Error(`transport ${name || "?"} missing ${key}`);
+    }
+  }
+  return transport;
+}
+
+module.exports = {
+  TRANSPORT_NAMES,
+  assertTransport,
+};

package/src/code/repl.js

@@ -113,21 +113,24 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
   }
   const modelMatch = text.match(/^(?:\/model|model)(?:\s+(.*))?$/i);
   if (modelMatch) {
-    const nextModel = String(modelMatch[1] || "").trim();
-    if (!nextModel) {
+    const rest = String(modelMatch[1] || "").trim();
+    if (!rest) {
       return { kind: "model", action: "show" };
     }
-    // Reject accidental multi-token garbage; model ids are single tokens.
-    if (/\s/.test(nextModel)) {
+    const parts = rest.split(/\s+/).filter(Boolean);
+    const modelId = parts[0] || "";
+    const thinking = parts[1] || "";
+    if (!modelId || parts.length > 2) {
       return {
         kind: "error",
-        output: "usage: /model [model-id]",
+        output: "usage: /model [model-id] [off|low|medium|high|max]",
       };
     }
     return {
       kind: "model",
       action: "set",
-      model: nextModel,
+      model: modelId,
+      thinking,
     };
   }
   const planMatch = text.match(/^(?:\/plan|plan)(?:\s+(.*))?$/i);
@@ -283,6 +286,7 @@ async function runUcodeCoreAgent({
     resolveUcodeProviderModel,
     runNaturalLanguageTask,
     resumeAfterUserInteraction,
+    submitUserInteractionAnswer,
   } = require("./agent");
   const resolvedWorkspaceRoot = resolveUfooProjectRoot(workspaceRoot);
   const resolvedUcode = resolveUcodeProviderModel({
@@ -290,10 +294,29 @@ async function runUcodeCoreAgent({
     provider,
     model,
   });
+  const {
+    currentThinkingLevel,
+  } = require("./modelCommand");
+  const {
+    resolveThinkingFromEnvAndConfig,
+    applyThinkingLevelToEnv,
+  } = require("./thinkingLevels");
+  const { loadGlobalUcodeConfig } = require("../config");
+  let initialThinking = "";
+  try {
+    initialThinking = String((loadGlobalUcodeConfig() || {}).ucodeThinking || "").trim();
+  } catch {
+    initialThinking = "";
+  }
+  const thinkingResolved = resolveThinkingFromEnvAndConfig({
+    env: process.env,
+    configLevel: initialThinking,
+  });
   const state = {
     workspaceRoot: resolvedWorkspaceRoot,
     provider: resolvedUcode.provider,
     model: resolvedUcode.model,
+    thinking: currentThinkingLevel({ thinking: initialThinking }),
     engine: "ufoo-core",
     context: buildNlContext({
       appendSystemPrompt,
@@ -307,6 +330,10 @@ async function runUcodeCoreAgent({
     timeoutMs: resolveNlTaskTimeoutMs(Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : NaN),
     jsonOutput,
   };
+  // Named levels sync into env; leave an explicit numeric budget override alone.
+  if (thinkingResolved.source !== "env-budget") {
+    applyThinkingLevelToEnv(state.thinking, process.env);
+  }
   persistSessionState(state);
 
   if (shouldUseUcodeTui({
@@ -465,7 +492,9 @@ async function runUcodeCoreAgent({
         }
       }
       if (result.kind === "model") {
-        const applied = applyUcodeModelCommand(state, result);
+        const applied = await applyUcodeModelCommand(state, result, {
+          workspaceRoot: runtimeWorkspace,
+        });
         stdout.write(`${applied.output}\n`);
         if (applied.ok && result.action === "set") {
           persistSessionState(state);
@@ -592,23 +621,12 @@ async function runUcodeCoreAgent({
 
       // Pending approval/choice/chat takes priority over nudge / new NL.
       try {
-        const {
-          hasPendingUserInteraction,
-          parseUserInteractionInput,
-          getPendingUserInteraction,
-        } = require("./context/userInteraction");
+        const { hasPendingUserInteraction } = require("./context/userInteraction");
         if (
           trimmed
           && state.executionState
           && hasPendingUserInteraction(state.executionState)
         ) {
-          const pending = getPendingUserInteraction(state.executionState);
-          const parsed = parseUserInteractionInput(pending, trimmed);
-          if (!parsed.ok) {
-            stdout.write(`${parsed.error || "Invalid reply"}\n`);
-            printPrompt(stdout);
-            return;
-          }
           chain = chain.then(async () => {
             let streamBuffer = null;
             let streamedVisible = false;
@@ -622,7 +640,7 @@ async function runUcodeCoreAgent({
             taskInFlight = true;
             let resumeResult;
             try {
-              resumeResult = await resumeAfterUserInteraction(trimmed, state, {
+              resumeResult = await submitUserInteractionAnswer(trimmed, state, {
                 onDelta: state.jsonOutput
                   ? null
                   : async (delta) => {
@@ -649,15 +667,12 @@ async function runUcodeCoreAgent({
             if (streamed && streamedVisible && resumeResult && resumeResult.streamLastChar !== "\n") {
               stdout.write("\n");
             }
-            if (resumeResult && resumeResult.waitingUserInteraction) {
-              stdout.write("Still waiting for your reply.\n");
-            } else if (!resumeResult || resumeResult.ok === false) {
+            if (!resumeResult || resumeResult.ok === false) {
               stdout.write(`Error: ${(resumeResult && resumeResult.error) || "resume failed"}\n`);
-            } else {
-              const shouldSkipSummary = Boolean(streamed && resumeResult.ok && streamedVisible);
-              if (!shouldSkipSummary && resumeResult.summary) {
-                stdout.write(`${resumeResult.summary}\n`);
-              }
+            } else if (resumeResult.shouldEchoSummary && resumeResult.echoSummaryText) {
+              stdout.write(`${resumeResult.echoSummaryText}\n`);
+            } else if (resumeResult.waitingUserInteraction) {
+              stdout.write("Still waiting for your reply.\n");
             }
             const persisted = persistSessionState(state);
             if (!state.jsonOutput && (!persisted || persisted.ok === false)) {
@@ -783,4 +798,5 @@ module.exports = {
   applyUcodeModelCommand,
   applyUcodePlanCommand,
   suggestUcodeModels,
-};
+  suggestUcodeThinkingLevels: require("./modelCommand").suggestUcodeThinkingLevels,
+};