deepline 0.1.294 → 0.1.295

package/dist/bundling-sources/sdk/src/release.ts

@@ -155,7 +155,7 @@ export const SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: '0.1.294',
+  version: '0.1.295',
   contracts: {
     api: {
       name: 'sdk-http-api',

package/dist/bundling-sources/shared_libs/play-runtime/governor/app-runtime-rate-state-backend.ts

@@ -228,13 +228,14 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
 
     const ordered = [...rules].sort((a, b) => a.ruleId.localeCompare(b.ruleId));
     const rulesKey = rulesSignature(ordered);
+    const laneKey = rateLaneKey(bucketId, rulesKey);
 
     // Drawing a cached permit is a synchronous, single-threaded critical
     // section (`drawFromBlock` has no `await`), so concurrent acquires can never
     // hand out the same permit — no lock is needed for the fast path. The ONLY
     // thing that needs coordination is the block refill, which we single-flight
-    // per bucket: one network round-trip (and any window-exhausted sleep) serves
-    // the whole waiting wave, then everyone re-draws. This replaces the old
+    // per bucket + rule set: one network round-trip (and any window-exhausted
+    // sleep) serves the whole matching wave, then everyone re-draws. This replaces the old
     // per-bucket lock that held across the RPC + up-to-5s sleep and thereby
     // serialized every map row behind one sleeping acquirer.
     while (true) {
@@ -243,7 +244,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
           ? signal.reason
           : new Error('Rate-state acquire aborted.');
       }
-      const localPermit = this.drawFromBlock(bucketId, rulesKey);
+      const localPermit = this.drawFromBlock(bucketId, laneKey);
       if (localPermit) {
         const waitMs = localPermit.scheduledAtMs - this.now();
         if (waitMs > 0) await this.sleep(waitMs);
@@ -258,19 +259,20 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
       // Count this acquirer as waiting on the refill so the single-flight refill
       // can size its block to the live wave. Decremented once a block lands (or
       // the refill errors) — see the finally in `refillBlock`.
-      this.waiters.set(bucketId, (this.waiters.get(bucketId) ?? 0) + 1);
+      this.waiters.set(laneKey, (this.waiters.get(laneKey) ?? 0) + 1);
       try {
         await this.refillBlock(
           bucketId,
           input.rateScopeToken?.trim() || null,
           ordered,
           rulesKey,
+          laneKey,
           signal,
         );
       } finally {
-        const remaining = (this.waiters.get(bucketId) ?? 1) - 1;
-        if (remaining > 0) this.waiters.set(bucketId, remaining);
-        else this.waiters.delete(bucketId);
+        const remaining = (this.waiters.get(laneKey) ?? 1) - 1;
+        if (remaining > 0) this.waiters.set(laneKey, remaining);
+        else this.waiters.delete(laneKey);
       }
     }
   }
@@ -285,7 +287,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
    * without reserving a single slot that cannot be used.
    */
   private requestedForBucket(
-    bucketId: string,
+    laneKey: string,
     rules: readonly PacingRule[],
   ): number {
     const floor = APP_RUNTIME_RATE_STATE_LEASE_BLOCK_SIZE;
@@ -294,7 +296,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     );
     const horizonBudget = Math.max(
       1,
-      Math.ceil(this.effectiveRps.get(bucketId) ?? configuredRps),
+      Math.ceil(this.effectiveRps.get(laneKey) ?? configuredRps),
     );
     const rateBudget = Math.min(
       horizonBudget,
@@ -303,7 +305,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
         .filter((value) => Number.isFinite(value) && value > 0),
     );
     if (!Number.isFinite(rateBudget) || rateBudget <= 0) return floor;
-    const waiters = this.waiters.get(bucketId) ?? 1;
+    const waiters = this.waiters.get(laneKey) ?? 1;
     const concurrencyLimits = rules.flatMap((rule) =>
       rule.maxConcurrency != null &&
       Number.isFinite(rule.maxConcurrency) &&
@@ -391,22 +393,24 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     rateScopeToken: string | null,
     ordered: PacingRule[],
     rulesKey: string,
+    laneKey: string,
     signal?: AbortSignal,
   ): Promise<void> {
-    const existing = this.refills.get(bucketId);
+    const existing = this.refills.get(laneKey);
     if (existing) return existing;
     const promise = this.performRefill(
       bucketId,
       rateScopeToken,
       ordered,
       rulesKey,
+      laneKey,
       signal,
     ).finally(() => {
-      if (this.refills.get(bucketId) === promise) {
-        this.refills.delete(bucketId);
+      if (this.refills.get(laneKey) === promise) {
+        this.refills.delete(laneKey);
       }
     });
-    this.refills.set(bucketId, promise);
+    this.refills.set(laneKey, promise);
     return promise;
   }
 
@@ -415,6 +419,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     rateScopeToken: string | null,
     ordered: PacingRule[],
     rulesKey: string,
+    laneKey: string,
     signal?: AbortSignal,
   ): Promise<void> {
     let consecutiveFailures = 0;
@@ -435,24 +440,25 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
         if (signal?.aborted) return;
       }
       try {
-        const observedSuccesses = this.pendingSuccesses.get(bucketId) ?? 0;
+        const successKey = pendingSuccessKey(bucketId, ordered);
+        const observedSuccesses = this.pendingSuccesses.get(successKey) ?? 0;
         const response = await this.port.acquire({
           bucketId,
           rateScopeToken,
           // Stamp adaptiveMaxRps on default-pacing rules so the DB row's ceiling
           // matches the old in-memory AIMD range.
           rules: withAdaptiveMaxRps(ordered),
-          requested: this.requestedForBucket(bucketId, ordered),
+          requested: this.requestedForBucket(laneKey, ordered),
           observedSuccesses,
           schedulerSchema: this.schedulerSchema,
         });
         if (observedSuccesses > 0) {
           const remaining = Math.max(
             0,
-            (this.pendingSuccesses.get(bucketId) ?? 0) - observedSuccesses,
+            (this.pendingSuccesses.get(successKey) ?? 0) - observedSuccesses,
           );
-          if (remaining > 0) this.pendingSuccesses.set(bucketId, remaining);
-          else this.pendingSuccesses.delete(bucketId);
+          if (remaining > 0) this.pendingSuccesses.set(successKey, remaining);
+          else this.pendingSuccesses.delete(successKey);
         }
         this.recordCooldown(bucketId, response);
         if (
@@ -460,7 +466,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
           Number(response.effectiveRequestsPerSecond) > 0
         ) {
           this.effectiveRps.set(
-            bucketId,
+            laneKey,
             Number(response.effectiveRequestsPerSecond),
           );
         }
@@ -472,6 +478,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
             rateScopeToken,
             ordered,
             rulesKey,
+            laneKey,
             response,
           );
           return;
@@ -523,6 +530,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     rateScopeToken: string | null,
     ordered: PacingRule[],
     rulesKey: string,
+    laneKey: string,
     response: {
       granted: number;
       leaseIds?: unknown;
@@ -579,6 +587,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
         hasConcurrency ? (leaseIds[index] ?? null) : null,
       ]),
       rulesKey,
