@mindstudio-ai/agent 0.1.133 → 0.1.134

package/dist/index.d.ts

@@ -380,7 +380,6 @@ interface UserInfoResult {
         userId: string;
         displayName: string;
         role: 'owner' | 'admin' | 'member' | 'guest' | 'agent';
-        isAgent: boolean;
     }[];
 }
 /**
@@ -745,13 +744,21 @@ interface RunAgentResult {
 }
 
 type AuthType = 'internal' | 'apiKey';
+/**
+ * Keeps an execution's calls within the server's concurrency limit, so a
+ * `Promise.all` over many steps queues here instead of being refused.
+ *
+ * The server's limits are per execution (per hook token), so the slots are
+ * too: each `runWithContext()` request gets its own, and a persistent sandbox
+ * worker's concurrent executions never wait on each other. Outside a request
+ * context (API-key use, or one execution per process) the instance holds one
+ * set. There is no call cap here: the server enforces it and answers 429 with
+ * `Retry-After`, which `http.ts` retries.
+ */
 declare class RateLimiter {
-    readonly authType: AuthType;
-    private inflight;
     private concurrencyLimit;
-    private callCount;
-    private callCap;
-    private queue;
+    private perRequest;
+    private shared;
     constructor(authType: AuthType);
     /** Acquire a slot. Resolves when a concurrent slot is available. */
     acquire(): Promise<void>;
@@ -759,11 +766,7 @@ declare class RateLimiter {
     release(): void;
     /** Update limits from response headers. */
     updateFromHeaders(headers: Headers): void;
-    /** Read current rate limit state from response headers. */
-    static parseHeaders(headers: Headers): {
-        remaining: number | undefined;
-        concurrencyRemaining: number | undefined;
-    };
+    private slots;
 }
 
 interface HttpClientConfig {
@@ -3980,9 +3983,9 @@ interface RunTaskResult<T = unknown> {
  * 5. `https://v1.mindstudio-api.com` (production default)
  *
  * Rate limiting is handled automatically:
- * - Concurrent requests are queued to stay within server limits
+ * - Concurrent requests are queued to stay within the server's concurrency
+ *   limit, per execution inside MindStudio
  * - 429 responses are retried automatically using the `Retry-After` header
- * - Internal (hook) tokens are capped at 500 calls per execution
  */
 declare class MindStudioAgent$1 {
     /** @internal */
@@ -4055,6 +4058,11 @@ declare class MindStudioAgent$1 {
      * ```
      */
     executeStep<TOutput = unknown>(stepType: string, step: Record<string, unknown>, options?: StepExecutionOptions): Promise<StepExecutionResult<TOutput>>;
+    /**
+     * @internal Async step execution — POST, then poll until the step finishes.
+     * Runs inside one concurrency slot (see `withSlot`).
+     */
+    private _executeStepPolled;
     /**
      * @internal Streaming step execution — sends `Accept: text/event-stream`
      * and parses SSE events for real-time debug logs.
@@ -4075,6 +4083,11 @@ declare class MindStudioAgent$1 {
      * ```
      */
     executeStepBatch(steps: BatchStepInput[], options?: ExecuteStepBatchOptions): Promise<ExecuteStepBatchResult>;
+    /**
+     * @internal Async batch execution — POST, then poll until the batch settles.
+     * Runs inside one concurrency slot (see `withSlot`).
+     */
+    private _executeStepBatchPolled;
     /**
      * Run a task agent — a multi-step tool-use loop that composes SDK actions
      * to produce structured output. The model receives the prompt and tools,

package/dist/index.js

@@ -23,17 +23,36 @@ var MindStudioError = class extends Error {
     };
   }
 };
+function errorCodeFrom(body, fallback) {
+  if (body == null || typeof body !== "object") {
+    return fallback;
+  }
+  const { code, errorString } = body;
+  if (typeof code === "string" && code) {
+    return code;
+  }
+  if (typeof errorString === "string" && /^\S+$/.test(errorString)) {
+    return errorString;
+  }
+  return fallback;
+}
 
 // src/http.ts
 async function request(config, method, path, body) {
-  const url = `${config.baseUrl}/developer/v2${path}`;
+  return withSlot(config, () => sendRequest(config, method, path, body));
+}
+async function withSlot(config, fn) {
   await config.rateLimiter.acquire();
   try {
-    return await requestWithRetry(config, method, url, body, 0);
+    return await fn();
   } finally {
     config.rateLimiter.release();
   }
 }
+async function sendRequest(config, method, path, body) {
+  const url = `${config.baseUrl}/developer/v2${path}`;
+  return requestWithRetry(config, method, url, body, 0);
+}
 async function requestWithRetry(config, method, url, body, attempt) {
   const res = await fetch(url, {
     method,
@@ -66,11 +85,7 @@ async function requestWithRetry(config, method, url, body, attempt) {
         } else if (body2.error || body2.message || body2.details) {
           message = JSON.stringify(body2.error ?? body2.message ?? body2.details);
         }
-        if (body2.code) {
-          code = typeof body2.code === "string" ? body2.code : JSON.stringify(body2.code);
-        } else if (typeof body2.errorString === "string") {
-          code = body2.errorString;
-        }
+        code = errorCodeFrom(body2, code);
       } catch {
         if (text) {
           const stripped = text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
@@ -393,48 +408,37 @@ async function executeDbBatchOverWs(url, token, databaseId, queries) {
 }
 
 // src/rate-limit.ts
-var DEFAULTS = {
-  internal: { concurrency: 10, callCap: 500 },
-  apiKey: { concurrency: 20, callCap: Infinity }
+var DEFAULT_CONCURRENCY = {
+  internal: 10,
+  apiKey: 20
 };
 var RateLimiter = class {
+  concurrencyLimit;
+  // Keyed by the request's context object, so an execution's slots go when it does.
+  perRequest = /* @__PURE__ */ new WeakMap();
+  shared = { inflight: 0, queue: [] };
   constructor(authType) {
-    this.authType = authType;
-    this.concurrencyLimit = DEFAULTS[authType].concurrency;
-    this.callCap = DEFAULTS[authType].callCap;
+    this.concurrencyLimit = DEFAULT_CONCURRENCY[authType];
   }
-  authType;
-  inflight = 0;
-  concurrencyLimit;
-  callCount = 0;
-  callCap;
-  queue = [];
   /** Acquire a slot. Resolves when a concurrent slot is available. */
   async acquire() {
-    if (this.callCount >= this.callCap) {
-      throw new MindStudioError(
-        `Call cap exceeded (${this.callCap} calls per execution). Reduce the number of API calls or use executeStepBatch() to combine multiple steps.`,
-        "call_cap_exceeded",
-        429
-      );
-    }
-    if (this.inflight < this.concurrencyLimit) {
-      this.inflight++;
-      this.callCount++;
+    const slots = this.slots();
+    if (slots.inflight < this.concurrencyLimit) {
+      slots.inflight++;
       return;
     }
     return new Promise((resolve) => {
-      this.queue.push(() => {
-        this.inflight++;
-        this.callCount++;
+      slots.queue.push(() => {
+        slots.inflight++;
         resolve();
       });
     });
   }
   /** Release a slot and let the next queued request proceed. */
   release() {
-    this.inflight--;
-    const next = this.queue.shift();
+    const slots = this.slots();
+    slots.inflight--;
+    const next = slots.queue.shift();
     if (next) {
       next();
     }
@@ -445,21 +449,19 @@ var RateLimiter = class {
     if (concurrency) {
       this.concurrencyLimit = parseInt(concurrency, 10);
     }
-    const limit = headers.get("x-ratelimit-limit");
-    if (limit && this.authType === "internal") {
-      this.callCap = parseInt(limit, 10);
-    }
   }
-  /** Read current rate limit state from response headers. */
-  static parseHeaders(headers) {
-    const remaining = headers.get("x-ratelimit-remaining");
-    const concurrencyRemaining = headers.get(
-      "x-ratelimit-concurrency-remaining"
-    );
-    return {
-      remaining: remaining != null ? parseInt(remaining, 10) : void 0,
-      concurrencyRemaining: concurrencyRemaining != null ? parseInt(concurrencyRemaining, 10) : void 0
-    };
+  // Release runs in the same async chain as its acquire, so both resolve the same request's slots.
+  slots() {
+    const ctx = getRequestContext();
+    if (!ctx) {
+      return this.shared;
+    }
+    let slots = this.perRequest.get(ctx);
+    if (!slots) {
+      slots = { inflight: 0, queue: [] };
+      this.perRequest.set(ctx, slots);
+    }
+    return slots;
   }
 };
 
@@ -5013,7 +5015,7 @@ async function runTaskPoll(httpConfig, body) {
       const errorBody = await res.json().catch(() => ({}));
       throw new MindStudioError(
         errorBody.message ?? errorBody.error ?? `Task poll failed: ${res.status} ${res.statusText}`,
-        errorBody.code ?? "poll_error",
+        errorCodeFrom(errorBody, "poll_error"),
         res.status,
         errorBody
       );
@@ -5077,9 +5079,7 @@ async function runTaskStream(httpConfig, body, onEvent) {
         if (errMsg) {
           message = errMsg;
         }
-        if (errBody.code) {
-          code = errBody.code;
-        }
+        code = errorCodeFrom(errBody, code);
       } catch {
         const stripped = text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
         if (stripped) {
@@ -6294,8 +6294,18 @@ var MindStudioAgent = class {
         options
       );
     }
+    return withSlot(
+      this._httpConfig,
+      () => this._executeStepPolled(stepType, step, options)
+    );
+  }
+  /**
+   * @internal Async step execution — POST, then poll until the step finishes.
+   * Runs inside one concurrency slot (see `withSlot`).
+   */
+  async _executeStepPolled(stepType, step, options) {
     const threadId = options?.threadId ?? (this._reuseThreadId && !getRequestContext() ? this._threadId : void 0);
-    const { data: asyncData, headers } = await request(this._currentHttpConfig, "POST", `/steps/${stepType}/execute-async`, {
+    const { data: asyncData, headers } = await sendRequest(this._currentHttpConfig, "POST", `/steps/${stepType}/execute-async`, {
       step,
       ...options?.appId != null && { appId: options.appId },
       ...threadId != null && { threadId },
@@ -6335,7 +6345,7 @@ var MindStudioAgent = class {
         const errorBody = await res.json().catch(() => ({}));
         throw new MindStudioError(
           errorBody.message ?? errorBody.error ?? `[${stepType}] Poll failed: ${res.status} ${res.statusText}`,
-          errorBody.code ?? "poll_error",
+          errorCodeFrom(errorBody, "poll_error"),
           res.status,
           errorBody
         );
@@ -6431,9 +6441,7 @@ var MindStudioAgent = class {
               body2.error ?? body2.message ?? body2.details
             );
           }
-          if (body2.code) {
-            code = body2.code;
-          }
+          code = errorCodeFrom(body2, code);
         } catch {
           const stripped = text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
           if (stripped) {
@@ -6585,8 +6593,18 @@ var MindStudioAgent = class {
    * ```
    */
   async executeStepBatch(steps, options) {
+    return withSlot(
+      this._httpConfig,
+      () => this._executeStepBatchPolled(steps, options)
+    );
+  }
+  /**
+   * @internal Async batch execution — POST, then poll until the batch settles.
+   * Runs inside one concurrency slot (see `withSlot`).
+   */
+  async _executeStepBatchPolled(steps, options) {
     const threadId = options?.threadId ?? (this._reuseThreadId && !getRequestContext() ? this._threadId : void 0);
-    const { data: asyncData } = await request(this._currentHttpConfig, "POST", "/steps/execute-batch-async", {
+    const { data: asyncData } = await sendRequest(this._currentHttpConfig, "POST", "/steps/execute-batch-async", {
       steps: steps.map((s) => ({
         ...s,
         stepType: resolveStepType2(s.stepType)
@@ -6620,7 +6638,7 @@ var MindStudioAgent = class {
         const errorBody = await res.json().catch(() => ({}));
         throw new MindStudioError(
           errorBody.message ?? errorBody.error ?? `Batch poll failed: ${res.status} ${res.statusText}`,
-          errorBody.code ?? "poll_error",
+          errorCodeFrom(errorBody, "poll_error"),
           res.status,
           errorBody
         );
@@ -6916,7 +6934,7 @@ var MindStudioAgent = class {
         const errorBody = await res.json().catch(() => ({}));
         throw new MindStudioError(
           errorBody.message ?? errorBody.error ?? `Poll request failed: ${res.status} ${res.statusText}`,
-          errorBody.code ?? "poll_error",
+          errorCodeFrom(errorBody, "poll_error"),
           res.status,
           errorBody
         );
@@ -7604,9 +7622,7 @@ var MindStudioAgent = class {
               body.error ?? body.message ?? body.details
             );
           }
-          if (body.code) {
-            code = body.code;
-          }
+          code = errorCodeFrom(body, code);
         } catch {
           if (text && text.length < 500) {
             message = text;
@@ -8225,7 +8241,7 @@ function deletes(externalIds) {
   };
 }
 var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_CONCURRENCY = 4;
+var DEFAULT_CONCURRENCY2 = 4;
 function errorInfo2(e) {
   if (e instanceof Error) {
     return { message: e.message, stack: e.stack };
@@ -8297,7 +8313,7 @@ function defineMapper(source, config) {
   const run = async (params) => {
     const startedAt = Date.now();
     const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const concurrency = Math.max(1, params.concurrency ?? DEFAULT_CONCURRENCY);
+    const concurrency = Math.max(1, params.concurrency ?? DEFAULT_CONCURRENCY2);
     const objects = Array.isArray(params.objects) ? params.objects : [];
     const outcomes = new Array(objects.length);
     let next = 0;