nolo-cli 0.1.38 → 0.1.40

package/client/agentRun.ts

@@ -9,7 +9,7 @@ import {
 } from "../agentAliases";
 import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { createCliLocalRuntimeAdapter, isBuiltinNoloAgentRef } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
 import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
 
@@ -44,7 +44,6 @@ type RunAgentTurnOptions = {
   parentDialogId?: string;
   background?: boolean;
   noStream?: boolean;
-  noDefaultTestRoot?: boolean;
   scriptDir: string;
   env: EnvLike;
   output: OutputLike;
@@ -52,9 +51,9 @@ type RunAgentTurnOptions = {
   localRuntimeAdapter?: AgentRuntimeHostAdapter;
   localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
   localRuntimeCwd?: string;
-  maxToolRounds?: number;
   timeoutMs?: number;
   traceTools?: boolean;
+  eventsMode?: "jsonl";
   taskRunContext?: TaskRunPromptContext;
   taskRunRecorder?: (args: {
     options: RunAgentTurnOptions;
@@ -180,10 +179,27 @@ function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
   const normalizedKey = normalizeAgentRef(options.agentKey);
   return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
 }
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
+
+function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
+  const machineId =
+    agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
+      ? String(agentConfig.runtimeBinding.machineId ?? "").trim()
+      : "";
+  const providerUrl = typeof agentConfig?.customProviderUrl === "string"
+    ? agentConfig.customProviderUrl.trim()
+    : "";
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
 
 function shouldShowUsage(env: EnvLike) {
   return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
@@ -214,6 +230,10 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 }
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  if (isBuiltinNoloAgentRef(options.agentKey)) return false;
+  if (options.localRuntimeCwd) {
+    return false;
+  }
   if (isKnownServerPlatformAgent(options)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
@@ -229,6 +249,13 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
+  if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +
+        "Use --local explicitly to force the current machine.\n"
+    );
+    return true;
+  }
   const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
@@ -250,7 +277,14 @@ function buildUserInputContent(message: string, imageUrls: string[] = []) {
 }
 
 function shouldTraceLocalTools(options: RunAgentTurnOptions) {
-  return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
+  const setting = (options.env.NOLO_TRACE_TOOLS ?? "").trim().toLowerCase();
+  if (setting === "0" || setting === "false" || setting === "off") return false;
+  return true;
+}
+
+function resolveAgentEventMode(options: RunAgentTurnOptions): "text" | "jsonl" {
+  if (options.eventsMode === "jsonl") return "jsonl";
+  return options.env.NOLO_AGENT_EVENTS === "jsonl" ? "jsonl" : "text";
 }
 
 function shouldCollectLocalToolEvidence(options: RunAgentTurnOptions) {
@@ -279,15 +313,6 @@ function summarizeLocalToolEvidence(events: LocalAgentToolEvent[]): TaskRunToolE
   };
 }
 
-const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 512;
-
-function parseLocalToolRoundLimitError(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  const match = message.match(/Local agent exceeded max tool rounds:\s*(\d+)/);
-  if (!match) return null;
-  return Number(match[1]);
-}
-
 function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
   return Boolean(
     error &&
@@ -298,37 +323,44 @@ function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
   );
 }
 
-function parsePositiveInteger(value: string | undefined) {
-  if (!value) return null;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) return null;
-  return parsed;
-}
-
-function resolveLocalToolRoundRetryLimit(options: RunAgentTurnOptions) {
-  return (
-    parsePositiveInteger(options.env.NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT) ??
-    DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT
-  );
-}
-
-function nextLocalToolRoundLimit(current: number) {
-  return current <= 0 ? 1 : current * 2;
-}
-
 function formatToolTraceEvent(event: LocalAgentToolEvent) {
   const round = event.round + 1;
+  const detail = event.argumentsPreview ? ` ${event.argumentsPreview}` : "";
   if (event.type === "tool-call") {
-    return `[nolo:tool] round ${round} -> ${event.toolName} (${event.toolCallId})\n`;
+    return `[nolo:tool] #${round} -> ${event.toolName}${detail}\n`;
   }
   if (event.type === "tool-error") {
-    return `[nolo:tool] round ${round} !! ${event.toolName}: ${event.message ?? "failed"}\n`;
+    const elapsed = typeof event.elapsedMs === "number" ? ` ${event.elapsedMs}ms` : "";
+    return `[nolo:tool] #${round} !! ${event.toolName}${elapsed}: ${event.message ?? "failed"}\n`;
   }
-  return `[nolo:tool] round ${round} <- ${event.toolName} (${event.toolCallId})\n`;
+  const elapsed = typeof event.elapsedMs === "number" ? ` ${event.elapsedMs}ms` : "";
+  const summary = event.summary ? ` ${event.summary}` : "";
+  return `[nolo:tool] #${round} <- ${event.toolName}${elapsed}${summary}\n`;
+}
+
+function formatToolJsonEvent(event: LocalAgentToolEvent) {
+  return `${JSON.stringify({
+    schemaVersion: 1,
+    type: event.type,
+    round: event.round + 1,
+    tool: event.toolName,
+    toolCallId: event.toolCallId,
+    ...(event.argumentsPreview ? { argsPreview: event.argumentsPreview } : {}),
+    ...(typeof event.elapsedMs === "number" ? { elapsedMs: event.elapsedMs } : {}),
+    ...(event.summary ? { summary: event.summary } : {}),
+    ...(event.message ? { message: event.message } : {}),
+  })}\n`;
 }
 
 function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
   if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  if (
+    options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" &&
+    isBuiltinNoloAgentRef(options.agentKey) &&
+    resolveAuthToken(options.env)
+  ) {
+    return true;
+  }
   return Boolean(
     options.env.NOLO_LOCAL_OPENAI_API_KEY ||
       options.env.OPENAI_API_KEY ||
@@ -594,7 +626,6 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
           : {}),
         ...(options.parentDialogId ? { parentDialogId: options.parentDialogId } : {}),
         ...(options.background ? { background: true } : {}),
