@iinm/plain-agent 1.11.4 → 1.11.6

package/README.md

@@ -3,7 +3,7 @@
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/iinm/plain-agent)
 [![npm version](https://img.shields.io/npm/v/@iinm/plain-agent)](https://www.npmjs.com/package/@iinm/plain-agent)
 [![install size](https://packagephobia.com/badge?p=@iinm/plain-agent)](https://packagephobia.com/result?p=@iinm/plain-agent)
-[![Socket Badge](https://badge.socket.dev/npm/package/@iinm/plain-agent/1.11.4)](https://socket.dev/npm/package/@iinm/plain-agent)
+[![Socket Badge](https://badge.socket.dev/npm/package/@iinm/plain-agent/1.11.6)](https://socket.dev/npm/package/@iinm/plain-agent)
 [![CodeQL](https://github.com/iinm/plain-agent/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/iinm/plain-agent/actions/workflows/github-code-scanning/codeql)
 
 A lightweight terminal-based coding agent focused on safety and low token cost

package/config/config.predefined.json

@@ -1676,7 +1676,7 @@
     },
 
     {
-      "name": "minimax-m2.7",
+      "name": "minimax-m3",
       "variant": "fireworks",
       "platform": {
         "name": "openai-compatible",
@@ -1685,30 +1685,7 @@
       "model": {
         "format": "openai-messages",
         "config": {
-          "model": "accounts/fireworks/models/minimax-m2p7"
-        }
-      },
-      "cost": {
-        "currency": "USD",
-        "unit": "1M",
-        "prices": {
-          "prompt_tokens": 0.3,
-          "prompt_tokens_details.cached_tokens": -0.24,
-          "completion_tokens": 1.2
-        }
-      }
-    },
-    {
-      "name": "minimax-m2.7",
-      "variant": "novita",
-      "platform": {
-        "name": "openai-compatible",
-        "variant": "novita"
-      },
-      "model": {
-        "format": "openai-messages",
-        "config": {
-          "model": "minimax/minimax-m2.7"
+          "model": "accounts/fireworks/models/minimax-m3"
         }
       },
       "cost": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.11.4",
+  "version": "1.11.6",
   "description": "A lightweight terminal-based coding agent focused on safety and low token cost",
   "license": "MIT",
   "type": "module",

package/src/cli/formatter.mjs

@@ -18,6 +18,9 @@ import { noThrow } from "../utils/noThrow.mjs";
 /** Length above which a single-line arg forces block-form rendering. */
 const ARG_BLOCK_LENGTH_THRESHOLD = 60;
 
+/** Total JSON length above which args are rendered in block form even if each individual arg is short. */
+const ARGS_TOTAL_BLOCK_LENGTH_THRESHOLD = 160;
+
 /**
  * Format an args array for display.
  * Uses compact JSON for short single-line args; switches to a YAML-style
@@ -27,18 +30,20 @@ const ARG_BLOCK_LENGTH_THRESHOLD = 60;
  * @param {unknown} args
  * @returns {string}
  */
-export function formatArgs(args) {
+export function formatCommandArgs(args) {
   if (!Array.isArray(args) || args.length === 0) {
     return `args: ${JSON.stringify(args ?? [])}`;
   }
 
-  const needsBlock = args.some(
-    (a) =>
-      typeof a === "string" &&
-      (a.includes("\n") || a.length > ARG_BLOCK_LENGTH_THRESHOLD),
-  );
+  const needsBlock =
+    JSON.stringify(args).length > ARGS_TOTAL_BLOCK_LENGTH_THRESHOLD ||
+    args.some(
+      (a) =>
+        typeof a === "string" &&
+        (a.includes("\n") || a.length > ARG_BLOCK_LENGTH_THRESHOLD),
+    );
   if (!needsBlock) {
-    return `args: ${JSON.stringify(args)}`;
+    return `args: ${highlightCommandArgs(JSON.stringify(args))}`;
   }
 
   const lines = ["args:"];
@@ -49,30 +54,60 @@ export function formatArgs(args) {
     ) {
       lines.push("  - |");
       for (const line of arg.split("\n")) {
-        lines.push(`      ${line}`);
+        lines.push(`      ${highlightCommandArgs(line)}`);
       }
     } else {
-      lines.push(`  - ${JSON.stringify(arg)}`);
+      lines.push(`  - ${highlightCommandArgs(JSON.stringify(arg))}`);
     }
   }
   return lines.join("\n");
 }
 
+/**
+ * @param {string} args
+ * @returns {string}
+ */
+function highlightCommandArgs(args) {
+  return (
+    args
+      // --foo
+      .replace(
+        /(^|\s|")(--[a-zA-Z0-9-]+)(\s|"|$)/gm,
+        (_, p1, p2, p3) => p1 + styleText("cyan", p2) + p3,
+      )
+      // -f
+      .replace(
+        /(^|\s|")(-[a-zA-Z]+)(\s|"|$)/gm,
+        (_, p1, p2, p3) => p1 + styleText("cyan", p2) + p3,
+      )
+  );
+}
+
+/**
+ * @import { SandboxModeProvider } from "../tool"
+ */
+
 /**
  * Format tool use for display.
  * @param {MessageContentToolUse} toolUse
+ * @param {{ execCommandTool?: SandboxModeProvider }} [options]
  * @returns {Promise<string>}
  */
-export async function formatToolUse(toolUse) {
+export async function formatToolUse(toolUse, options = {}) {
   const { toolName, input } = toolUse;
 
   if (toolName === "exec_command") {
     /** @type {Partial<ExecCommandInput>} */
     const execCommandInput = input;
+    const mode = options.execCommandTool?.getSandboxMode?.(input);
+    const toolNameLine =
+      mode === "unsandboxed"
+        ? `${toolName}${styleText("yellow", " [unsandboxed]")}`
+        : toolName;
     return [
-      `${toolName}`,
+      toolNameLine,
       `command: ${JSON.stringify(execCommandInput.command)}`,
-      formatArgs(execCommandInput.args),
+      formatCommandArgs(execCommandInput.args),
     ].join("\n");
   }
 
@@ -117,7 +152,7 @@ export async function formatToolUse(toolUse) {
     return [
       `${toolName}`,
       `command: ${tmuxCommandInput.command}`,
-      formatArgs(tmuxCommandInput.args),
+      formatCommandArgs(tmuxCommandInput.args),
     ].join("\n");
   }
 
@@ -355,9 +390,10 @@ export function formatCostForBatch(summary) {
 /**
  * Print a message to the console.
  * @param {Message} message
+ * @param {{ execCommandTool?: SandboxModeProvider }} [options]
  * @returns {Promise<void>}
  */
-export async function printMessage(message) {
+export async function printMessage(message, options = {}) {
   switch (message.role) {
     case "assistant": {
       // console.log(styleText("bold", "\nAgent:"));
@@ -366,7 +402,7 @@ export async function printMessage(message) {
         (part) => part.type === "tool_use",
       );
       const formattedToolUses = await Promise.all(
-        toolUseParts.map((part) => formatToolUse(part)),
+        toolUseParts.map((part) => formatToolUse(part, options)),
       );
       let toolUseIndex = 0;
       for (const part of message.content) {
@@ -385,7 +421,7 @@ export async function printMessage(message) {
           //   console.log(part.text);
           //   break;
           case "tool_use":
-            console.log(styleText("bold", "\nTool call:"));
+            console.log(styleText("bold", "\nTool use:"));
             console.log(formattedToolUses[toolUseIndex++]);
             break;
         }

package/src/cli/interactive.mjs

@@ -1,6 +1,7 @@
 /**
  * @import { UserEventEmitter, AgentEventEmitter, AgentCommands } from "../agent"
  * @import { ClaudeCodePlugin } from "../claudeCodePlugin.mjs"
+ * @import { Tool, SandboxModeProvider } from "../tool"
  * @import { VoiceInputConfig } from "../voice/input.mjs"
  * @import { VoiceSession } from "../voice/session.mjs"
  */
@@ -67,6 +68,7 @@ const HELP_MESSAGE = [
  * @property {() => Promise<void>} onStop
  * @property {ClaudeCodePlugin[]} [claudeCodePlugins]
  * @property {VoiceInputConfig} [voiceInput]
+ * @property {Tool & SandboxModeProvider} [execCommandTool]
  */
 
 /**
@@ -111,6 +113,7 @@ export function startInteractiveSession({
   onStop,
   claudeCodePlugins,
   voiceInput,
+  execCommandTool,
 }) {
   /** @type {{ turn: boolean, multiLineBuffer: string[] | null, subagentName: string, toolSpinnerIndex: number, toolSpinnerLastTime: number }} */
   const state = {
@@ -517,7 +520,7 @@ export function startInteractiveSession({
 
   agentEventEmitter.on("message", (message) => {
     enqueueOutput(() =>
-      printMessage(message).catch((err) => {
+      printMessage(message, { execCommandTool }).catch((err) => {
         console.error(
           styleText("red", `Error rendering message: ${err.message}`),
         );

package/src/main.mjs

@@ -308,8 +308,9 @@ export async function main(argv = process.argv) {
     skills: Array.from(prompts.values()).filter((p) => p.isSkill),
   });
 
+  const execCommandTool = createExecCommandTool({ sandbox: appConfig.sandbox });
   const builtinTools = [
-    createExecCommandTool({ sandbox: appConfig.sandbox }),
+    execCommandTool,
     readFileTool,
     writeFileTool,
     createPatchFileTool(),
@@ -443,6 +444,7 @@ export async function main(argv = process.argv) {
   } else {
     startInteractiveSession({
       ...sessionOptions,
+      execCommandTool,
       notifyCmd: appConfig.notifyCmd,
       claudeCodePlugins: resolvePluginPaths(appConfig.claudeCodePlugins ?? []),
       voiceInput: appConfig.voiceInput,

package/src/providers/anthropic.mjs

@@ -145,7 +145,7 @@ export async function callAnthropicModel(
 
     const response = await runFetch();
 
-    if (response.status === 429 || response.status >= 500) {
+    if ((response.status === 429 || response.status >= 500) && retryCount < 5) {
       const interval = Math.min(2 * 2 ** retryCount, 16);
       console.error(
         styleText(

package/src/providers/bedrock.mjs

@@ -107,7 +107,7 @@ export async function callBedrockConverseModel(
         (response.status === 429 ||
           response.status === 502 ||
           response.status === 503) &&
-        retryCount < 3
+        retryCount < 5
       ) {
         const retryInterval = Math.min(2 * 2 ** retryCount, 16);
         console.error(

package/src/providers/gemini.mjs

@@ -145,7 +145,10 @@ export function createCacheEnabledGeminiModelCaller(
         signal: AbortSignal.timeout(8 * 60 * 1000),
       });
 
-      if (response.status === 429 || response.status >= 500) {
+      if (
+        (response.status === 429 || response.status >= 500) &&
+        retryCount < 5
+      ) {
         const interval = Math.min(2 * 2 ** retryCount, 16);
         console.error(
           styleText(
@@ -219,15 +222,20 @@ export function createCacheEnabledGeminiModelCaller(
         message instanceof GeminiNoCandidateError ||
         message instanceof GeminiMalformedFunctionCallError
       ) {
-        const interval = Math.min(2 * 2 ** retryCount, 16);
-        console.error(
-          styleText(
-            "yellow",
-            `${message.name}: Retrying in ${interval} seconds...`,
-          ),
+        if (retryCount < 5) {
+          const interval = Math.min(2 * 2 ** retryCount, 16);
+          console.error(
+            styleText(
+              "yellow",
+              `${message.name}: Retrying in ${interval} seconds...`,
+            ),
+          );
+          await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+          return modelCaller(config, input, retryCount + 1);
+        }
+        return new Error(
+          `${message.name}: Retry limit (${retryCount}) exceeded: ${message.message}`,
         );
-        await new Promise((resolve) => setTimeout(resolve, interval * 1000));
-        return modelCaller(config, input, retryCount + 1);
       }
 
       // Create context cache for next request

package/src/providers/openai.mjs

@@ -68,7 +68,7 @@ export async function callOpenAIModel(
     });
 
     const retryInterval = Math.min(2 * 2 ** retryCount, 16);
-    if (response.status === 429 || response.status >= 500) {
+    if ((response.status === 429 || response.status >= 500) && retryCount < 5) {
       console.error(
         styleText(
           "yellow",

package/src/providers/openaiCompatible.mjs

@@ -179,7 +179,7 @@ export async function callOpenAICompatibleModel(
       maxAttempt: 5,
     });
 
-    if (response.status === 429 || response.status >= 500) {
+    if ((response.status === 429 || response.status >= 500) && retryCount < 5) {
       console.error(
         styleText(
           "yellow",
@@ -236,18 +236,25 @@ export async function callOpenAICompatibleModel(
 
     const chatCompletion = convertOpenAIStreamDataToChatCompletion(dataList);
     if (chatCompletion instanceof Error) {
-      console.error(
-        styleText(
-          "yellow",
-          `Failed to process stream: ${chatCompletion.message}; Retry in ${retryInterval} seconds...`,
-        ),
-      );
-      await new Promise((resolve) => setTimeout(resolve, retryInterval * 1000));
-      return callOpenAICompatibleModel(
-        platformConfig,
-        modelConfig,
-        input,
-        retryCount + 1,
+      if (retryCount < 5) {
+        console.error(
+          styleText(
+            "yellow",
+            `Failed to process stream: ${chatCompletion.message}; Retry in ${retryInterval} seconds...`,
+          ),
+        );
+        await new Promise((resolve) =>
+          setTimeout(resolve, retryInterval * 1000),
+        );
+        return callOpenAICompatibleModel(
+          platformConfig,
+          modelConfig,
+          input,
+          retryCount + 1,
+        );
+      }
+      throw new Error(
+        `Failed to process OpenAI compatible stream after ${retryCount} retries: ${chatCompletion.message}`,
       );
     }
 

package/src/tool.d.ts

@@ -10,6 +10,20 @@ export type Tool = {
   injectImpl?: (impl: ToolImplementation) => void;
 };
 
+export type SandboxMode = "sandbox" | "unsandboxed" | null;
+
+/**
+ * Implemented by tools that can report the sandbox mode for a given input.
+ * - `null` if the tool has no sandbox configuration
+ * - `"unsandboxed"` if a sandbox rule matched with `mode: "unsandboxed"`
+ * - `"sandbox"` otherwise (sandbox config exists, default execution is sandboxed)
+ * Used by the CLI to display an `[unsandboxed]` badge for tool calls that
+ * will execute outside the sandbox.
+ */
+export type SandboxModeProvider = {
+  getSandboxMode: (input: unknown) => SandboxMode;
+};
+
 export type ToolDefinition = {
   name: string;
   description: string;

package/src/tools/execCommand.mjs

@@ -1,5 +1,5 @@
 /**
- * @import { Tool } from '../tool'
+ * @import { Tool, SandboxModeProvider } from '../tool'
  * @import { ExecCommandConfig, ExecCommandInput, ExecCommandSanboxConfig } from './execCommand'
  */
 
@@ -13,10 +13,10 @@ const OUTPUT_TRUNCATED_LENGTH = 1024 * 2;
 
 /**
  * @param {ExecCommandConfig=} config
- * @returns {Tool}
+ * @returns {Tool & SandboxModeProvider}
  */
 export function createExecCommandTool(config) {
-  /** @type {Tool} */
+  /** @type {Tool & SandboxModeProvider} */
   return {
     def: {
       name: "exec_command",
@@ -190,6 +190,21 @@ Examples:
           child.stdin?.end();
         });
       }),
+
+    /**
+     * Report the sandbox mode for a given tool input. Mirrors
+     * `rewriteInputForSandbox`'s rule-matching logic so the CLI can preview
+     * the mode before execution.
+     * @param {unknown} input
+     * @returns {"sandbox" | "unsandboxed" | null}
+     */
+    getSandboxMode: (input) => {
+      if (!config?.sandbox) return null;
+      const matchedRule = (config.sandbox.rules || []).find((rule) =>
+        matchValue(/** @type {ExecCommandInput} */ (input), rule.pattern),
+      );
+      return matchedRule?.mode === "unsandboxed" ? "unsandboxed" : "sandbox";
+    },
   };
 }