agent-relay-orchestrator 0.78.3 → 0.78.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.78.3",
+  "version": "0.78.4",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.55"
+    "agent-relay-sdk": "0.2.56"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/quota-poller.ts

@@ -3,13 +3,14 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { createServer } from "node:net";
 import { join } from "node:path";
 import {
+  DEFAULT_PROVIDER_QUOTA_CONFIG,
   QUOTA_FAILURE_LOG_INTERVAL_MS,
   QUOTA_FAST_RETRY_MS,
-  QUOTA_POLL_INTERVAL_MS,
   QuotaCollectionError,
   collectClaudeQuotaSample,
   collectCodexQuotaSample,
   credentialAccountKey,
+  normalizeProviderQuotaConfig,
   providerQuotaErrorFromCollectorError,
   quotaRetryAfterMs,
   readClaudeOAuthAccessToken,
@@ -18,7 +19,7 @@ import {
   type ProviderQuotaIdentity,
   type ProviderQuotaSample,
 } from "agent-relay-sdk/provider-quota";
-import type { ProviderQuotaLeaseAcquireInput, ProviderQuotaUpdateInput } from "agent-relay-sdk";
+import type { ProviderQuotaConfig, ProviderQuotaConfigMap, ProviderQuotaLeaseAcquireInput, ProviderQuotaUpdateInput } from "agent-relay-sdk";
 import { errMessage } from "agent-relay-sdk";
 import { codexCommandFromEnv, providerHomeRootFromEnv, type OrchestratorConfig } from "./config";
 
@@ -43,6 +44,7 @@ type QuotaRelay = {
   }>;
   releaseProviderQuotaLease(orchestratorId: string, input: ProviderQuotaLeaseAcquireInput & { leaseToken: string }): Promise<unknown>;
   reportProviderQuota(input: ProviderQuotaUpdateInput): Promise<unknown>;
+  getProviderQuotaConfig(): Promise<ProviderQuotaConfigMap>;
   connected: boolean;
 };
 
@@ -69,6 +71,10 @@ export class OrchestratorQuotaPoller {
   private inFlight = false;
   private readonly states = new Map<string, QuotaPollState>();
   private readonly logStates = new Map<string, { key: string; at: number }>();
+  // Per-provider quota config (#605), refreshed each tick. Empty until the first
+  // successful fetch — configFor() falls back to defaults so a fresh/empty config
+  // (or an older relay without the endpoint) preserves today's behavior.
+  private quotaConfig: ProviderQuotaConfigMap = {};
 
   constructor(
     private readonly config: OrchestratorConfig,
@@ -105,6 +111,7 @@ export class OrchestratorQuotaPoller {
     if (this.inFlight || !this.active || !this.relay.connected) return;
     this.inFlight = true;
     try {
+      await this.refreshQuotaConfig();
       const { candidates, skips } = await this.discoverCandidates();
       await this.releaseRemovedCandidates(candidates);
       for (const candidate of candidates) {
@@ -129,15 +136,34 @@ export class OrchestratorQuotaPoller {
     }, Math.max(1_000, delayMs));
   }
 
+  // Refresh per-provider quota config (#605). Best-effort: on failure we keep the
+  // last known config (defaults for any unset provider), so a transient relay blip
+  // never silently stops collection.
+  private async refreshQuotaConfig(): Promise<void> {
+    try {
+      this.quotaConfig = await this.relay.getProviderQuotaConfig();
+    } catch {
+      // keep prior config; configFor() defaults any missing provider.
+    }
+  }
+
+  private configFor(provider: string): ProviderQuotaConfig {
+    const stored = this.quotaConfig[provider];
+    return stored ? normalizeProviderQuotaConfig(stored) : { ...DEFAULT_PROVIDER_QUOTA_CONFIG };
+  }
+
   private async discoverCandidates(): Promise<QuotaDiscovery> {
     const candidates: QuotaCandidate[] = [];
     const skips: ProviderSkip[] = [];
-    if (this.config.providers.includes("claude")) {
+    // A disabled provider (#605) is collected from at all: no discovery → no
+    // polling/API calls, leases released by releaseRemovedCandidates, and no
+    // skip-marker row (disabled is intentional, not a credential failure).
+    if (this.config.providers.includes("claude") && this.configFor("claude").enabled) {
       const found = await this.discoverClaudeCandidates();
       candidates.push(...found.candidates);
       if (found.skipReason) skips.push({ provider: "claude", reason: found.skipReason });
     }
-    if (this.config.providers.includes("codex")) {
+    if (this.config.providers.includes("codex") && this.configFor("codex").enabled) {
       const found = await this.discoverCodexCandidates();
       candidates.push(...found.candidates);
       if (found.skipReason) skips.push({ provider: "codex", reason: found.skipReason });
@@ -226,6 +252,9 @@ export class OrchestratorQuotaPoller {
     if (!await this.ensureLease(candidate, state, now)) return;
     if (state.nextPollAt !== undefined && state.nextPollAt > now) return;
 
+    // Per-provider cadence (#605): the configured interval governs the gap between
+    // successful polls and the post-failure retry once a first attempt has landed.
+    const pollIntervalMs = this.configFor(candidate.provider).pollIntervalMs;
     const lastAttemptAt = now;
     try {
       const sample = await this.collect(candidate);
@@ -240,13 +269,17 @@ export class OrchestratorQuotaPoller {
       };
       await this.relay.reportProviderQuota(update);
       state.lastAttemptAt = update.lastAttemptAt;
-      state.nextPollAt = now + QUOTA_POLL_INTERVAL_MS;
+      state.nextPollAt = now + pollIntervalMs;
     } catch (error) {
       const retryAfterMs = quotaRetryAfterMs(error);
       const lastError = providerQuotaErrorFromCollectorError(error, retryAfterMs);
-      const retryDelayMs = retryAfterMs ?? (state.lastAttemptAt ? QUOTA_POLL_INTERVAL_MS : QUOTA_FAST_RETRY_MS);
+      const retryDelayMs = retryAfterMs ?? (state.lastAttemptAt ? pollIntervalMs : QUOTA_FAST_RETRY_MS);
       state.lastAttemptAt = lastAttemptAt;
       state.nextPollAt = now + retryDelayMs;
+      if (candidate.provider === "claude" && retryAfterMs !== undefined) {
+        this.logFailure(candidate, error, retryAfterMs);
+        return;
+      }
       await this.relay.reportProviderQuota({
         provider: candidate.provider,
         accountKey: candidate.accountKey,

package/src/relay.ts

@@ -2,7 +2,7 @@ import type { OrchestratorConfig } from "./config";
 import type { ProviderProbeCache } from "./provider-probe";
 import { detectSelfSupervision } from "./self-supervision";
 import { GIT_SHA, ORCHESTRATOR_PROTOCOL_VERSION, VERSION, runtimeMetadata } from "./version";
-import type { AgentLifecycle, ProviderQuotaLeaseAcquireInput, ProviderQuotaLeaseAcquireResult, ProviderQuotaUpdateInput, WorkspaceMetadata, WorkspaceMode, ManagedSessionExitDiagnostics as SdkManagedSessionExitDiagnostics } from "agent-relay-sdk";
+import type { AgentLifecycle, ProviderQuotaConfigMap, ProviderQuotaLeaseAcquireInput, ProviderQuotaLeaseAcquireResult, ProviderQuotaUpdateInput, WorkspaceMetadata, WorkspaceMode, ManagedSessionExitDiagnostics as SdkManagedSessionExitDiagnostics } from "agent-relay-sdk";
 import { ReconnectionManager, RelayHttpClient } from "agent-relay-sdk";
 
 export interface RelayClient {
@@ -14,6 +14,7 @@ export interface RelayClient {
   acquireProviderQuotaLease(orchestratorId: string, input: ProviderQuotaLeaseAcquireInput): Promise<ProviderQuotaLeaseAcquireResult>;
   releaseProviderQuotaLease(orchestratorId: string, input: ProviderQuotaLeaseAcquireInput & { leaseToken: string }): Promise<{ released: boolean }>;
   reportProviderQuota(input: ProviderQuotaUpdateInput): Promise<unknown>;
+  getProviderQuotaConfig(): Promise<ProviderQuotaConfigMap>;
   setApiUrl(url: string): void;
   startHeartbeatLoop(): void;
   stopHeartbeatLoop(): void;
@@ -251,6 +252,9 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
     reportProviderQuota(input: ProviderQuotaUpdateInput): Promise<unknown> {
       return http.upsertProviderQuota(input);
     },
+    getProviderQuotaConfig(): Promise<ProviderQuotaConfigMap> {
+      return http.getProviderQuotaConfig();
+    },
     get connected() { return connected; },
   };
 }