nolo-cli 0.16.0-alpha.9 → 0.16.0

package/{chunk-ZVDRAEZL.js → chunk-6EVITP2G.js}

@@ -7,6 +7,9 @@ import {
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";
@@ -333,6 +336,242 @@ async function buildProviderExecutionPlan(args) {
   };
 }
 
+// packages/agent-runtime/openAiCompatibleMessages.ts
+function preserveAgentStateFields(source, target, options) {
+  const mutableTarget = target;
+  if (source.role === "assistant") {
+    if (!options?.stripReasoningContent && typeof source.reasoning_content === "string") {
+      mutableTarget.reasoning_content = source.reasoning_content;
+    }
+    if (Array.isArray(source.tool_calls)) {
+      mutableTarget.tool_calls = source.tool_calls;
+    }
+  }
+  if (source.role === "tool") {
+    const toolCallId = typeof source.tool_call_id === "string" ? source.tool_call_id.trim() : typeof source.toolCallId === "string" ? source.toolCallId.trim() : "";
+    if (toolCallId) mutableTarget.tool_call_id = toolCallId;
+  }
+  return target;
+}
+function toOpenAiCompatibleMessages(messages, options) {
+  return messages.map(
+    (message) => preserveAgentStateFields(message, {
+      role: message.role,
+      content: message.content ?? ""
+    }, options)
+  );
+}
+function shouldStripReasoningContentForOutbound(provider, model) {
+  const p = provider?.trim().toLowerCase();
+  const m = model?.trim().toLowerCase();
+  if (!p || !m) return false;
+  if (p === "deepseek" || p === "nolo") return m === "deepseek-v4-flash";
+  return false;
+}
+
+// packages/integrations/openai/responsesHelpers.ts
+var RESPONSES_TOP_LEVEL_SCHEMA_KEYS = ["anyOf", "oneOf", "allOf", "enum", "not"];
+var sanitizeResponsesParameters = (parameters) => {
+  if (!isRecord(parameters)) {
+    return parameters;
+  }
+  const next = { ...parameters };
+  for (const key of RESPONSES_TOP_LEVEL_SCHEMA_KEYS) {
+    delete next[key];
+  }
+  return next;
+};
+var appendTextPart = (parts, text, role) => {
+  if (!text) return;
+  const last = parts.at(-1);
+  const textType = role === "assistant" ? "output_text" : "input_text";
+  if (last?.type === textType) {
+    last.text += text;
+    return;
+  }
+  parts.push({ type: textType, text });
+};
+var normalizeMessageParts = (content, role) => {
+  if (typeof content === "string") {
+    if (!content) return [];
+    return [
+      {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text: content
+      }
+    ];
+  }
+  const parts = [];
+  for (const part of content ?? []) {
+    const typedPart = part;
+    if (typedPart?.type === "text" && typeof typedPart.text === "string") {
+      appendTextPart(parts, typedPart.text, role);
+      continue;
+    }
+    if (typedPart?.type === "image_url" && typeof typedPart.image_url?.url === "string" && typedPart.image_url.url) {
+      if (role === "assistant") continue;
+      parts.push({
+        type: "input_image",
+        image_url: typedPart.image_url.url,
+        detail: typedPart.image_url.detail
+      });
+    }
+  }
+  return parts;
+};
+var normalizeToolOutput = (content) => {
+  if (typeof content === "string") return content;
+  return JSON.stringify(content ?? "");
+};
+var toResponsesTools = (tools) => {
+  if (!Array.isArray(tools) || tools.length === 0) return void 0;
+  return tools.map((tool) => {
+    const fn = tool?.function;
+    if (!fn?.name) return null;
+    return {
+      type: "function",
+      name: fn.name,
+      description: fn.description,
+      parameters: sanitizeResponsesParameters(fn.parameters),
+      strict: fn.strict
+    };
+  }).filter(Boolean);
+};
+var convertMessagesToResponsesInput = (messages, options) => {
+  const input = [];
+  for (const message of messages) {
+    if (!message?.role) continue;
+    if (message.role === "tool") {
+      if (!message.tool_call_id) continue;
+      input.push({
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: normalizeToolOutput(message.content)
+      });
+      continue;
+    }
+    const role = message.role;
+    if (role === "assistant" && !options?.stripReasoningContent && typeof message.reasoning_content === "string" && message.reasoning_content) {
+      input.push({ type: "reasoning", content: message.reasoning_content });
+    }
+    const contentParts = normalizeMessageParts(message.content, role);
+    if (contentParts.length > 0) {
+      input.push({
+        type: "message",
+        role,
+        content: contentParts
+      });
+    }
+    if (role === "assistant" && Array.isArray(message.content)) {
+      const replayImages = message.content.map((part) => part).filter(
+        (part) => part?.type === "image_url" && typeof part.image_url?.url === "string" && Boolean(part.image_url.url)
+      ).map((part) => ({
+        type: "input_image",
+        image_url: part.image_url.url,
+        detail: part.image_url.detail
+      }));
+      if (replayImages.length > 0) {
+        input.push({
+          type: "message",
+          role: "user",
+          content: replayImages
+        });
+      }
+    }
+    if (role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const toolCall of message.tool_calls) {
+        if (!toolCall?.id || !toolCall.function?.name) continue;
+        input.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments ?? {})
+        });
+      }
+    }
+  }
+  return input;
+};
+var extractTextFromResponseOutput = (response) => {
+  const parts = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+};
+var toDataUrl = (base64Data, mimeType) => {
+  const normalizedMimeType = asOptionalTrimmedString(mimeType) ?? "image/png";
+  return `data:${normalizedMimeType};base64,${base64Data}`;
+};
+var extractImagePartsFromResponseOutput = (response) => {
+  const images = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type === "image_generation_call") {
+      const result = asOptionalTrimmedString(item.result);
+      if (result) {
+        const outputFormat = asOptionalTrimmedString(item.output_format);
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              result,
+              outputFormat ? `image/${outputFormat}` : void 0
+            )
+          }
+        });
+      }
+      continue;
+    }
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      const result = asOptionalTrimmedString(content?.result);
+      if (content?.type === "output_image" && result) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              result,
+              content.mime_type ?? content.mimeType ?? null
+            )
+          }
+        });
+      }
+    }
+  }
+  return images;
+};
+var extractToolCallsFromResponseOutput = (response) => {
+  const calls = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "function_call") continue;
+    if (!item.call_id || !item.name) continue;
+    calls.push({
+      id: item.call_id,
+      type: "function",
+      function: {
+        name: item.name,
+        arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {})
+      }
+    });
+  }
+  return calls;
+};
+
+// packages/core/chat/imageParts.ts
+function isImageUrlPart(part) {
+  return isRecord(part) && part.type === "image_url";
+}
+function hasImageParts(messages) {
+  return messages.some(
+    (message) => Array.isArray(message.content) && message.content.some(isImageUrlPart)
+  );
+}
+
 export {
   pickAgentRuntimeInferenceOptions,
   isOpenAiResponsesModel,
@@ -346,5 +585,15 @@ export {
   resolveAgentRuntimeLocation,
   resolveProviderTransportDecision,
   buildProviderAuthHeaders,
-  buildProviderExecutionPlan
+  buildProviderExecutionPlan,
+  isImageUrlPart,
+  hasImageParts,
+  preserveAgentStateFields,
+  toOpenAiCompatibleMessages,
+  shouldStripReasoningContentForOutbound,
+  toResponsesTools,
+  convertMessagesToResponsesInput,
+  extractTextFromResponseOutput,
+  extractImagePartsFromResponseOutput,
+  extractToolCallsFromResponseOutput
 };

package/{chunk-AFNJWHKL.js → chunk-7UKFVQ5W.js}

@@ -4,34 +4,31 @@ import {
   providerHttpFailure,
   readSseFrames,
   throwIfChatCompletionStreamFailed
-} from "./chunk-4N7QA72L.js";
+} from "./chunk-AVVZUXXC.js";
 import {
   parseToolArgumentsJson
-} from "./chunk-LZYEWFPK.js";
+} from "./chunk-GSINCD4P.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
-  createToolCallTextParserState,
   extractThinkContent,
   finalizeAccumulatedToolCalls
