@minionry/minion 0.7.36

package/dist/server/services/sdk/rate-limits.js

@@ -0,0 +1,198 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { addGrantUsage, getGrant } from './grant-store.js';
+import { getLiveRunsForApp, getLiveSubscriptionsForApp } from './live-registry.js';
+export const DEFAULT_AGENTS_RUN_CONCURRENCY = 1;
+export const DEFAULT_DAILY_RUN_BUDGET = 50;
+export const DEFAULT_DAILY_TOKEN_BUDGET = 5_000_000;
+export const REQUEST_BUCKET_CAPACITY = 30;
+export const REQUEST_BUCKET_REFILL_PER_SECOND = 15;
+export const AI_ASSIST_BUCKET_CAPACITY = 3;
+export const AI_ASSIST_REFILL_PER_SECOND = 1 / 30;
+export const DEFAULT_INFERENCE_CONCURRENCY = 2;
+function ledgerKey(appId, spaceKey) {
+    return `${appId}\u0000${spaceKey}`;
+}
+function utcDayOf(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+const pendingStarts = new Map();
+const pendingInferenceStarts = new Map();
+const requestBuckets = new Map();
+const aiAssistBuckets = new Map();
+const sessionUsage = new Map();
+export function resetSdkRateLimitState() {
+    pendingStarts.clear();
+    pendingInferenceStarts.clear();
+    requestBuckets.clear();
+    aiAssistBuckets.clear();
+    sessionUsage.clear();
+}
+function intKnob(value, fallback) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 1 ? value : fallback;
+}
+function budgetKnob(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function readUsage(appId, spaceKey, day) {
+    const persisted = getGrant(appId, spaceKey);
+    const stored = persisted ? persisted.usage : sessionUsage.get(ledgerKey(appId, spaceKey));
+    return stored?.day === day ? stored : { day, runs: 0, tokens: 0 };
+}
+function debitUsage(appId, spaceKey, day, delta) {
+    if (addGrantUsage(appId, spaceKey, day, delta))
+        return;
+    const key = ledgerKey(appId, spaceKey);
+    const stored = sessionUsage.get(key);
+    const prior = stored?.day === day ? stored : { day, runs: 0, tokens: 0 };
+    sessionUsage.set(key, {
+        day,
+        runs: prior.runs + (delta.runs ?? 0),
+        tokens: prior.tokens + (delta.tokens ?? 0),
+    });
+}
+function throttleRequest(appId, nowMs) {
+    let bucket = requestBuckets.get(appId);
+    if (!bucket) {
+        bucket = { tokens: REQUEST_BUCKET_CAPACITY, lastRefillMs: nowMs };
+        requestBuckets.set(appId, bucket);
+    }
+    const elapsedMs = Math.max(0, nowMs - bucket.lastRefillMs);
+    bucket.tokens = Math.min(REQUEST_BUCKET_CAPACITY, bucket.tokens + (elapsedMs / 1000) * REQUEST_BUCKET_REFILL_PER_SECOND);
+    bucket.lastRefillMs = nowMs;
+    if (bucket.tokens < 1)
+        return true;
+    bucket.tokens -= 1;
+    return false;
+}
+function throttleAiAssist(appId, nowMs) {
+    let bucket = aiAssistBuckets.get(appId);
+    if (!bucket) {
+        bucket = { tokens: AI_ASSIST_BUCKET_CAPACITY, lastRefillMs: nowMs };
+        aiAssistBuckets.set(appId, bucket);
+    }
+    const elapsedMs = Math.max(0, nowMs - bucket.lastRefillMs);
+    bucket.tokens = Math.min(AI_ASSIST_BUCKET_CAPACITY, bucket.tokens + (elapsedMs / 1000) * AI_ASSIST_REFILL_PER_SECOND);
+    bucket.lastRefillMs = nowMs;
+    if (bucket.tokens < 1)
+        return true;
+    bucket.tokens -= 1;
+    return false;
+}
+const ENGINE_RUN_METHODS = new Set([
+    'agents.run',
+    'browser.automate',
+]);
+export const AI_ASSIST_METHODS = new Set([
+    'git.generateCommitMessage',
+    'git.pr.generateDescription',
+    'quality.run',
+]);
+function activeEngineRuns(appId, spaceKey, key) {
+    const automations = getLiveSubscriptionsForApp(appId, spaceKey).filter((sub) => sub.kind === 'browser.automate').length;
+    return getLiveRunsForApp(appId, spaceKey).length + automations + (pendingStarts.get(key) ?? 0);
+}
+function gateEngineRun(op, nowMs) {
+    const key = ledgerKey(op.appId, op.spaceKey);
+    const concurrency = intKnob(op.grant?.config?.agentsRunConcurrency, DEFAULT_AGENTS_RUN_CONCURRENCY);
+    const active = activeEngineRuns(op.appId, op.spaceKey, key);
+    if (active >= concurrency) {
+        return {
+            limited: true,
+            message: `${op.method} concurrency limit reached (${active} active, limit ${concurrency}) — wait for the current run to finish, or raise the grant's agentsRunConcurrency`,
+        };
+    }
+    const day = utcDayOf(nowMs);
+    const usage = readUsage(op.appId, op.spaceKey, day);
+    const runBudget = budgetKnob(op.grant?.config?.dailyRunBudget, DEFAULT_DAILY_RUN_BUDGET);
+    if (usage.runs >= runBudget) {
+        return {
+            limited: true,
+            message: `daily agents.run budget exhausted (${usage.runs}/${runBudget} runs today) — resets at UTC midnight`,
+        };
+    }
+    const tokenBudget = budgetKnob(op.grant?.config?.dailyTokenBudget, DEFAULT_DAILY_TOKEN_BUDGET);
+    if (usage.tokens >= tokenBudget) {
+        return {
+            limited: true,
+            message: `daily token budget exhausted (${usage.tokens}/${tokenBudget} tokens today) — resets at UTC midnight`,
+        };
+    }
+    debitUsage(op.appId, op.spaceKey, day, { runs: 1 });
+    pendingStarts.set(key, (pendingStarts.get(key) ?? 0) + 1);
+    let released = false;
+    return {
+        limited: false,
+        onDispatched: () => {
+            if (released)
+                return;
+            released = true;
+            const remaining = (pendingStarts.get(key) ?? 1) - 1;
+            if (remaining <= 0)
+                pendingStarts.delete(key);
+            else
+                pendingStarts.set(key, remaining);
+        },
+    };
+}
+function gateInference(op, nowMs) {
+    const key = ledgerKey(op.appId, op.spaceKey);
+    const live = getLiveSubscriptionsForApp(op.appId, op.spaceKey).filter((sub) => sub.kind === 'inference.chat').length;
+    const active = live + (pendingInferenceStarts.get(key) ?? 0);
+    if (active >= DEFAULT_INFERENCE_CONCURRENCY) {
+        return {
+            limited: true,
+            message: `inference.chat concurrency limit reached (${active} active, limit ${DEFAULT_INFERENCE_CONCURRENCY}) — wait for a completion to finish`,
+        };
+    }
+    const usage = readUsage(op.appId, op.spaceKey, utcDayOf(nowMs));
+    const tokenBudget = budgetKnob(op.grant?.config?.dailyTokenBudget, DEFAULT_DAILY_TOKEN_BUDGET);
+    if (usage.tokens >= tokenBudget) {
+        return {
+            limited: true,
+            message: `daily token budget exhausted (${usage.tokens}/${tokenBudget} tokens today) — resets at UTC midnight`,
+        };
+    }
+    pendingInferenceStarts.set(key, (pendingInferenceStarts.get(key) ?? 0) + 1);
+    let released = false;
+    return {
+        limited: false,
+        onDispatched: () => {
+            if (released)
+                return;
+            released = true;
+            const remaining = (pendingInferenceStarts.get(key) ?? 1) - 1;
+            if (remaining <= 0)
+                pendingInferenceStarts.delete(key);
+            else
+                pendingInferenceStarts.set(key, remaining);
+        },
+    };
+}
+export function checkSdkRateLimit(op, now = Date.now) {
+    if (ENGINE_RUN_METHODS.has(op.method))
+        return gateEngineRun(op, now());
+    if (op.method === 'inference.chat')
+        return gateInference(op, now());
+    if (AI_ASSIST_METHODS.has(op.method)) {
+        if (throttleAiAssist(op.appId, now())) {
+            return {
+                limited: true,
+                message: `AI git assist rate limit reached — each ${op.method} call spawns a model subprocess (burst ${AI_ASSIST_BUCKET_CAPACITY}, then one every 30s); retry shortly`,
+            };
+        }
+        return null;
+    }
+    if (throttleRequest(op.appId, now())) {
+        return {
+            limited: true,
+            message: `request throttled — sustained rate above ${REQUEST_BUCKET_REFILL_PER_SECOND} requests/second (burst ${REQUEST_BUCKET_CAPACITY}); retry shortly`,
+        };
+    }
+    return null;
+}
+export function recordAppRunTokens(appId, spaceKey, tokens, now = Date.now) {
+    if (!Number.isFinite(tokens) || tokens <= 0)
+        return;
+    debitUsage(appId, spaceKey, utcDayOf(now()), { tokens });
+}