deepline 0.3.279 → 0.3.281

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

@@ -11,6 +11,7 @@ import type {
 // Value import from the dependency-free module: the client is bundled into
 // authored Plays, where `zod` (the contract's schemas) cannot resolve.
 import { playTriggerConfigPath } from '../../shared_libs/plays/trigger-config-route';
+import { CSV_HEADER_MATCHING_NOTE } from './csv-header-matching.js';
 import { iterateCursorPages } from './pagination.js';
 import { playInputExampleArgs } from './plays/input-example.js';
 /**
@@ -3033,7 +3034,11 @@ export class DeeplineClient {
           : isRecord(play.liveRevision?.staticPipeline)
             ? play.liveRevision.staticPipeline
             : null,
-      ...(csvInput ? { csvInput } : {}),
+      ...(csvInput
+        ? {
+            csvInput: { ...csvInput, headerMatching: CSV_HEADER_MATCHING_NOTE },
+          }
+        : {}),
       ...(rowOutputSchema ? { rowOutputSchema } : {}),
       runCommand,
       examples: [runCommand],
@@ -3292,7 +3297,7 @@ export class DeeplineClient {
   /**
    * Execute a tool and return the standard execution envelope.
    *
-   * The `toolResponse.raw` field contains the raw tool response.
+   * The `toolResponse.rawV2` field contains the complete parsed and scrubbed tool response.
    * `toolResponse.meta` contains tool/provider metadata.
    * Top-level fields such as `status`, `job_id`, and `billing` describe the
    * Deepline execution envelope.

package/dist/bundling-sources/sdk/src/csv-header-matching.ts

@@ -0,0 +1,7 @@
+/**
+ * How a CSV header is matched to a play column (`normalizeCsvHeader` in the
+ * runtime). Returned with every play description that takes a CSV, because
+ * agents otherwise read the SDK source to find out whether LINKEDIN_URL matches.
+ */
+export const CSV_HEADER_MATCHING_NOTE =
+  'A header matches a column when it equals the column name or its default header, ignoring case, spaces and punctuation: LINKEDIN_URL, linkedin-url and "Linkedin Url" all match linkedin_url. A capital inside a word starts a new word, so "LinkedIn URL" reads as linked_in_url and does not match. Map any other header in the input: {"csv":"<path>","columns":{"<column>":"<your header>"}}.';

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

@@ -123,7 +123,7 @@ function normalizeRequestAbortError(
  * from the environment, so an explicitly passed header always wins.
  *
  * HTTP header names are case-insensitive, so an existing header is removed by
- * case-insensitive match before the normalized lowercase name is set. Without
+ * case-insensitive match before the incoming name is set. Without
  * that, `Authorization` and `authorization` would both survive into the record
  * and `new Headers(record)` would concatenate the two values.
  */
@@ -138,7 +138,7 @@ function applyExplicitHeaders(
     for (const existing of Object.keys(headers)) {
       if (existing.toLowerCase() === name) delete headers[existing];
     }
-    headers[name] = value;
+    headers[rawName.trim()] = value;
   }
   return headers;
 }
@@ -270,7 +270,7 @@ export class HttpClient {
   }
 
   private authHeaders(extra?: Record<string, string>): Record<string, string> {
-    const headers: Record<string, string> = {
+    const transportHeaders: Record<string, string> = {
       Authorization: `Bearer ${this.config.apiKey}`,
       'User-Agent': `deepline-ts-sdk/${SDK_VERSION}`,
       'X-Deepline-Client-Family': 'sdk',
@@ -280,9 +280,8 @@ export class HttpClient {
       'X-Deepline-SDK-Version': SDK_VERSION,
       'X-Deepline-API-Contract': SDK_API_CONTRACT,
       'X-Deepline-Run-Result-Shape': 'canonical',
-      ...extra,
-      ...deploymentProtectionHeaders(),
     };
+    const headers = deploymentProtectionHeaders();
     const skillsVersion = this.readSkillsVersionHeader();
     if (skillsVersion) {
       headers['X-Deepline-Skills-Version'] = skillsVersion;
@@ -381,7 +380,16 @@ export class HttpClient {
     // applied last so an operator can override an env-derived header without
     // rewriting the environment. Authorization of these headers stays
     // server-side.
-    return applyExplicitHeaders(headers, this.config.headers);
+    // Preserve layer precedence without leaving differently-cased duplicates
+    // for Fetch to concatenate. Environment-derived headers still supersede
+    // per-request headers, and explicit client-option headers remain last.
+    return applyExplicitHeaders(
+      applyExplicitHeaders(
+        applyExplicitHeaders(transportHeaders, extra),
+        headers,
+      ),
+      this.config.headers,
+    );
   }
 
   /**
@@ -415,7 +423,7 @@ export class HttpClient {
     const headers = this.authHeaders(options?.headers);
 
     if (options?.body !== undefined) {
-      headers['Content-Type'] = 'application/json';
+      applyExplicitHeaders(headers, { 'Content-Type': 'application/json' });
     }
 
     let lastError: Error | null = null;
@@ -779,7 +787,7 @@ export class HttpClient {
       ...options?.headers,
     });
     if (options?.body !== undefined) {
-      headers['Content-Type'] = 'application/json';
+      applyExplicitHeaders(headers, { 'Content-Type': 'application/json' });
     }
     let lastError: Error | null = null;
 

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

@@ -26,7 +26,7 @@ export type {
  *
  * // Execute a tool
  * const result = await deepline.tools.execute('test_company_search', { domain: 'stripe.com' });
- * const company = result.toolResponse.raw;
+ * const providerResponse = result.toolResponse.rawV2;
  *
  * // Run a named play
  * const job = await deepline.play('email-waterfall').run({ domain: 'stripe.com' });

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

@@ -1096,7 +1096,7 @@ export class DeeplineContext {
    * const tools = await deepline.tools.list();
    * const meta = await deepline.tools.get('dropleads_search_people');
    * const companyLookup = await deepline.tools.execute('test_company_search', { domain: 'stripe.com' });
-   * const company = companyLookup.toolResponse.raw;
+   * const providerResponse = companyLookup.toolResponse.rawV2;
    * ```
    */
   get tools(): DeeplineToolsNamespace {

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

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.279',
+  version: '0.3.281',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/sdk/src/tool-calls.ts

@@ -227,7 +227,7 @@ function resolveToolExecuteTimeoutMs(
  * Standard provider/tool execution envelope returned by low-level SDK calls.
  *
  * `toolResponse.rawV2` contains the complete scrubbed provider response;
- * `toolResponse.raw` is derived locally as the legacy provider-result projection. `extractedValues` and
+ * `extractedValues` and
  * `extractedLists` contain Deepline-normalized getters when the tool exposes
  * them. Billing fields are Deepline-facing and must not expose provider spend.
  */
@@ -236,6 +236,7 @@ export type ToolExecution<TData = unknown, TMeta = Record<string, unknown>> = {
   job_id?: string;
   meta?: Record<string, unknown>;
   toolResponse: {
+    /** @deprecated Use declared getters or toolResponse.rawV2. */
     raw: TData;
     rawV2?: unknown;
     view?: 'data' | 'rawV2';

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

@@ -243,6 +243,7 @@ export interface ToolDefinition extends ToolExecutionMetadataFields {
         expression?: string;
         meaning?: string;
       };
+      /** @deprecated Use canonicalToolResponse. */
       rawToolResponse?: {
         expression?: string;
         meaning?: string;
@@ -256,6 +257,7 @@ export interface ToolDefinition extends ToolExecutionMetadataFields {
     toolExecutionResult?: {
       type?: 'ToolExecutionResult';
       toolResponse?: {
+        /** @deprecated Use rawV2. */
         raw?: string;
         rawV2?: string;
         view?: string;

package/dist/bundling-sources/shared_libs/play-data-plane/runtime-sheet-storage-contract.ts

@@ -3,6 +3,33 @@ import { RUNTIME_SHEET_CELL_META_COLUMN } from './runtime-sheet-orm';
 
 export { RUNTIME_SHEET_CELL_META_COLUMN } from './runtime-sheet-orm';
 
+/** Reserved metadata shared by row provenance and result ownership. */
+export const ROW_META_CELL_KEY = '_row';
+
+/**
+ * A witnessed rerun admission preserves cached cells but changes the row to
+ * pending. Only a terminal row write accepts those values for this admission.
+ * Older admissions leave the witness untouched and retain legacy read behavior.
+ */
+export function runtimeSheetResultFreshnessSql(
+  cellMetaExpression: string,
+  runIdExpression: string,
+  statusExpression = '_status',
+): string {
+  const admission = `(${cellMetaExpression}) -> '${ROW_META_CELL_KEY}' ->> 'resultAdmissionRunId'`;
+  return `(${admission} IS DISTINCT FROM ${runIdExpression} OR ${statusExpression} IN ('enriched', 'failed'))`;
+}
+
+/** Preserve all row/cell facts while witnessing the pending admission. */
+export function runtimeSheetResultAdmissionSql(
+  cellMetaExpression: string,
+  runIdExpression: string,
+): string {
+  return `coalesce(${cellMetaExpression}, '{}'::jsonb) || jsonb_build_object(
+    '${ROW_META_CELL_KEY}', coalesce((${cellMetaExpression}) -> '${ROW_META_CELL_KEY}', '{}'::jsonb)
+      || jsonb_build_object('resultAdmissionRunId', ${runIdExpression}))`;
+}
+
 export type RuntimeSheetCellMetaColumnState = {
   data_type: string;
   is_nullable: string;

package/dist/bundling-sources/shared_libs/play-runtime/async-operation.ts

@@ -411,22 +411,38 @@ function positiveStartInputNumber(
 export function resolveAsyncOperationPolling(input: {
   contract: AsyncOperationContract;
   startInput: Readonly<Record<string, unknown>>;
+  /**
+   * Set only by Play row execution. Direct and keyed API calls leave it unset
+   * so a caller's `max_wait_ms` keeps bounding their request.
+   */
+  playRuntimeWait?: boolean;
 }): { intervalMs: number; timeoutMs: number; maxAttempts?: number } {
   const maxAttempts = positiveStartInputNumber(
     input.startInput,
     input.contract.polling.maxAttemptsInputField,
   );
+  const requestedTimeoutMs = positiveStartInputNumber(
+    input.startInput,
+    input.contract.polling.timeoutInputField,
+  );
+  // The public timeout field (`max_wait_ms`) is a direct caller's sync-wait
+  // control: the provider clamps it to the ~30s ceiling and hands back a
+  // pollable `running` envelope when it expires, so direct and keyed API calls
+  // honor it. A runtime-managed Play wait has no such envelope; expiry fails
+  // the run and abandons an accepted, already-billed provider job. So in a Play
+  // the per-call value may only lengthen the lifecycle bound, never shorten it
+  // below the contract's own timeout.
+  const timeoutMs =
+    input.playRuntimeWait === true && input.contract.runtimeManagedWait === true
+      ? Math.max(requestedTimeoutMs ?? 0, input.contract.polling.timeoutMs)
+      : (requestedTimeoutMs ?? input.contract.polling.timeoutMs);
   return {
     intervalMs:
       positiveStartInputNumber(
         input.startInput,
         input.contract.polling.intervalInputField,
       ) ?? input.contract.polling.intervalMs,
-    timeoutMs:
-      positiveStartInputNumber(
-        input.startInput,
-        input.contract.polling.timeoutInputField,
-      ) ?? input.contract.polling.timeoutMs,
+    timeoutMs,
     ...(maxAttempts ? { maxAttempts: Math.floor(maxAttempts) } : {}),
   };
 }
@@ -977,6 +993,8 @@ export async function executeAsyncOperationLifecycle<Response>(input: {
   }) => void;
   /** Legacy direct callers historically poll once immediately after launch. */
   pollImmediately?: boolean;
+  /** Play row execution only; see `resolveAsyncOperationPolling`. */
+  playRuntimeWait?: boolean;
 }): Promise<
   | {
       kind: 'terminal';
@@ -1017,6 +1035,7 @@ export async function executeAsyncOperationLifecycle<Response>(input: {
   const polling = resolveAsyncOperationPolling({
     contract: input.contract,
     startInput: input.startInput,
+    playRuntimeWait: input.playRuntimeWait,
   });
   const effectiveContract: AsyncOperationContractWire = {
     ...input.contract,

package/dist/bundling-sources/shared_libs/play-runtime/cell-provenance.ts

@@ -80,7 +80,7 @@ export const MAX_CELL_READ_REFS = 12;
 export const MAX_ROW_READ_CELLS = 24;
 
 /** Reserved `_cell_meta` key holding row-grain facts rather than a cell. */
-export const ROW_META_CELL_KEY = '_row';
+export { ROW_META_CELL_KEY } from '../play-data-plane/runtime-sheet-storage-contract';
 
 /**
  * Row-grain read order (ADR 0019).
@@ -126,6 +126,8 @@ export function cellReadCut(
 export interface PlayRowMeta {
   reads?: PlayRowReadOrder;
   bornFrom?: PlayRowBornFromRow;
+  /** Rerun admission whose cached cells await a terminal row write. */
+  resultAdmissionRunId?: string;
 }
 
 /**

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

@@ -3129,7 +3129,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         ...(options?.timeoutMs !== undefined
           ? { timeoutMs: options.timeoutMs }
           : {}),
-      })) as { toolOutput?: { raw?: unknown } };
+      })) as ToolExecuteResult;
       const raw = result.toolOutput?.raw;
       if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
         throw new Error(
@@ -3143,6 +3143,18 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           'query_customer_db returned an invalid Customer DB rows result.',
         );
       }
+      const dataset = result.extractedLists.rows?.get();
+      if (isPlayDataset(dataset)) {
+        const count = await dataset.count();
+        const materialized = await dataset.materialize(options?.maxRows);
+        const expectedCount = Math.min(count, options?.maxRows ?? count);
+        if (materialized.length !== expectedCount) {
+          throw new Error(
+            `query_customer_db returned ${materialized.length} of ${expectedCount} requested rows. The result changed while paging; retry the query.`,
+          );
+        }
+        return materialized as TRow[];
+      }
       return [...rows] as TRow[];
     },
   };
@@ -18599,6 +18611,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       startInput: input.startInput,
       startResult,
       jobId,
+      playRuntimeWait: true,
       executeAction: ({ action, input: actionInput, timeoutMs, abortSignal }) =>
         this.callToolExecutionAPI(action, actionInput, {
           timeoutMs,

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

@@ -32,7 +32,11 @@ import {
   RuntimeSheetColumns,
   type RuntimeSheetColumnTypes,
 } from '../play-data-plane/sheet-column-storage';
-import { RUNTIME_SHEET_CELL_META_COLUMN } from '../play-data-plane/runtime-sheet-storage-contract';
+import {
+  RUNTIME_SHEET_CELL_META_COLUMN,
+  runtimeSheetResultFreshnessSql,
+  runtimeSheetResultAdmissionSql,
+} from '../play-data-plane/runtime-sheet-storage-contract';
 import {
   createRuntimeSheetOrm,
   isRuntimeSheetOwnerMetadataConstraintError,
@@ -3237,6 +3241,7 @@ async function readRuntimeRows(
                   bool_or(_status = 'failed') OVER () AS __has_failed
            FROM ${sheetTable(session)}
            WHERE _run_id = $1::text
+             AND ${runtimeSheetResultFreshnessSql('_cell_meta', '$1::text')}
          )
          SELECT *
          FROM scoped
@@ -3637,6 +3642,7 @@ async function prepareRuntimeSheetDatasetRows(
     physicalRefreshSetSql: string;
     physicalUpsertSetSql: string;
     outputPhysicalColumns: PhysicalSheetColumnProjection[];
+    pendingRerunAdmission?: boolean;
     force?: boolean;
     mode?: RuntimeSheetDatasetMode;
   },
@@ -3721,8 +3727,13 @@ async function prepareRuntimeSheetDatasetRows(
        versioned_completed_rows AS (
           UPDATE ${sheetTable(session)} AS target
           SET _run_id = $4::text,
+              _status = ${input.pendingRerunAdmission === true ? "'pending'" : 'target._status'},
+              ${input.pendingRerunAdmission === true ? '_attempt_id = $7::text, _attempt_owner_run_id = $8::text, _attempt_expires_at = $9::timestamptz, _attempt_seq = $10::integer,' : ''}
               _writer_run_id = $4::text,
               _write_version = $12::bigint,
+              -- Retain cached cells for resolver hydration while the new
+              -- admission waits for its own terminal row write.
+              _cell_meta = ${input.pendingRerunAdmission === true ? runtimeSheetResultAdmissionSql('target._cell_meta', '$4::text') : 'target._cell_meta'},
               _input_index = input_rows._input_index,
               _updated_at = now(),
               _version = ${nextRuntimeSheetVersionExpression(session)}${input.physicalRefreshSetSql}
@@ -3736,12 +3747,14 @@ async function prepareRuntimeSheetDatasetRows(
        versioned_failed_rows AS (
           UPDATE ${sheetTable(session)} AS target
           SET _run_id = $4::text,
+              _status = ${input.pendingRerunAdmission === true ? "'pending'" : 'target._status'},
               _writer_run_id = $4::text,
               _write_version = $12::bigint,
+              _cell_meta = ${input.pendingRerunAdmission === true ? runtimeSheetResultAdmissionSql('target._cell_meta', '$4::text') : 'target._cell_meta'},
               _input_index = input_rows._input_index,
               _attempt_id = $7::text,
               _attempt_owner_run_id = $8::text,
-              _attempt_expires_at = NULL,
+              _attempt_expires_at = ${input.pendingRerunAdmission === true ? '$9::timestamptz' : 'NULL'},
               _attempt_seq = $10::integer,
               _updated_at = now(),
               _version = ${nextRuntimeSheetVersionExpression(session)}${input.physicalRefreshSetSql}
@@ -3830,6 +3843,7 @@ async function prepareRuntimeSheetDatasetRows(
         superseded_rows AS (
           UPDATE ${sheetTable(session)} AS target
           SET _run_id = $4::text,
+              _cell_meta = ${input.pendingRerunAdmission === true ? runtimeSheetResultAdmissionSql('target._cell_meta', '$4::text') : 'target._cell_meta'},
               _input_index = input_rows._input_index,
               _attempt_id = $7::text,
               _attempt_owner_run_id = $8::text,
@@ -3993,7 +4007,9 @@ async function prepareRuntimeSheetDatasetRows(
         summary_counts AS (
           SELECT
             (SELECT c FROM inserted_count_cte) AS inserted_count,
-            (SELECT c FROM missing_output_count_cte) AS missing_output_count
+            (SELECT c FROM missing_output_count_cte) AS missing_output_count,
+            ${input.pendingRerunAdmission === true ? '(SELECT count(*) FROM versioned_completed_rows)' : '0'}::int AS completed_reopened_count,
+            ${input.pendingRerunAdmission === true ? '(SELECT count(*) FROM versioned_failed_rows)' : '0'}::int AS failed_reopened_count
         ),
         summary_delta AS (
           INSERT INTO ${summaryTable(session)} AS target (play_name, table_namespace, total, queued, running, completed, failed)
@@ -4001,22 +4017,26 @@ async function prepareRuntimeSheetDatasetRows(
             $5::text,
             $6::text,
             inserted_count::int,
-            (inserted_count + missing_output_count)::int,
+            (inserted_count + missing_output_count + completed_reopened_count + failed_reopened_count)::int,
             0,
-            (-missing_output_count)::int,
-            0
+            (-missing_output_count - completed_reopened_count)::int,
+            -failed_reopened_count
           FROM summary_counts
-          WHERE inserted_count > 0 OR missing_output_count > 0
+          WHERE inserted_count > 0 OR missing_output_count > 0 OR completed_reopened_count > 0 OR failed_reopened_count > 0
           ON CONFLICT (play_name, table_namespace) DO UPDATE SET
             queued = GREATEST(target.queued + EXCLUDED.queued, 0),
             completed = GREATEST(target.completed + EXCLUDED.completed, 0),
+            ${input.pendingRerunAdmission === true ? 'failed = GREATEST(target.failed + EXCLUDED.failed, 0),' : ''}
             total = ${runtimeSummaryTotalSql({
               currentTotal: 'target.total',
               totalDelta: 'EXCLUDED.total',
               queued: 'GREATEST(target.queued + EXCLUDED.queued, 0)',
               running: 'target.running',
               completed: 'GREATEST(target.completed + EXCLUDED.completed, 0)',
-              failed: 'target.failed',
+              failed:
+                input.pendingRerunAdmission === true
+                  ? 'GREATEST(target.failed + EXCLUDED.failed, 0)'
+                  : 'target.failed',
             })},
             _updated_at = now()
           RETURNING 1
@@ -6555,12 +6575,14 @@ export async function startRuntimeSheetDataset(
     inputOffset?: number;
     force?: boolean;
     mode?: RuntimeSheetDatasetMode;
+    /** Preserve cached cells while making a rerun await its own terminal write. */
+    pendingRerunAdmission?: boolean;
   },
 ): Promise<PrepareRuntimeSheetResult> {
   if (context.dbSessionStrategy === 'gateway_only') {
     return await postRuntimeApi<PrepareRuntimeSheetResult>(context, {
       action: 'runtime_sheet_start',
-      input,
+      input: { ...input, pendingRerunAdmission: true },
     });
   }
   const totalStartedAt = Date.now();
@@ -6835,6 +6857,7 @@ export async function startRuntimeSheetDataset(
                 input.force === true ? physicalRefreshSetSql : '',
               physicalUpsertSetSql,
               outputPhysicalColumns,
+              pendingRerunAdmission: input.pendingRerunAdmission,
               force: input.force === true,
             });
       timings.push({

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -149,6 +149,7 @@ export const PLAY_AUTHORING_CONTRACT_ISSUE_CODES = [
   'play_authoring_slack_action_wait_result_ignored',
   'play_authoring_slack_action_wait_unbounded_loop',
   'play_authoring_tool_deprecated',
+  'play_authoring_tool_response_raw_deprecated',
   'play_authoring_replay_unsafe_nondeterminism',
   'play_authoring_row_sleep_unsupported',
   'play_authoring_hitl_retry_loop_unsafe',

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -159,6 +159,7 @@ export type ToolResponseEnvelope<
   TData = unknown,
   TMeta = Record<string, unknown>,
 > = {
+  /** @deprecated Use declared getters or toolResponse.rawV2. */
   raw: TData;
   /** Complete parsed and scrubbed provider response, materialized from raw-v2. */
   rawV2?: unknown;
@@ -219,15 +220,15 @@ export type ToolExecuteResultAccessors<
  *
  * The top-level object is Deepline-owned execution metadata and semantic
  * extraction state. The canonical provider response lives under
- * `toolResponse.rawV2`; `toolResponse.raw` remains the legacy compatibility
- * projection. Response metadata lives under `toolResponse.meta`. Semantic single-value
+ * `toolResponse.rawV2`. Response metadata lives under `toolResponse.meta`. Semantic single-value
  * getters live under `extractedValues.<name>.get()`, and list getters live
  * under `extractedLists.<name>.get()`.
  *
  * Use extractors first when a tool contract exposes them. Use list getters for
- * row-shaped data. Drop to `toolResponse.raw` only for provider-specific scalar
- * fields or bounded debugging context; persisted rows may clip declared lists to
- * previews.
+ * row-shaped data. Use `toolResponse.rawV2` for provider-specific fields or
+ * debugging. Inspect the observed response before selecting a nested field;
+ * provider envelopes are preserved, including pagination and sibling resources.
+ * This is parsed, scrubbed data, not the original HTTP bytes or headers.
  *
  * @sdkReference runtime 200
  */