deepline 0.1.252 → 0.1.254

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

@@ -116,7 +116,8 @@ export const SDK_RELEASE = {
   // 0.1.252 hard-cuts the customer Monitor catalog to the two launched
   // Deepline-native radars. Older clients must update before discovering,
   // checking, or deploying an unlaunched monitor integration.
-  version: '0.1.252',
+  // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
+  version: '0.1.254',
   apiContract: '2026-07-native-monitor-launch-hard-cutover',
   supportPolicy: {
     minimumSupported: '0.1.53',
@@ -124,9 +125,9 @@ export const SDK_RELEASE = {
     commandMinimumSupported: [
       {
         command: 'enrich',
-        minimumSupported: '0.1.238',
+        minimumSupported: '0.1.253',
         reason:
-          'Older SDK CLI enrich generated stale play source; SDK CLI enrich 0.1.153 generated removed StepOptions fields in play source; SDK CLI enrich before 0.1.175 could silently succeed on the empty-waterfall bug when a requested waterfall returned no values for selected rows; SDK CLI enrich before 0.1.230 could convert extractor failures into successful unmatched results; SDK CLI enrich before 0.1.238 could drop a nested provider email match during generic pick("email") extraction and materialize it as NO_MATCH.',
+          'Older SDK CLI enrich generated stale play source; SDK CLI enrich 0.1.153 generated removed StepOptions fields in play source; SDK CLI enrich before 0.1.175 could silently succeed on the empty-waterfall bug when a requested waterfall returned no values for selected rows; SDK CLI enrich before 0.1.230 could convert extractor failures into successful unmatched results; SDK CLI enrich before 0.1.238 could drop a nested provider email match during generic pick("email") extraction and materialize it as NO_MATCH; SDK CLI enrich before 0.1.253 opens the generated play page by default and accepts the removed --no-open flag.',
       },
       {
         command: 'plays',
@@ -136,16 +137,16 @@ export const SDK_RELEASE = {
       },
       {
         command: 'plays run',
-        minimumSupported: '0.1.241',
+        minimumSupported: '0.1.253',
         reason:
-          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract.',
+          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract; versions before 0.1.253 open the play page by default and accept the removed --no-open flag.',
       },
       {
         command: 'run',
         displayCommand: 'plays run',
-        minimumSupported: '0.1.241',
+        minimumSupported: '0.1.253',
         reason:
-          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract.',
+          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract; versions before 0.1.253 open the play page by default and accept the removed --no-open flag.',
       },
       {
         command: 'plays check',

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

@@ -551,6 +551,8 @@ export interface PlayRunPackage {
     durationMs?: number | null;
     error?: string;
   };
+  /** Bounded customer-safe warnings about output projection or availability. */
+  warnings?: string[];
   /** Step-level summaries emitted by the runtime. */
   steps: Array<Record<string, unknown>>;
   /** Named output summaries, including dataset handles and scalar outputs. */

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

@@ -42,7 +42,17 @@ import {
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
-import { PLAY_RUNTIME_API_COMPAT_PATH } from './runtime-api-paths';
+import {
+  PLAY_RUNTIME_API_COMPAT_PATH,
+  PLAY_RUNTIME_OPERATION_ATTEMPT_HEADER,
+  PLAY_RUNTIME_OPERATION_ID_HEADER,
+} from './runtime-api-paths';
+import {
+  isRetryableSecretResolutionStatus,
+  secretResolutionRetryDecision,
+  SECRET_RESOLUTION_MAX_ATTEMPTS,
+  type SecretResolutionRetryDecision,
+} from './secret-resolution-retry-policy';
 import {
   createRootRunExecutionScope,
   deriveChildRunExecutionScope,
@@ -519,6 +529,26 @@ function loadSafeFetch(): Promise<SafeFetchModule> {
   return safeFetchModule;
 }
 
+function waitForSecretResolutionRetry(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+
+function cancelRuntimeResponseBody(response: Response): void {
+  try {
+    void response.body?.cancel().catch(() => {});
+  } catch {
+    // Connection cleanup must never replace the resolver failure or retry.
+  }
+}
+
+const NO_SECRET_RESOLUTION_RETRY: SecretResolutionRetryDecision = {
+  retry: false,
+  retryDelayMs: 0,
+  retryAfterMs: null,
+  retryAfterExceedsCap: false,
+};
+
 function isUnsafeOutboundUrlError(error: unknown): boolean {
   return error instanceof Error && error.name === 'UnsafeOutboundUrlError';
 }
@@ -1543,106 +1573,160 @@ export class PlayContextImpl {
       this.#options.runId
     ) {
       const url = `${this.#options.baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`;
-      const requestId = `ctx-secret-${crypto.randomUUID()}`;
-      const startedAt = Date.now();
-      let response: Response;
-      try {
-        response = await fetch(url, {
-          method: 'POST',
-          headers: {
-            Authorization: `Bearer ${this.#options.executorToken}`,
-            'Content-Type': 'application/json',
-            'x-deepline-request-id': requestId,
-            ...(await this.vercelProtectionHeaders()),
-          },
-          body: JSON.stringify({
-            action: 'resolve_secret',
-            name: auth.secret.name,
-            playName: this.#options.playName,
-          }),
-        });
-      } catch (error) {
-        const diagnostic = describeTransportError(error);
-        this.log(
-          `[runtime.secret_resolution_failure] ${JSON.stringify({
-            stage: 'transport',
-            secret_name: auth.secret.name,
-            gateway_origin: transportGatewayOriginForDiagnostic(url),
-            request_id: requestId,
-            elapsed_ms: Date.now() - startedAt,
-            error: diagnostic,
-          })}`,
-        );
-        throw new Error(
-          `Secret ${auth.secret.name} resolution transport failed (request_id=${requestId}): ${diagnostic.message ?? 'unknown transport error'}`,
-        );
-      }
+      const operationId = `ctx-secret-operation-${crypto.randomUUID()}`;
+      const operationStartedAt = Date.now();
+      for (
+        let attempt = 1;
+        attempt <= SECRET_RESOLUTION_MAX_ATTEMPTS;
+        attempt += 1
+      ) {
+        const requestId = `ctx-secret-${crypto.randomUUID()}`;
+        const attemptStartedAt = Date.now();
+        let response: Response;
+        try {
+          response = await fetch(url, {
+            method: 'POST',
+            headers: {
+              Authorization: `Bearer ${this.#options.executorToken}`,
+              'Content-Type': 'application/json',
+              'x-deepline-request-id': requestId,
+              [PLAY_RUNTIME_OPERATION_ID_HEADER]: operationId,
+              [PLAY_RUNTIME_OPERATION_ATTEMPT_HEADER]: String(attempt),
+              ...(await this.vercelProtectionHeaders()),
+            },
+            body: JSON.stringify({
+              action: 'resolve_secret',
+              name: auth.secret.name,
+              playName: this.#options.playName,
+            }),
+          });
+        } catch (error) {
+          const diagnostic = describeTransportError(error);
+          const retry = secretResolutionRetryDecision({
+            attempt,
+            retryAfter: null,
+          });
+          this.log(
+            `[runtime.secret_resolution_failure] ${JSON.stringify({
+              stage: 'transport',
+              secret_name: auth.secret.name,
+              gateway_origin: transportGatewayOriginForDiagnostic(url),
+              operation_id: operationId,
+              request_id: requestId,
+              attempt,
+              max_attempts: SECRET_RESOLUTION_MAX_ATTEMPTS,
+              retrying: retry.retry,
+              retry_delay_ms: retry.retryDelayMs,
+              elapsed_ms: Date.now() - attemptStartedAt,
+              operation_elapsed_ms: Date.now() - operationStartedAt,
+              error: diagnostic,
+            })}`,
+          );
+          if (!retry.retry) {
+            throw new Error(
+              `Secret ${auth.secret.name} resolution transport failed (request_id=${requestId}): ${diagnostic.message ?? 'unknown transport error'}`,
+            );
+          }
+          await waitForSecretResolutionRetry(retry.retryDelayMs);
+          continue;
+        }
 
-      const responseDiagnostic = {
-        stage: response.ok ? 'invalid_response' : 'http_response',
-        secret_name: auth.secret.name,
-        gateway_origin: transportGatewayOriginForDiagnostic(url),
-        request_id: requestId,
-        elapsed_ms: Date.now() - startedAt,
-        http_status: response.status,
-        status_text: response.statusText || null,
-        content_type: response.headers.get('content-type'),
-        server: response.headers.get('server'),
-        vercel_request_id:
-          response.headers.get('x-vercel-id') ??
-          response.headers.get('x-vercel-request-id'),
-        response_request_id: response.headers.get('x-deepline-request-id'),
-        error_code: response.headers.get('x-deepline-error-code'),
-        retry_after: response.headers.get('retry-after'),
-      };
-      if (!response.ok) {
-        this.log(
-          `[runtime.secret_resolution_failure] ${JSON.stringify(responseDiagnostic)}`,
-        );
-        throw new Error(
-          `Secret ${auth.secret.name} is not available to this run (resolution status=${response.status}, request_id=${requestId}).`,
-        );
-      }
+        const retryAfter = response.headers.get('retry-after');
+        const retry = isRetryableSecretResolutionStatus(response.status)
+          ? secretResolutionRetryDecision({ attempt, retryAfter })
+          : NO_SECRET_RESOLUTION_RETRY;
+        const responseDiagnostic = {
+          stage: response.ok ? 'invalid_response' : 'http_response',
+          secret_name: auth.secret.name,
+          gateway_origin: transportGatewayOriginForDiagnostic(url),
+          operation_id: operationId,
+          request_id: requestId,
+          attempt,
+          max_attempts: SECRET_RESOLUTION_MAX_ATTEMPTS,
+          retrying: retry.retry,
+          retry_delay_ms: retry.retryDelayMs,
+          elapsed_ms: Date.now() - attemptStartedAt,
+          operation_elapsed_ms: Date.now() - operationStartedAt,
+          http_status: response.status,
+          status_text: response.statusText || null,
+          content_type: response.headers.get('content-type'),
+          server: response.headers.get('server'),
+          vercel_request_id:
+            response.headers.get('x-vercel-id') ??
+            response.headers.get('x-vercel-request-id'),
+          response_request_id: response.headers.get('x-deepline-request-id'),
+          error_code: response.headers.get('x-deepline-error-code'),
+          retry_after: retryAfter,
+          retry_after_ms: retry.retryAfterMs,
+          retry_after_exceeds_cap: retry.retryAfterExceedsCap,
+        };
+        if (!response.ok) {
+          this.log(
+            `[runtime.secret_resolution_failure] ${JSON.stringify(responseDiagnostic)}`,
+          );
+          cancelRuntimeResponseBody(response);
+          if (retry.retry) {
+            await waitForSecretResolutionRetry(retry.retryDelayMs);
+            continue;
+          }
+          throw new Error(
+            `Secret ${auth.secret.name} is not available to this run (resolution status=${response.status}, request_id=${requestId}).`,
+          );
+        }
 
-      let payload: unknown;
-      try {
-        payload = await response.json();
-      } catch (error) {
-        this.log(
-          `[runtime.secret_resolution_failure] ${JSON.stringify({
-            ...responseDiagnostic,
-            response_kind: 'invalid_json',
-            parse_error_name:
-              error instanceof Error ? error.name : typeof error,
-          })}`,
-        );
-        throw new Error(
-          `Secret ${auth.secret.name} is not available to this run (invalid resolution response, request_id=${requestId}).`,
-        );
-      }
+        let payload: unknown;
+        try {
+          payload = await response.json();
+        } catch (error) {
+          this.log(
+            `[runtime.secret_resolution_failure] ${JSON.stringify({
+              ...responseDiagnostic,
+              response_kind: 'invalid_json',
+              parse_error_name:
+                error instanceof Error ? error.name : typeof error,
+            })}`,
+          );
+          throw new Error(
+            `Secret ${auth.secret.name} is not available to this run (invalid resolution response, request_id=${requestId}).`,
+          );
+        }
 
-      value =
-        payload &&
-        typeof payload === 'object' &&
-        !Array.isArray(payload) &&
-        typeof (payload as { value?: unknown }).value === 'string'
-          ? (payload as { value: string }).value
-          : null;
-      if (!value) {
-        this.log(
-          `[runtime.secret_resolution_failure] ${JSON.stringify({
-            ...responseDiagnostic,
-            response_kind:
-              payload === null
-                ? 'null'
-                : Array.isArray(payload)
-                  ? 'array'
-                  : typeof payload,
-          })}`,
-        );
-        throw new Error(
-          `Secret ${auth.secret.name} is not available to this run (missing resolution value, request_id=${requestId}).`,
-        );
+        value =
+          payload &&
+          typeof payload === 'object' &&
+          !Array.isArray(payload) &&
+          typeof (payload as { value?: unknown }).value === 'string'
+            ? (payload as { value: string }).value
+            : null;
+        if (!value) {
+          this.log(
+            `[runtime.secret_resolution_failure] ${JSON.stringify({
+              ...responseDiagnostic,
+              response_kind:
+                payload === null
+                  ? 'null'
+                  : Array.isArray(payload)
+                    ? 'array'
+                    : typeof payload,
+            })}`,
+          );
+          throw new Error(
+            `Secret ${auth.secret.name} is not available to this run (missing resolution value, request_id=${requestId}).`,
+          );
+        }
+        if (attempt > 1) {
+          this.log(
+            `[runtime.secret_resolution_recovered] ${JSON.stringify({
+              secret_name: auth.secret.name,
+              gateway_origin: transportGatewayOriginForDiagnostic(url),
+              operation_id: operationId,
+              request_id: requestId,
+              attempts: attempt,
+              operation_elapsed_ms: Date.now() - operationStartedAt,
+            })}`,
+          );
+        }
+        break;
       }
     } else {
       throw new Error(
@@ -8282,9 +8366,9 @@ export class PlayContextImpl {
     const url = `${this.#options.baseUrl}/api/v2/integrations/${encodeURIComponent(toolId)}/execute`;
     const timeoutMs = resolveToolRuntimeTimeoutMs(toolId, options?.timeoutMs);
 
-    // The Governor's tool slot is the single seam for tool-call budget + the
-    // global tool-concurrency backstop + per-(org, provider) pacing. It blocks
-    // until all three are satisfied and is held (across retries) until release.
+    // Hold one logical tool slot and charge one logical tool call for this
+    // execution. Per-provider rate admission is intentionally deferred until
+    // each physical fetch is ready to leave this process.
     const admissionStartedAt = Date.now();
     const toolSlot = await this.resourceGovernor.acquireTool({
       orgId: this.#options.orgId ?? null,
@@ -8408,7 +8492,6 @@ export class PlayContextImpl {
                   `[perf] tool call id=${toolId} phase=before_provider_ownership elapsed_ms=${Date.now() - ownershipStartedAt}`,
                 );
               }
-              providerCallStartedAt = Date.now();
               const heartbeatIntervalMs = hasReceiptHeartbeat
                 ? runtimeLeaseHeartbeatIntervalFromExpiry({
                     leaseExpiresAt: options?.receiptLeaseExpiresAt,
@@ -8438,71 +8521,87 @@ export class PlayContextImpl {
                   : null;
               receiptHeartbeatSupervisor?.start();
               try {
+                // Complete all local/receipt preparation before taking the
+                // shared provider permit. Once admitted, the next awaited work
+                // is the fetch itself, so independently delayed runners cannot
+                // compress real provider arrivals after their tickets.
+                const protectionHeaders = await this.vercelProtectionHeaders();
+                const providerPermit =
+                  await this.resourceGovernor.acquireProviderPermit({
+                    toolId,
+                    signal: abortController?.signal,
+                  });
                 const integrationFetchStartedAt = Date.now();
-                response = await fetch(url, {
-                  method: 'POST',
-                  signal: abortController?.signal,
-                  headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.#options.executorToken}`,
-                    [EXECUTE_RESPONSE_CONTRACT_HEADER]:
-                      V2_EXECUTE_RESPONSE_CONTRACT,
-                    [EXECUTE_RESPONSE_INTENT_HEADER]: 'dataset',
-                    [EXECUTE_TOOL_METADATA_HEADER]: 'true',
-                    'x-deepline-request-id': deeplineRequestId,
-                    ...(providerIdempotencyKey
-                      ? {
-                          'x-deepline-idempotency-key': providerIdempotencyKey,
-                        }
-                      : {}),
-                    ...(await this.vercelProtectionHeaders()),
-                  },
-                  body: JSON.stringify({
-                    payload: input,
-                    metadata: {
-                      parent_run_id: this.#options.runId,
-                      ...(durableCallReceiptKey
-                        ? {
-                            durable_call_receipt_key: durableCallReceiptKey,
-                            ...(executionAuthScopeDigest
-                              ? {
-                                  execution_auth_scope_digest:
-                                    executionAuthScopeDigest,
-                                }
-                              : {}),
-                          }
-                        : {}),
-                      ...(options?.customerDbDataset
+                providerCallStartedAt = integrationFetchStartedAt;
+                try {
+                  response = await fetch(url, {
+                    method: 'POST',
+                    signal: abortController?.signal,
+                    headers: {
+                      'Content-Type': 'application/json',
+                      Authorization: `Bearer ${this.#options.executorToken}`,
+                      [EXECUTE_RESPONSE_CONTRACT_HEADER]:
+                        V2_EXECUTE_RESPONSE_CONTRACT,
+                      [EXECUTE_RESPONSE_INTENT_HEADER]: 'dataset',
+                      [EXECUTE_TOOL_METADATA_HEADER]: 'true',
+                      'x-deepline-request-id': deeplineRequestId,
+                      ...(providerIdempotencyKey
                         ? {
-                            query_result_dataset: {
-                              limit: options.customerDbDataset.limit,
-                              offset: options.customerDbDataset.offset,
-                              page_size: options.customerDbDataset.pageSize,
-                              total_rows: options.customerDbDataset.totalRows,
-                            },
-                            ...(isCustomerDbDatasetTool(toolId)
-                              ? {
-                                  customer_db_dataset: {
-                                    limit: options.customerDbDataset.limit,
-                                    offset: options.customerDbDataset.offset,
-                                    page_size:
-                                      options.customerDbDataset.pageSize,
-                                    total_rows:
-                                      options.customerDbDataset.totalRows,
-                                  },
-                                }
-                              : {}),
+                            'x-deepline-idempotency-key':
+                              providerIdempotencyKey,
                           }
                         : {}),
-                      ...(providerIdempotencyKey
-                        ? { provider_idempotency_key: providerIdempotencyKey }
-                        : {}),
+                      ...protectionHeaders,
                     },
-                    ...(this.#options.integrationMode
-                      ? { integration_mode: this.#options.integrationMode }
-                      : {}),
-                  }),
-                });
+                    body: JSON.stringify({
+                      payload: input,
+                      metadata: {
+                        parent_run_id: this.#options.runId,
+                        ...(durableCallReceiptKey
+                          ? {
+                              durable_call_receipt_key: durableCallReceiptKey,
+                              ...(executionAuthScopeDigest
+                                ? {
+                                    execution_auth_scope_digest:
+                                      executionAuthScopeDigest,
+                                  }
+                                : {}),
+                            }
+                          : {}),
+                        ...(options?.customerDbDataset
+                          ? {
+                              query_result_dataset: {
+                                limit: options.customerDbDataset.limit,
+                                offset: options.customerDbDataset.offset,
+                                page_size: options.customerDbDataset.pageSize,
+                                total_rows: options.customerDbDataset.totalRows,
+                              },
+                              ...(isCustomerDbDatasetTool(toolId)
+                                ? {
+                                    customer_db_dataset: {
+                                      limit: options.customerDbDataset.limit,
+                                      offset: options.customerDbDataset.offset,
+                                      page_size:
+                                        options.customerDbDataset.pageSize,
+                                      total_rows:
+                                        options.customerDbDataset.totalRows,
+                                    },
+                                  }
+                                : {}),
+                            }
+                          : {}),
+                        ...(providerIdempotencyKey
+                          ? { provider_idempotency_key: providerIdempotencyKey }
+                          : {}),
+                      },
+                      ...(this.#options.integrationMode
+                        ? { integration_mode: this.#options.integrationMode }
+                        : {}),
+                    }),
+                  });
+                } finally {
+                  providerPermit.release();
+                }
                 if (runtimeReceiptReadTraceEnabled) {
                   this.log(
                     `[perf] tool call id=${toolId} phase=integration_fetch_headers elapsed_ms=${Date.now() - integrationFetchStartedAt} status=${response.status}`,

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

@@ -6,7 +6,8 @@
  * at once" policy. See ADR 0007 + CONTEXT.md.
  *
  * Surface (small, by design):
- *   - acquireRowSlot / acquireToolSlot                         → blocking leases
+ *   - acquireRowSlot / acquireToolSlot                         → local execution leases
+ *   - acquireProviderPermit                                   → per-attempt provider admission
  *   - chargeBudget                                            → throws on breach
  *   - forkInlineChild                                         → inline recursion scope
  *   - resolveRowConcurrency / reportProviderBackpressure / snapshot
@@ -102,15 +103,24 @@ export interface PlayExecutionGovernor {
   /** Block until a map-row slot is free. */
   acquireRowSlot(opts?: { signal?: AbortSignal }): Promise<WorkLease>;
   /**
-   * Block until the per-provider pacer permit and then a global
-   * tool-concurrency slot are free, charge the tool-call budget, and return a
-   * lease. Parked future permits never consume scarce execution slots.
+   * Acquire the local execution slot and charge one logical tool-call budget.
+   * Provider pacing deliberately happens separately at the HTTP-attempt edge.
    */
   acquireToolSlot(
     toolId: string,
     opts?: { signal?: AbortSignal },
   ): Promise<WorkLease>;
 
+  /**
+   * Block until one physical provider HTTP attempt is admitted under the
+   * provider's shared rate/concurrency rules. Call this immediately before the
+   * outbound request and again for every retry.
+   */
+  acquireProviderPermit(
+    toolId: string,
+    opts?: { signal?: AbortSignal },
+  ): Promise<WorkLease>;
+
   /**
    * Suggested batch parallelism for a tool: the provider's own rate hints
    * tightened to the policy's suggested ceiling. No hints → the fallback.
@@ -373,44 +383,34 @@ export function createPlayExecutionGovernor(
     policy,
 
     acquireRowSlot: (opts) => rowSlots.acquire(opts?.signal),
-    async acquireToolSlot(toolId, opts) {
-      // 1. Per-provider pacing. The provider comes from the pacing
-      //    resolver, so callers only need the toolId. No rules → no pacing.
+    async acquireToolSlot(_toolId, opts) {
+      const slot = await toolSlots.acquire(opts?.signal);
+      // Charge the logical call only after its local execution slot is held, so
+      // a failed/aborted slot acquisition never consumes the budget. The
+      // physical provider admission is intentionally deferred to
+      // acquireProviderPermit at the outbound HTTP edge.
+      try {
+        await chargeBudget('toolCall');
+      } catch (error) {
+        slot.release();
+        throw error;
+      }
+      return slot;
+    },
+
+    async acquireProviderPermit(toolId, opts) {
+      // The rate ticket is an admission for a physical outbound attempt, not a
+      // reservation made while receipt ownership, headers, or local tool slots
+      // may still be waiting. This is what keeps real provider arrivals inside
+      // the declared rolling window under concurrent runners.
       const pacing = await resolveAdaptivePacing(toolId);
       const rateScope = await resolveScope(toolId, pacing.provider);
-      const permit = await input.rateState.acquire({
+      return await input.rateState.acquire({
         bucketId: rateScope[0],
         rateScopeToken: rateScope[1],
         rules: pacing.rules,
         signal: opts?.signal,
       });
-      // 2. Acquire a scarce execution slot only after the provider permit is
-      // due. If the slot wait aborts, refund any concurrency-bearing permit.
-      let slot: WorkLease;
-      try {
-        slot = await toolSlots.acquire(opts?.signal);
-      } catch (error) {
-        permit.release();
-        throw error;
-      }
-      // 3. Charge the budget only once the call is actually cleared to run, so a
-      // failed/aborted acquisition never permanently consumes tool budget.
-      try {
-        await chargeBudget('toolCall');
-      } catch (error) {
-        permit.release();
-        slot.release();
-        throw error;
-      }
-      let released = false;
-      return {
-        release: () => {
-          if (released) return;
-          released = true;
-          permit.release();
-          slot.release();
-        },
-      };
     },
 
     async suggestedParallelism(toolId, fallback) {
@@ -541,6 +541,8 @@ function createInlineChildGovernor(
     policy: root.policy,
     acquireRowSlot: (opts) => root.acquireRowSlot(opts),
     acquireToolSlot: (toolId, opts) => root.acquireToolSlot(toolId, opts),
+    acquireProviderPermit: (toolId, opts) =>
+      root.acquireProviderPermit(toolId, opts),
     suggestedParallelism: (toolId, fallback) =>
       root.suggestedParallelism(toolId, fallback),
     chargeBudget: (kind, amount) => root.chargeBudget(kind, amount),