deepline 0.1.230 → 0.1.232

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -1454,7 +1454,7 @@ async function executeTool(
     providerIdempotencyKey?: string | null;
   },
   workflowStep?: WorkflowStep,
-  onProviderBackpressure?: (retryAfterMs: number) => void,
+  onProviderBackpressure?: (retryAfterMs: number) => void | Promise<void>,
   onRetryAttempt?: () => void | Promise<void>,
   transientHttpRetrySafe = false,
   abortSignal?: AbortSignal,
@@ -1500,7 +1500,7 @@ async function executeToolWithLifecycle(
   },
   workflowStep: WorkflowStep | undefined,
   callbacks: WorkerCtxCallbacks | undefined,
-  onProviderBackpressure?: (retryAfterMs: number) => void,
+  onProviderBackpressure?: (retryAfterMs: number) => void | Promise<void>,
   onRetryAttempt?: () => void | Promise<void>,
   transientHttpRetrySafe = false,
   abortSignal?: AbortSignal,
@@ -1690,7 +1690,7 @@ async function callToolDirect(
     executionAuthScopeDigest?: string | null;
     providerIdempotencyKey?: string | null;
   },
-  onProviderBackpressure?: (retryAfterMs: number) => void,
+  onProviderBackpressure?: (retryAfterMs: number) => void | Promise<void>,
   // Invoked once per in-process retry attempt (429 / retryable 5xx / synthetic
   // transient) so the Governor charges chargeBudget('retry') per attempt — the
   // same runaway guard the cjs runner applies (context.ts charges retry on each
