deepline 0.1.318 → 0.1.320

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

@@ -1862,7 +1862,9 @@ function attachSdkQueryResultDatasetResult(
   }
   const datasetLimit =
     finitePositiveInteger(dataset.returned_limit) ?? totalRows;
-  const previewRows = rowsFromUnknown(raw?.rows).slice(0, 25);
+  const effectiveCount = Math.min(totalRows, datasetLimit);
+  const rawRows = rowsFromUnknown(raw?.rows);
+  const previewRows = rawRows.slice(0, 25);
   const fetchPage = async (
     offset: number,
     limit: number,
@@ -1927,10 +1929,15 @@ function attachSdkQueryResultDatasetResult(
     datasetId: `sdk-tool-list:${toolId}:${stableHash(datasetScope)}:${datasetLimit}:${safeNonce}`,
     count: Math.min(totalRows, datasetLimit),
     previewRows,
+    residentRows:
+      rawRows.length >= effectiveCount
+        ? rawRows.slice(0, effectiveCount)
+        : null,
     sourceLabel: 'query result rows',
     tableNamespace: null,
     resolvers: {
       count: async () => Math.min(totalRows, datasetLimit),
+      at: async (index) => (await fetchPage(index, 1))[0],
       peek: async (limit) => collectRows(limit),
       materialize: async (limit) => collectRows(limit),
       iterate: () =>

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

@@ -157,7 +157,7 @@ export const SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: '0.1.318',
+  version: '0.1.320',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -276,16 +276,30 @@ export interface ToolDefinition {
   }>;
   /**
    * Whether this tool is callable in the current workspace. `false` for a
-   * bring-your-own-credential provider (e.g. Apollo) that has not been
-   * connected — the agent should offer to connect it rather than call it.
+   * bring-your-own-credential provider that has not been connected.
    */
   connected?: boolean;
+  /** Whether the tool can be executed. Exact lookup may return non-callable deprecated aliases. */
+  callable?: boolean;
+  /** True when callers should migrate this exact tool id to its replacement. */
+  deprecated?: boolean;
+  /** Deprecation reason, replacement, and compatibility execution behavior. */
+  deprecation?: {
+    replacementToolId: string;
+    message: string;
+    execution?: 'terminal' | 'forward';
+  };
   /**
    * Connection status for discovery: `managed` (Deepline-run credentials),
    * `connected` (your own credential is connected), or `requires_connection`
-   * (BYO provider not yet connected in this workspace).
+   * (BYO provider not yet connected in this workspace). `deprecated` means
+   * connecting credentials will not make the tool callable.
    */
-  credentialStatus?: 'managed' | 'connected' | 'requires_connection';
+  credentialStatus?:
+    | 'managed'
+    | 'connected'
+    | 'requires_connection'
+    | 'deprecated';
   /** True when the tool requires a customer-provided credential to run. */
   requiresOwnCredential?: boolean;
   /** Actionable message shown when a connection is required. */

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

@@ -3658,6 +3658,7 @@ export class PlayContextImpl {
     const originalRequestInput = requestInput as Record<string, unknown>;
     const datasetLimit =
       finitePositiveInteger(dataset.returned_limit) ?? totalRows;
+    const effectiveCount = Math.min(totalRows, datasetLimit);
     const previewRows = rows.slice(0, Math.min(rows.length, 25));
     const executionNonce =
       typeof wrapped.job_id === 'string' && wrapped.job_id.trim()
@@ -3718,12 +3719,15 @@ export class PlayContextImpl {
     const playDataset = createDeferredPlayDataset({
       datasetKind: 'csv',
       datasetId,
-      count: Math.min(totalRows, datasetLimit),
+      count: effectiveCount,
       previewRows,
+      residentRows:
+        rows.length >= effectiveCount ? rows.slice(0, effectiveCount) : null,
       sourceLabel: 'query result rows',
       tableNamespace: null,
       resolvers: {
         count: async () => Math.min(totalRows, datasetLimit),
+        at: async (index) => (await fetchPage(index, 1))[0],
         peek: async (limit) => collectRows(limit),
         materialize: async (limit) => collectRows(limit),
         iterate: () =>
@@ -4803,6 +4807,10 @@ export class PlayContextImpl {
           },
         },
         previewRows,
+        residentRows:
+          immediateMaterializedRows.length === successfulCount
+            ? immediateMaterializedRows
+            : null,
         tableNamespace: resolvedTableNamespace,
         workProgress: {
           total: totalInputCount,
@@ -5417,6 +5425,7 @@ export class PlayContextImpl {
       previewRows: results
         .slice(0, 5)
         .map((row) => this.toMaterializedOutputRow(row)),
+      residentRows: terminalRows,
       tableNamespace: resolvedTableNamespace,
       workProgress: {
         total: totalInputCount,

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

@@ -8139,7 +8139,8 @@ export function createRuntimeBackedPlayDataset(input: {
 }): PlayDataset<Record<string, unknown>> {
   const csvRows =
     input.datasetKind === 'csv' &&
-    (input.initialPreviewRows?.length ?? 0) >= (input.initialCount ?? 0)
+    typeof input.initialCount === 'number' &&
+    (input.initialPreviewRows?.length ?? 0) >= input.initialCount
       ? [...(input.initialPreviewRows ?? [])]
       : null;
   if (csvRows) {
@@ -8151,6 +8152,7 @@ export function createRuntimeBackedPlayDataset(input: {
       ),
       count: input.initialCount ?? csvRows.length,
       previewRows: csvRows.slice(0, 10),
+      residentRows: csvRows,
       sourceLabel: input.sourceLabel ?? null,
       resolvers: {
         count: async () => csvRows.length,
@@ -8181,6 +8183,7 @@ export function createRuntimeBackedPlayDataset(input: {
       input.tableNamespace,
     ),
     count: input.initialCount ?? 0,
+    knownCount: input.initialCount ?? null,
     backing: {
       storage: 'neon_sheet',
       sheet: {
@@ -8222,6 +8225,22 @@ export function createRuntimeBackedPlayDataset(input: {
         );
         return rows.map((row) => row.data);
       },
+      at: async (index) => {
+        const session = await getRuntimeDbSession(runtimeContext, {
+          tableNamespace: input.tableNamespace,
+          logicalTable: 'sheet_rows',
+          operations: ['rows.read'],
+        });
+        const rows = await readRuntimeRows(
+          requireRuntimePostgresSession(session),
+          {
+            limit: 1,
+            offset: index,
+            runId: input.runId ?? null,
+          },
+        );
+        return rows[0]?.data;
+      },
       materialize: async (limit) => {
         const pageSize = 1000;
         const materialized: Record<string, unknown>[] = [];

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

@@ -42,6 +42,7 @@ import {
   createDeferredPlayDataset,
   createPlayDataset,
   isSerializedPlayDataset,
+  residentPlayDatasetRows,
   trimSerializedPlayDatasetPreview,
   type PlayDataset,
   type SerializedPlayDataset,
@@ -1395,6 +1396,15 @@ function serializedListRowsFromResult(input: {
   ]);
   const entries = [...names].flatMap((name) => {
     const dataset = input.listDatasets?.[name];
+    const liveDataset = input.value.extractedLists[name]?.get();
+    const residentRows = liveDataset
+      ? residentPlayDatasetRows(liveDataset)
+      : null;
+    if (residentRows && (!dataset || residentRows.length >= dataset.count)) {
+      return [
+        [name, [...residentRows] as Array<Record<string, unknown>>] as const,
+      ];
+    }
     const preservedRows = preserved?.[name];
     if (preservedRows && (!dataset || preservedRows.length >= dataset.count)) {
       return [[name, preservedRows]] as const;
@@ -1509,6 +1519,7 @@ function createDatasetFromSerializedToolList(
     count: serialized.count,
     backing: serialized.backing,
     previewRows: preview,
+    residentRows: isPartialPreview ? null : sourceRows,
     sourceLabel: serialized.sourceLabel ?? null,
     tableNamespace: serialized.tableNamespace ?? null,
     workProgress: serialized._metadata?.workProgress,

package/dist/bundling-sources/shared_libs/plays/dataset.ts

@@ -2,6 +2,7 @@ import type { PlayExecutionFileRef } from './file-refs';
 
 const PLAY_DATASET_BRAND = Symbol.for('deepline.play.dataset');
 const NODE_INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');
+const residentRowsByDataset = new WeakMap<object, readonly unknown[]>();
 const DEFAULT_MATERIALIZE_LIMIT = 10_000;
 export const PLAY_DATASET_EXECUTION_PAGE_ROWS = 1_000;
 export const PLAY_DATASET_EXECUTION_PAGE_BYTES = 64 * 1024 * 1024;
@@ -109,8 +110,12 @@ export type PlayDatasetTransformOptions = {
  *
  * @sdkReference runtime 190
  */
-export interface PlayDataset<T> extends AsyncIterable<T> {
+export interface PlayDataset<T> extends AsyncIterable<T>, Iterable<T> {
   readonly [PLAY_DATASET_BRAND]: true;
+  /** Authoritative row count when known without I/O. */
+  readonly length: number;
+  /** Resident row access. Throws when the requested row requires I/O. */
+  readonly [index: number]: T;
   /** Dataset kind. */
   readonly datasetKind: PlayDatasetKind;
   /** Dataset id. */
@@ -125,6 +130,10 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
   count(): Promise<number>;
   /** Preview rows. */
   peek(limit?: number): Promise<T[]>;
+  /** First row, loading it asynchronously when necessary. */
+  first(): Promise<T | undefined>;
+  /** Row at an array-style index, loading it asynchronously when necessary. */
+  at(index: number): Promise<T | undefined>;
   map<U>(
     mapper: (row: T, index: number) => U | Promise<U>,
     options?: PlayDatasetTransformOptions,
@@ -164,6 +173,7 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
 type PlayDatasetResolvers<T> = {
   count: () => Promise<number>;
   peek: (limit: number) => Promise<T[]>;
+  at?: (index: number) => Promise<T | undefined>;
   materialize: (limit?: number) => Promise<T[]>;
   materializeFullPersistedDataset?: (limit?: number) => Promise<T[]>;
   iterate: () => AsyncIterable<T>;
@@ -223,6 +233,13 @@ export function isPlayDataset<T>(value: unknown): value is PlayDataset<T> {
   );
 }
 
+/** Internal compatibility view for preserving proven-complete rows on replay. */
+export function residentPlayDatasetRows<T>(
+  dataset: PlayDataset<T>,
+): readonly T[] | null {
+  return (residentRowsByDataset.get(dataset as object) as readonly T[]) ?? null;
+}
+
 export function isSerializedPlayDataset<T>(
   value: unknown,
 ): value is SerializedPlayDataset<T> {
@@ -317,6 +334,7 @@ export function deserializePlayDatasetCell<T>(
     count: rows.length,
     backing: dataset.backing,
     previewRows: rows.slice(0, 10),
+    residentRows: rows,
     sourceLabel: dataset.sourceLabel ?? null,
     tableNamespace: dataset.tableNamespace ?? null,
     workProgress: dataset._metadata?.workProgress,
@@ -355,6 +373,7 @@ export function deserializeLegacyPlayDataset<T>(
     count: dataset.count,
     backing: dataset.backing,
     previewRows: rows,
+    residentRows: complete ? rows : null,
     sourceLabel: dataset.sourceLabel ?? null,
     tableNamespace: dataset.tableNamespace ?? null,
     workProgress: dataset._metadata?.workProgress,
@@ -394,6 +413,7 @@ export function trimSerializedPlayDatasetPreview<T>(
 }
 
 class DeferredPlayDataset<T> implements PlayDataset<T> {
+  readonly [index: number]: T;
   readonly [PLAY_DATASET_BRAND] = true as const;
   readonly datasetKind: PlayDatasetKind;
   readonly datasetId: string;
@@ -404,14 +424,18 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
   private readonly previewColumns?: string[];
   private readonly workProgress?: PlayDatasetWorkProgressSummary;
   private cachedCount: number;
+  private knownCount: number | null;
+  private readonly residentRows: readonly T[] | null;
   private readonly resolvers: PlayDatasetResolvers<T>;
 
   constructor(input: {
     datasetKind: PlayDatasetKind;
     datasetId: string;
     count: number;
+    knownCount?: number | null;
     backing?: PlayDatasetBacking;
     previewRows: readonly T[];
+    residentRows?: readonly T[] | null;
     sourceLabel?: string | null;
     tableNamespace?: string | null;
     workProgress?: PlayDatasetWorkProgressSummary;
@@ -420,8 +444,11 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     this.datasetKind = input.datasetKind;
     this.datasetId = input.datasetId;
     this.cachedCount = input.count;
+    this.knownCount =
+      input.knownCount === undefined ? input.count : input.knownCount;
     this.backing = input.backing;
     this.previewRows = input.previewRows;
+    this.residentRows = input.residentRows ?? null;
     this.previewColumns = inferPreviewColumns(this.previewRows);
     this.sourceLabel = input.sourceLabel ?? null;
     this.tableNamespace = input.tableNamespace ?? null;
@@ -429,8 +456,18 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     this.resolvers = input.resolvers;
   }
 
+  get length(): number {
+    if (this.knownCount === null) {
+      throw this.requiresAsyncAccess(
+        'The row count is not known until this lazy transform executes.',
+      );
+    }
+    return this.knownCount;
+  }
+
   async count(): Promise<number> {
     this.cachedCount = await this.resolvers.count();
+    this.knownCount = this.cachedCount;
     return this.cachedCount;
   }
 
@@ -441,6 +478,29 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     return await this.resolvers.peek(limit);
   }
 
+  async first(): Promise<T | undefined> {
+    return await this.at(0);
+  }
+
+  async at(index: number): Promise<T | undefined> {
+    if (!Number.isFinite(index)) return undefined;
+    const integer = Math.trunc(index);
+    const count = integer < 0 ? await this.count() : this.knownCount;
+    const normalized =
+      integer < 0 && count !== null ? count + integer : integer;
+    if (normalized < 0 || (count !== null && normalized >= count)) {
+      return undefined;
+    }
+    if (this.residentRows) return this.residentRows[normalized];
+    if (this.resolvers.at) return await this.resolvers.at(normalized);
+    let current = 0;
+    for await (const row of this.resolvers.iterate()) {
+      if (current === normalized) return row;
+      current += 1;
+    }
+    return undefined;
+  }
+
   map<U>(
     mapper: (row: T, index: number) => U | Promise<U>,
     options?: PlayDatasetTransformOptions,
@@ -531,6 +591,33 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     }
   }
 
+  [Symbol.iterator](): Iterator<T> {
+    if (!this.residentRows) {
+      throw this.requiresAsyncAccess(
+        'Synchronous iteration is available only when every row is resident.',
+      );
+    }
+    return this.residentRows[Symbol.iterator]();
+  }
+
+  residentAt(index: number): T | undefined {
+    if (this.knownCount !== null && index >= this.knownCount) return undefined;
+    if (!this.residentRows) {
+      throw this.requiresAsyncAccess(
+        `Row ${index} is not resident and may require dataset paging.`,
+      );
+    }
+    return this.residentRows[index];
+  }
+
+  private requiresAsyncAccess(detail: string): Error {
+    return new Error(
+      `PLAY_DATASET_REQUIRES_ASYNC_ACCESS: ${detail} ` +
+        `Dataset Handle ${this.sourceLabel ?? this.datasetId}. ` +
+        'Use await dataset.first(), await dataset.at(index), await dataset.materialize(limit), or for await...of.',
+    );
+  }
+
   toJSON() {
     return {
       kind: 'dataset' as const,
@@ -666,6 +753,7 @@ function createTransformedPlayDataset<T, U>(
       key: options?.key,
     }),
     count: 0,
+    knownCount: null,
     backing: source.backing,
     sourceLabel,
     tableNamespace: options?.key ?? null,
@@ -687,17 +775,60 @@ export function createDeferredPlayDataset<T>(input: {
   datasetKind: PlayDatasetKind;
   datasetId: string;
   count: number;
+  /** Authoritative synchronous count, or null when execution must determine it. */
+  knownCount?: number | null;
   backing?: PlayDatasetBacking;
   previewRows?: readonly T[];
+  /** Complete in-memory row set. Never pass a bounded preview here. */
+  residentRows?: readonly T[] | null;
   sourceLabel?: string | null;
   tableNamespace?: string | null;
   workProgress?: PlayDatasetWorkProgressSummary;
   resolvers: PlayDatasetResolvers<T>;
 }): PlayDataset<T> {
-  return new DeferredPlayDataset({
+  if (
+    input.residentRows &&
+    input.knownCount !== null &&
+    input.residentRows.length !== (input.knownCount ?? input.count)
+  ) {
+    throw new Error(
+      `Resident Dataset Handle ${input.datasetId} has ${input.residentRows.length} rows but declares ${input.knownCount ?? input.count}.`,
+    );
+  }
+  const target = new DeferredPlayDataset({
     ...input,
     previewRows: input.previewRows ?? [],
   });
+  const boundMethods = new Map<PropertyKey, unknown>();
+  const dataset = new Proxy(target, {
+    get(dataset, property) {
+      if (typeof property === 'string' && /^(0|[1-9]\d*)$/.test(property)) {
+        return dataset.residentAt(Number(property));
+      }
+      const value = Reflect.get(dataset, property, dataset);
+      if (typeof value !== 'function') return value;
+      if (!boundMethods.has(property)) {
+        boundMethods.set(property, value.bind(dataset));
+      }
+      return boundMethods.get(property);
+    },
+    set(_dataset, property) {
+      if (
+        property === 'length' ||
+        (typeof property === 'string' && /^(0|[1-9]\d*)$/.test(property))
+      ) {
+        throw new Error(
+          'PLAY_DATASET_READ_ONLY: Dataset Handle rows cannot be assigned directly.',
+        );
+      }
+      return false;
+    },
+  });
+  if (input.residentRows) {
+    residentRowsByDataset.set(target, input.residentRows);
+    residentRowsByDataset.set(dataset, input.residentRows);
+  }
+  return dataset;
 }
 
 export function createPlayDataset<T>(
@@ -719,6 +850,7 @@ export function createPlayDataset<T>(
       `${metadata?.kind ?? 'map'}:${metadata?.tableNamespace ?? metadata?.sourceLabel ?? 'inline'}`,
     count: materializedRows.length,
     previewRows: materializedRows.slice(0, 5),
+    residentRows: materializedRows,
     sourceLabel: metadata?.sourceLabel ?? null,
     tableNamespace: metadata?.tableNamespace ?? null,
     resolvers: {

package/dist/cli/index.js

@@ -1037,7 +1037,7 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.318",
+  version: "0.1.320",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -11991,7 +11991,7 @@ async function traceCliSpan(phase, fields, run) {
 
 // src/cli/play-check-hints.ts
 var EXTRACTED_GETTER_ERROR_HINT = "Deepline hint: extractedValues/extractedLists .get() only works for declared Deepline getters listed by `deepline tools describe <tool> --json`. Use `toolExecutionResult.toolResponse.raw` for provider/tool-specific scalar fields, and `toolExecutionResult.extractedLists.<name>.get()` for declared row/list outputs.";
-var DATASET_API_HINT = "Deepline hint: PlayDataset is lazy and durable. Use `.peek(n)` for a small preview or `.materialize()` when you intentionally need rows in memory; do not use `.rows`, `.toArray()`, or array methods directly on the dataset handle.";
+var DATASET_API_HINT = "Deepline hint: PlayDataset is lazy and durable. Complete resident handles support read-only length/index/iteration. For paged rows use `.first()`, `.at(index)`, `.peek(n)`, `.materialize(limit)`, or async iteration; do not use `.rows` or `.toArray()`.";
 var ROW_PROPERTY_HINT = "Deepline hint: this row type only contains fields produced by the CSV/schema and previous map steps. Check source column casing and the exact output field names from earlier steps before scaling.";
 var TOOLS_EXECUTE_SIGNATURE_HINT = "Deepline hint: ctx.tools.execute requires a request object: `ctx.tools.execute({ id, tool, input, description })`. The stable `id` is required for logs, metadata, and receipt attachment; provider-call reuse is based on play, tool, semantic input, auth scope, provider action version, and cache policy.";
 var RUN_PLAY_SIGNATURE_HINT = "Deepline hint: ctx.runPlay uses a stable key plus a composable child play reference. Direct-run-only or dataset-backed batch plays must be run directly, exported, then consumed by a separate play.";
@@ -28589,14 +28589,23 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
     "deeplineUsdPerPricingUnit",
     "deepline_usd_per_pricing_unit"
   );
-  const starterScript = !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
+  const deprecation = recordField2(tool, "deprecation");
+  const replacementToolId = stringField2(
+    deprecation,
+    "replacementToolId",
+    "replacement_tool_id"
+  );
+  const deprecationMessage = stringField2(deprecation, "message");
+  const deprecationExecution = stringField2(deprecation, "execution");
+  const deprecated = tool.deprecated === true || stringField2(tool, "credentialStatus", "credential_status") === "deprecated";
+  const starterScript = !deprecated && !isPlayLikeTool(tool) && extractedLists.length > 0 ? starterScriptJson(
     seedToolListScript({
       toolId,
       payload: samplePayloadForInputFields(inputFields),
       rows: []
     })
   ) : null;
-  const executeCommand = isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}' --json`;
+  const executeCommand = deprecated && replacementToolId ? `deepline tools execute ${replacementToolId} --input '{...}' --json` : isPlayLikeTool(tool) ? playRunCommandForTool(tool, toolId) : `deepline tools execute ${toolId} --input '{...}' --json`;
   return {
     schemaVersion: 1,
     toolId,
@@ -28604,6 +28613,15 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
     displayName: tool.displayName,
     description: tool.description,
     categories: tool.categories,
+    ...deprecated ? {
+      deprecated: true,
+      callable: tool.callable !== false,
+      deprecation: {
+        replacementToolId,
+        message: deprecationMessage,
+        ...deprecationExecution ? { execution: deprecationExecution } : {}
+      }
+    } : {},
     inputFields: inputFields.map((field) => ({
       name: field.name,
       type: field.type ?? "unknown",
@@ -28746,6 +28764,29 @@ function printCompactToolContract(tool, requestedToolId) {
   if (Array.isArray(contract.categories) && contract.categories.length) {
     console.log(`Tags: ${contract.categories.join(", ")}`);
   }
+  if (contract.deprecated === true) {
+    const deprecation = isRecord11(contract.deprecation) ? contract.deprecation : {};
+    const message = stringField2(deprecation, "message");
+    const replacementToolId = stringField2(
+      deprecation,
+      "replacementToolId",
+      "replacement_tool_id"
+    );
+    console.log(
+      contract.callable === false ? "Status: deprecated \u2014 this tool cannot be executed" : "Status: deprecated \u2014 legacy executions forward for compatibility"
+    );
+    if (message) console.log(`Migration: ${message}`);
+    if (replacementToolId) {
+      console.log(
+        `Use: deepline tools execute ${replacementToolId} --input '{...}'`
+      );
+    }
+    console.log("");
+    console.log(
+      `More: deepline tools describe ${replacementToolId || contract.toolId} --json`
+    );
+    return;
+  }
   printToolPricingOnly(tool, requestedToolId, { heading: "Cost" });
   if (inputFields.length) {
     console.log("");
@@ -29245,6 +29286,32 @@ function samplePayload(samples, key) {
 function commandEnvelopeFromRawResponse(rawResponse) {
   return isRecord11(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
+function extractToolExecutionWarningMessages(rawResponse) {
+  if (!isRecord11(rawResponse)) return [];
+  const candidates = [
+    recordField2(recordField2(rawResponse, "toolResponse"), "meta"),
+    recordField2(
+      recordField2(recordField2(rawResponse, "toolResponse"), "raw"),
+      "meta"
+    ),
+    recordField2(rawResponse, "meta"),
+    recordField2(recordField2(rawResponse, "result"), "meta")
+  ];
+  const messages = [];
+  for (const candidate of candidates) {
+    const warnings = candidate?.warnings;
+    if (!Array.isArray(warnings)) continue;
+    for (const warning of warnings) {
+      if (typeof warning === "string" && warning.trim()) {
+        messages.push(warning.trim());
+      } else if (isRecord11(warning)) {
+        const message = stringField2(warning, "message");
+        if (message) messages.push(message);
+      }
+    }
+  }
+  return [...new Set(messages)];
+}
 function apifySyncRecoveryNext(rawResponse) {
   if (!isRecord11(rawResponse) || rawResponse.status !== "running") return null;
   const toolResponse = recordField2(rawResponse, "toolResponse");
@@ -29512,6 +29579,9 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
 }
 function buildToolExecuteBaseEnvelope(input2) {
   const envelope = commandEnvelopeFromRawResponse(input2.rawResponse);
+  const warningMessages = extractToolExecutionWarningMessages(
+    input2.rawResponse
+  );
   const apifyRecovery = apifySyncRecoveryNext(input2.rawResponse);
   const summaryEntries = Object.entries(input2.summary);
   const outputPreview = input2.listConversion ? {
@@ -29549,6 +29619,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     ...envelope,
     ...envelopeHasCanonicalOutput || envelopeHasDeclaredOutput ? { output_preview: outputPreview } : { output: outputPreview },
     ...summaryEntries.length > 0 ? { summary: input2.summary } : {},
+    ...warningMessages.length > 0 ? { warnings: warningMessages } : {},
     next: {
       inspect: inspectCommand,
       ...apifyRecovery ?? {},
@@ -29560,6 +29631,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     },
     render: {
       sections: input2.listConversion ? [
+        ...warningMessages.length > 0 ? [{ title: "warnings", lines: warningMessages }] : [],
         {
           title: "output",
           lines: [
@@ -29570,6 +29642,7 @@ function buildToolExecuteBaseEnvelope(input2) {
           ]
         }
       ] : [
+        ...warningMessages.length > 0 ? [{ title: "warnings", lines: warningMessages }] : [],
         {
           title: "result",
           lines: apifyRecovery ? [