@protolabsai/proto 0.49.0 → 0.51.0

package/cli.js

@@ -168684,7 +168684,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.49.0";
+  const version2 = "0.51.0";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -196940,6 +196940,7 @@ var init_GoalManager = __esm({
       }
       active;
       lastAchieved;
+      lastFailed;
       /**
        * Set a new goal. Replaces any active goal. Returns the created state.
        * Throws if the condition is empty or exceeds the length limit.
@@ -196991,6 +196992,24 @@ var init_GoalManager = __esm({
         debugLogger39.info(`Goal achieved after ${achieved.turnCount} turns: "${truncate2(achieved.condition, 60)}".`);
         return achieved;
       }
+      /**
+       * Mark the active goal as abandoned because the condition is impossible, and
+       * move it to `lastFailed`. Records the evaluator's reason so `/goal` can
+       * report why it stopped. Returns the failed record. No-op if no goal active.
+       */
+      markImpossible(reason) {
+        if (!this.active)
+          return void 0;
+        const failed = {
+          ...this.active,
+          lastReason: reason,
+          failedAt: Date.now()
+        };
+        this.lastFailed = failed;
+        this.active = void 0;
+        debugLogger39.info(`Goal abandoned as impossible after ${failed.turnCount} turns: "${truncate2(failed.condition, 60)}" (${truncate2(reason, 80)}).`);
+        return failed;
+      }
       /** Record that the agent completed a turn while the goal was active. */
       recordTurn() {
         if (this.active) {
@@ -197016,10 +197035,14 @@ var init_GoalManager = __esm({
       getLastAchievedGoal() {
         return this.lastAchieved ? { ...this.lastAchieved } : void 0;
       }
-      /** Reset both active and achieved state. Used on session clear/end. */
+      getLastFailedGoal() {
+        return this.lastFailed ? { ...this.lastFailed } : void 0;
+      }
+      /** Reset active, achieved, and failed state. Used on session clear/end. */
       reset() {
         this.active = void 0;
         this.lastAchieved = void 0;
+        this.lastFailed = void 0;
       }
     };
     __name(truncate2, "truncate");
@@ -197091,7 +197114,8 @@ function parseEvaluatorJson(text) {
     const parsed = JSON.parse(jsonObj);
     const met = parsed.met === true;
     const reason = typeof parsed.reason === "string" && parsed.reason.trim().length > 0 ? parsed.reason.trim() : met ? "Condition met." : "No reason provided.";
-    return { met, reason };
+    const impossible = !met && parsed.impossible === true;
+    return impossible ? { met, reason, impossible: true } : { met, reason };
   } catch {
     return {
       met: false,
@@ -197159,13 +197183,17 @@ var init_goalEvaluator = __esm({
 
 You only see what the assistant has surfaced in the transcript -- tool calls it ran, their outcomes, and the final assistant message. You do not run commands yourself.
 
-Respond ONLY with valid JSON matching exactly this schema:
-{"met": boolean, "reason": "one short sentence explaining why"}
+Respond ONLY with valid JSON matching one of these shapes:
+{"met": true, "reason": "one short sentence quoting the satisfying evidence"}
+{"met": false, "reason": "one short sentence on what is missing or blocking"}
+{"met": false, "impossible": true, "reason": "one short sentence on why it can never be satisfied"}
 
 Rules:
 - Set "met": true only when the condition is clearly demonstrated by the visible evidence (a test output, an exit code, a file count, an empty queue, etc.).
 - If the assistant only claims the work is done without showing evidence, set "met": false and ask for the missing evidence in "reason".
 - If the condition cannot be verified from what is shown, set "met": false and explain what would prove it in "reason".
+- Only set "impossible": true when the condition is genuinely unachievable in this session: it is self-contradictory, depends on an unavailable resource or capability, or the assistant has exhausted reasonable approaches and the transcript confirms there is no path forward. The assistant claiming the goal is impossible is evidence, not proof -- independently confirm it rather than deferring to the assistant's self-assessment. Do NOT set it just because progress is slow or evidence is currently missing. When in doubt, return {"met": false} without "impossible".
+- "impossible" is only meaningful alongside "met": false. Never set it when "met" is true.
 - Keep "reason" to one short sentence. It will be shown to the assistant as guidance for the next turn.`;
     __name(evaluateGoal, "evaluateGoal");
     __name(buildEvaluatorPrompt, "buildEvaluatorPrompt");
@@ -197801,6 +197829,9 @@ Please address these issues before finishing.`;
               goalManager.recordEvaluation(evalResult);
               if (evalResult.met) {
                 goalManager.markAchieved();
+              } else if (evalResult.impossible) {
+                goalManager.markImpossible(evalResult.reason);
+                this.config.getDebugLogger().info(`[goal] abandoned as impossible: ${evalResult.reason.slice(0, 120)}`);
               } else {
                 const continueReason = `Goal not yet met. Evaluator: ${evalResult.reason}
 
@@ -275245,6 +275276,7 @@ var init_config3 = __esm({
       ideMode;
       maxSessionTurns;
       maxToolCalls;
+      maxWallTimeSeconds;
       sessionTokenLimit;
       listExtensions;
       overrideExtensions;
@@ -275358,6 +275390,7 @@ var init_config3 = __esm({
         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;
@@ -275789,6 +275822,9 @@ var init_config3 = __esm({
       getMaxToolCalls() {
         return this.maxToolCalls;
       }
+      getMaxWallTimeSeconds() {
+        return this.maxWallTimeSeconds;
+      }
       getSessionTokenLimit() {
         return this.sessionTokenLimit;
       }
@@ -405867,6 +405903,15 @@ var SETTINGS_SCHEMA = {
         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",
@@ -415411,6 +415456,7 @@ async function handleQwenAuth(command2, options2) {
       sessionId: void 0,
       maxSessionTurns: void 0,
       maxToolCalls: void 0,
+      maxWallTime: void 0,
       coreTools: void 0,
       excludeTools: void 0,
       disabledSlashCommands: void 0,
@@ -416561,7 +416607,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.49.0";
+  return "0.51.0";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -420674,6 +420720,81 @@ 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;
@@ -421049,6 +421170,9 @@ async function parseArguments() {
     }).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,
@@ -421447,6 +421571,10 @@ async function loadCliConfig(settings2, argv, cwd6 = process.cwd(), overrideExte
     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,
@@ -424679,7 +424807,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "58b119575";
+var GIT_COMMIT_INFO = "922a31b17";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -428990,6 +429118,20 @@ function statusText(manager) {
     return lines.join("\n");
   }
   const achieved = manager.getLastAchievedGoal();
+  const failed = manager.getLastFailedGoal();
+  const achievedAt = achieved?.achievedAt ?? 0;
+  const failedAt = failed?.failedAt ?? 0;
+  if (failed && failedAt >= achievedAt && failedAt > 0) {
+    const elapsed = formatElapsed(failedAt - failed.startedAt);
+    const lines = [
+      `Last goal abandoned as impossible after ${elapsed} (${failed.turnCount} turn(s), ${failed.tokensSpent} eval tokens):`,
+      `  ${failed.condition}`
+    ];
+    if (failed.lastReason) {
+      lines.push(`Reason: ${failed.lastReason}`);
+    }
+    return lines.join("\n");
+  }
   if (achieved && achieved.achievedAt) {
     const elapsed = formatElapsed(achieved.achievedAt - achieved.startedAt);
     return [
@@ -436840,7 +436982,10 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
     const geminiClient = config2.getGeminiClient();
     const abortController = options2.abortController ?? new AbortController();
     const budgetEnforcer = new RunBudgetEnforcer(
-      { maxToolCalls: config2.getMaxToolCalls() },
+      {
+        maxToolCalls: config2.getMaxToolCalls(),
+        maxWallTimeSeconds: config2.getMaxWallTimeSeconds()
+      },
       abortController
     );
     const routeAbort = /* @__PURE__ */ __name(() => {
@@ -436966,6 +437111,9 @@ async function runNonInteractive(config2, settings2, input, prompt_id, options2
         if (config2.getMaxSessionTurns() >= 0 && turnCount > config2.getMaxSessionTurns()) {
           handleMaxTurnsExceededError(config2);
         }
+        if (abortController.signal.aborted) {
+          routeAbort();
+        }
         const toolCallRequests = [];
         const apiStartTime = Date.now();
         const responseStream = geminiClient.sendMessageStream(
@@ -437081,6 +437229,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) {
@@ -493447,7 +493599,7 @@ var QwenAgent = class {
   async initialize(args2) {
     this.clientCapabilities = args2.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.49.0";
+    const version2 = "0.51.0";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {

package/package.json

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