deepline 0.3.307 → 0.3.309

package/README.md

@@ -44,7 +44,8 @@ pagination and retention. `runs logs` reads text or structured events;
 `runs get`, `runs watch`, `runs export` and `runs receipt` cover status, live
 observation, dataset rows and retained tool results. These inspection commands
 read existing evidence without starting provider work. TypeScript callers use
-`client.runs.logs`, `client.runs.searchEvents` and `client.runs.getReceipts`;
+`client.runs.logs`, its structured `query`/`count`/`summarize`/`fields` methods,
+`client.runs.events`, `client.runs.searchEvents` and `client.runs.getReceipts`;
 their source JSDoc and the generated SDK/API references describe the same reads.
 
 Paste this into Claude Code, Codex, or another coding agent:

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

@@ -77,6 +77,20 @@ import {
 } from '../../shared_libs/product-notifications/configuration.js';
 import { watchRunEvents as pollRunSnapshotEvents } from './runs/watch-polling.js';
 import { encodeRunLogsCursor, parseRunLogsCursor } from './runs/log-cursor.js';
+import {
+  normalizeRunEventOperationRequest,
+  RunEventQueryInputError,
+  type RunEventOperationRequest,
+  type RunEventQueryCriteria,
+  type RunEventQueryOptions,
+  type RunEventSummaryOptions,
+  type RunEventLogsResult,
+  type RunEventEventsResult,
+  type RunEventCountResult,
+  type RunEventSummaryResult,
+  type RunEventFieldsResult,
+  type NormalizedRunEventQuery,
+} from '../../shared_libs/play-runtime/run-event-query';
 import type {
   DeeplineClientOptions,
   ResolvedConfig,
@@ -942,6 +956,84 @@ export type RunsEventPayload = {
   errorPayload: unknown | null;
 };
 
+/** Structured log criteria; relative `since` values such as `1h` are resolved once. */
+export type RunsLogCriteria = Omit<RunEventQueryCriteria, 'runId'> & {
+  /** Read an explicitly authorized Preview scope using its runtime credential. */
+  runtime?: PlayRuntimeSelection;
+};
+
+/** One structured log page; filters are evaluated before the page limit. */
+export type RunsLogsQueryOptions = RunsLogCriteria & RunEventQueryOptions;
+type RunQueryResultWithRuntime<T extends { query: NormalizedRunEventQuery }> =
+  Omit<T, 'query'> & {
+    query: T['query'] & { runtime?: PlayRuntimeSelection };
+  };
+type RunLogQueryResult<T extends { query: NormalizedRunEventQuery }> = Omit<
+  T,
+  'query'
+> & {
+  query: Omit<T['query'], 'runId'> & { runtime?: PlayRuntimeSelection };
+};
+export type RunsLogsQueryResult = RunLogQueryResult<RunEventLogsResult>;
+export type RunsLogsCountResult = RunLogQueryResult<RunEventCountResult>;
+export type RunsLogsSummaryOptions = RunsLogCriteria & RunEventSummaryOptions;
+export type RunsLogsSummaryResult = RunLogQueryResult<RunEventSummaryResult>;
+
+/** Event criteria may span the active organization or target one run. */
+export type RunsEventsCriteria = RunsLogCriteria & { runId?: string };
+export type RunsEventsListOptions = RunsEventsCriteria & RunEventQueryOptions;
+export type RunsEventsListResult =
+  RunQueryResultWithRuntime<RunEventEventsResult>;
+export type RunsEventsCountResult =
+  RunQueryResultWithRuntime<RunEventCountResult>;
+export type RunsEventsSummaryResult =
+  RunQueryResultWithRuntime<RunEventSummaryResult>;
+export type RunsEventsSummaryOptions = RunsEventsCriteria &
+  RunEventSummaryOptions;
+export type RunsEventsFieldsOptions = { runtime?: PlayRuntimeSelection };
+
+/**
+ * Use `client.runs.logs(runId, options)` for the established text reader, or
+ * `client.runs.logs.query/count/summarize/fields` for structured retained logs.
+ */
+export type RunsLogsNamespace = {
+  (runId: string, options?: RunsLogsOptions): Promise<RunsLogsResult>;
+  /** Filter retained log records, newest first, in one server page. */
+  query: (
+    runId: string,
+    options?: RunsLogsQueryOptions,
+  ) => Promise<RunsLogsQueryResult>;
+  /** Exact count of matching retained records; does not list or retrieve payloads. */
+  count: (
+    runId: string,
+    criteria?: RunsLogCriteria,
+  ) => Promise<RunsLogsCountResult>;
+  /** Group matching retained records; groups have their own continuation cursor. */
+  summarize: (
+    runId: string,
+    options: RunsLogsSummaryOptions,
+  ) => Promise<RunsLogsSummaryResult>;
+  /** Discover filter fields, operators, types and availability. */
+  fields: (options?: RunsEventsFieldsOptions) => Promise<RunEventFieldsResult>;
+};
+
+/**
+ * Use `client.runs.events` for lifecycle, receipt and organization-wide events.
+ * Omit `runId` to query the active organization's retained events.
+ */
+export type RunsEventsNamespace = {
+  /** Filter retained events, newest first, in one server page. */
+  list: (options?: RunsEventsListOptions) => Promise<RunsEventsListResult>;
+  /** Exact count of matching retained events without listing or payload reads. */
+  count: (criteria?: RunsEventsCriteria) => Promise<RunsEventsCountResult>;
+  /** Group matching retained events with an independent continuation cursor. */
+  summarize: (
+    options: RunsEventsSummaryOptions,
+  ) => Promise<RunsEventsSummaryResult>;
+  /** Discover declared filter fields, operators, types and availability. */
+  fields: (options?: RunsEventsFieldsOptions) => Promise<RunEventFieldsResult>;
+};
+
 /** Server page cap for GET /api/v2/runs/:runId/logs (ADR-0009). */
 const RUN_LOGS_PAGE_LIMIT = 1_000;
 
@@ -1014,7 +1106,7 @@ export type PlaySecretCheck = {
 };
 
 /**
- * Use `client.runs` (`/api/v2/runs`) to watch, stop, read logs, and export durable dataset rows.
+ * Use `client.runs` to watch, stop, query logs/events, and export durable dataset rows.
  *
  * @sdkReference client 020 client.runs
  */
@@ -1056,8 +1148,10 @@ export type RunsNamespace = {
   watch: (runId: string, options?: RunsWatchOptions) => Promise<PlayStatus>;
   /** @deprecated Use `watch`; retained as a source-compatible alias. */
   tail: (runId: string, options?: RunsTailOptions) => Promise<PlayStatus>;
-  /** Read a run's retained text tail, full stream (`all`) or terminal failure window (`failed`). For structured filters and payloads, see [run logs and events](run-events.md). */
-  logs: (runId: string, options?: RunsLogsOptions) => Promise<RunsLogsResult>;
+  /** Call for the retained text tail, full stream (`all`) or terminal failure window (`failed`). Use `logs.query/count/summarize/fields` for structured filters and exact aggregates; see [run logs and events](run-events.md). */
+  logs: RunsLogsNamespace;
+  /** Use `events.list/count/summarize/fields` for lifecycle, receipt and organization-wide events; see [run logs and events](run-events.md). */
+  events: RunsEventsNamespace;
   /** Search existing events across the active organization; default last hour, up to 200 events per page (ten with payloads). See [run logs and events](run-events.md) for the catalog, query fields and response types. */
   searchEvents: (
     options?: RunsEventSearchOptions,
@@ -1858,13 +1952,9 @@ export type MonitorsRepairResult = {
 };
 
 /**
- * Public monitors namespace exposed as `client.monitors`.
- *
- * Mirrors the /api/v2/monitors resource family so the monitors CLI and
- * programmatic callers share one product surface — every `deepline monitors`
- * verb maps to a method here. Monitors are fully expressible as SDK code: author
- * a definition with {@link defineMonitor}, then check/deploy/list/get/update/
- * delete/reactivate through this namespace.
+ * Use `client.monitors` for the /api/v2/monitors resource family.
+ * Every `deepline monitors` verb maps here. Author a definition with {@link defineMonitor},
+ * then check/deploy/list/get/update/delete/reactivate through this namespace.
  *
  * @sdkReference client 040 client.monitors
  */
@@ -2799,7 +2889,26 @@ export class DeeplineClient {
       history: (options) => this.getRunsHistory(options),
       watch: (runId, options) => this.watchRunToTerminal(runId, options),
       tail: (runId, options) => this.tailRun(runId, options),
-      logs: (runId, options) => this.getRunLogs(runId, options),
+      logs: Object.assign(
+        (runId: string, options?: RunsLogsOptions) =>
+          this.getRunLogs(runId, options),
+        {
+          query: (runId: string, options?: RunsLogsQueryOptions) =>
+            this.queryRunLogs(runId, options),
+          count: (runId: string, criteria?: RunsLogCriteria) =>
+            this.countRunLogs(runId, criteria),
+          summarize: (runId: string, options: RunsLogsSummaryOptions) =>
+            this.summarizeRunLogs(runId, options),
+          fields: (options?: RunsEventsFieldsOptions) =>
+            this.getRunEventFields('logs', options),
+        },
+      ),
+      events: {
+        list: (options) => this.listRunEvents(options),
+        count: (criteria) => this.countRunEvents(criteria),
+        summarize: (options) => this.summarizeRunEvents(options),
+        fields: (options) => this.getRunEventFields('events', options),
+      },
       searchEvents: (options) => this.searchRunEvents(options),
       input: (runId) => this.getRunInput(runId),
       rerun: (runId, options) => this.rerun(runId, options),
@@ -4726,6 +4835,156 @@ export class DeeplineClient {
     };
   }
 
+  /** Query one page of this run's retained logs. `where` accepts typed objects or the shared filter language. */
+  private async queryRunLogs(
+    runId: string,
+    options: RunsLogsQueryOptions = {},
+  ): Promise<RunsLogsQueryResult> {
+    this.assertRunLogQueryRunId(runId, options);
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: 'list', resource: 'logs', runId },
+      runtime,
+    );
+  }
+
+  /** Count matching retained logs exactly, without fetching list pages or saved results. */
+  private async countRunLogs(
+    runId: string,
+    criteria: RunsLogCriteria = {},
+  ): Promise<RunsLogsCountResult> {
+    this.assertRunLogQueryRunId(runId, criteria);
+    const { runtime, ...query } = criteria;
+    return this.postRunEventQuery(
+      { ...query, operation: 'count', resource: 'logs', runId },
+      runtime,
+    );
+  }
+
+  /** Summarize retained logs with explicit group pagination and count or numeric sums. */
+  private async summarizeRunLogs(
+    runId: string,
+    options: RunsLogsSummaryOptions,
+  ): Promise<RunsLogsSummaryResult> {
+    this.assertRunLogQueryRunId(runId, options);
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: 'summarize', resource: 'logs', runId },
+      runtime,
+    );
+  }
+
+  /** Query one page of retained lifecycle, log and receipt events in the active organization. */
+  private async listRunEvents(
+    options: RunsEventsListOptions = {},
+  ): Promise<RunsEventsListResult> {
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: 'list', resource: 'events' },
+      runtime,
+    );
+  }
+
+  /** Count matching retained events exactly in one server query. */
+  private async countRunEvents(
+    criteria: RunsEventsCriteria = {},
+  ): Promise<RunsEventsCountResult> {
+    const { runtime, ...query } = criteria;
+    return this.postRunEventQuery(
+      { ...query, operation: 'count', resource: 'events' },
+      runtime,
+    );
+  }
+
+  /**
+   * Group retained events with exact counts, numeric sums and continuation.
+   * Fractional sums use JavaScript number precision.
+   */
+  private async summarizeRunEvents(
+    options: RunsEventsSummaryOptions,
+  ): Promise<RunsEventsSummaryResult> {
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: 'summarize', resource: 'events' },
+      runtime,
+    );
+  }
+
+  /** Discover query fields and their recorded types; custom scalar fields use `context.<key>`. */
+  private async getRunEventFields(
+    resource: 'logs' | 'events' = 'events',
+    options: RunsEventsFieldsOptions = {},
+  ): Promise<RunEventFieldsResult> {
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: 'fields', resource },
+      runtime,
+    );
+  }
+
+  private async postRunEventQuery<T>(
+    input: RunEventOperationRequest,
+    selection?: PlayRuntimeSelection,
+  ): Promise<T> {
+    const request = normalizeRunEventOperationRequest(input);
+    const params = new URLSearchParams();
+    let headers: Record<string, string> | undefined;
+    let selectedRuntime: PlayRuntimeSelection | undefined;
+    if (selection !== undefined) {
+      const runtime = normalizePlayRuntimeSelection(selection);
+      if (!runtime) {
+        throw new DeeplineError(
+          'Run event queries require a valid Preview runtime selection.',
+          undefined,
+          'INVALID_RUNTIME_SELECTION',
+        );
+      }
+      params.set('runtime', 'preview');
+      params.set('namespace', runtime.namespace);
+      if (runtime.backend) params.set('backend', runtime.backend);
+      headers = runtimeSelectionHeaders(runtime);
+      selectedRuntime = runtime;
+    } else {
+      headers = isolatedCiRuntimeEventReadHeaders();
+    }
+    const suffix = params.size > 0 ? `?${params.toString()}` : '';
+    const result = await this.http.post<T>(
+      `/api/v2/runs/events${suffix}`,
+      request,
+      headers,
+      { retryApiErrors: true },
+    );
+    if (
+      selectedRuntime &&
+      result &&
+      typeof result === 'object' &&
+      'query' in result
+    ) {
+      return {
+        ...result,
+        query: {
+          ...(result as { query: NormalizedRunEventQuery }).query,
+          runtime: selectedRuntime,
+        },
+      };
+    }
+    return result;
+  }
+
+  private assertRunLogQueryRunId(runId: string, criteria: unknown): void {
+    if (
+      criteria &&
+      typeof criteria === 'object' &&
+      'runId' in criteria &&
+      criteria.runId !== undefined &&
+      criteria.runId !== runId
+    ) {
+      throw new RunEventQueryInputError(
+        'Log criteria runId conflicts with the positional run ID. Pass the run ID only as the first argument.',
+      );
+    }
+  }
+
   /** Read structured history across the active organization without requiring a run ID. Defaults to the last hour, newest first; use the returned cursor and exact time bounds to continue. See [run logs and events](run-events.md) for all kinds, indexed fields, payloads and SDK/API response types. */
   async searchRunEvents(
     options: RunsEventSearchOptions = {},

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

@@ -10,7 +10,7 @@ import {
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { sdkCliStateDirPath } from './config.js';
+import { resolveApiKeyForBaseUrl, sdkCliStateDirPath } from './config.js';
 import { deploymentProtectionHeaders } from './deployment-protection.js';
 
 export type SdkCompatibilityStatus =
@@ -338,6 +338,11 @@ export async function checkSdkCompatibility(
     skillsVersion?: string | null;
     /** Blocking budget for the live request; defaults to the full timeout. */
     timeoutMs?: number;
+    /** Optional read-only catalog result carried by the same live check. */
+    catalog?: {
+      toolId: string;
+      acceptMetadata: (metadata: unknown) => void;
+    };
   } = {},
 ): Promise<{
   response: SdkCompatibilityResponse | null;
@@ -360,6 +365,9 @@ export async function checkSdkCompatibility(
     if (options.skillsVersion !== undefined) {
       url.searchParams.set('skills_version', options.skillsVersion ?? '');
     }
+    if (options.catalog) {
+      url.searchParams.set('catalog_tool_id', options.catalog.toolId);
+    }
     const response = await fetch(url, {
       method: 'GET',
       headers: {
@@ -369,30 +377,40 @@ export async function checkSdkCompatibility(
         'X-Deepline-API-Major': String(SDK_API_MAJOR),
         'X-Deepline-API-Contract': SDK_API_CONTRACT,
         'X-Deepline-CLI-Update-Preferences': '1',
+        ...(options.catalog
+          ? { Authorization: `Bearer ${resolveApiKeyForBaseUrl(baseUrl)}` }
+          : {}),
       },
       signal: controller.signal,
     });
-    const data = (await response
-      .json()
-      .catch(() => null)) as SdkCompatibilityResponse | null;
+    const raw = (await response.json().catch(() => null)) as
+      | (SdkCompatibilityResponse & { catalog_metadata?: unknown })
+      | null;
     // Only a policy-shaped body counts as a response. A JSON error page from
     // a proxy is a failed check: it is never cached, and it falls through to
     // the cached-policy fallback below like a network error would.
-    if (
-      !data ||
-      typeof data.ok !== 'boolean' ||
-      typeof data.status !== 'string'
-    ) {
+    if (!raw || typeof raw.ok !== 'boolean' || typeof raw.status !== 'string') {
       throw new Error(
         `SDK compatibility endpoint returned a non-policy response (HTTP ${response.status}).`,
       );
     }
+    // Catalog results belong to this command only, never the policy cache.
+    const { catalog_metadata: catalogMetadata, ...data } = raw;
     writeCachedCompatibility(
       baseUrl,
       options.command,
       options.skillsVersion,
       data,
     );
+    if (
+      options.catalog &&
+      catalogMetadata &&
+      typeof catalogMetadata === 'object' &&
+      'toolId' in catalogMetadata &&
+      catalogMetadata.toolId === options.catalog.toolId
+    ) {
+      options.catalog.acceptMetadata(catalogMetadata);
+    }
     return { response: data, error: null };
   } catch (error) {
     // Live compat policy must win when the server is reachable: rollback and

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

@@ -78,6 +78,26 @@ export {
 } from './client.js';
 export { CtxFetchHttpError } from './play.js';
 export { RunObserveTransportUnavailableError } from './runs/observe-transport.js';
+export { RunEventQueryInputError } from '../../shared_libs/play-runtime/run-event-query';
+export type {
+  RunEventField,
+  RunEventFieldOperators,
+  RunEventFieldDescriptor,
+  RunEventScalar,
+  RunEventWhere,
+  RunEventMeasure,
+  RunEventQueryCriteria,
+  RunEventQueryOptions,
+  NormalizedRunEventQuery,
+  RunEventQueryPage,
+  RunEventQueryRetention,
+  RunEventSummaryOptions,
+  RunEventQueryEvent,
+  RunEventCountResult,
+  RunEventSummaryResult,
+  RunEventFieldsResult,
+  RunEventGroupValue,
+} from '../../shared_libs/play-runtime/run-event-query';
 export type {
   BillingCreditPool,
   BillingInvoiceEntry,
@@ -147,6 +167,21 @@ export type {
   PlaysListPage,
   RunsLogsOptions,
   RunsLogsResult,
+  RunsLogCriteria,
+  RunsLogsNamespace,
+  RunsLogsQueryOptions,
+  RunsLogsQueryResult,
+  RunsLogsCountResult,
+  RunsLogsSummaryOptions,
+  RunsLogsSummaryResult,
+  RunsEventsNamespace,
+  RunsEventsCriteria,
+  RunsEventsListOptions,
+  RunsEventsListResult,
+  RunsEventsCountResult,
+  RunsEventsSummaryResult,
+  RunsEventsSummaryOptions,
+  RunsEventsFieldsOptions,
   RunChildrenPage,
   RunsChildrenOptions,
   RunsEventSearchOptions,

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.307',
+  version: '0.3.309',
   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/shared_libs/play-runtime/batch-runtime.ts

@@ -23,6 +23,7 @@ export interface CompiledRequestBatch<TRequest> {
   batchOperation: string;
   memberRequests: TRequest[];
   batchPayload: Record<string, unknown>;
+  resultView?: 'rawV2';
   splitResults: (value: unknown) => Array<unknown | null>;
 }
 
@@ -190,6 +191,9 @@ export function compileRequestsWithStrategy<TRequest>(input: {
         batchOperation: compiled.batchOperation,
         memberRequests,
         batchPayload: compiled.batchPayload as Record<string, unknown>,
+        ...(input.strategy.resultView
+          ? { resultView: input.strategy.resultView }
+          : {}),
         splitResults: (value: unknown) => {
           const splitResults = input.strategy.splitResult(
             value as never,

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

@@ -45,6 +45,8 @@ export type BatchOperationStrategy<
   batchOperation: string;
   kind: BatchStrategyKind;
   maxBatchSize: number;
+  /** Omitted keeps the historical legacy raw input to the splitter. */
+  resultView?: 'rawV2';
   /**
    * Payload field names that can change the batch bucket. Static map planning
    * may treat a tool call as one bucket only when these fields are absent from
@@ -68,6 +70,7 @@ export type AnyBatchOperationStrategy = {
   batchOperation: string;
   kind: BatchStrategyKind;
   maxBatchSize: number;
+  resultView?: 'rawV2';
   bucketKeyPayloadFields?: string[];
   canBatchWith(
     left: Record<string, unknown>,

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

@@ -1504,16 +1504,25 @@ function publicToolResponseForBatchedItem(
 }
 
 /**
- * Batch splitters predate raw-v2 and receive the same legacy value they got
- * from callToolAPI. Keep that input contract stable; raw-v2 is attached to the
- * completed logical call separately by publicToolResponseForBatchedItem.
+ * Batch splitters default to their historical legacy input. A strategy whose
+ * provider envelope is lost by that projection can explicitly select rawV2.
+ * Older responses without rawV2 retain the historical input.
  *
  * Physical map dispatch now crosses the Tool Call Module, which returns the
  * public ToolExecuteResult rather than leaking its private HTTP parse shape.
  * This adapter deliberately projects that result back to the splitter's
  * long-lived legacy input contract at the edge.
  */
-function legacyResultForBatchSplitter(execution: ToolExecuteResult): unknown {
+function resultForBatchSplitter(
+  execution: ToolExecuteResult,
+  resultView?: 'rawV2',
+): unknown {
+  if (
+    resultView === 'rawV2' &&
+    Object.prototype.hasOwnProperty.call(execution.toolResponse, 'rawV2')
+  ) {
+    return execution.toolResponse.rawV2;
+  }
   return execution.toolResponse.raw;
 }
 
@@ -1856,6 +1865,8 @@ type ToolExecutionApiOptions = {
   } | null;
   /** The receipt key is a completed-result cache for this read-only call. */
   completedResultCache?: boolean;
+  /** Runner-local projection required by this native batch's splitter. */
+  batchResultView?: 'rawV2';
   executionAuthScopeDigest?: string | null;
   providerIdempotencyKey?: string | null;
   /** Invocation identities that participate in the canonical operation key. */
@@ -16165,6 +16176,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         },
                       ],
                       completedResultCache: true,
+                      batchResultView: detail.compiled.resultView,
                       memoryLedgerRowScopes: detail.members.map((member) => ({
                         rowKey: member.rowKey,
                         fieldName: member.fieldName,
@@ -16389,7 +16401,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 );
               }
               const split = detail.compiled.splitResults(
-                legacyResultForBatchSplitter(aggregate),
+                resultForBatchSplitter(aggregate, detail.compiled.resultView),
               );
               // The members are separable now, so the body stops being an
               // average and becomes each row's own slice. A batch where one
@@ -16766,6 +16778,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       resultReceiptKey: aggregateReceiptKey,
                       providerOperationKey: aggregateProviderOperationKey,
                       apiOptions: {
+                        batchResultView: batch.resultView,
                         durableCallReceiptKey: aggregateReceiptKey,
                         onProviderAdmissionPending: () =>
                           admissionObserver?.pending(batch.memberRequests),
@@ -16859,8 +16872,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                     const splitResults =
                       batchExecution != null
                         ? entry.request.splitResults(
-                            legacyResultForBatchSplitter(
+                            resultForBatchSplitter(
                               batchExecution.execution,
+                              entry.request.resultView,
                             ),
                           )
                         : entry.request.memberRequests.map(() => null);
@@ -17336,6 +17350,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     contract: AsyncOperationContractWire;
     startInput: Record<string, unknown>;
     startResponse: ParsedToolExecuteResponse;
+    batchResultView?: 'rawV2';
   }): Promise<ParsedToolExecuteResponse> {
     const startResult = input.startResponse.toolResponse?.raw;
     const startClassificationFallback = input.startResponse.toolResponse?.rawV2;
@@ -17416,7 +17431,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           skipAsyncOperationResolution: true,
           uncachedAsyncLifecycleCall: true,
         }),
-      responseValue: (response) => response.toolResponse?.raw,
+      responseValue: (response) =>
+        input.batchResultView === 'rawV2' &&
+        Object.prototype.hasOwnProperty.call(
+          response.toolResponse ?? {},
+          'rawV2',
+        )
+          ? response.toolResponse?.rawV2
+          : response.toolResponse?.raw,
       classificationFallback: (response) => response.toolResponse?.rawV2,
       onJobStarted: () => {
         this.runtimeLog(
@@ -17494,14 +17516,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const materialized = lifecycle.materialized;
     const originalRawV2 = input.startResponse.toolResponse?.rawV2;
     const rawV2 =
-      originalRawV2 &&
-      typeof originalRawV2 === 'object' &&
-      !Array.isArray(originalRawV2)
-        ? {
-            ...(originalRawV2 as Record<string, unknown>),
-            data: materialized.result,
-          }
-        : { data: materialized.result };
+      input.batchResultView === 'rawV2'
+        ? materialized.result
+        : originalRawV2 &&
+            typeof originalRawV2 === 'object' &&
+            !Array.isArray(originalRawV2)
+          ? {
+              ...(originalRawV2 as Record<string, unknown>),
+              data: materialized.result,
+            }
+          : { data: materialized.result };
     const responseMeta = input.startResponse.toolResponse?.meta;
     return {
       ...input.startResponse,
@@ -17961,7 +17985,11 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         : {}),
                     }
                   : {}),
-                ...(options?.relayReceiptOutput
+                // Runtime-managed polling replaces the launch body locally.
+                // The relay can publish only its own body, so terminal cache
+                // publication must remain with the runner for these calls.
+                ...(options?.relayReceiptOutput &&
+                !shouldResolveAsyncOperationInRuntime
                   ? {
                       runtime_receipt_output: {
                         receipt_key: options.relayReceiptOutput.receiptKey,
@@ -19482,6 +19510,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   contract: asyncContract!,
                   startInput: toolInputSnapshot,
                   startResponse: parsed,
+                  batchResultView: options?.batchResultView,
                 })
               : parsed;
             // Only the configured execution relay may mint this header. The
@@ -19489,6 +19518,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             // established full-payload completion behavior even if an
             // upstream response happens to contain a lookalike header.
             const receiptOutputRef =
+              !shouldResolveAsyncOperationInRuntime &&
               this.#options.executionGatewayBaseUrl?.trim()
                 ? parseExecutionGatewayReceiptOutputReference(
                     response.headers.get(