@protolabsai/proto 0.48.1 → 0.50.0

package/cli.js

@@ -19092,7 +19092,7 @@ function parseResponseData(error40) {
   }
   return error40.response?.data;
 }
-var FatalError, FatalAuthenticationError, FatalInputError, FatalSandboxError, FatalConfigError, FatalTurnLimitedError, FatalToolExecutionError, FatalCancellationError, ForbiddenError, UnauthorizedError, BadRequestError;
+var FatalError, FatalAuthenticationError, FatalInputError, FatalSandboxError, FatalConfigError, FatalTurnLimitedError, FatalToolExecutionError, FatalBudgetExceededError, FatalCancellationError, ForbiddenError, UnauthorizedError, BadRequestError;
 var init_errors = __esm({
   "packages/core/dist/src/utils/errors.js"() {
     "use strict";
@@ -19160,6 +19160,14 @@ var init_errors = __esm({
         super(message, 54);
       }
     };
+    FatalBudgetExceededError = class extends FatalError {
+      static {
+        __name(this, "FatalBudgetExceededError");
+      }
+      constructor(message) {
+        super(message, 55);
+      }
+    };
     FatalCancellationError = class extends FatalError {
       static {
         __name(this, "FatalCancellationError");
@@ -168676,7 +168684,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.48.1";
+  const version2 = "0.50.0";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -275236,6 +275244,8 @@ var init_config3 = __esm({
       folderTrust;
       ideMode;
       maxSessionTurns;
+      maxToolCalls;
+      maxWallTimeSeconds;
       sessionTokenLimit;
       listExtensions;
       overrideExtensions;
@@ -275348,6 +275358,8 @@ var init_config3 = __esm({
         this.fileDiscoveryService = params.fileDiscoveryService ?? null;
         this.bugCommand = params.bugCommand;
         this.maxSessionTurns = params.maxSessionTurns ?? -1;
+        this.maxToolCalls = params.maxToolCalls ?? -1;
+        this.maxWallTimeSeconds = params.maxWallTimeSeconds ?? -1;
         this.sessionTokenLimit = params.sessionTokenLimit ?? -1;
         this.experimentalZedIntegration = params.experimentalZedIntegration ?? false;
         this.cronEnabled = params.cronEnabled ?? false;
@@ -275776,6 +275788,12 @@ var init_config3 = __esm({
       getMaxSessionTurns() {
         return this.maxSessionTurns;
       }
+      getMaxToolCalls() {
+        return this.maxToolCalls;
+      }
+      getMaxWallTimeSeconds() {
+        return this.maxWallTimeSeconds;
+      }
       getSessionTokenLimit() {
         return this.sessionTokenLimit;
       }
@@ -288111,6 +288129,7 @@ __export(dist_exports, {
   ExtensionUpdateState: () => ExtensionUpdateState,
   FILE_MUTATING_TOOLS: () => FILE_MUTATING_TOOLS,
   FatalAuthenticationError: () => FatalAuthenticationError,
+  FatalBudgetExceededError: () => FatalBudgetExceededError,
   FatalCancellationError: () => FatalCancellationError,
   FatalConfigError: () => FatalConfigError,
   FatalError: () => FatalError,
@@ -405844,6 +405863,24 @@ var SETTINGS_SCHEMA = {
         description: "Maximum number of user/model/tool turns to keep in a session. -1 means unlimited.",
         showInDialog: false
       },
+      maxToolCalls: {
+        type: "number",
+        label: "Max Tool Calls",
+        category: "Model",
+        requiresRestart: false,
+        default: -1,
+        description: "Maximum number of tool calls for a headless run before aborting (exit code 55). -1 means unlimited.",
+        showInDialog: false
+      },
+      maxWallTimeSeconds: {
+        type: "number",
+        label: "Max Wall Time (seconds)",
+        category: "Model",
+        requiresRestart: false,
+        default: -1,
+        description: "Wall-clock budget in seconds for a headless run before aborting (exit code 55). -1 means unlimited.",
+        showInDialog: false
+      },
       chatCompression: {
         type: "object",
         label: "Chat Compression",
@@ -408902,6 +408939,17 @@ function handleMaxTurnsExceededError(config2) {
   }
 }
 __name(handleMaxTurnsExceededError, "handleMaxTurnsExceededError");
+function handleBudgetExceededError(config2, exceeded) {
+  const budgetError = new FatalBudgetExceededError(exceeded.message);
+  if (config2.getOutputFormat() === OutputFormat.JSON) {
+    const formatter = new JsonFormatter();
+    writeStderrLine(formatter.formatError(budgetError, budgetError.exitCode));
+  } else {
+    writeStderrLine(budgetError.message);
+  }
+  process.exit(budgetError.exitCode);
+}
+__name(handleBudgetExceededError, "handleBudgetExceededError");
 
 // packages/cli/src/commands/extensions/consent.ts
 init_esbuild_shims();
@@ -415376,6 +415424,8 @@ async function handleQwenAuth(command2, options2) {
       resume: void 0,
       sessionId: void 0,
       maxSessionTurns: void 0,
+      maxToolCalls: void 0,
+      maxWallTime: void 0,
       coreTools: void 0,
       excludeTools: void 0,
       disabledSlashCommands: void 0,
@@ -416526,7 +416576,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.48.1";
+  return "0.50.0";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -420634,6 +420684,179 @@ function buildWebSearchConfig(argv, settings2, authType) {
 }
 __name(buildWebSearchConfig, "buildWebSearchConfig");
 
+// packages/cli/src/utils/runBudget.ts
+init_esbuild_shims();
+var SECOND = 1e3;
+var MAX_TIMEOUT_MS = 2147483647;
+var MAX_WALL_TIME_SECONDS = Math.floor(MAX_TIMEOUT_MS / SECOND);
+var MIN_WALL_TIME_SECONDS = 1;
+function parseDurationSeconds(input) {
+  const trimmed2 = input.trim().toLowerCase();
+  if (trimmed2.length === 0) {
+    throw new Error("Invalid duration: empty string");
+  }
+  const match2 = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/.exec(trimmed2);
+  if (!match2) {
+    throw new Error(
+      `Invalid duration "${input}". Use a positive number of seconds (e.g. 90) or a duration with unit (e.g. 30s, 5m, 1h, 500ms).`
+    );
+  }
+  const value = Number.parseFloat(match2[1]);
+  const unit = match2[2] ?? "s";
+  let seconds;
+  switch (unit) {
+    case "ms":
+      seconds = value / 1e3;
+      break;
+    case "s":
+      seconds = value;
+      break;
+    case "m":
+      seconds = value * 60;
+      break;
+    case "h":
+      seconds = value * 3600;
+      break;
+    default:
+      throw new Error(`Invalid duration unit "${unit}"`);
+  }
+  if (seconds <= 0) {
+    throw new Error(
+      `Invalid duration "${input}": must be greater than zero. Omit the flag entirely if you don't want a wall-clock budget.`
+    );
+  }
+  if (seconds < MIN_WALL_TIME_SECONDS) {
+    const hint = /ms\b/i.test(trimmed2) ? ` (probably a typo \u2014 did you mean ${input.replace(/ms\b/i, "s")}?)` : "";
+    throw new Error(
+      `Invalid duration "${input}": below the ${MIN_WALL_TIME_SECONDS}s minimum${hint}. Sub-second wall-clock budgets fire before any model round-trip can complete.`
+    );
+  }
+  if (seconds > MAX_WALL_TIME_SECONDS) {
+    throw new Error(
+      `Invalid duration "${input}": exceeds the maximum supported wall-clock budget (${MAX_WALL_TIME_SECONDS}s \u2248 24 days). Use a smaller value.`
+    );
+  }
+  return seconds;
+}
+__name(parseDurationSeconds, "parseDurationSeconds");
+function validateMaxWallTimeSetting(value) {
+  if (value === -1) return -1;
+  if (!Number.isFinite(value)) {
+    throw new Error(
+      `model.maxWallTimeSeconds must be a finite number; got ${value}.`
+    );
+  }
+  if (value <= 0) {
+    throw new Error(
+      `model.maxWallTimeSeconds must be > 0 (or -1 for unlimited); got ${value}. Use -1 to disable, not 0.`
+    );
+  }
+  if (value < MIN_WALL_TIME_SECONDS) {
+    throw new Error(
+      `model.maxWallTimeSeconds ${value} is below the ${MIN_WALL_TIME_SECONDS}s minimum. Sub-second budgets fire before any model round-trip can complete.`
+    );
+  }
+  if (value > MAX_WALL_TIME_SECONDS) {
+    throw new Error(
+      `model.maxWallTimeSeconds ${value} exceeds the maximum supported wall-clock budget (${MAX_WALL_TIME_SECONDS}s \u2248 24 days).`
+    );
+  }
+  return value;
+}
+__name(validateMaxWallTimeSetting, "validateMaxWallTimeSetting");
+var MAX_TOOL_CALLS = 1e6;
+function validateMaxToolCalls(value) {
+  if (value === -1) return -1;
+  if (!Number.isFinite(value)) {
+    throw new Error(`maxToolCalls must be a finite number; got ${value}.`);
+  }
+  if (!Number.isInteger(value)) {
+    throw new Error(
+      `maxToolCalls must be an integer (or -1 for unlimited); got ${value}.`
+    );
+  }
+  if (value < 0) {
+    throw new Error(
+      `maxToolCalls must be >= 0 (or -1 for unlimited); got ${value}. Use -1 to disable, not a negative number.`
+    );
+  }
+  if (value > MAX_TOOL_CALLS) {
+    throw new Error(
+      `maxToolCalls ${value} exceeds the supported ceiling (${MAX_TOOL_CALLS}). Likely a typo \u2014 use a smaller value or -1 for unlimited.`
+    );
+  }
+  return value;
+}
+__name(validateMaxToolCalls, "validateMaxToolCalls");
+var RunBudgetEnforcer = class {
+  static {
+    __name(this, "RunBudgetEnforcer");
+  }
+  maxWallTimeSeconds;
+  maxToolCalls;
+  abortController;
+  wallTimer = null;
+  toolCallCount = 0;
+  exceeded = null;
+  constructor(opts, abortController) {
+    this.maxWallTimeSeconds = opts.maxWallTimeSeconds ?? -1;
+    this.maxToolCalls = opts.maxToolCalls ?? -1;
+    this.abortController = abortController;
+  }
+  /**
+   * Starts the wall-clock timer (if configured). Idempotent so callers
+   * don't need to thread "did I already start?" state.
+   */
+  start() {
+    if (this.wallTimer !== null) return;
+    if (this.maxWallTimeSeconds <= 0) return;
+    this.wallTimer = setTimeout(() => {
+      this.markExceeded({
+        kind: "wall-time",
+        limit: this.maxWallTimeSeconds,
+        observed: this.maxWallTimeSeconds,
+        message: `Run aborted: wall-clock budget of ${this.maxWallTimeSeconds}s exceeded (--max-wall-time).`
+      });
+    }, this.maxWallTimeSeconds * SECOND);
+    this.wallTimer.unref?.();
+  }
+  /** Records one tool execution and enforces `maxToolCalls`. */
+  tickToolCall() {
+    this.toolCallCount += 1;
+    if (this.maxToolCalls >= 0 && this.toolCallCount > this.maxToolCalls) {
+      this.markExceeded({
+        kind: "tool-calls",
+        limit: this.maxToolCalls,
+        observed: this.toolCallCount,
+        message: `Run aborted: tool-call budget of ${this.maxToolCalls} exceeded (--max-tool-calls); observed ${this.toolCallCount}.`
+      });
+    }
+  }
+  /**
+   * Returns the budget-exceeded record if one fired, else null. The
+   * non-interactive loop checks this after `abortController.signal`
+   * fires to distinguish "budget abort" from "user SIGINT" so it can
+   * emit a structured-error envelope with the right reason.
+   */
+  getExceeded() {
+    return this.exceeded;
+  }
+  /** Cancels the wall-clock timer. Safe to call multiple times. */
+  stop() {
+    if (this.wallTimer !== null) {
+      clearTimeout(this.wallTimer);
+      this.wallTimer = null;
+    }
+  }
+  markExceeded(record2) {
+    if (this.exceeded !== null) return;
+    if (this.abortController.signal.aborted) return;
+    this.exceeded = record2;
+    this.stop();
+    this.abortController.abort();
+  }
+};
+
 // packages/cli/src/config/config.ts
 var SESSION_ID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(-agent-[a-zA-Z0-9_.-]+)?$/i;
 function isValidSessionId(value) {
@@ -420913,6 +421136,12 @@ async function parseArguments() {
     }).option("max-session-turns", {
       type: "number",
       description: "Maximum number of session turns"
+    }).option("max-tool-calls", {
+      type: "number",
+      description: "Maximum number of tool calls for a headless run before aborting (exit code 55). Defaults to unlimited."
+    }).option("max-wall-time", {
+      type: "string",
+      description: "Wall-clock budget for a headless run before aborting (exit code 55). Accepts seconds or a unit suffix (e.g. 90, 30s, 5m, 1h). Defaults to unlimited."
     }).option("core-tools", {
       type: "array",
       string: true,
@@ -421308,6 +421537,13 @@ async function loadCliConfig(settings2, argv, cwd6 = process.cwd(), overrideExte
     outputLanguageFilePath,
     sessionTokenLimit: settings2.model?.sessionTokenLimit ?? -1,
     maxSessionTurns: argv.maxSessionTurns ?? settings2.model?.maxSessionTurns ?? -1,
+    maxToolCalls: validateMaxToolCalls(
+      argv.maxToolCalls ?? settings2.model?.maxToolCalls ?? -1
+    ),
+    // The CLI flag is a duration string (parsed/validated by
+    // parseDurationSeconds); the settings entry is a plain number of seconds
+    // (validated by validateMaxWallTimeSetting). Flag wins when both are set.
+    maxWallTimeSeconds: argv.maxWallTime !== void 0 ? parseDurationSeconds(argv.maxWallTime) : validateMaxWallTimeSetting(settings2.model?.maxWallTimeSeconds ?? -1),
     experimentalZedIntegration: argv.acp || argv.experimentalAcp || false,
     cronEnabled: settings2.experimental?.cron ?? false,
     listExtensions: argv.listExtensions || false,
@@ -424540,7 +424776,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "47108a5d6";
+var GIT_COMMIT_INFO = "8a7cb3843";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -436700,6 +436936,20 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
     }, "stdoutErrorHandler");
     const geminiClient = config2.getGeminiClient();
     const abortController = options2.abortController ?? new AbortController();
+    const budgetEnforcer = new RunBudgetEnforcer(
+      {
+        maxToolCalls: config2.getMaxToolCalls(),
+        maxWallTimeSeconds: config2.getMaxWallTimeSeconds()
+      },
+      abortController
+    );
+    const routeAbort = /* @__PURE__ */ __name(() => {
+      const exceeded = budgetEnforcer.getExceeded();
+      if (exceeded) {
+        handleBudgetExceededError(config2, exceeded);
+      }
+      handleCancellationError(config2);
+    }, "routeAbort");
     const authError = await checkAuthPreflight(config2);
     if (authError) {
       if (outputFormat === OutputFormat.JSON || outputFormat === OutputFormat.STREAM_JSON) {
@@ -436809,12 +437059,16 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
       }
       const initialParts = normalizePartList(initialPartList);
       let currentMessages = [{ role: "user", parts: initialParts }];
+      budgetEnforcer.start();
       let isFirstTurn = true;
       while (true) {
         turnCount++;
         if (config2.getMaxSessionTurns() >= 0 && turnCount > config2.getMaxSessionTurns()) {
           handleMaxTurnsExceededError(config2);
         }
+        if (abortController.signal.aborted) {
+          routeAbort();
+        }
         const toolCallRequests = [];
         const apiStartTime = Date.now();
         const responseStream = geminiClient.sendMessageStream(
@@ -436829,7 +437083,7 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
         adapter.startAssistantMessage();
         for await (const event of responseStream) {
           if (abortController.signal.aborted) {
-            handleCancellationError(config2);
+            routeAbort();
           }
           adapter.processEvent(event);
           if (event.type === GeminiEventType.ToolCallRequest) {
@@ -436862,6 +437116,10 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
               finalRequestInfo.callId,
               adapter
             ) : createToolProgressHandler(finalRequestInfo, adapter);
+            budgetEnforcer.tickToolCall();
+            if (abortController.signal.aborted) {
+              routeAbort();
+            }
             const toolResponse = await executeToolCall(
               config2,
               finalRequestInfo,
@@ -436926,6 +437184,10 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
                       adapter.startAssistantMessage();
                       for await (const event of cronStream) {
                         if (abortController.signal.aborted) {
+                          if (budgetEnforcer.getExceeded()) {
+                            scheduler.stop();
+                            routeAbort();
+                          }
                           const summary = scheduler.getExitSummary();
                           scheduler.stop();
                           if (summary) {
@@ -436950,6 +437212,10 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
                             requestInfo.callId,
                             adapter
                           ) : createToolProgressHandler(requestInfo, adapter);
+                          budgetEnforcer.tickToolCall();
+                          if (abortController.signal.aborted) {
+                            routeAbort();
+                          }
                           const toolResponse = await executeToolCall(
                             config2,
                             requestInfo,
@@ -437028,6 +437294,7 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
       });
       handleError(error40, config2);
     } finally {
+      budgetEnforcer.stop();
       process.stdout.removeListener("error", stdoutErrorHandler);
       process.removeListener("SIGINT", shutdownHandler);
       process.removeListener("SIGTERM", shutdownHandler);
@@ -461455,7 +461722,7 @@ var getStatusText = /* @__PURE__ */ __name((status) => {
       return "Unknown";
   }
 }, "getStatusText");
-var MAX_TOOL_CALLS = 5;
+var MAX_TOOL_CALLS2 = 5;
 var MAX_VERBOSE_TOOL_CALLS = 12;
 var MAX_TASK_PROMPT_LINES = 5;
 var DEFAULT_DETAIL_HEIGHT = 18;
@@ -461510,7 +461777,7 @@ var AgentExecutionDisplay = /* @__PURE__ */ __name(({
     Math.floor((renderableBudget - promptBudget) / ROWS_PER_TOOL_CALL)
   );
   const maxTaskPromptLines = displayMode === "verbose" ? Math.min(8, promptBudget) : Math.min(MAX_TASK_PROMPT_LINES, promptBudget);
-  const maxToolCalls = displayMode === "verbose" ? Math.min(MAX_VERBOSE_TOOL_CALLS, toolBudget) : Math.min(MAX_TOOL_CALLS, toolBudget);
+  const maxToolCalls = displayMode === "verbose" ? Math.min(MAX_VERBOSE_TOOL_CALLS, toolBudget) : Math.min(MAX_TOOL_CALLS2, toolBudget);
   const agentColor = (0, import_react62.useMemo)(() => {
     const colorOption = COLOR_OPTIONS.find(
       (option2) => option2.name === data.subagentColor
@@ -493287,7 +493554,7 @@ var QwenAgent = class {
   async initialize(args2) {
     this.clientCapabilities = args2.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.48.1";
+    const version2 = "0.50.0";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protolabsai/proto",
-  "version": "0.48.1",
+  "version": "0.50.0",
   "description": "proto - AI-powered coding agent",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "bundled"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.48.1"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.50.0"
   },
   "dependencies": {},
   "optionalDependencies": {