nolo-cli 0.1.39 → 0.1.40

package/cli/client/agentRun.ts

@@ -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;
@@ -232,7 +231,7 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
   if (isBuiltinNoloAgentRef(options.agentKey)) return false;
-  if (options.localRuntimeCwd && options.env.NOLO_LOCAL_SHELL_MODE === "worktree") {
+  if (options.localRuntimeCwd) {
     return false;
   }
   if (isKnownServerPlatformAgent(options)) {
@@ -278,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) {
@@ -307,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 &&
@@ -326,33 +323,33 @@ 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) {
@@ -629,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,
       }),
@@ -717,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) {
@@ -727,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 }
@@ -790,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,
@@ -804,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
         ? {
@@ -812,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)
+                );
               }
             },
           }
@@ -968,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,
@@ -982,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) {

package/cli/client/localRuntimeAdapter.ts

@@ -21,6 +21,7 @@ import {
   resolveCurrentRunRuntimeToolPolicy,
   resolveLocalWorkspaceExecutorOptionsFromPolicy,
   resolveRequestedRuntimeToolNames,
+  resolveRuntimeToolSurfaceForAgent,
   shouldUsePlatformChatProvider,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../../agent-runtime";
@@ -43,6 +44,7 @@ import {
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
 import { taskRunFunctionSchema } from "../../ai/tools/agent/taskRunTool";
 import {
+  MIMO_MONTH_AGENT_KEY,
   NOLO_DEFAULT_AGENT_ID,
   NOLO_DEFAULT_AGENT_KEY,
 } from "../agentAliases";
@@ -50,14 +52,26 @@ import {
   buildNoloWorkspaceCliToolExecutors,
   buildNoloWorkspaceOpenAiTools,
   filterNoloWorkspaceToolNames,
-  NOLO_WORKSPACE_TOOL_NAMES,
-  NOLO_WORKSPACE_TOOL_PROMPT,
   parseNoloWorkspaceToolArguments,
 } from "../../agent-runtime/noloWorkspaceTools";
+import { executeCli as defaultExecuteCli, type CliExecuteResult, type CliImageInput } from "../../ai/agent/cliExecutor";
+import { buildCliPrompt } from "../../ai/agent/cliPrompt";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: Record<string, string | undefined>;
+    imageInputs?: CliImageInput[];
+  }
+) => Promise<CliExecuteResult>;
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
 export const BUILTIN_NOLO_AGENT_ID = NOLO_DEFAULT_AGENT_ID;
@@ -77,6 +91,7 @@ export type CliLocalRuntimeAdapterDeps = {
   cwd?: string;
   output?: { write(chunk: string): unknown };
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  executeCli?: LocalCliExecutor;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
 };
@@ -93,10 +108,6 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
-function shellModeEnabled(env: EnvLike) {
-  return env.NOLO_LOCAL_SHELL_MODE === "worktree";
-}
-
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -251,7 +262,79 @@ function parseJsonObject(raw: string) {
   }
 }
 
+function isCliProviderAgent(agentConfig: AgentRuntimeAgentConfig) {
+  return Boolean(
+    agentConfig.apiSource === "cli" ||
+      agentConfig.provider === "cli" ||
+      agentConfig.cliProvider
+  );
+}
+
+function resolveCliProviderName(agentConfig: AgentRuntimeAgentConfig) {
+  return (agentConfig.cliProvider || agentConfig.provider || "codex").trim() || "codex";
+}
+
+function stringifyRuntimeMessageContent(content: AgentRuntimeChatMessage["content"]) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part) {
+          return String((part as any).text ?? "");
+        }
+        return JSON.stringify(part);
+      })
+      .filter((part) => part.trim())
+      .join("\n");
+  }
+  return content == null ? "" : String(content);
+}
+
+function buildPromptForCliProvider(messages: AgentRuntimeChatMessage[]) {
+  const systemPrompt = messages
+    .filter((message) => message.role === "system")
+    .map((message) => stringifyRuntimeMessageContent(message.content).trim())
+    .filter(Boolean)
+    .join("\n\n");
+  const taskPrompt = messages
+    .filter((message) => message.role !== "system")
+    .map((message) => {
+      const content = stringifyRuntimeMessageContent(message.content).trim();
+      if (!content) return "";
+      return `[${message.role}]\n${content}`;
+    })
+    .filter(Boolean)
+    .join("\n\n");
+  return buildCliPrompt(systemPrompt, taskPrompt);
+}
+
+function collectCliProviderImageInputs(messages: AgentRuntimeChatMessage[]) {
+  const urls: string[] = [];
+  for (const message of messages) {
+    if (!Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (
+        part &&
+        typeof part === "object" &&
+        (part as any).type === "image_url" &&
+        typeof (part as any).image_url?.url === "string" &&
+        (part as any).image_url.url.trim()
+      ) {
+        urls.push((part as any).image_url.url.trim());
+      }
+    }
+  }
+  return urls;
+}
+
 function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown>) {
+  if (
+    process.env.NOLO_LOCAL_RUNTIME_DEBUG !== "1" &&
+    process.env.NOLO_DEBUG !== "1"
+  ) {
+    return;
+  }
   console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
 }
 
