deepline 0.3.49 → 0.3.50

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.49',
+  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

@@ -652,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' ||

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/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,
         });
       }