+      laneKey,
       ordered,
     );
   }
@@ -589,7 +598,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     cooldownMs: number;
   }): Promise<void> {
     if (input.cooldownMs <= 0) return;
-    this.drainBlock(input.bucketId);
+    this.drainBlocksForBucket(input.bucketId);
     try {
       await this.port.penalize({
         bucketId: input.bucketId,
@@ -609,10 +618,14 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     }
   }
 
-  observeSuccess(input: { bucketId: string }): void {
+  observeSuccess(input: {
+    bucketId: string;
+    rules: readonly PacingRule[];
+  }): void {
+    const key = pendingSuccessKey(input.bucketId, input.rules);
     this.pendingSuccesses.set(
-      input.bucketId,
-      Math.min(1_000_000, (this.pendingSuccesses.get(input.bucketId) ?? 0) + 1),
+      key,
+      Math.min(1_000_000, (this.pendingSuccesses.get(key) ?? 0) + 1),
     );
   }
 
@@ -645,12 +658,13 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     rateScopeToken: string | null,
     permits: LeasedBlock['permits'],
     rulesKey: string,
+    laneKey: string,
     rules: PacingRule[],
   ): void {
     const lastScheduledAtMs = permits.at(-1)?.[0] ?? this.now();
     const freshExpiresAt =
       Math.max(this.now(), lastScheduledAtMs) + leasedBlockTtlMs(rules);
-    const existing = this.blocks.get(bucketId);
+    const existing = this.blocks.get(laneKey);
     if (
       existing &&
       existing.rulesKey === rulesKey &&
@@ -668,7 +682,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
         existing.rules,
         existing.permits.flatMap(([, leaseId]) => (leaseId ? [leaseId] : [])),
       );
-    this.blocks.set(bucketId, {
+    this.blocks.set(laneKey, {
       permits,
       rateScopeToken,
       expiresAt: freshExpiresAt,
@@ -679,12 +693,12 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
 
   private drawFromBlock(
     bucketId: string,
-    rulesKey: string,
+    laneKey: string,
   ): { permit: PacingPermit; scheduledAtMs: number } | null {
-    const block = this.blocks.get(bucketId);
+    const block = this.blocks.get(laneKey);
     if (!block) return null;
-    if (block.rulesKey !== rulesKey || block.expiresAt <= this.now()) {
-      this.blocks.delete(bucketId);
+    if (block.expiresAt <= this.now()) {
+      this.blocks.delete(laneKey);
       // Unused window permits are forfeited on TTL expiry (the server already
       // decremented the provider window for them, and the rule-scoped TTL is
       // capped so at most one block's worth is stranded per bucket/window).
@@ -699,10 +713,10 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     }
     const scheduled = block.permits.shift();
     if (!scheduled) {
-      this.blocks.delete(bucketId);
+      this.blocks.delete(laneKey);
       return null;
     }
-    if (block.permits.length === 0) this.blocks.delete(bucketId);
+    if (block.permits.length === 0) this.blocks.delete(laneKey);
     return {
       permit: this.permitFor(
         bucketId,
@@ -714,16 +728,18 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     };
   }
 
-  private drainBlock(bucketId: string): void {
-    const block = this.blocks.get(bucketId);
-    if (!block) return;
-    this.blocks.delete(bucketId);
-    this.releaseReserved(
-      bucketId,
-      block.rateScopeToken,
-      block.rules,
-      block.permits.flatMap(([, leaseId]) => (leaseId ? [leaseId] : [])),
-    );
+  private drainBlocksForBucket(bucketId: string): void {
+    const prefix = `${bucketId}\0`;
+    for (const [laneKey, block] of this.blocks) {
+      if (!laneKey.startsWith(prefix)) continue;
+      this.blocks.delete(laneKey);
+      this.releaseReserved(
+        bucketId,
+        block.rateScopeToken,
+        block.rules,
+        block.permits.flatMap(([, leaseId]) => (leaseId ? [leaseId] : [])),
+      );
+    }
   }
 
   private releaseReserved(
@@ -814,20 +830,22 @@ function isDefaultPacingRuleId(ruleId: string): boolean {
 }
 
 /**
- * Stamp `adaptiveMaxRps` onto default-pacing rules so the DB row's ceiling matches
- * the old in-memory AIMD range (base * 25). Declared rules pass through untouched
- * (the DB pins them at base). The field is extra on the wire; the server's
- * `normalizeRules` reads it, everyone else ignores it.
+ * Preserve explicit advisory ceilings and stamp the legacy base * 25 ceiling
+ * only onto undeclared default-pacing rules. Declared rules without a ceiling
+ * remain pinned at base.
  */
 function withAdaptiveMaxRps(rules: readonly PacingRule[]): PacingRule[] {
   return rules.map((rule) =>
-    isDefaultPacingRuleId(rule.ruleId)
-      ? ({
-          ...rule,
-          adaptiveMaxRps:
-            rule.requestsPerWindow * DEFAULT_PACING_ADAPTIVE_MAX_RPS_MULTIPLIER,
-        } as PacingRule)
-      : rule,
+    rule.adaptiveMaxRps != null
+      ? rule
+      : isDefaultPacingRuleId(rule.ruleId)
+        ? ({
+            ...rule,
+            adaptiveMaxRps:
+              rule.requestsPerWindow *
+              DEFAULT_PACING_ADAPTIVE_MAX_RPS_MULTIPLIER,
+          } as PacingRule)
+        : rule,
   );
 }
 
@@ -835,12 +853,23 @@ function rulesSignature(rules: readonly PacingRule[]): string {
   return [...rules]
     .map(
       (rule) =>
-        `${rule.ruleId}:${rule.requestsPerWindow}:${rule.windowMs}:${rule.maxConcurrency ?? ''}`,
+        `${rule.ruleId}:${rule.requestsPerWindow}:${rule.windowMs}:${rule.adaptiveMaxRps ?? ''}:${rule.maxConcurrency ?? ''}`,
     )
     .sort()
     .join('|');
 }
 
+function rateLaneKey(bucketId: string, rulesKey: string): string {
+  return `${bucketId}\0${rulesKey}`;
+}
+
+function pendingSuccessKey(
+  bucketId: string,
+  rules: readonly PacingRule[],
+): string {
+  return rateLaneKey(bucketId, rulesSignature(rules));
+}
+
 function leasedBlockTtlMs(rules: readonly PacingRule[]): number {
   const shortestWindowMs = Math.min(
     ...rules

package/dist/bundling-sources/shared_libs/play-runtime/governor/governor.ts

@@ -267,6 +267,7 @@ export function createPlayExecutionGovernor(
     });
   const budgetState = input.budgetState ?? new InMemoryBudgetStateBackend();
   const providerByTool = new Map<string, string>();
+  const pacingRulesByTool = new Map<string, PacingRule[]>();
   const scopeByTool = new Map<string, [string, string]>();
   const providerConcurrencySlotsByTool = new Map<string, Semaphore>();
 
@@ -308,6 +309,7 @@ export function createPlayExecutionGovernor(
       // row is authoritative.
       const pacing = declaredPacing ?? defaultPacingForTool(toolId, policy);
       providerByTool.set(toolId, pacing.provider);
+      pacingRulesByTool.set(toolId, pacing.rules);
       return pacing;
     }
     const pacing = adaptiveAdmission.resolvePacing({
@@ -317,6 +319,7 @@ export function createPlayExecutionGovernor(
       fallbackPacing: defaultPacingForTool(toolId, policy),
     });
     providerByTool.set(toolId, pacing.provider);
+    pacingRulesByTool.set(toolId, pacing.rules);
     return pacing;
   }
 
@@ -486,9 +489,13 @@ export function createPlayExecutionGovernor(
 
     observeProviderSuccess(success) {
       if (dbAuthoritativePacing) {
+        if (!success.toolId) return;
         const rateScope = scopeFor(success.toolId, success.provider);
+        const rules = pacingRulesByTool.get(success.toolId);
+        if (!rules) return;
         input.rateState.observeSuccess?.({
           bucketId: rateScope[0],
+          rules,
         });
         return;
       }

package/dist/bundling-sources/shared_libs/play-runtime/governor/rate-state-backend.ts

@@ -11,6 +11,8 @@ export interface PacingRule {
   readonly ruleId: string;
   readonly requestsPerWindow: number;
   readonly windowMs: number;
+  /** Optional learned-rate ceiling in requests per second. */
+  readonly adaptiveMaxRps?: number | null;
   /**
    * Optional simultaneous-in-flight cap for this rule.
    *
@@ -35,6 +37,7 @@ export interface PlayQueueHint {
   ruleId: string;
   requestsPerWindow: number;
   windowMs: number;
+  adaptiveMaxRps?: number | null;
   maxConcurrency: number | null;
 }
 
@@ -88,6 +91,7 @@ export interface RateStateBackend {
   observeSuccess?(input: {
     bucketId: string;
     rateScopeToken?: string | null;
+    rules: readonly PacingRule[];
   }): void;
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/pacing.ts

@@ -8,7 +8,12 @@ export type ResolvedPacingPolicy = {
 
 type PacingPolicyQueueHint = Pick<
   PlayQueueHint,
-  'provider' | 'ruleId' | 'requestsPerWindow' | 'windowMs' | 'maxConcurrency'
+  | 'provider'
+  | 'ruleId'
+  | 'requestsPerWindow'
+  | 'windowMs'
+  | 'adaptiveMaxRps'
+  | 'maxConcurrency'
 >;
 
 function isFinitePositiveNumber(value: unknown): value is number {
@@ -35,6 +40,9 @@ export function pacingPolicyFromQueueHints(
         ruleId: hint.ruleId,
         requestsPerWindow: hint.requestsPerWindow,
         windowMs: hint.windowMs,
+        adaptiveMaxRps: isFinitePositiveNumber(hint.adaptiveMaxRps)
+          ? hint.adaptiveMaxRps
+          : null,
         maxConcurrency:
           typeof hint.maxConcurrency === 'number' &&
           Number.isFinite(hint.maxConcurrency) &&
@@ -65,6 +73,8 @@ export function pacingPolicyFromUnknownQueueHints(
             : Number.NaN,
         windowMs:
           typeof hint.windowMs === 'number' ? hint.windowMs : Number.NaN,
+        adaptiveMaxRps:
+          typeof hint.adaptiveMaxRps === 'number' ? hint.adaptiveMaxRps : null,
         maxConcurrency:
           typeof hint.maxConcurrency === 'number' ? hint.maxConcurrency : null,
       })),

package/dist/cli/index.js

@@ -718,7 +718,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.294",
+  version: "0.1.295",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/cli/index.mjs

@@ -703,7 +703,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.294",
+  version: "0.1.295",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/index.js

@@ -438,7 +438,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.294",
+  version: "0.1.295",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/index.mjs

@@ -367,7 +367,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.294",
+  version: "0.1.295",
   contracts: {
     api: {
       name: "sdk-http-api",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.294",
+  "version": "0.1.295",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {