agent-relay-runner 0.77.0 → 0.78.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.77.0",
+  "version": "0.78.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.52"
+    "agent-relay-sdk": "0.2.53"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.77.0",
+  "version": "0.78.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/quota.ts

@@ -1,586 +1,28 @@
-import { readFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { homedir, hostname } from "node:os";
-import { dirname, join } from "node:path";
-import type { ContextProbeMetrics, ProviderQuotaError, ProviderQuotaUpdateInput, QuotaState, QuotaWindowName } from "agent-relay-sdk";
-import { errMessage, isRecord, quotaStateFromProbeMetrics, stringValue } from "agent-relay-sdk";
-import { sanitizeFsName } from "agent-relay-sdk/fs-name";
-import type { ManagedProcess } from "./adapter";
-import { agentRelayHome, runnerOutboxDirWithInfoFallback } from "./config";
-
-const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
-const CLAUDE_OAUTH_BETA = "oauth-2025-04-20";
-const QUOTA_POLL_INTERVAL_MS = 5 * 60 * 1000;
-const QUOTA_FAST_RETRY_MS = 15 * 1000;
-const QUOTA_FAILURE_LOG_INTERVAL_MS = 5 * 60 * 1000;
-const QUOTA_LOCK_STALE_MS = 60 * 1000;
-
-type CodexQuotaClient = {
-  isConnected?: () => boolean;
-  accountRateLimitsRead?: () => Promise<unknown>;
-};
-
-type QuotaIdentity = {
-  provider: string;
-  accountKey: string;
-  credentialsPath?: string;
-};
-
-type RunnerQuotaSample = {
-  quota?: QuotaState;
-  accountKey?: string;
-};
-
-type SharedQuotaEntry = {
-  provider: string;
-  accountKey: string;
-  lastAttemptAt?: number;
-  nextAttemptAt?: number;
-  quota?: QuotaState;
-  lastError?: ProviderQuotaError | null;
-};
-
-export class RunnerQuotaPoller {
-  private quotaState?: QuotaState;
-  private timer?: Timer;
-  private inFlight = false;
-  private active = false;
-  private lastLog?: { key: string; at: number };
-
-  constructor(private readonly options: {
-    provider: string;
-    agentId: string;
-    getProcess: () => ManagedProcess | undefined;
-    onUpdate: () => void;
-    log: (message: string) => void;
-    reportProviderQuota?: (input: ProviderQuotaUpdateInput) => Promise<unknown>;
-    quotaStateDir?: string;
-    fetchImpl?: typeof fetch;
-  }) {}
-
-  get current(): QuotaState | undefined {
-    return this.quotaState;
-  }
-
-  start(): void {
-    this.stop();
-    if (!quotaProviderSupported(this.options.provider)) return;
-    this.active = true;
-    void this.refresh();
-  }
-
-  stop(): void {
-    this.active = false;
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = undefined;
-  }
-
-  clear(): void {
-    this.quotaState = undefined;
-  }
-
-  private schedule(delayMs = QUOTA_POLL_INTERVAL_MS): void {
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = undefined;
-    if (!this.active || !quotaProviderSupported(this.options.provider)) return;
-    this.timer = setTimeout(() => {
-      this.timer = undefined;
-      void this.refresh();
-    }, Math.max(1_000, delayMs));
-  }
-
-  private async refresh(): Promise<void> {
-    if (this.inFlight) return;
-    this.inFlight = true;
-    const now = Date.now();
-    let identity: QuotaIdentity | undefined;
-    let lockDir: string | undefined;
-    try {
-      const process = this.options.getProcess();
-      identity = await resolveRunnerQuotaIdentity({
-        provider: this.options.provider,
-        process,
-      });
-      const attempt = beginSharedQuotaAttempt(identity, this.options.quotaStateDir, now);
-      if (!attempt.poll) {
-        if (attempt.entry?.quota && this.active) {
-          this.quotaState = attempt.entry.quota;
-          this.options.onUpdate();
-        }
-        this.schedule(attempt.retryInMs);
-        return;
-      }
-      lockDir = attempt.lockDir;
-      const sample = await collectRunnerQuotaSample({
-        provider: this.options.provider,
-        agentId: this.options.agentId,
-        process,
-        credentialsPath: identity.credentialsPath,
-        fetchImpl: this.options.fetchImpl,
-      });
-      const quota = sample.quota;
-      if (!quota) throw new QuotaCollectionError("creds_not_ready", `${this.options.provider} quota source is not ready`);
-      if (this.active) {
-        const update: ProviderQuotaUpdateInput = {
-          provider: identity.provider,
-          accountKey: sample.accountKey ?? identity.accountKey,
-          quota,
-          lastAttemptAt: quota.updatedAt,
-          sourceAgentId: this.options.agentId,
-        };
-        await this.reportProviderQuota(update);
-        finishSharedQuotaAttempt(identity, {
-          provider: update.provider,
-          accountKey: update.accountKey,
-          quota,
-          lastAttemptAt: update.lastAttemptAt,
-          nextAttemptAt: now + QUOTA_POLL_INTERVAL_MS,
-          lastError: null,
-        }, this.options.quotaStateDir);
-        this.quotaState = quota;
-        this.options.onUpdate();
-      }
-      this.schedule();
-    } catch (error) {
-      const retryAfterMs = quotaRetryAfterMs(error);
-      const lastError = providerQuotaErrorFromCollectorError(error, retryAfterMs);
-      const lastAttemptAt = Date.now();
-      const retryDelayMs = retryAfterMs ?? (identity && !readSharedQuotaEntry(identity, this.options.quotaStateDir)?.lastAttemptAt ? QUOTA_FAST_RETRY_MS : QUOTA_POLL_INTERVAL_MS);
-      if (identity) {
-        await this.reportProviderQuota({
-          provider: identity.provider,
-          accountKey: identity.accountKey,
-          lastAttemptAt,
-          lastError,
-          sourceAgentId: this.options.agentId,
-        }).catch((publishError) => {
-          this.options.log(`quota status publish failed: ${errMessage(publishError)}`);
-        });
-        finishSharedQuotaAttempt(identity, {
-          provider: identity.provider,
-          accountKey: identity.accountKey,
-          lastAttemptAt,
-          nextAttemptAt: lastAttemptAt + retryDelayMs,
-          lastError,
-        }, this.options.quotaStateDir);
-      }
-      if (this.active) this.logFailure(error, retryAfterMs);
-      this.schedule(retryDelayMs);
-    } finally {
-      if (lockDir) releaseQuotaLock(lockDir);
-      this.inFlight = false;
-    }
-  }
-
-  private async reportProviderQuota(input: ProviderQuotaUpdateInput): Promise<void> {
-    if (!this.options.reportProviderQuota) return;
-    await this.options.reportProviderQuota(input);
-  }
-
-  private logFailure(error: unknown, retryAfterMs: number | undefined): void {
-    const key = retryAfterMs !== undefined ? `retry-after:${retryAfterMs}` : errMessage(error);
-    const now = Date.now();
-    if (this.lastLog?.key === key && now - this.lastLog.at < QUOTA_FAILURE_LOG_INTERVAL_MS) return;
-    this.lastLog = { key, at: now };
-    const suffix = retryAfterMs !== undefined ? `; retrying in ${Math.round(retryAfterMs / 1000)}s` : "";
-    this.options.log(`quota refresh failed${suffix}: ${errMessage(error)}`);
-  }
-}
-
-export class QuotaRetryAfterError extends Error {
-  constructor(readonly retryAfterMs: number, message = "quota source requested retry backoff") {
-    super(message);
-    this.name = "QuotaRetryAfterError";
-  }
-}
-
-class QuotaCollectionError extends Error {
-  constructor(readonly type: ProviderQuotaError["type"], message: string) {
-    super(message);
-    this.name = "QuotaCollectionError";
-  }
-}
-
-function quotaRetryAfterMs(error: unknown): number | undefined {
-  return error instanceof QuotaRetryAfterError ? error.retryAfterMs : undefined;
-}
-
-function providerQuotaErrorFromCollectorError(error: unknown, retryAfterMs: number | undefined): ProviderQuotaError {
-  if (retryAfterMs !== undefined) {
-    return { type: "rate_limited", message: errMessage(error), retryAfterMs };
-  }
-  if (error instanceof QuotaCollectionError) {
-    return { type: error.type, message: error.message };
-  }
-  return { type: "other", message: errMessage(error) };
-}
-
-export async function resolveRunnerQuotaIdentity(input: {
-  provider: string;
-  process?: ManagedProcess;
-}): Promise<QuotaIdentity> {
-  const provider = input.provider.trim().toLowerCase();
-  if (provider === "claude") {
-    const credentialsPath = claudeCredentialsPathFromProcess(input.process);
-    const token = await readClaudeOAuthAccessToken(credentialsPath);
-    return {
-      provider,
-      accountKey: token ? `credential:${shortHash(token)}` : hostProviderAccountKey(provider),
-      credentialsPath,
-    };
-  }
-  return {
-    provider,
-    accountKey: codexAccountKeyFromProcess(input.process) ?? hostProviderAccountKey(provider),
-  };
-}
-
-async function collectRunnerQuotaSample(input: {
-  provider: string;
-  agentId: string;
-  process?: ManagedProcess;
-  credentialsPath?: string;
-  fetchImpl?: typeof fetch;
-}): Promise<RunnerQuotaSample> {
-  if (input.provider === "claude") return collectClaudeQuotaSample({ agentId: input.agentId, credentialsPath: input.credentialsPath, fetchImpl: input.fetchImpl });
-  if (input.provider !== "codex") return {};
-  const client = input.process?.meta?.client as CodexQuotaClient | undefined;
-  if (!client?.isConnected?.() || typeof client.accountRateLimitsRead !== "function") return {};
-  return collectCodexQuotaSample({
-    agentId: codexProcessAgentId(input.process, input.agentId),
-    rateLimitsRead: () => client.accountRateLimitsRead!(),
-  });
-}
-
-async function collectClaudeQuotaSample(options: {
-  agentId: string;
-  credentialsPath?: string;
-  fetchImpl?: typeof fetch;
-  now?: number;
-}): Promise<RunnerQuotaSample> {
-  const payload = await fetchClaudeUsagePayload(options);
-  if (payload === undefined) return {};
-  return {
-    quota: claudeUsageQuotaState(payload, options.agentId, options.now ?? Date.now()),
-    accountKey: providerPayloadAccountKey(payload),
-  };
-}
-
-export async function collectClaudeQuotaState(options: {
-  agentId: string;
-  credentialsPath?: string;
-  fetchImpl?: typeof fetch;
-  now?: number;
-}): Promise<QuotaState | undefined> {
-  return (await collectClaudeQuotaSample(options)).quota;
-}
-
-async function fetchClaudeUsagePayload(options: {
-  credentialsPath?: string;
-  fetchImpl?: typeof fetch;
-}): Promise<unknown | undefined> {
-  const accessToken = await readClaudeOAuthAccessToken(options.credentialsPath ?? defaultClaudeCredentialsPath());
-  if (!accessToken) return undefined;
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const response = await fetchImpl(CLAUDE_USAGE_URL, {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${accessToken}`,
-      "anthropic-beta": CLAUDE_OAUTH_BETA,
-    },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (response.status === 429) {
-    throw new QuotaRetryAfterError(retryAfterHeaderMs(response.headers.get("retry-after")) ?? 60_000, "Claude quota source returned 429");
-  }
-  if (response.status === 401 || response.status === 403) throw new QuotaCollectionError("auth", `Claude quota source returned ${response.status}`);
-  if (!response.ok) throw new QuotaCollectionError("other", `Claude quota source returned ${response.status}`);
-  return response.json();
-}
-
-export function claudeUsageQuotaState(payload: unknown, agentId: string, now = Date.now()): QuotaState | undefined {
-  return quotaStateFromProbeMetrics({
-    agentId,
-    contextPercent: 0,
-    quotaWindows: [
-      quotaWindowFromAnthropicUsage("five_hour", payload),
-      quotaWindowFromAnthropicUsage("seven_day", payload),
-    ].filter((window): window is NonNullable<ContextProbeMetrics["quotaWindows"]>[number] => Boolean(window)),
-    source: "api",
-    confidence: "reported",
-    timestamp: now,
-  });
-}
-
-export async function collectCodexQuotaState(input: {
-  agentId: string;
-  rateLimitsRead: () => Promise<unknown>;
-  now?: number;
-}): Promise<QuotaState | undefined> {
-  return (await collectCodexQuotaSample(input)).quota;
-}
-
-async function collectCodexQuotaSample(input: {
-  agentId: string;
-  rateLimitsRead: () => Promise<unknown>;
-  now?: number;
-}): Promise<RunnerQuotaSample> {
-  try {
-    const payload = await input.rateLimitsRead();
-    return {
-      quota: codexRateLimitsQuotaState(payload, input.agentId, input.now ?? Date.now()),
-      accountKey: providerPayloadAccountKey(payload),
-    };
-  } catch (error) {
-    const retryAfter = codexRetryAfterMs(error);
-    if (retryAfter !== undefined) throw new QuotaRetryAfterError(retryAfter, "Codex quota source returned 429");
-    throw error;
-  }
-}
-
-export function codexRateLimitsQuotaState(payload: unknown, agentId: string, now = Date.now()): QuotaState | undefined {
-  const rateLimits = isRecord(payload) && isRecord(payload.rateLimits) ? payload.rateLimits
-    : isRecord(payload) && isRecord(payload.rate_limits) ? payload.rate_limits
-    : payload;
-  return quotaStateFromProbeMetrics({
-    agentId,
-    contextPercent: 0,
-    quotaWindows: [
-      quotaWindowFromCodexRateLimit("primary", rateLimits),
-      quotaWindowFromCodexRateLimit("secondary", rateLimits),
-    ].filter((window): window is NonNullable<ContextProbeMetrics["quotaWindows"]>[number] => Boolean(window)),
-    source: "api",
-    confidence: "reported",
-    timestamp: now,
-  });
-}
-
-function defaultClaudeCredentialsPath(): string {
-  return join(defaultClaudeConfigDir(), ".credentials.json");
-}
-
-export function defaultClaudeConfigDir(): string {
-  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
-}
-
-function claudeCredentialsPathFromProcess(proc: ManagedProcess | undefined): string {
-  const env = processEnvFromMeta(proc);
-  const configDir = stringValue(env?.CLAUDE_CONFIG_DIR) ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
-  return join(configDir, ".credentials.json");
-}
-
-function codexAccountKeyFromProcess(proc: ManagedProcess | undefined): string | undefined {
-  const env = processEnvFromMeta(proc);
-  const codexHome = stringValue(env?.CODEX_HOME) ?? process.env.CODEX_HOME;
-  return codexHome ? `home:${shortHash(codexHome)}` : undefined;
-}
-
-function processEnvFromMeta(proc: ManagedProcess | undefined): Record<string, unknown> | undefined {
-  const direct = isRecord(proc?.meta?.env) ? proc.meta.env : undefined;
-  if (direct) return direct;
-  const config = isRecord(proc?.meta?.config) ? proc.meta.config : undefined;
-  return isRecord(config?.env) ? config.env : undefined;
-}
-
-function hostProviderAccountKey(provider: string): string {
-  return `host:${hostname()}:${provider}`;
-}
-
-export function beginSharedQuotaAttempt(identity: QuotaIdentity, stateDir?: string, now = Date.now()): {
-  poll: boolean;
-  retryInMs: number;
-  entry?: SharedQuotaEntry;
-  lockDir?: string;
-} {
-  const entry = readSharedQuotaEntry(identity, stateDir);
-  const nextAttemptAt = entry?.nextAttemptAt;
-  if (nextAttemptAt !== undefined && nextAttemptAt > now) {
-    return { poll: false, retryInMs: nextAttemptAt - now, entry };
-  }
-
-  const lockDir = sharedQuotaLockDir(identity, stateDir);
-  if (!acquireQuotaLock(lockDir, now)) {
-    return { poll: false, retryInMs: QUOTA_FAST_RETRY_MS, entry };
-  }
-  return { poll: true, retryInMs: 0, entry, lockDir };
-}
-
-function finishSharedQuotaAttempt(identity: QuotaIdentity, entry: SharedQuotaEntry, stateDir?: string): void {
-  const path = sharedQuotaStatePath(identity, stateDir);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(entry, null, 2));
-}
-
-function readSharedQuotaEntry(identity: QuotaIdentity, stateDir?: string): SharedQuotaEntry | undefined {
-  try {
-    const parsed = JSON.parse(readFileSync(sharedQuotaStatePath(identity, stateDir), "utf8")) as unknown;
-    if (!isRecord(parsed)) return undefined;
-    const provider = stringValue(parsed.provider);
-    const accountKey = stringValue(parsed.accountKey);
-    if (!provider || !accountKey) return undefined;
-    return {
-      provider,
-      accountKey,
-      ...(typeof parsed.lastAttemptAt === "number" && Number.isFinite(parsed.lastAttemptAt) ? { lastAttemptAt: parsed.lastAttemptAt } : {}),
-      ...(typeof parsed.nextAttemptAt === "number" && Number.isFinite(parsed.nextAttemptAt) ? { nextAttemptAt: parsed.nextAttemptAt } : {}),
-      ...(isQuotaState(parsed.quota) ? { quota: parsed.quota } : {}),
-      ...(parsed.lastError === null || isRecord(parsed.lastError) ? { lastError: parsed.lastError as ProviderQuotaError | null } : {}),
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function sharedQuotaStatePath(identity: QuotaIdentity, stateDir?: string): string {
-  return join(sharedQuotaStateDir(stateDir), `${sharedQuotaKey(identity)}.json`);
-}
-
-function sharedQuotaLockDir(identity: QuotaIdentity, stateDir?: string): string {
-  return join(sharedQuotaStateDir(stateDir), `${sharedQuotaKey(identity)}.lock`);
-}
-
-function sharedQuotaStateDir(stateDir?: string): string {
-  return stateDir ?? join(runnerOutboxDirWithInfoFallback() ?? agentRelayHome(), "quota");
-}
-
-function sharedQuotaKey(identity: QuotaIdentity): string {
-  return sanitizeFsName(`${identity.provider}-${identity.accountKey}`);
-}
-
-function acquireQuotaLock(lockDir: string, now = Date.now()): boolean {
-  try {
-    mkdirSync(lockDir, { recursive: false });
-    writeFileSync(join(lockDir, "owner"), String(now));
-    return true;
-  } catch {
-    const ownerPath = join(lockDir, "owner");
-    try {
-      const lockedAt = Number(readFileSync(ownerPath, "utf8"));
-      if (Number.isFinite(lockedAt) && now - lockedAt <= QUOTA_LOCK_STALE_MS) return false;
-      rmSync(lockDir, { recursive: true, force: true });
-      mkdirSync(lockDir, { recursive: false });
-      writeFileSync(ownerPath, String(now));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-function releaseQuotaLock(lockDir: string): void {
-  rmSync(lockDir, { recursive: true, force: true });
-}
-
-function isQuotaState(value: unknown): value is QuotaState {
-  return isRecord(value) && Array.isArray(value.windows) && typeof value.updatedAt === "number";
-}
-
-export function providerPayloadAccountKey(payload: unknown): string | undefined {
-  if (!isRecord(payload)) return undefined;
-  const direct = stringValue(payload.accountKey) ??
-    stringValue(payload.account_key) ??
-    stringValue(payload.accountId) ??
-    stringValue(payload.account_id) ??
-    stringValue(payload.orgId) ??
-    stringValue(payload.org_id) ??
-    stringValue(payload.organizationId) ??
-    stringValue(payload.organization_id);
-  if (direct) return direct;
-  const account = isRecord(payload.account) ? payload.account : undefined;
-  const org = isRecord(payload.org) ? payload.org : isRecord(payload.organization) ? payload.organization : undefined;
-  return stringValue(account?.id) ?? stringValue(org?.id);
-}
-
-function shortHash(value: string): string {
-  return createHash("sha256").update(value).digest("hex").slice(0, 16);
-}
-
-function quotaProviderSupported(provider: string): boolean {
-  return provider === "claude" || provider === "codex";
-}
-
-function codexProcessAgentId(process: ManagedProcess | undefined, fallback: string): string {
-  const config = isRecord(process?.meta?.config) ? process.meta.config : undefined;
-  return stringValue(config?.agentId) ?? fallback;
-}
-
-async function readClaudeOAuthAccessToken(path: string): Promise<string | undefined> {
-  try {
-    const parsed = JSON.parse(await readFile(path, "utf8")) as unknown;
-    const oauth = isRecord(parsed) && isRecord(parsed.claudeAiOauth) ? parsed.claudeAiOauth : undefined;
-    const token = oauth?.accessToken;
-    return typeof token === "string" && token.trim() ? token : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function quotaWindowFromAnthropicUsage(name: QuotaWindowName, payload: unknown): NonNullable<ContextProbeMetrics["quotaWindows"]>[number] | undefined {
-  if (!isRecord(payload)) return undefined;
-  const raw = isRecord(payload[name]) ? payload[name] : undefined;
-  const utilization = normalizePercentLike(raw?.utilization);
-  if (utilization === undefined) return undefined;
-  return {
-    name,
-    utilization,
-    ...(resetValueMs(raw?.resets_at) !== undefined ? { resetsAt: resetValueMs(raw?.resets_at)! } : {}),
-    unit: "%",
-  };
-}
-
-function quotaWindowFromCodexRateLimit(name: QuotaWindowName, payload: unknown): NonNullable<ContextProbeMetrics["quotaWindows"]>[number] | undefined {
-  if (!isRecord(payload)) return undefined;
-  const raw = isRecord(payload[name]) ? payload[name] : undefined;
-  const utilization = normalizePercentLike(raw?.usedPercent ?? raw?.used_percent ?? raw?.utilization);
-  if (utilization === undefined) return undefined;
-  return {
-    name,
-    utilization,
-    ...(resetValueMs(raw?.resetsAt ?? raw?.resets_at) !== undefined ? { resetsAt: resetValueMs(raw?.resetsAt ?? raw?.resets_at)! } : {}),
-    unit: "%",
-  };
-}
-
-function normalizePercentLike(value: unknown): number | undefined {
-  const number = numberValue(value);
-  if (number === undefined) return undefined;
-  const fraction = number > 1 ? number / 100 : number;
-  return Math.max(0, Math.min(1, fraction));
-}
-
-function resetValueMs(value: unknown): number | undefined {
-  const number = numberValue(value);
-  if (number !== undefined) return number < 10_000_000_000 ? number * 1000 : number;
-  if (typeof value !== "string" || !value.trim()) return undefined;
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function retryAfterHeaderMs(value: string | null): number | undefined {
-  if (!value) return undefined;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
-  const date = Date.parse(value);
-  if (!Number.isFinite(date)) return undefined;
-  return Math.max(0, date - Date.now());
-}
-
-function codexRetryAfterMs(error: unknown): number | undefined {
-  const message = errMessage(error);
-  if (!/\b429\b/.test(message)) return undefined;
-  return retryAfterHeaderMs(retryAfterFromText(message)) ?? 60_000;
-}
-
-function retryAfterFromText(message: string): string | null {
-  return /retry-after[:=]\s*([^,;\s]+)/i.exec(message)?.[1] ?? null;
-}
-
-function numberValue(value: unknown): number | undefined {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-  }
-  return undefined;
-}
+export {
+  CLAUDE_OAUTH_BETA,
+  CLAUDE_USAGE_URL,
+  QUOTA_FAILURE_LOG_INTERVAL_MS,
+  QUOTA_FAST_RETRY_MS,
+  QUOTA_POLL_INTERVAL_MS,
+  QuotaCollectionError,
+  QuotaRetryAfterError,
+  claudeUsageQuotaState,
+  collectClaudeQuotaSample,
+  collectClaudeQuotaState,
+  collectCodexQuotaSample,
+  collectCodexQuotaState,
+  codexRateLimitsQuotaState,
+  credentialAccountKey,
+  defaultClaudeConfigDir,
+  defaultClaudeCredentialsPath,
+  hostProviderAccountKey,
+  providerPayloadAccountKey,
+  providerQuotaErrorFromCollectorError,
+  quotaRetryAfterMs,
+  readClaudeOAuthAccessToken,
+  resolveClaudeQuotaIdentity,
+  resolveCodexQuotaIdentity,
+  resolveCodexQuotaIdentityFromHome,
+  type ProviderQuotaIdentity,
+  type ProviderQuotaSample,
+} from "agent-relay-sdk/provider-quota";

package/src/runner-core.ts

@@ -24,7 +24,6 @@ import { RunnerInsights } from "./runner-insights";
 import { BusyReconciler } from "./busy-reconciler";
 import { publishCapturedResponse } from "./response-capture-report";
 import { runnerLaunchInjectionSessionEvents, type RunnerRelayInjectionEvent } from "./relay-injection-events";
-import { RunnerQuotaPoller } from "./quota";
 import { capsFromEnv, contextStateDirFromEnv, logLevelFromEnv, mcpProxyEnabledFromEnv, orchestratorBaseDirFromEnv, orchestratorUrlFromEnv, registrationTimeoutMsFromEnv, runnerInfoFileFromEnv, runnerLogFileFromEnv, runnerOutboxDirWithInfoFallback, sessionDebugEnabled, tagsFromEnv, workspaceModeFromEnv } from "./config";
 import {
   appliedAgentProfileMetadata,
@@ -205,7 +204,6 @@ export class AgentRunner {
   private readonly sessionOutbox: Outbox;
   private readonly insights: RunnerInsights;
   private readonly busyReconciler: BusyReconciler;
-  private readonly quotaPoller: RunnerQuotaPoller;
   private currentToken?: string;
   private currentTokenJti?: string;
   private currentTokenProfileId?: string;
@@ -353,7 +351,6 @@ export class AgentRunner {
       clearProviderTurn: (reason) => this.forceClearProviderTurn(reason),
       sessionDebug: (message) => this.sessionDebug(message),
     });
-    this.quotaPoller = new RunnerQuotaPoller({ provider: options.provider, agentId: this.agentId, getProcess: () => this.process, onUpdate: () => this.publishStatus(), log: (message) => this.logRunnerDiagnostic(message), reportProviderQuota: (input) => this.http.upsertProviderQuota(input).then(() => {}) });
     this.bus = new RelayBusClient({
       url: relayBusUrl(options.relayUrl),
       role: "provider",
@@ -464,7 +461,7 @@ export class AgentRunner {
     void this.sweepStaleScratch();
     this.process = await this.spawnProvider();
     this.writeRunnerInfoFile();
-    this.processStartedAt = Date.now(); this.quotaPoller.start();
+    this.processStartedAt = Date.now();
     this.publishStatus();
     await this.deliverInitialPrompt();
     await this.bootstrapUnreadMessages();
@@ -496,7 +493,7 @@ export class AgentRunner {
     if (this.httpLivenessTimer) clearInterval(this.httpLivenessTimer);
     this.httpLivenessTimer = undefined;
     if (this.tokenRenewTimer) clearTimeout(this.tokenRenewTimer);
-    this.tokenRenewTimer = undefined; this.quotaPoller.stop();
+    this.tokenRenewTimer = undefined;
     this.busyReconciler.disarm();
     this.stopReasoningTail();
     this.obligationCache.stop();
@@ -937,7 +934,6 @@ export class AgentRunner {
       if (this.stopped) return;
       this.process = await this.spawnProvider();
       this.processStartedAt = Date.now();
-      this.quotaPoller.clear(); this.quotaPoller.start();
     } finally {
       this.restartInProgress = false;
     }
@@ -2114,7 +2110,7 @@ export class AgentRunner {
     const probeMetrics = this.latestProbeMetrics();
     const probeContext = probeMetrics ? contextStateFromProbeMetrics(probeMetrics) : undefined;
     const context = processContext ?? probeContext;
-    const quota = this.quotaPoller.current ?? (probeMetrics ? quotaStateFromProbeMetrics(probeMetrics) : undefined);
+    const quota = probeMetrics ? quotaStateFromProbeMetrics(probeMetrics) : undefined;
     const terminalSession = this.providerTerminalSession();
     const terminalSocket = this.providerTerminalSocket();
     const probeModel: ProbeModelInfo | undefined = probeMetrics?.model || probeMetrics?.effort