deepline 0.3.48 → 0.3.50

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

@@ -3106,14 +3106,6 @@ export class DeeplineClient {
       signal?: AbortSignal;
       lastEventId?: string;
       mode?: 'cli' | 'ui';
-      /**
-       * A run just accepted by durable scheduler admission can take a short
-       * time to appear in the asynchronous Convex read model. Callers that
-       * received that admission may opt into a bounded retry of the initial
-       * pending response; a normal arbitrary run id still fails loudly by
-       * default.
-       */
-      waitForProjection?: boolean;
     },
   ): AsyncGenerator<PlayLiveEvent> {
     const headers =
@@ -3122,33 +3114,12 @@ export class DeeplineClient {
         : undefined;
     const params = new URLSearchParams();
     params.set('mode', options?.mode ?? 'cli');
-    const projectionDeadline = Date.now() + 30_000;
-    let projectionAttempt = 0;
-    for (;;) {
-      let sawEvent = false;
-      try {
-        for await (const event of this.http.streamSse<PlayLiveEvent>(
-          `/api/v2/runs/${encodeURIComponent(workflowId)}/tail?${params.toString()}`,
-          { signal: options?.signal, headers },
-        )) {
-          sawEvent = true;
-          if (event.scope === 'play') {
-            yield event;
-          }
-        }
-        return;
-      } catch (error) {
-        const projectionPending =
-          options?.waitForProjection === true &&
-          !sawEvent &&
-          error instanceof DeeplineError &&
-          (error.statusCode === 404 ||
-            (error.statusCode === 202 &&
-              error.code === 'RUN_PROJECTION_PENDING')) &&
-          Date.now() < projectionDeadline;
-        if (!projectionPending) throw error;
-        await sleep(streamReconnectDelayMs(projectionAttempt));
-        projectionAttempt += 1;
+    for await (const event of this.http.streamSse<PlayLiveEvent>(
+      `/api/v2/runs/${encodeURIComponent(workflowId)}/tail?${params.toString()}`,
+      { signal: options?.signal, headers },
+    )) {
+      if (event.scope === 'play') {
+        yield event;
       }
     }
   }
@@ -4468,7 +4439,6 @@ export class DeeplineClient {
     for await (const event of this.streamPlayRunEvents(workflowId, {
       mode: 'cli',
       signal: options?.signal,
-      waitForProjection: true,
     })) {
       if (options?.signal?.aborted) {
         await this.cancelPlay(workflowId);

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

@@ -621,10 +621,7 @@ export class HttpClient {
           signal: options?.signal,
         });
 
-        // An SSE endpoint must either establish an event stream or reject the
-        // request. A 202 JSON response is a deliberately retryable admission
-        // state, not an empty, successfully completed stream.
-        if (!response.ok || response.status === 202) {
+        if (!response.ok) {
           const body = await response.text();
           const parsed = parseResponseBody(body);
           if (

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

@@ -199,7 +199,7 @@ export const SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: '0.3.48',
+  version: '0.3.50',
   updateSummary:
     'Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.',
   packageCapabilities: {

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

@@ -657,6 +657,8 @@ export interface PlayRunPackage {
     playName: string;
     status: string;
     dashboardUrl?: string;
+    /** Durable acceptance time: the run record was created. */
+    acceptedAt?: number | null;
     updatedAt?: number | null;
     startedAt?: number | null;
     finishedAt?: number | null;

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -156,7 +156,6 @@ type RuntimeApiRequest =
       action: 'start_run';
       idempotencyKey?: string;
       playName: string;
-      playReference?: string | null;
       runId: string;
       artifactStorageKey?: string | null;
       artifactHash?: string | null;
@@ -173,45 +172,6 @@ type RuntimeApiRequest =
       inputSha256?: string;
       replayedFromRunId?: string | null;
     }
-  | {
-      /** Ordered projection of a Runtime Postgres/Absurd admission. */
-      action: 'project_run_created';
-      idempotencyKey?: string;
-      playName: string;
-      playReference?: string | null;
-      workflowId: string;
-      runId: string;
-      workflowFamilyKey: string;
-      definitionScope?: 'org' | 'system';
-      revisionId?: string | null;
-      artifactStorageKey?: string | null;
-      artifactHash?: string | null;
-      graphHash?: string | null;
-      runtimeBackend?: string | null;
-      schedulerBackend?: string | null;
-      schedulerSchema?: string | null;
-      executionProfile?: string | null;
-      runtimeReleaseId?: string | null;
-      runtimeDeployVersion?: string | null;
-      runtimeCallbackBaseUrl?: string | null;
-      coordinatorUrl?: string | null;
-      coordinatorWorkerName?: string | null;
-      runtimeWorkflowName?: string | null;
-      runtimeHarnessWorkerName?: string | null;
-      maxCreditsPerRun?: number | null;
-      staticPipeline?: unknown;
-      source?: 'published' | 'ad_hoc' | 'draft';
-      triggerSource?: 'webhook' | 'cron' | 'sql_listener' | 'api';
-      inputFileId?: string;
-      inputBytes?: number;
-      inputSha256?: string;
-      replayedFromRunId?: string | null;
-      secretRefs?: unknown[];
-      inputSummary?: Record<string, unknown>;
-      /** Terminal bypass used only when the causal admission projection is
-       * permanently blocked and no queued row can be projected. */
-      admissionFailure?: string;
-    }
   | ({
       action: 'save_results';
     } & RuntimeSaveResults)
@@ -692,6 +652,7 @@ function isRetryableAppRuntimeAction(
     action === 'create_signed_staged_file_url' ||
     action === 'get_runtime_step_receipt' ||
     action === 'get_runtime_step_receipts' ||
+    action === 'governor_budget_charge' ||
     action === 'heartbeat_runtime_step_receipts' ||
     action === 'claim_runtime_step_receipt' ||
     action === 'claim_runtime_step_receipts' ||
@@ -708,8 +669,7 @@ function isRetryableAppRuntimeAction(
     action === 'release_runtime_step_receipt' ||
     action === 'save_results' ||
     action === 'skip_runtime_step_receipt' ||
-    action === 'start_run' ||
-    action === 'project_run_created'
+    action === 'start_run'
   );
 }
 
@@ -1966,7 +1926,6 @@ export async function startRunViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: {
     playName: string;
-    playReference?: string | null;
     runId: string;
     artifactStorageKey?: string | null;
     artifactHash?: string | null;
@@ -1991,24 +1950,6 @@ export async function startRunViaAppRuntime(
   });
 }
 
-/**
- * Deliver the causally-first `run.created` projection after Runtime Postgres
- * has atomically admitted the run and its Absurd task. It is safe to retry:
- * the server preserves any existing queued, running, or terminal run.
- */
-export async function projectRunCreatedViaAppRuntime(
-  context: WorkerRuntimeApiContext,
-  input: Omit<
-    Extract<RuntimeApiRequest, { action: 'project_run_created' }>,
-    'action'
-  >,
-): Promise<void> {
-  await postAppRuntimeApi<{ ok: true; status: 'queued' }>(context, {
-    action: 'project_run_created',
-    ...input,
-  });
-}
-
 export async function saveResultsViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: RuntimeSaveResults,

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

@@ -2040,8 +2040,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   #options: ContextOptions;
   private readonly executionScope: RunExecutionScope;
   private logBuffer: string[] = [];
-  private fixtureProviderPacingBypassLogged = false;
-  private fixtureProviderPacingEnforcementLogged = false;
   private checkpoint: PlayCheckpoint;
   private readonly durableCallCacheEpochMs: number;
   /**
@@ -8698,13 +8696,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     }
   }
 
-  private fixtureProviderPacingDisabled(): boolean {
-    return (
-      this.#options.integrationMode === 'fixture' &&
-      this.#options.enforceFixtureProviderPacing !== true
-    );
-  }
-
   private toolDispatchLane(request: ToolCallRequest): {
     key: string;
     readyCount: number;
@@ -11065,12 +11056,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         this.governor.policy.concurrency.toolCalls,
         Math.max(
           1,
-          this.fixtureProviderPacingDisabled()
-            ? this.governor.policy.concurrency.toolCalls
-            : await this.resourceGovernor.suggestedToolParallelism(
-                toolId,
-                this.governor.policy.concurrency.toolCalls,
-              ),
+          await this.resourceGovernor.suggestedToolParallelism(
+            toolId,
+            this.governor.policy.concurrency.toolCalls,
+          ),
         ),
       );
       const dispatchOwned = async (
@@ -11226,7 +11215,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const batchParallelismCeiling =
       this.governor.policy.pacing.workerToolBatchDefaultParallelism;
     const batchSize =
-      compiledBatches.length > 0 && !this.fixtureProviderPacingDisabled()
+      compiledBatches.length > 0
         ? await this.resourceGovernor.suggestedToolParallelism(
             compiledBatches[0]!.batchOperation,
             batchParallelismCeiling,
@@ -12501,8 +12490,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               const batchParallelismCeiling =
                 this.governor.policy.pacing.workerToolBatchDefaultParallelism;
               const batchSize =
-                compiledBatches.length > 0 &&
-                !this.fixtureProviderPacingDisabled()
+                compiledBatches.length > 0
                   ? await this.resourceGovernor.suggestedToolParallelism(
                       compiledBatches[0]!.batchOperation,
                       batchParallelismCeiling,
@@ -12756,23 +12744,18 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                     void flushCompletionBuffer();
                   }, 0);
                 });
-              // Seed the dispatch width from the governor's provider-shaped
-              // parallelism instead of the flat policy.concurrency.toolCalls
-              // ceiling. The flat width launched every pending row at once into
-              // the pacer, so unhinted providers 429'd on the first burst before
-              // AIMD could halve the rate. The shaped estimate is derived from the
-              // provider's RPS/maxConcurrency pacing rules (see
-              // suggestedParallelism in governor.ts), floored at 1 and capped by
-              // the global tool-call concurrency ceiling. The pacer still gates
-              // each in-flight call, so this only trims the launch burst.
+              // Bound direct map dispatch separately from ordinary provider
+              // residency. This prevents a blocked first chunk from launching
+              // another chunk ahead of a provider's admitted start rate, while
+              // preserving the wider resident-call capacity used by batched and
+              // high-latency providers.
               const toolCallConcurrencyCeiling =
                 this.governor.policy.concurrency.toolCalls;
-              const shapedToolParallelism = this.fixtureProviderPacingDisabled()
-                ? toolCallConcurrencyCeiling
-                : await this.resourceGovernor.suggestedToolParallelism(
-                    toolId,
-                    toolCallConcurrencyCeiling,
-                  );
+              const shapedToolParallelism =
+                await this.resourceGovernor.suggestedDirectToolParallelism(
+                  toolId,
+                  toolCallConcurrencyCeiling,
+                );
               const dispatchWidth = Math.min(
                 toolCallConcurrencyCeiling,
                 Math.max(1, shapedToolParallelism),
@@ -13339,44 +13322,17 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 // is the fetch itself, so independently delayed runners cannot
                 // compress real provider arrivals after their tickets.
                 const protectionHeaders = await this.vercelProtectionHeaders();
-                // Use the mode carried by this physical execution request.
-                // A restored execution scope may predate integration-mode
-                // authority metadata, while the signed launch and every tool
-                // request still carry options.integrationMode. Pacing the
-                // latter as live would make fixture runs both slow and
-                // unauditable even though the app never dispatches a provider
-                // request.
+                // Fixture responses simulate provider residence, but provider
+                // admission remains real. This makes fixture volume results a
+                // faithful measurement of the runtime controller without
+                // spending provider credits.
                 const fixtureExecution =
                   this.#options.integrationMode === 'fixture';
-                const enforceFixtureProviderPacing =
-                  fixtureExecution &&
-                  this.#options.enforceFixtureProviderPacing === true;
-                const fixtureOnlyExecution =
-                  this.fixtureProviderPacingDisabled();
-                if (
-                  fixtureOnlyExecution &&
-                  !this.fixtureProviderPacingBypassLogged
-                ) {
-                  this.fixtureProviderPacingBypassLogged = true;
-                  this.log(
-                    'Fixture mode: provider pacing bypassed because no provider request is dispatched.',
-                  );
-                }
-                if (
-                  enforceFixtureProviderPacing &&
-                  !this.fixtureProviderPacingEnforcementLogged
-                ) {
-                  this.fixtureProviderPacingEnforcementLogged = true;
-                  this.log(
-                    'Fixture mode: provider pacing explicitly enforced for production-parity testing.',
-                  );
-                }
-                const providerPermit = fixtureOnlyExecution
-                  ? { release() {} }
-                  : await this.resourceGovernor.acquireProviderPermit({
-                      toolId,
-                      signal: abortController?.signal,
-                    });
+                const providerPermit =
+                  await this.resourceGovernor.acquireProviderPermit({
+                    toolId,
+                    signal: abortController?.signal,
+                  });
                 try {
                   // Provider admission is our queue, not provider execution.
                   // Start the tool deadline only after admission so a busy

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

@@ -619,8 +619,6 @@ export interface ContextOptions {
   docflowEnabled?: boolean;
   /** Internal fixture-only simulation of provider response residence. */
   fixtureBehavior?: FixtureBehavior | null;
-  /** Preview/dev test seam that applies provider pacing to fixture responses. */
-  enforceFixtureProviderPacing?: boolean;
   /**
    * Server-validated per-run ceiling for concurrently resident provider-tool
    * executions and direct ctx.fetch calls. Omitted uses the platform default.

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

@@ -137,6 +137,15 @@ export interface PlayExecutionGovernor {
    */
   suggestedParallelism(toolId: string, fallback: number): Promise<number>;
 
+  /**
+   * Suggested resident width for direct, unbatched tool dispatch.
+   * Provider permits, not this queue width, govern outbound starts.
+   */
+  suggestedDirectToolParallelism(
+    toolId: string,
+    fallback: number,
+  ): Promise<number>;
+
   /** Increment a monotonic budget counter; throws GovernorBudgetError on breach. */
   chargeBudget(kind: BudgetKind, amount?: number): Promise<void>;
 
@@ -479,14 +488,43 @@ export function createPlayExecutionGovernor(
 
     async suggestedParallelism(toolId, fallback) {
       const pacing = await resolveAdaptivePacing(toolId);
-      const limits = pacing.rules.flatMap((rule) =>
-        rule.maxConcurrency != null
-          ? [rule.requestsPerWindow, rule.maxConcurrency]
-          : [rule.requestsPerWindow],
+      const concurrencyLimits = pacing.rules.flatMap((rule) =>
+        rule.maxConcurrency != null ? [rule.maxConcurrency] : [],
       );
+      // A provider that declares only RPS has no resident-call contract, so
+      // retain the caller's bounded envelope; the rate-state backend still
+      // governs every outbound start.
+      const widthLimits =
+        concurrencyLimits.length > 0 ? concurrencyLimits : [fallback];
       return Math.max(
         1,
-        Math.min(policy.pacing.suggestedMaxParallelism, ...limits),
+        Math.min(
+          Math.max(1, fallback),
+          policy.pacing.suggestedMaxParallelism,
+          ...widthLimits,
+        ),
+      );
+    },
+
+    async suggestedDirectToolParallelism(toolId, fallback) {
+      const pacing = await resolveAdaptivePacing(toolId);
+      const concurrencyLimits = pacing.rules.flatMap((rule) =>
+        rule.maxConcurrency != null ? [rule.maxConcurrency] : [],
+      );
+      // The shared rate backend controls every outbound start. An RPS-only
+      // provider needs enough resident work to cover response residence; using
+      // requestsPerWindow as this width turns, for example, a 25-RPS provider
+      // with 4-second responses into a 6.25-RPS lane. Only an explicit provider
+      // concurrency contract may tighten the resident envelope.
+      const widthLimits =
+        concurrencyLimits.length > 0 ? concurrencyLimits : [fallback];
+      return Math.max(
+        1,
+        Math.min(
+          Math.max(1, fallback),
+          policy.pacing.suggestedMaxParallelism,
+          ...widthLimits,
+        ),
       );
     },
 
@@ -615,6 +653,8 @@ function createInlineChildGovernor(
       root.acquireProviderPermit(toolId, opts),
     suggestedParallelism: (toolId, fallback) =>
       root.suggestedParallelism(toolId, fallback),
+    suggestedDirectToolParallelism: (toolId, fallback) =>
+      root.suggestedDirectToolParallelism(toolId, fallback),
     chargeBudget: (kind, amount) => root.chargeBudget(kind, amount),
     resolveRowConcurrency: (requested) => root.resolveRowConcurrency(requested),
     reportProviderBackpressure: async (input) =>

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

@@ -80,7 +80,11 @@ export interface ResolvedExecutionPolicy {
 }
 
 export const DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS = 64;
-export const MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS = 256;
+// A 1,000-row Play may legitimately need 1,000 resident provider calls to
+// sustain a declared start rate while responses are slow. This is a validated
+// opt-in ceiling, not the default transport load: short runtime-to-app fetches
+// remain guarded independently by `integrationRequests` below.
+export const MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS = 1_000;
 export const MAX_CONFIGURABLE_CONCURRENT_ROWS = 1_000;
 // Dispatch groups are only a scheduler envelope. The external-call semaphore
 // remains the resource bound, so do not impose a lower hidden ceiling here.
@@ -146,7 +150,7 @@ export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
     rowMax: 1_000,
     // Global logical-call backstop. The default is intentionally close to the
     // standard row cohort so slow small responses do not serialize most rows.
-    // Runs may request a value through the validated 1..256 launch contract;
+    // Runs may request a value through the validated 1..1000 launch contract;
     // provider pacing and the runner-owned hard ceiling still apply.
     toolCalls: DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS,
     // Physical runtime-to-app fetch/body admission. Keep short socket bursts
@@ -173,7 +177,11 @@ export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
   pacing: {
     // Undeclared providers; declared providers (rate-limit-definitions.ts) win.
     defaultProviderRequestsPerSecond: 10,
-    suggestedMaxParallelism: 256,
+    // This is the scheduler's resident-call envelope, not an RPS target.
+    // Keep it aligned with the explicit run ceiling so an RPS-only provider
+    // can retain the calls required by its observed residence time. A declared
+    // provider maxConcurrency still tightens this per lane.
+    suggestedMaxParallelism: MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS,
     // Worker isolate pacing knobs. The budget module owns platform accounting;
     // the Governor owns the policy values that decide when work is chunked.
     workerYieldElapsedMs: 45_000,

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

@@ -138,8 +138,6 @@ export interface PlayRunnerContextConfig {
   docflowEnabled?: boolean;
   /** Validated internal fixture-only provider response simulation. */
   fixtureBehavior?: FixtureBehavior | null;
-  /** Preview/dev test seam that applies provider pacing to fixture responses. */
-  enforceFixtureProviderPacing?: boolean;
   /** Validated per-run ceiling for provider-tool executions and ctx.fetch. */
   maxConcurrentExternalCalls?: number | null;
   maxConcurrentRows?: number | null;

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

@@ -60,6 +60,10 @@ export interface RuntimeResourceGovernor {
     signal?: AbortSignal;
   }): Promise<RuntimeResourceLease>;
   suggestedToolParallelism(toolId: string, fallback: number): Promise<number>;
+  suggestedDirectToolParallelism(
+    toolId: string,
+    fallback: number,
+  ): Promise<number>;
   resolveRowConcurrency(requested?: number): number;
   reportProviderBackpressure(input: {
     provider: string;
@@ -228,6 +232,13 @@ export function createRuntimeResourceGovernor(input: {
       return input.executionGovernor.suggestedParallelism(toolId, fallback);
     },
 
+    suggestedDirectToolParallelism(toolId, fallback) {
+      return input.executionGovernor.suggestedDirectToolParallelism(
+        toolId,
+        fallback,
+      );
+    },
+
     resolveRowConcurrency(requested) {
       return input.executionGovernor.resolveRowConcurrency(requested);
     },

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -42,15 +42,7 @@ export type { PlayRunInputPayload };
 export type PlaySchedulerSubmitInput = {
   runId: string;
   playId: string;
-  /** Canonical definition name used by the Convex read-model projector. */
-  definitionName?: string | null;
   playName: string;
-  /** Immutable display/lookup name selected at admission, if distinct. */
-  playReference?: string | null;
-  /** Definition ownership selected at admission; never re-resolve on replay. */
-  definitionScope?: 'org' | 'system' | null;
-  /** Immutable published revision selected at admission. */
-  revisionId?: string | null;
   workflowFamilyKey?: string | null;
   artifactStorageKey: string;
   /** Optional inline artifact for the Node scheduler. */
@@ -60,10 +52,6 @@ export type PlaySchedulerSubmitInput = {
   /** Immutable scheduler/worker/runner ABI snapshot (not a Git SHA). */
   runtimeProtocolVersion?: PlayRuntimeProtocolVersion | null;
   input: PlayRunInputPayload;
-  /** Immutable secret authority selected at admission; never re-resolve on projection. */
-  secretRefs?: unknown[];
-  /** Display-only, size-bounded projection of the admitted input. */
-  inputSummary?: Record<string, unknown>;
   /** Convex metadata for the exact input saved before scheduler submission. */
   inputFileId?: string;
   inputBytes?: number;
@@ -83,8 +71,6 @@ export type PlaySchedulerSubmitInput = {
     storageKey?: string;
     fileName?: string;
     logicalPath?: string;
-    storageKind?: 'r2';
-    contentHash?: string;
     contentType?: string;
     bytes?: number;
   } | null;
@@ -101,8 +87,6 @@ export type PlaySchedulerSubmitInput = {
     logicalPath?: string;
     fileName?: string;
     storageKey: string;
-    storageKind?: 'r2';
-    contentHash?: string;
     contentType?: string;
     bytes?: number;
     inlineText?: string;
@@ -152,16 +136,6 @@ export type PlaySchedulerSubmitInput = {
    */
   queuePriority?: number | null;
   executionProfile?: string | null;
-  /** Concrete Runtime Postgres namespace selected at admission. */
-  schedulerSchema?: string | null;
-  /** Immutable release tuple for the Convex read-model projection. */
-  runtimeReleaseId?: string | null;
-  runtimeCallbackBaseUrl?: string | null;
-  coordinatorWorkerName?: string | null;
-  runtimeWorkflowName?: string | null;
-  runtimeHarnessWorkerName?: string | null;
-  /** Billing admission cap from the immutable contract snapshot. */
-  maxCreditsPerRun?: number | null;
   /** runner backend to use for executing attempts */
   runtimeBackend: string;
   /**

package/dist/bundling-sources/shared_libs/play-runtime/test-runtime-seams.ts

@@ -36,8 +36,6 @@ type ValidatedRuntimeTestFaultHeader =
 export type RuntimeTestPolicyOverrides = {
   /** Opt-in bounded runner map latency profile for local/preview diagnosis. */
   mapLatencyProfile?: boolean;
-  /** Exercise provider pacing during fixture runs without dispatching provider traffic. */
-  enforceFixtureProviderPacing?: boolean;
   receiptLeaseTtlMs?: number;
   sheetAttemptLeaseMs?: number;
   heartbeatIntervalMs?: number;
@@ -258,8 +256,7 @@ function parseRuntimeTestPolicyOverrides(
     (key) =>
       !RUNTIME_TEST_POLICY_MS_FIELDS.has(key) &&
       key !== 'workBudgetYieldLimits' &&
-      key !== 'mapLatencyProfile' &&
-      key !== 'enforceFixtureProviderPacing',
+      key !== 'mapLatencyProfile',
   );
   if (unknownKeys.length > 0) {
     return {
@@ -276,16 +273,6 @@ function parseRuntimeTestPolicyOverrides(
     }
     overrides.mapLatencyProfile = record.mapLatencyProfile;
   }
-  if ('enforceFixtureProviderPacing' in record) {
-    if (typeof record.enforceFixtureProviderPacing !== 'boolean') {
-      return {
-        error:
-          'testPolicyOverrides.enforceFixtureProviderPacing must be a boolean.',
-      };
-    }
-    overrides.enforceFixtureProviderPacing =
-      record.enforceFixtureProviderPacing;
-  }
   for (const field of RUNTIME_TEST_POLICY_MS_FIELDS) {
     if (!(field in record)) continue;
     const parsed = readPositiveIntegerField({

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/contract.ts

@@ -105,15 +105,25 @@ export type ToolResultReceipts = {
   }): Promise<void>;
 };
 
+export type AlwaysFreshToolCallDispatch = {
+  call: ToolCallInput;
+  /** An always-fresh call must not claim a provider idempotency identity. */
+  providerOperationKey: null;
+  /** Receiptless means structurally absent, not a nullable lease. */
+  receipt?: never;
+};
+
+export type ReceiptBackedToolCallDispatch = {
+  call: ToolCallInput;
+  providerOperationKey: string;
+  receipt: ToolCallReceiptLease;
+};
+
 /** Direct and map execution are Adapter choices, never separate public jobs. */
 export type ToolCallDispatcher = {
-  dispatch(input: {
-    call: ToolCallInput;
-    /** Null means the adapter must not emit a provider-idempotency identity. */
-    providerOperationKey: string | null;
-    /** Null means this is a receiptless, always-fresh physical call. */
-    receipt: ToolCallReceiptLease | null;
-  }): Promise<ToolExecuteResult>;
+  dispatch(
+    input: AlwaysFreshToolCallDispatch | ReceiptBackedToolCallDispatch,
+  ): Promise<ToolExecuteResult>;
 };
 
 export type ToolCallDependencies = {

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/index.ts

@@ -160,7 +160,6 @@ export function createToolCallJob(
         return await dependencies.dispatcher.dispatch({
           call: input,
           providerOperationKey: null,
-          receipt: null,
         });
       }