-} from "./chunk-LSFAWXKC.js";
+} from "./chunk-3WGLLTK4.js";
 import {
   requiresBareImageUrl,
   toBareImageUrlMessages
-} from "./chunk-ASZ2C44S.js";
+} from "./chunk-LPEUV5RE.js";
 import {
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan,
   shouldStripReasoningContentForOutbound,
   toOpenAiCompatibleMessages
-} from "./chunk-KFEVY3ST.js";
-import {
-  buildProviderAuthHeaders,
-  buildProviderExecutionPlan
-} from "./chunk-ZVDRAEZL.js";
+} from "./chunk-6EVITP2G.js";
 import {
   canonicalizeToolName,
   createGlob,
   resolveExecutableOnPath
-} from "./chunk-B4KT7RN2.js";
+} from "./chunk-JTMNCCWF.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -88,10 +85,6 @@ function parseSseDataLineJson(line) {
     return null;
   }
 }
-function parseSseDataLineObject(line) {
-  const parsed = parseSseDataLineJson(line);
-  return parsed && typeof parsed === "object" ? parsed : null;
-}
 
 // packages/agent-runtime/openAiCompatibleProvider.ts
 function buildOpenAiCompatibleChatCompletionRequest(args) {
@@ -167,7 +160,6 @@ async function readOpenAiCompatibleSseCompletion(args) {
     usage: void 0,
     accumulatedToolCalls: createToolCallAccumulator(),
     thinkState: createThinkParserState(),
-    toolCallTextState: createToolCallTextParserState(),
     onTextDelta: args.onTextDelta,
     onReasoningDelta: args.onReasoningDelta
   };
@@ -841,16 +833,12 @@ var buildCombinedShellInput = (args) => {
     typeof args.input === "string" ? args.input : ""
   ].filter(Boolean).join("\n");
 };