@@ -1877,7 +1877,7 @@ async function callToolDirect(
     if (failure.backpressureDelayMs !== null) {
       // Feed the provider's backpressure into the shared pacer even on the
       // final attempt so the (org, provider) bucket backs off across isolates.
-      onProviderBackpressure?.(failure.backpressureDelayMs);
+      await onProviderBackpressure?.(failure.backpressureDelayMs);
     }
     if (!failure.shouldRetry) {
       throw lastError;
@@ -2616,7 +2616,7 @@ function isWorkerFetchResponse(value: unknown): value is WorkerFetchResponse {
 async function postRuntimeEgressFetch(
   req: RunRequest,
   payload: RuntimeEgressFetchPayload,
-  onProviderBackpressure?: (retryAfterMs: number) => void,
+  onProviderBackpressure?: (retryAfterMs: number) => void | Promise<void>,
   onRetryAttempt?: () => void | Promise<void>,
 ): Promise<WorkerFetchResponse> {
   let lastError: Error | null = null;
@@ -2667,7 +2667,7 @@ async function postRuntimeEgressFetch(
       Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
         ? Math.ceil(retryAfterSeconds * 1000)
         : 1_000;
-    onProviderBackpressure?.(retryAfterMs);
+    await onProviderBackpressure?.(retryAfterMs);
     if (attempt >= TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS) {
       throw lastError;
     }
@@ -3776,7 +3776,7 @@ function createWorkerToolAuthScopeDigestResolver(req: RunRequest) {
   // (RuntimeToolAuthScopeDigestResolver), whose `invalidate` member is
   // REQUIRED — the AUTH_SCOPE_CHANGED re-claim wiring below calls it directly,
   // and a resolver without eviction support must be a type error.
-  return createRuntimeToolAuthScopeDigestResolver({
+  const digestResolver = createRuntimeToolAuthScopeDigestResolver({
     missingToolIdMessage: 'Tool auth scope needs tool id.',
     fetchDigest: async (normalized) => {
       const runScopedPath =
@@ -3807,12 +3807,19 @@ function createWorkerToolAuthScopeDigestResolver(req: RunRequest) {
       return digest;
     },
   });
+  return digestResolver;
 }
 
 function createWorkerPacingResolver(req: RunRequest): WorkerPacingResolver {
   const cache = new Map<
     string,
-    Promise<(ResolvedPacingPolicy & { retrySafeTransientHttp: boolean }) | null>
+    Promise<
+      | (ResolvedPacingPolicy & {
+          retrySafeTransientHttp: boolean;
+          r: { bucketId: string; token: string } | null;
+        })
+      | null
+    >
   >();
   return (toolId: string) => {
     const normalized = String(toolId || '').trim();
@@ -3840,6 +3847,7 @@ function createWorkerPacingResolver(req: RunRequest): WorkerPacingResolver {
         provider?: unknown;
         queueHints?: unknown;
         retry?: unknown;
+        r?: { bucketId: string; token: string };
       } | null;
       if (!body) return null;
       const pacing = pacingPolicyFromUnknownQueueHints(body.queueHints);
@@ -3857,6 +3865,7 @@ function createWorkerPacingResolver(req: RunRequest): WorkerPacingResolver {
               : '',
           rules: [],
         }),
+        r: body.r ?? null,
         retrySafeTransientHttp: retry.retrySafeTransientHttp === true,
       };
     })();
@@ -3883,11 +3892,13 @@ function resumeGovernanceFromRequest(req: RunRequest): GovernanceSnapshot {
   };
 }
 
-function createGovernorForRun(req: RunRequest): {
+function createGovernorForRun(
+  req: RunRequest,
+  resolvePacing: WorkerPacingResolver,
+): {
   governor: PlayExecutionGovernor;
   resolvePacing: WorkerPacingResolver;
 } {
-  const resolvePacing = createWorkerPacingResolver(req);
   const governor = createPlayExecutionGovernor({
     adapter: 'esm_workers',
     scope: {
@@ -3906,6 +3917,8 @@ function createGovernorForRun(req: RunRequest): {
         }),
     ),
     resolvePacing,
+    resolveRateScope: async (toolId) =>
+      (await resolvePacing(toolId))?.r ?? null,
     resume: resumeGovernanceFromRequest(req),
   });
   return { governor, resolvePacing };
@@ -3944,12 +3957,15 @@ function createMinimalWorkerCtx(
   leasedSheetNamespaces?: Set<string>,
   receiptSalvage?: ReceiptSalvageBuffer,
 ): unknown {
-  const { governor, resolvePacing: resolveToolPacing } =
-    createGovernorForRun(req);
-  const resolveToolActionCacheVersion =
-    createWorkerToolActionCacheVersionResolver(req);
+  const resolveToolPacing = createWorkerPacingResolver(req);
+  const { governor } = createGovernorForRun(req, resolveToolPacing);
   const resolveToolAuthScopeDigest =
     createWorkerToolAuthScopeDigestResolver(req);
+  const resolveToolActionCacheVersion =
+    createWorkerToolActionCacheVersionResolver(req);
+  // Play-call depth/count/per-parent budgets, child-play concurrency, and the
+  // lineage snapshot are owned by the Governor (createGovernorForRun above).
+  // The worker keeps only substrate mechanism here.
   const stepCallCounts: Record<string, number> = {};
   const secretRedactor = createSecretRedactionContext();
 
@@ -4004,7 +4020,7 @@ function createMinimalWorkerCtx(
     input: Record<string, unknown>;
     workflowStep?: unknown;
     callbacks?: WorkerCtxCallbacks;
-    onProviderBackpressure?: (retryAfterMs: number) => void;
+    onProviderBackpressure?: (retryAfterMs: number) => void | Promise<void>;
     onRetryAttempt?: () => void | Promise<void>;
     transientHttpRetrySafe?: boolean;
     durableCallReceiptKey?: string | null;

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-dispatch.ts

@@ -73,7 +73,11 @@ import type { WorkerWorkBudgetMeter } from './work-budget';
 export type WorkerPacingResolver = (
   toolId: string,
 ) => Promise<
-  (ResolvedPacingPolicy & { retrySafeTransientHttp: boolean }) | null
+  | (ResolvedPacingPolicy & {
+      retrySafeTransientHttp: boolean;
+      r: { bucketId: string; token: string } | null;
+    })
+  | null
 >;
 
 export type WorkerToolActionCacheVersionResolver = (
@@ -111,7 +115,7 @@ export type WorkerToolDispatchExecuteTool = (input: {
   input: Record<string, unknown>;
   workflowStep?: WorkflowStepLike;
   callbacks?: WorkerToolDispatchCallbacks;
-  onProviderBackpressure?: (retryAfterMs: number) => void;
+  onProviderBackpressure?: (retryAfterMs: number) => void | Promise<void>;
   onRetryAttempt?: () => void | Promise<void>;
   transientHttpRetrySafe?: boolean;
   durableCallReceiptKey?: string | null;
@@ -561,17 +565,19 @@ export class WorkerToolBatchScheduler {
    * isolates. Provider comes from the same pacing resolver the Governor uses
    * (the worker has no local catalog), so callers pass only the toolId.
    */
-  private reportBackpressure(toolId: string, retryAfterMs: number): void {
+  private async reportBackpressure(
+    toolId: string,
+    retryAfterMs: number,
+  ): Promise<void> {
     if (retryAfterMs <= 0) return;
-    void (async () => {
-      const pacing = await this.options.resolvePacing(toolId).catch(() => null);
-      if (pacing?.provider) {
-        this.options.governor.reportProviderBackpressure({
-          provider: pacing.provider,
-          retryAfterMs,
-        });
-      }
-    })();
+    const pacing = await this.options.resolvePacing(toolId).catch(() => null);
+    if (pacing?.provider) {
+      await this.options.governor.reportProviderBackpressure({
+        provider: pacing.provider,
+        toolId,
+        retryAfterMs,
+      });
+    }
   }
 
   async execute(

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

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.230',
+  version: '0.1.232',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.230',
+    latest: '0.1.232',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

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

@@ -57,10 +57,12 @@ export {
 import {
   createDefaultGovernanceSnapshot,
   createPlayExecutionGovernor,
+  defaultPacingForTool,
   type GovernanceSnapshot,
   type PacingResolver,
   type PlayExecutionGovernor,
 } from './governor/governor';
+import { resolveExecutionPolicy } from './governor/policy';
 import {
   createRuntimeResourceGovernor,
   type RuntimeResourceGovernor,
@@ -1142,12 +1144,20 @@ function cloneMapFrame(frame: MapExecutionFrame): MapExecutionFrame {
  */
 function createPacingResolver(
   getToolQueueHints: ContextOptions['getToolQueueHints'],
+  getToolProvider: ContextOptions['getToolProvider'],
 ): PacingResolver {
   return async (toolId: string) => {
     const builtin = pacingPolicyForTool(toolId, []);
     if (builtin) return builtin;
     const hints = getToolQueueHints ? await getToolQueueHints(toolId) : [];
-    return pacingPolicyForTool(toolId, hints);
+    const declared = pacingPolicyForTool(toolId, hints);
+    if (declared) return declared;
+    const provider = (await getToolProvider?.(toolId))?.trim();
+    if (!provider) return null;
+    return {
+      ...defaultPacingForTool(toolId, resolveExecutionPolicy('cjs_node20')),
+      provider,
+    };
   };
 }
 
@@ -1375,7 +1385,11 @@ export class PlayContextImpl {
         },
         rateState: options.rateState ?? new InMemoryRateStateBackend(),
         budgetState: options.budgetState,
-        resolvePacing: createPacingResolver(options.getToolQueueHints),
+        resolvePacing: createPacingResolver(
+          options.getToolQueueHints,
+          options.getToolProvider,
+        ),
+        resolveRateScope: options.getToolRateScope,
         // A root run keeps depth 0 (its first child play is depth 1) but still
         // seeds its own play id into the ancestry/currentPlayId so the cycle guard
         // catches a child re-invoking the root. createDefaultGovernanceSnapshot
@@ -8533,8 +8547,9 @@ export class PlayContextImpl {
       ? await this.#options.getToolQueueHints(toolId)
       : [];
     const provider = hints[0]?.provider?.trim() || `tool:${toolId}`;
-    this.resourceGovernor.reportProviderBackpressure({
+    await this.resourceGovernor.reportProviderBackpressure({
       provider,
+      toolId,
       retryAfterMs,
     });
   }

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -641,12 +641,20 @@ export interface ContextOptions {
   runtimeSheetBackedMapDatasets?: boolean;
   resolvePlay?: (playRef: string) => Promise<ResolvedPlayExecution | null>;
   getToolQueueHints?: (toolId: string) => Promise<readonly PlayQueueHint[]>;
+  getToolProvider?: (toolId: string) => Promise<string | null>;
   getToolRetryPolicy?: (toolId: string) => Promise<{
     retrySafeTransientHttp?: boolean;
     requiresExecutionFence?: boolean;
   } | null>;
   getToolActionCacheVersion?: (toolId: string) => Promise<string> | string;
   getToolAuthScopeDigest?: (toolId: string) => Promise<string> | string;
+  getToolRateScope?: (
+    toolId: string,
+    provider: string,
+  ) =>
+    | Promise<{ bucketId: string; token: string } | null>
+    | { bucketId: string; token: string }
+    | null;
   invalidateToolAuthScopeDigest?: (toolId: string) => void;
   getToolTargetGetters?: (
     toolId: string,