@@ -266,31 +349,38 @@ function summarizeOpenAiToolNames(tools: Array<Record<string, unknown>>) {
     .filter((name): name is string => Boolean(name));
 }
 
-function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+function shouldExposeLocalPlatformTools(agentKey?: string) {
+  return agentKey !== MIMO_MONTH_AGENT_KEY;
+}
+
+function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
+  const exposePlatformTools = shouldExposeLocalPlatformTools(args.agentKey);
   return [
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
     }),
-    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
-    ...buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }),
+    ...(exposePlatformTools ? buildServerPlatformOpenAiTools({ toolNames: args.toolNames }) : []),
+    ...(exposePlatformTools ? buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }) : []),
   ];
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
+  void args.env;
   const toolset = buildLocalWorkspaceToolset({
     declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled(args.env),
+    exposeShellTools: true,
   });
   return toolset;
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
+  void args.env;
   return [
     ...buildLocalWorkspacePolicyToolNames({
       declaredToolNames: args.toolNames,
-      exposeShellTools: shellModeEnabled(args.env),
+      exposeShellTools: true,
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
     ...filterNoloWorkspaceToolNames(args.toolNames),
@@ -336,16 +426,32 @@ function isBuiltinNoloAgentConfig(agentConfig: AgentRuntimeAgentConfig | null |
   return isBuiltinNoloAgentRef(key) || isBuiltinNoloAgentRef(id);
 }
 
-function withBuiltinNoloCliTools(agentConfig: AgentRuntimeAgentConfig | null) {
-  if (!agentConfig || !isBuiltinNoloAgentConfig(agentConfig)) return agentConfig;
-  const toolNames = [...new Set([...(agentConfig.toolNames ?? []), ...NOLO_WORKSPACE_TOOL_NAMES])];
+function withResolvedRuntimeToolSurface(
+  agentConfig: AgentRuntimeAgentConfig | null,
+  env: EnvLike
+) {
+  if (!agentConfig) return agentConfig;
+  const currentUserId = resolveLocalUserId(env);
+  const rawRecord = (agentConfig as any).rawRecord ?? {};
+  const ownerId =
+    typeof rawRecord.userId === "string" && rawRecord.userId.trim()
+      ? rawRecord.userId.trim()
+      : null;
+  const toolSurface = resolveRuntimeToolSurfaceForAgent({
+    explicitToolNames: agentConfig.toolNames,
+    currentUserId,
+    agentOwnerId: ownerId,
+    agentKey: rawRecord.dbKey ?? agentConfig.key,
+    isPublic: !isBuiltinNoloAgentConfig(agentConfig) && rawRecord.isPublic === true,
+    sharingLevel: typeof rawRecord.sharingLevel === "string" ? rawRecord.sharingLevel : null,
+    trustedPrivateInvocation: isBuiltinNoloAgentConfig(agentConfig),
+    runtimeHost: "cli",
+  });
   return {
     ...agentConfig,
-    toolNames,
-    prompt: [
-      agentConfig.prompt?.trim() ?? "",
-      NOLO_WORKSPACE_TOOL_PROMPT,
-    ].filter(Boolean).join("\n\n"),
+    toolNames: toolSurface.finalToolNames,
+    toolSurface,
+    prompt: agentConfig.prompt,
   };
 }
 
@@ -500,11 +606,14 @@ export function createCliLocalRuntimeAdapter(
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
-      const agentConfig = withBuiltinNoloCliTools(await readAgentFromStore({
-        agentRef,
-        store: await resolveStore(deps),
-        userId,
-      }));
+      const agentConfig = withResolvedRuntimeToolSurface(
+        await readAgentFromStore({
+          agentRef,
+          store: await resolveStore(deps),
+          userId,
+        }),
+        deps.env
+      );
       const requestedToolNames = agentConfig
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
@@ -537,6 +646,50 @@ export function createCliLocalRuntimeAdapter(
       cwd: workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
+      if (isCliProviderAgent(agentConfig)) {
+        const provider = resolveCliProviderName(agentConfig);
+        logLocalRuntimeDiagnostic("provider.selected", {
+          agentKey: agentConfig.key,
+          transport: "local-cli",
+          apiSource: agentConfig.apiSource ?? null,
+          provider,
+          model: agentConfig.model ?? null,
+          cwd: workspaceRoot,
+        });
+        return {
+          model: agentConfig.model || provider,
+          complete: async (messages, options) => {
+            const executeCli = deps.executeCli ?? (defaultExecuteCli as LocalCliExecutor);
+            const imageUrls = collectCliProviderImageInputs(messages);
+            const imageInputs: CliImageInput[] | undefined =
+              imageUrls.length > 0
+                ? imageUrls.map((url) => ({ source: url }))
+                : undefined;
+            const prompt = buildPromptForCliProvider(messages);
+            try {
+              const result = await executeCli(provider, prompt, {
+                ...(agentConfig.model ? { model: agentConfig.model } : {}),
+                ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
+                cwd: workspaceRoot,
+                yolo: true,
+                env: deps.env,
+                ...(imageInputs ? { imageInputs } : {}),
+              });
+              return {
+                content: result.text,
+                model: agentConfig.model || provider,
+                raw: result.raw,
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              throw new Error(
+                `Local CLI provider "${provider}" is unavailable or failed: ${message}`
+              );
+            }
+          },
+        };
+      }
+
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
         const providerConfig = resolvePlatformChatProviderConfig({
           agentConfig,
@@ -563,6 +716,7 @@ export function createCliLocalRuntimeAdapter(
               agentConfig,
             });
             const tools = buildOpenAiTools({
+              agentKey: agentConfig.key,
               toolNames: requestedToolNames,
               env: deps.env,
             });
@@ -582,7 +736,6 @@ export function createCliLocalRuntimeAdapter(
               toolCount: tools.length,
               requestedToolNames,
               openAiToolNames: summarizeOpenAiToolNames(tools),
-              shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
               timeoutMs: options?.timeoutMs ?? null,
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -636,6 +789,7 @@ export function createCliLocalRuntimeAdapter(
             agentConfig,
           });
           const tools = buildOpenAiTools({
+            agentKey: agentConfig.key,
             toolNames: requestedToolNames,
             env: deps.env,
           });
@@ -654,7 +808,6 @@ export function createCliLocalRuntimeAdapter(
             toolCount: tools.length,
             requestedToolNames,
             openAiToolNames: summarizeOpenAiToolNames(tools),
-            shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
             timeoutMs: options?.timeoutMs ?? null,
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {

package/cli/commandRegistry.ts

@@ -69,8 +69,8 @@ export function renderHelpText() {
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
     "  nolo table query --table 01ABCXYZ",
-    '  nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
-    '  nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
+    '  nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
+    '  nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
     "  nolo task-run read-context --row-dbkey row-user-table-row",
     "  nolo llama status",
   ];

package/cli/machineWsRunDispatch.ts

@@ -20,9 +20,52 @@ type EnvLike = Record<string, string | undefined>;
 export type LocalCliExecutor = (
   provider: string,
   prompt: string,
-  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean; env?: EnvLike }
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: EnvLike;
+    imageInputs?: Array<{ source: string; materializedPath?: string }>;
+  }
 ) => Promise<{ text: string; raw?: string; elapsed?: number }>;
 
+/**
+ * 从 connector payload 的 userInput 中提取 multimodal 内容。
+ * 如果 userInput 是字符串，直接返回 { text, imageUrls: [] }。
+ * 如果 userInput 是 multimodal content array（`[{ type: "text" }, { type: "image_url" }]`），
+ * 提取 text 和 image_url parts。
+ */
+function extractMultimodalUserInput(userInput: unknown): {
+  text: string;
+  imageUrls: string[];
+} {
+  if (typeof userInput === "string") {
+    return { text: userInput, imageUrls: [] };
+  }
+  if (!Array.isArray(userInput)) {
+    return { text: String(userInput ?? ""), imageUrls: [] };
+  }
+
+  const textParts: string[] = [];
+  const imageUrls: string[] = [];
+
+  for (const part of userInput) {
+    if (!part || typeof part !== "object") continue;
+    if ((part as any).type === "text" && typeof (part as any).text === "string") {
+      textParts.push((part as any).text);
+    } else if (
+      (part as any).type === "image_url" &&
+      typeof (part as any).image_url?.url === "string" &&
+      (part as any).image_url.url.trim()
+    ) {
+      imageUrls.push((part as any).image_url.url.trim());
+    }
+  }
+
+  return { text: textParts.join("\n"), imageUrls };
+}
+
 type ConnectorRuntimePolicy = {
   runtimeTools?: string[];
   agentTools?: string[];
@@ -103,7 +146,6 @@ function summarizeRuntimePolicyForLogs(policy?: ConnectorRuntimePolicy) {
     workspaceMode: policy?.workspace?.mode ?? null,
     workspaceCwd: policy?.workspace?.cwd ?? null,
     shellEnabled: policy?.shell?.enabled ?? null,
-    shellMode: policy?.shell?.mode ?? null,
   };
 }
 
@@ -188,13 +230,13 @@ function runtimeWorkspacePermissionPolicy(
   runtimeEnv: EnvLike,
   cwd: string
 ): PermissionPolicy | null {
+  void runtimeEnv;
   if (!requestsLocalWorkspaceRuntime(runtimePolicy)) return null;
   return {
     mode: "full_access",
     allowFilesystemRead: true,
     allowFilesystemWrite: true,
     allowShell:
-      runtimeEnv.NOLO_LOCAL_SHELL_MODE === "worktree" &&
       Array.isArray(runtimePolicy?.runtimeTools) &&
       runtimePolicy.runtimeTools.includes("execShell"),
     writableRoots: [cwd],
@@ -332,8 +374,6 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     requestId: args.parsed.requestId,
     agentKey,
     cwd: args.cwd,
-    runtimeEnvShellModeBeforePolicy: args.runtimeEnv.NOLO_LOCAL_SHELL_MODE ?? null,
-    runtimeEnvShellModeAfterPolicy: env.NOLO_LOCAL_SHELL_MODE ?? null,
     ...summarizeRuntimePolicyForLogs(policy),
   });
   const adapter = createCliLocalRuntimeAdapter({
@@ -454,7 +494,9 @@ export async function handleConnectorRunMessage(
   try {
     const machinePermissionPolicy = resolveMachineRunPermissionPolicy(agentConfig);
     const runtimePolicy = runtimePolicyFromConnectorPayload(parsed);
-    const userInput = String(parsed.payload?.userInput ?? "");
+    const extractedInput = extractMultimodalUserInput(parsed.payload?.userInput);
+    const userInput = extractedInput.text;
+    const connectorImageUrls = extractedInput.imageUrls;
     const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
     let cwd = resolveConnectorRunCwd({ env: runtimeEnv, policy: machinePermissionPolicy });
     let runContent = "";
@@ -553,6 +595,9 @@ export async function handleConnectorRunMessage(
             effectiveRuntimeEnv.AUTH_TOKEN ||
             effectiveRuntimeEnv.AUTH,
         },
+        ...(connectorImageUrls.length > 0
+          ? { imageInputs: connectorImageUrls.map((url) => ({ source: url })) }
+          : {}),
       }).finally(() => clearInterval(heartbeat));
       logConnectorRun("agent.run.cli.result", {
         requestId: parsed.requestId,