-function resolveScannableShellInput(args) {
+function isDestructiveShellCommand(args) {
   const combined = buildCombinedShellInput(args);
-  if (!combined.trim()) return void 0;
-  return SHELL_STRING_EXECUTION_PATTERNS.some(
+  if (!combined.trim()) return false;
+  const scannable = SHELL_STRING_EXECUTION_PATTERNS.some(
     (pattern) => pattern.test(combined)
   ) ? combined : stripQuotedSegments(combined);
-}
-function isDestructiveShellCommand(args) {
-  const scannable = resolveScannableShellInput(args);
-  if (scannable === void 0) return false;
   return SHELL_DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(scannable));
 }
 var LONG_RUNNING_COMMAND_PATTERNS = [
@@ -866,42 +854,13 @@ var LONG_RUNNING_COMMAND_PATTERNS = [
   /\bpm2\b.*\bstart\b/i
 ];
 function isLongRunningShellCommand(args) {
-  const scannable = resolveScannableShellInput(args);
-  if (scannable === void 0) return false;
+  const combined = buildCombinedShellInput(args);
+  if (!combined.trim()) return false;
+  const scannable = SHELL_STRING_EXECUTION_PATTERNS.some(
+    (pattern) => pattern.test(combined)
+  ) ? combined : stripQuotedSegments(combined);
   return LONG_RUNNING_COMMAND_PATTERNS.some((pattern) => pattern.test(scannable));
 }
-var IMMEDIATE_DETACH_COMMAND_PATTERNS = [
-  /\btail\s+(?:-\S*[fF]\S*|--follow)\b/,
-  /\bwatch\s+\S/,
-  /\bwhile\s+(?:true|:|\[\s*true\s*\])\s*;\s*do\b/
-];
-var IMMEDIATE_DETACH_SLEEP_THRESHOLD_SECONDS = 5;
-var SLEEP_PREFIX_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:nohup\s+|time\s+)*sleep\s+(\S+)/;
-function parseSleepDurationSeconds(token) {
-  const match = /^(\d+(?:\.\d+)?)(s|m|h|d)?$/i.exec(token);
-  if (!match) return void 0;
-  const value = Number(match[1]);
-  if (!Number.isFinite(value)) return void 0;
-  const unit = (match[2] ?? "s").toLowerCase();
-  const factor = unit === "m" ? 60 : unit === "h" ? 3600 : unit === "d" ? 86400 : 1;
-  return value * factor;
-}
-function isLongSleepCommand(scannable) {
-  const match = SLEEP_PREFIX_PATTERN.exec(scannable.trim());
-  if (!match) return false;
-  const durationToken = match[1] ?? "";
-  if (/^inf(inity)?$/i.test(durationToken)) return true;
-  const seconds = parseSleepDurationSeconds(durationToken);
-  if (seconds === void 0) return true;
-  return seconds > IMMEDIATE_DETACH_SLEEP_THRESHOLD_SECONDS;
-}
-function isImmediateDetachShellCommand(args) {
-  const scannable = resolveScannableShellInput(args);
-  if (scannable === void 0) return false;
-  return isLongSleepCommand(scannable) || LONG_RUNNING_COMMAND_PATTERNS.some((pattern) => pattern.test(scannable)) || IMMEDIATE_DETACH_COMMAND_PATTERNS.some(
-    (pattern) => pattern.test(scannable)
-  );
-}
 function evaluateShellCommandPolicy(args) {
   if (isDestructiveShellCommand(args) && !hasExplicitDestructivePermission(args.userInput)) {
     return {
@@ -1584,7 +1543,7 @@ function buildExecShellTool(toolName) {
     type: "function",
     function: {
       name: toolName,
-      description: "Run a shell command in the local workspace. Commands already execute from the workspace root; do not cd into guessed paths such as /workspace, /repo, /home/user, or /home/user/workspace. Prefer one command that performs a complete verification or related git operation instead of many tiny commands. For branch setup, prefer idempotent commands such as git switch -C <branch> when replacing or recreating a benchmark branch is acceptable. Use portable POSIX commands for macOS/BSD shells; avoid GNU-only flags such as cat -A. Do not use cat -A. Do not use brittle byte-offset commands such as xxd -s -32. For separator lines, use echo or printf '%s\\n'. For text-file content or trailing-newline checks, prefer readFile over shell byte inspection when that tool is available. Do not run repeated git status, git log, git rev-parse, or branch checks after a successful command already returned the needed clean status and commit information; use one final verification command. If a command fails, use the error output to adjust the next command rather than repeating the same shape. For long-running commands that should keep running in the background (dev servers, watchers, REPLs, `--watch`/`serve`/`dev` scripts), prefer launchProcess. Obviously long-running commands run via execShell (sleep over 5s, tail -f, watch, infinite loops, dev/serve/watch scripts) are moved to the background automatically and return {detached: true, pid, label} \u2014 use listProcesses to inspect or stop them, and tell the user the command is running in the background. Any other command blocks until it exits, so keep those short.",
+      description: "Run a shell command in the local workspace. Commands already execute from the workspace root; do not cd into guessed paths such as /workspace, /repo, /home/user, or /home/user/workspace. Prefer one command that performs a complete verification or related git operation instead of many tiny commands. For branch setup, prefer idempotent commands such as git switch -C <branch> when replacing or recreating a benchmark branch is acceptable. Use portable POSIX commands for macOS/BSD shells; avoid GNU-only flags such as cat -A. Do not use cat -A. Do not use brittle byte-offset commands such as xxd -s -32. For separator lines, use echo or printf '%s\\n'. For text-file content or trailing-newline checks, prefer readFile over shell byte inspection when that tool is available. Do not run repeated git status, git log, git rev-parse, or branch checks after a successful command already returned the needed clean status and commit information; use one final verification command. If a command fails, use the error output to adjust the next command rather than repeating the same shape. For long-running commands that should keep running in the background (dev servers, watchers, REPLs, `--watch`/`serve`/`dev` scripts), use launchProcess instead \u2014 execShell blocks until the command exits and will freeze the conversation.",
       parameters: {
         type: "object",
         properties: {
@@ -1781,9 +1740,8 @@ function resolveExecShellTimeoutMs(override) {
   return asOptionalPositiveFiniteNumber(Number(raw));
 }
 function resolveDetachMs(override) {
-  if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
-    return override;
-  }
+  const fromOverride = asOptionalPositiveFiniteNumber(override);
+  if (fromOverride !== void 0) return fromOverride;
   const raw = process.env[EXEC_SHELL_DETACH_ENV];
   if (raw === void 0) return DEFAULT_EXEC_SHELL_DETACH_MS;
   const parsed = asOptionalPositiveFiniteNumber(Number(raw));
@@ -2547,9 +2505,9 @@ async function runWorkspaceCommand(args) {
     args.abortSignal.addEventListener("abort", abortListener, { once: true });
   }) : null;
   const effectiveDetachMs = resolveDetachMs(args.detachMs);
-  const detachPromise = new Promise((r) => {
+  const detachPromise = effectiveDetachMs ? new Promise((r) => {
     detachTimer = setTimeout(() => r(detachResult), effectiveDetachMs);
-  });
+  }) : null;
   const racers = [exitPromise];
   if (timeoutMs) {
     racers.push(
@@ -2559,7 +2517,7 @@ async function runWorkspaceCommand(args) {
     );
   }
   if (abortPromise) racers.push(abortPromise);
-  racers.push(detachPromise);
+  if (detachPromise) racers.push(detachPromise);
   let raceWinner;
   try {
     raceWinner = await Promise.race(racers);
@@ -2592,35 +2550,25 @@ async function runWorkspaceCommand(args) {
     killChild("SIGKILL");
   }
   if (didDetach) {
-    exitPromise.catch(() => {
-    });
+    detachSignalCleanup();
     const pid = typeof proc.pid === "number" ? proc.pid : 0;
     const label = deriveLabel(args.command.join(" "));
     const pgid = pid;
     const registry2 = getProcessRegistry();
     registry2.add({ pid, pgid, command: args.command.join(" "), label });
     proc.on("close", (code) => {
-      detachSignalCleanup();
       registry2.markExited(pid, code ?? 1);
     });
-    const immediate = effectiveDetachMs === 0;
-    const reason = immediate ? `command looks long-running; moved to background immediately (pid=${pid}, label=${label})` : `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})`;
     return {
       stdout: "",
-      stderr: `${reason}
-Use listProcesses to inspect or stop it.`,
+      stderr: `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})
+Use listProcesses / processRegistry to inspect.`,
       exitCode: 0,
       timedOut: false,
       detached: true,
       pid,
       label,
-      content: JSON.stringify({
-        detached: true,
-        pid,
-        label,
-        status: "running",
-        ...immediate ? { reason: "long-running-command" } : {}
-      })
+      content: JSON.stringify({ detached: true, pid, label, status: "running" })
     };
   }
   const [stdout, rawStderr] = await Promise.all([
@@ -3452,11 +3400,7 @@ async function execShellTool(args) {
     outputLimit: args.commandOutputLimit,
     commandPrefix: args.commandPrefix,
     abortSignal: args.abortSignal,
-    // Commands that clearly never exit (long sleeps, tail -f, watch, dev
-    // servers, infinite loops) are promoted to background immediately so the
-    // turn — and the user's conversation — keeps going. Everything else keeps
-    // the caller/env detach grace window.
-    detachMs: isImmediateDetachShellCommand({ command }) ? 0 : args.detachMs
+    detachMs: args.detachMs
   });
   const activity = extractActivity(parsed);
   return {
@@ -3630,7 +3574,6 @@ function createLocalWorkspaceToolExecutors(args) {
 
 export {
   parseSseDataLineJson,
-  parseSseDataLineObject,
   buildOpenAiCompatibleChatCompletionRequest,
   parseOpenAiCompatibleChatCompletionResponse,
   readOpenAiCompatibleSseCompletion,