-        ...(typeof options.maxToolRounds === "number" ? { maxRounds: options.maxToolRounds } : {}),
         ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
         stream: !options.noStream && !options.background,
       }),
@@ -632,8 +663,21 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
 
   if (!res.ok) {
     options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
-    if (data?.error || data?.message) {
-      options.output.write(`${data.error || data.message}\n`);
+    const errorText = typeof data?.error === "string" ? data.error.trim() : "";
+    const messageText = typeof data?.message === "string" ? data.message.trim() : "";
+    const reasonText = typeof data?.reason === "string" ? data.reason.trim() : "";
+    const codeText = typeof data?.code === "string" ? data.code.trim() : "";
+    if (errorText || messageText) {
+      options.output.write(`${errorText || messageText}\n`);
+      if (messageText && messageText !== errorText) {
+        options.output.write(`${messageText}\n`);
+      }
+      if (codeText && codeText !== errorText && codeText !== messageText) {
+        options.output.write(`code=${codeText}\n`);
+      }
+      if (reasonText && reasonText !== errorText && reasonText !== messageText) {
+        options.output.write(`reason=${reasonText}\n`);
+      }
     }
     await recordTaskRunOutcome({
       options,
@@ -669,7 +713,7 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
 }
 
 async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
-  return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
+  return runLocalAgentTurnForCli(options, { reportFailure: true });
 }
 
 async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
@@ -679,53 +723,6 @@ async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
   return Boolean(agentConfig);
 }
 
-async function runLocalAgentTurnWithAutoRoundExpansion(
-  options: RunAgentTurnOptions,
-  settings: { reportFailure: boolean }
-) {
-  const maxRetryLimit = resolveLocalToolRoundRetryLimit(options);
-  let currentMaxToolRounds = options.maxToolRounds;
-  let lastResult: Awaited<ReturnType<typeof runLocalAgentTurnForCli>> | null = null;
-
-  while (true) {
-    const attemptOptions = {
-      ...options,
-      ...(typeof currentMaxToolRounds === "number" ? { maxToolRounds: currentMaxToolRounds } : {}),
-    };
-    const result = await runLocalAgentTurnForCli(attemptOptions, { reportFailure: false });
-    lastResult = result;
-    if (result.exitCode === 0) return result;
-
-    const exhaustedRounds = parseLocalToolRoundLimitError(result.localError);
-    if (exhaustedRounds === null) break;
-
-    const nextMaxToolRounds = nextLocalToolRoundLimit(exhaustedRounds);
-    if (nextMaxToolRounds > maxRetryLimit) break;
-
-    options.output.write(
-      `[nolo] Local agent used all ${exhaustedRounds} tool rounds; retrying with ${nextMaxToolRounds}.\n`
-    );
-    currentMaxToolRounds = nextMaxToolRounds;
-  }
-
-  if (settings.reportFailure && lastResult?.localError) {
-    options.output.write(
-      `[nolo] Local agent run failed: ${
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError)
-      }\n`
-    );
-    await recordTaskRunOutcome({
-      options,
-      status: "failed",
-      errorCode: "LOCAL_AGENT_FAILED",
-      resultSummary:
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError),
-      toolEvidence: lastResult.toolEvidence,
-    });
-  }
-  return lastResult ?? { exitCode: 1 };
-}
-
 async function runLocalAgentTurnForCli(
   options: RunAgentTurnOptions,
   settings: { reportFailure: boolean }
@@ -742,6 +739,7 @@ async function runLocalAgentTurnForCli(
   try {
     const traceLocalTools = shouldTraceLocalTools(options);
     const collectToolEvidence = shouldCollectLocalToolEvidence(options);
+    const eventMode = resolveAgentEventMode(options);
     const result = await runLocalAgentTurn({
       adapter,
       agentRef: options.agentKey,
@@ -756,7 +754,6 @@ async function runLocalAgentTurnForCli(
       parentDialogId: options.parentDialogId,
       background: options.background,
       noStream: options.noStream,
-      maxToolRounds: options.maxToolRounds,
       ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
       ...(traceLocalTools || collectToolEvidence
         ? {
@@ -764,7 +761,11 @@ async function runLocalAgentTurnForCli(
               if (collectToolEvidence) toolEvents.push(event);
               if (traceLocalTools) {
                 spinner.stop();
-                options.output.write(formatToolTraceEvent(event));
+                options.output.write(
+                  eventMode === "jsonl"
+                    ? formatToolJsonEvent(event)
+                    : formatToolTraceEvent(event)
+                );
               }
             },
           }
@@ -920,7 +921,7 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
   if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
     const skipLocal = await shouldSkipAutoLocalForServerPlatformTools(options);
     if (!skipLocal) {
-      const localResult = await runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: false });
+      const localResult = await runLocalAgentTurnForCli(options, { reportFailure: false });
       if (localResult.exitCode === 0) {
         return {
           exitCode: localResult.exitCode,
@@ -934,7 +935,7 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
         try {
           const refreshed = await refreshMissingLocalAgentConfig(options);
           if (refreshed) {
-            const retriedLocalResult = await runLocalAgentTurnWithAutoRoundExpansion(options, {
+            const retriedLocalResult = await runLocalAgentTurnForCli(options, {
               reportFailure: false,
             });
             if (retriedLocalResult.exitCode === 0) {