@testdriverai/mcp 7.9.174-test → 7.9.176-test

package/agent/lib/sandbox.js

@@ -6,6 +6,17 @@ const { version } = require("../../package.json");
 const { withRetry, getSentryTraceHeaders } = require("./sdk");
 const sentry = require("../../lib/sentry");
 
+// How long (ms) to keep polling for a free concurrency slot before giving up.
+// Configurable via TD_CONCURRENCY_MAX_WAIT (in seconds). Defaults to 60s.
+// A value of 0 (or negative) disables polling entirely — fail on first denial.
+function resolveConcurrencyMaxWait() {
+  var raw = process.env.TD_CONCURRENCY_MAX_WAIT;
+  if (raw === undefined || raw === "") return 60000;
+  var seconds = Number(raw);
+  if (!Number.isFinite(seconds) || seconds < 0) return 60000;
+  return Math.round(seconds * 1000);
+}
+
 const createSandbox = function (emitter, analytics, sessionInstance) {
   class Sandbox {
     constructor() {
@@ -463,6 +474,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
      */
     async _httpPostWithConcurrencyRetry(path, body, timeout) {
       var concurrencyRetryInterval = 10000; // 10 seconds between concurrency retries
+      var concurrencyMaxWait = resolveConcurrencyMaxWait(); // give up polling for a slot after this many ms
       var startTime = Date.now();
       var sessionId = this.sessionInstance ? this.sessionInstance.get() : null;
 
@@ -506,6 +518,15 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           var responseData = err.response && err.response.data;
           if (responseData && responseData.errorCode === "CONCURRENCY_LIMIT_EXCEEDED") {
             var elapsed = Date.now() - startTime;
+            if (elapsed >= concurrencyMaxWait) {
+              var giveUpErr = new Error(
+                (responseData.errorMessage || responseData.message || "Concurrency limit reached") +
+                " — gave up after " + Math.round(elapsed / 1000) + "s " +
+                "(max wait " + (concurrencyMaxWait / 1000) + "s).",
+              );
+              giveUpErr.responseData = responseData;
+              throw giveUpErr;
+            }
             logger.log(
               "Concurrency limit reached — waiting " +
               concurrencyRetryInterval / 1000 +
@@ -614,6 +635,10 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       // On slot-denied, we poll forever (re-calling authenticate every 10s)
       // until a slot opens, matching _httpPostWithConcurrencyRetry behavior.
       var concurrencyRetryInterval = 10000;
+      // Overall cap on how long we'll keep polling for a free slot before
+      // giving up. Keeps a queued agent from hanging forever when the account
+      // is at its concurrency limit. Configurable via TD_CONCURRENCY_MAX_WAIT.
+      var concurrencyMaxWait = resolveConcurrencyMaxWait();
       var slotPollStart = Date.now();
       while (reply.status === 'pending') {
         logger.log('Slot claim pending — waiting for approval via Ably...');
@@ -689,6 +714,21 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           // Slot denied — disconnect Ably and re-try the full authenticate
           // flow after a delay, polling forever until a slot opens.
           var elapsed = Date.now() - slotPollStart;
+          if (elapsed >= concurrencyMaxWait) {
+            try {
+              if (this._ably) this._ably.close();
+              this._ably = null;
+              this._sessionChannel = null;
+            } catch (_) {}
+            var giveUpErr = new Error(
+              'Slot denied: ' + (slotDecision.data.message || 'concurrency limit reached') +
+              ' — gave up after ' + Math.round(elapsed / 1000) + 's ' +
+              '(max wait ' + (concurrencyMaxWait / 1000) + 's). ' +
+              'Upgrade for more slots → https://console.testdriver.ai/checkout/team'
+            );
+            giveUpErr.responseData = slotDecision.data;
+            throw giveUpErr;
+          }
           logger.log(
             'Slot denied: ' + (slotDecision.data.message || 'concurrency limit reached') +
             ' — waiting ' + (concurrencyRetryInterval / 1000) + 's before retrying' +

package/docs/v7/ci-cd.mdx

@@ -635,6 +635,47 @@ describe("Cross-platform tests", () => {
 });
 ```
 
+## Concurrency limits
+
+Your plan allows a fixed number of sandboxes running at once. When a test asks for
+a sandbox and you're already at that limit, the request is **queued** rather than
+failed immediately: the SDK waits for a slot to free up, retrying every 10 seconds,
+then proceeds automatically once one opens. This is what lets a parallel CI matrix
+(many jobs starting at once) work on a plan with fewer slots than jobs — the extra
+jobs simply wait their turn instead of erroring.
+
+By default the SDK waits up to **60 seconds** for a slot before giving up with a
+concurrency-limit error. Control that ceiling with `TD_CONCURRENCY_MAX_WAIT`:
+
+| Value | Behavior |
+| ----- | -------- |
+| _unset_ | Wait up to **60 seconds** (the default). |
+| `TD_CONCURRENCY_MAX_WAIT=300` | Wait up to **300 seconds** (5 minutes) before giving up. |
+| `TD_CONCURRENCY_MAX_WAIT=0` | **Don't queue** — fail on the first denial. |
+
+The value is **in seconds** (fractional values are allowed and rounded to the
+nearest millisecond). Any invalid or negative value falls back to the 60-second
+default. The wait applies per sandbox request, across both the initial allocation
+and the realtime slot-approval handshake.
+
+```yaml
+# Example: a large parallel matrix that may queue for a while.
+# Give each job up to 5 minutes to acquire a slot before failing.
+- name: Run TestDriver tests
+  env:
+    TD_API_KEY: ${{ secrets.TD_API_KEY }}
+    TD_CONCURRENCY_MAX_WAIT: "300"
+  run: npx vitest run
+```
+
+<Tip>
+Raise `TD_CONCURRENCY_MAX_WAIT` when you run more parallel jobs than your plan has
+slots and would rather they queue than fail. Set it to `0` when you'd prefer a job
+to **fail fast** on a busy account (e.g. a quick smoke test that shouldn't sit
+waiting). When jobs routinely give up waiting, that's the signal to
+[add more slots](https://console.testdriver.ai/checkout/team).
+</Tip>
+
 ## Viewing Results
 
 All test runs are automatically recorded and visible in your TestDriver dashboard at [console.testdriver.ai](https://console.testdriver.ai):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testdriverai/mcp",
-  "version": "7.9.174-test",
+  "version": "7.9.176-test",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",