deepline 0.3.392 → 0.3.394

package/dist/cli/{chunk-2GAHHSLB.mjs → chunk-FJGW5GXU.mjs}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-NXGCO4JB.mjs";
 import {
   SDK_RELEASE
-} from "./chunk-YAZCDBXX.mjs";
+} from "./chunk-TJI2EN6K.mjs";
 
 // src/errors.ts
 var CustomerDbQueryOutcomeUnknownError = class extends DeeplineError {
@@ -1739,7 +1739,8 @@ var HttpClient = class {
       applyExplicitHeaders(headers, { "Content-Type": "application/json" });
     }
     let lastError = null;
-    for (const candidateUrl of buildCandidateUrls(url)) {
+    const candidateUrls = options?.exactUrlOnly ? [url] : buildCandidateUrls(url);
+    for (const candidateUrl of candidateUrls) {
       try {
         const response = await fetch(candidateUrl, {
           method,

package/dist/cli/{chunk-YN6YA7ZZ.mjs → chunk-JHIJIHFB.mjs}

@@ -6,14 +6,14 @@ import {
 } from "./chunk-6IKARAYD.mjs";
 import {
   PLAY_RUN_START_STREAM_PATH,
-  buildPlayRunStartBody,
   decodePlayRunPublicStatus,
   isPlayRunPackage,
   isTerminalPlayRunLifecycleStatus,
   mintStagedPlayFileUploads,
+  preparePlayRunAdmission,
   stagePlayFiles,
   startPlayRun
-} from "./chunk-Q6EOHNRH.mjs";
+} from "./chunk-JI2B4RZP.mjs";
 import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
   CustomerDbQueryOutcomeUnknownError,
@@ -21,7 +21,7 @@ import {
   RETAINED_PIPELINE_RECEIVERS_HEADER,
   RUNTIME_ENVIRONMENT_TOKEN_HEADER,
   resolveConfig
-} from "./chunk-2GAHHSLB.mjs";
+} from "./chunk-FJGW5GXU.mjs";
 import {
   DeeplineError,
   TOOL_EXECUTION_ERROR_SCHEMA_HEADER,
@@ -3256,6 +3256,7 @@ var DeeplineClient = class _DeeplineClient {
       input: (runId) => this.getRunInput(runId),
       rerun: (runId, options2) => this.rerun(runId, options2),
       exportDatasetRows: (input) => this.getPlaySheetRows(input),
+      rowHistory: (input) => this.getPlayRunRowHistory(input),
       stop: (runId, options2) => this.stopRun(runId, options2),
       stopAll: ((options2) => this.stopAllRuns(options2))
     };
@@ -3264,6 +3265,7 @@ var DeeplineClient = class _DeeplineClient {
       planQuery: (input) => planCustomerDbQuery(input)
     };
     this.billing = {
+      quote: (input) => this.http.post("/api/v2/billing/quote", input),
       entitlements: () => this.http.get("/api/v2/billing/entitlements"),
       topUp: (options2) => this.topUpBillingBalance(options2),
       topUpWithReceipt: (options2) => this.topUpBillingBalanceWithReceipt(options2),
@@ -3737,14 +3739,62 @@ var DeeplineClient = class _DeeplineClient {
    * });
    * ```
    */
-  async startPlayRun(request) {
+  async startPlayRun(request, options) {
     const resolved = resolveStartPlayRunRequest(request, this.environment);
     return startPlayRun(
       this.http,
       resolved.request,
-      runtimeSelectionHeaders(resolved.runtime, this.environment)
+      runtimeSelectionHeaders(resolved.runtime, this.environment),
+      options?.onSubmission
     );
   }
+  /**
+   * Prepare a tenant-scoped start intent without executing it. Its stream
+   * sender retains the exact body and transport selected during preparation.
+   */
+  async preparePlayRunAdmission(request, options) {
+    const resolved = resolveStartPlayRunRequest(request, this.environment);
+    const prepared = await preparePlayRunAdmission(
+      this.http,
+      resolved.request,
+      options?.onSubmission
+    );
+    const bodyJson = JSON.stringify(prepared.body);
+    const headers = runtimeSelectionHeaders(resolved.runtime, this.environment);
+    const http = this.http;
+    let submitted = false;
+    return {
+      ...prepared,
+      async *startStream(streamOptions) {
+        if (submitted && !prepared.supportsCallerIntent) {
+          throw new DeeplineError(
+            "This server has not enabled caller-owned admission recovery. Do not retry an ambiguous start.",
+            409,
+            "PLAY_RUN_ADMISSION_RECOVERY_UNSUPPORTED"
+          );
+        }
+        if (submitted) {
+          await preparePlayRunAdmission(
+            http,
+            JSON.parse(bodyJson)
+          );
+        }
+        submitted = true;
+        for await (const event of http.streamSse(
+          PLAY_RUN_START_STREAM_PATH,
+          {
+            method: "POST",
+            body: JSON.parse(bodyJson),
+            headers,
+            signal: streamOptions?.signal,
+            exactUrlOnly: true
+          }
+        )) {
+          if (event.scope === "play") yield event;
+        }
+      }
+    };
+  }
   /**
    * Submit a play run through the legacy event response.
    *
@@ -3759,21 +3809,8 @@ var DeeplineClient = class _DeeplineClient {
    * @returns Async generator of play-scoped live events.
    */
   async *startPlayRunStream(request, options) {
-    const resolved = resolveStartPlayRunRequest(request, this.environment);
-    const body = buildPlayRunStartBody(resolved.request);
-    for await (const event of this.http.streamSse(
-      PLAY_RUN_START_STREAM_PATH,
-      {
-        method: "POST",
-        body,
-        headers: runtimeSelectionHeaders(resolved.runtime, this.environment),
-        signal: options?.signal
-      }
-    )) {
-      if (event.scope === "play") {
-        yield event;
-      }
-    }
+    const prepared = await this.preparePlayRunAdmission(request, options);
+    yield* prepared.startStream({ signal: options?.signal });
   }
   /**
    * Register a bundled play artifact.
@@ -4795,6 +4832,21 @@ var DeeplineClient = class _DeeplineClient {
       { headers, retryApiErrors: true }
     );
   }
+  /**
+   * Read one page of immutable admitted and terminal rows for a Play Run dataset.
+   * Follow nextCursor; coverage explicitly identifies unavailable or incomplete history.
+   */
+  async getPlayRunRowHistory(input) {
+    const params = new URLSearchParams({
+      runId: input.runId,
+      tableNamespace: input.tableNamespace
+    });
+    if (input.limit !== void 0) params.set("limit", String(input.limit));
+    if (input.cursor !== void 0) params.set("cursor", input.cursor);
+    return this.http.get(
+      `/api/v2/plays/${encodeURIComponent(input.playName)}/sheet/history?${params}`
+    );
+  }
   /**
    * Export persisted runtime-sheet rows for a play dataset/table namespace.
    *
@@ -5004,6 +5056,13 @@ var DeeplineClient = class _DeeplineClient {
   async getNotificationSettings() {
     return this.http.get("/api/v2/settings/notifications");
   }
+  /** Save provider-owned credential fields without starting an OAuth browser flow. */
+  async setIntegrationCredentials(provider, credentials) {
+    return this.http.post("/api/v2/integrations/connect", {
+      provider,
+      credentials
+    });
+  }
   /** Start the Slack OAuth flow required by product notifications. */
   async connectNotificationSlack(options) {
     return this.http.post("/api/v2/integrations/connect", {

package/dist/cli/{chunk-Q6EOHNRH.mjs → chunk-JI2B4RZP.mjs}

@@ -1,3 +1,7 @@
+import {
+  buildCallerPlayWorkflowId,
+  callerPlayWorkflowIdMatchesRequest
+} from "./chunk-UBKA33KY.mjs";
 import {
   apiErrorCodeFromResponse,
   apiErrorMessage
@@ -74,6 +78,9 @@ var PLAY_FILES_STAGE_PATH = "/api/v2/plays/files/stage";
 var PLAY_FILES_STAGE_MINT_PATH = `${PLAY_FILES_STAGE_PATH}/mint`;
 function buildPlayRunStartBody(request) {
   return {
+    ...request.admissionOrgId ? { admissionOrgId: request.admissionOrgId } : {},
+    ...request.workflowId ? { workflowId: request.workflowId } : {},
+    ...request.maxTotalCredits !== void 0 ? { maxTotalCredits: request.maxTotalCredits } : {},
     ...request.name ? { name: request.name } : {},
     ...request.revisionId ? { revisionId: request.revisionId } : {},
     ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
@@ -105,13 +112,117 @@ function buildPlayRunStartBody(request) {
     ...request.testPolicyOverrides ? { testPolicyOverrides: request.testPolicyOverrides } : {}
   };
 }
-async function startPlayRun(http, request, headers) {
-  const response = await http.post(
-    PLAY_RUN_START_PATH,
-    buildPlayRunStartBody(request),
-    headers,
-    { maxRetries: 0, exactUrlOnly: true }
+async function preparePlayRunAdmission(http, request, onSubmission) {
+  let capability = null;
+  if (http.get) {
+    try {
+      capability = await http.get(PLAY_RUN_START_PATH);
+    } catch (error) {
+      if (!(error instanceof DeeplineError) || ![404, 405].includes(error.statusCode ?? 0))
+        throw error;
+    }
+    if (capability && !["caller-intent-v1", "unsupported"].includes(
+      capability.admissionContract ?? ""
+    )) {
+      throw new DeeplineError(
+        "The server admission capability response is unknown; execution was not submitted.",
+        503,
+        "PLAY_RUN_ADMISSION_CAPABILITY_UNKNOWN"
+      );
+    }
+  }
+  const supportsCallerIntent = capability?.admissionContract === "caller-intent-v1";
+  if (supportsCallerIntent && (!capability?.orgId || request.admissionOrgId && request.admissionOrgId !== capability.orgId)) {
+    throw new DeeplineError(
+      "The admission workspace could not be pinned to this request; execution was not submitted.",
+      409,
+      "PLAY_RUN_ADMISSION_TENANT_CONFLICT"
+    );
+  }
+  if (request.workflowId && !supportsCallerIntent) {
+    throw new DeeplineError(
+      "This server has not enabled caller-owned admission recovery. Do not retry an ambiguous start.",
+      409,
+      "PLAY_RUN_ADMISSION_RECOVERY_UNSUPPORTED"
+    );
+  }
+  if (request.maxTotalCredits !== void 0 && capability?.strictTotalBudget !== "fail-closed-v1") {
+    throw new DeeplineError(
+      "This server cannot honor a strict total Play budget. Execution was not submitted.",
+      409,
+      "PLAY_TOTAL_BUDGET_UNSUPPORTED"
+    );
+  }
+  const wireBody = JSON.parse(
+    JSON.stringify(
+      buildPlayRunStartBody({
+        ...request,
+        ...supportsCallerIntent ? { admissionOrgId: capability.orgId } : {}
+      })
+    )
   );
+  const workflowId = supportsCallerIntent ? request.workflowId ?? buildCallerPlayWorkflowId(request.name ?? "play", wireBody) : void 0;
+  const submittedBody = workflowId ? { workflowId, ...wireBody } : wireBody;
+  if (workflowId && !callerPlayWorkflowIdMatchesRequest(workflowId, submittedBody)) {
+    throw new DeeplineError(
+      "workflowId must be the caller run ID of this same immutable request.",
+      400,
+      "PLAY_RUN_START_INTENT_CONFLICT"
+    );
+  }
+  if (onSubmission) {
+    if (!workflowId || !capability?.orgId) {
+      throw new DeeplineError(
+        "This server cannot persist a recoverable submission intent. Execution was not submitted.",
+        409,
+        "PLAY_RUN_ADMISSION_RECOVERY_UNSUPPORTED"
+      );
+    }
+    await onSubmission({
+      workflowId,
+      orgId: capability.orgId,
+      request: submittedBody
+    });
+  }
+  return { body: submittedBody, workflowId, supportsCallerIntent };
+}
+async function startPlayRun(http, request, headers, onSubmission) {
+  const {
+    body: submittedBody,
+    workflowId,
+    supportsCallerIntent
+  } = await preparePlayRunAdmission(http, request, onSubmission);
+  let response;
+  try {
+    response = await http.post(
+      PLAY_RUN_START_PATH,
+      submittedBody,
+      headers,
+      { maxRetries: 0, exactUrlOnly: true }
+    );
+  } catch (error) {
+    if (error instanceof DeeplineError && ["NETWORK_TIMEOUT", "NETWORK_ERROR", "FETCH_FAILED"].includes(
+      error.code ?? ""
+    ) || error instanceof TypeError || error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name)) {
+      const originalMessage = error instanceof Error ? error.message : "Transport failed";
+      const failure = new DeeplineError(
+        workflowId ? `${originalMessage} Admission outcome is unknown for ${workflowId}. Inspect this run before retrying; reuse this workflowId for the same immutable request.` : `${originalMessage} Admission outcome is unknown. This server did not prove caller-owned recovery support; inspect existing runs before starting again.`,
+        error instanceof DeeplineError ? error.statusCode : void 0,
+        error instanceof DeeplineError ? error.code : "NETWORK_ERROR",
+        {
+          ...workflowId ? { runId: workflowId, workflowId } : {},
+          admissionState: "unknown",
+          recoverySupported: supportsCallerIntent,
+          next: {
+            inspect: workflowId ? `deepline runs get ${workflowId} --json` : "deepline runs list --json"
+          }
+        }
+      );
+      Object.assign(failure, { cause: error });
+      throw failure;
+    }
+    throw error;
+  }
   return normalizePlayRunStart(response);
 }
 function isPlayRunPackage(value) {
@@ -520,6 +631,7 @@ function createSessionPlayRunHttp(fetchImpl = (...args) => fetch(...args)) {
     return parsed;
   };
   return {
+    get: (path) => send(path, { method: "GET" }),
     post: (path, body, headers) => send(path, {
       method: "POST",
       headers: { "content-type": "application/json", ...headers },
@@ -540,6 +652,7 @@ export {
   PLAY_FILES_STAGE_PATH,
   PLAY_FILES_STAGE_MINT_PATH,
   buildPlayRunStartBody,
+  preparePlayRunAdmission,
   startPlayRun,
   isPlayRunPackage,
   normalizePlayRunStart,

package/dist/cli/{chunk-5O4B6AUN.js → chunk-KB4SDX5S.js}

@@ -2,6 +2,13 @@
 var _typebox = require('@sinclair/typebox');
 var _value = require('@sinclair/typebox/value');
 var PLAY_AUTHORING_CONTRACT_EDITION = 10;
+var EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION = [
+  "Edition 11 requires an explicit choice.",
+  "`0` starts a fresh logical call, though a matching operation receipt may recover that same operation after resume;",
+  "`null` allows indefinite result reuse;",
+  "a positive integer is the maximum result age in seconds.",
+  "Omitted values retain legacy behavior in older editions."
+].join(" ");
 var SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
   1,
   2,
@@ -12,7 +19,8 @@ var SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
   7,
   8,
   9,
-  10
+  10,
+  11
 ];
 var PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS = [
   {
@@ -74,6 +82,12 @@ var PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS = [
     compatibilityOwner: "Plays Runtime",
     newWritesEnd: null,
     readerRemoval: null
+  },
+  {
+    changed: 'Requires explicit freshness and semantic identity for supported durable calls, and gives CSV datasets source-row identity so every input occurrence is processed even when key or rowIdentity: "key" is supplied. Edition 10 retains its list-getter behavior and editions 1\u201310 retain their admitted CSV identity and completed receipts; non-CSV datasets keep explicit key deduplication.',
+    compatibilityOwner: "Plays Runtime",
+    newWritesEnd: null,
+    readerRemoval: null
   }
 ];
 function playToolListGetterMode(edition = PLAY_AUTHORING_CONTRACT_EDITION) {
@@ -735,7 +749,7 @@ var PLAY_AUTHORING_FIELD_REGISTRY = {
     required: false,
     resolution: "runtime-allowed",
     issueCode: "play_authoring_durable_policy_invalid",
-    description: "`0` always executes; `null`/omitted never expires; a positive integer is a TTL in seconds.",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
     errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
   },
   "ctx.tools.execute.id": {
@@ -985,6 +999,22 @@ var PLAY_AUTHORING_FIELD_REGISTRY = {
     description: "Stable field or fields used for durable row identity.",
     errorMessage: "ctx.dataset run key must be a non-empty field, field list, or key function."
   },
+  "ctx.dataset.run.rowIdentity": {
+    schema: _typebox.Type.Union([_typebox.Type.Literal("source_row"), _typebox.Type.Literal("key")]),
+    fixtures: {
+      valid: "source_row",
+      invalid: "dedupe",
+      absent: void 0,
+      unresolved: { expression: "rowIdentity" },
+      edition1: "key"
+    },
+    referenceType: "'source_row' | 'key'",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Edition 11 CSV inputs always use source-row occurrence identity, even with rowIdentity: key; key-based deduplication remains available for non-CSV inputs and editions 1\u201310.",
+    errorMessage: 'ctx.dataset run rowIdentity must be "source_row" or "key".'
+  },
   "ctx.dataset.run.onRowError": {
     schema: _typebox.Type.Union([_typebox.Type.Literal("isolate"), _typebox.Type.Literal("fail")]),
     fixtures: {
@@ -1078,7 +1108,7 @@ var PLAY_AUTHORING_FIELD_REGISTRY = {
     required: false,
     resolution: "runtime-dynamic",
     issueCode: "play_authoring_durable_policy_invalid",
-    description: "Checkpoint freshness: null/omitted never expires, 0 always executes.",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
     errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
   },
   "ctx.fetch.key": {
@@ -1111,7 +1141,7 @@ var PLAY_AUTHORING_FIELD_REGISTRY = {
     required: false,
     resolution: "runtime-dynamic",
     issueCode: "play_authoring_durable_policy_invalid",
-    description: "Fetch freshness: null/omitted never expires, 0 always executes.",
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
     errorMessage: "staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds."
   },
   "ctx.runPlay.key": {
@@ -1356,6 +1386,38 @@ var PLAY_AUTHORING_FIELD_REGISTRY = {
     description: "One non-empty Customer DB SQL string; the deprecated SqlQuery object is accepted only without parameter values.",
     errorMessage: "ctx.customerDb.query statement must be a non-empty SQL string. Deprecated SqlQuery objects cannot contain parameter values."
   },
+  "ctx.customerDb.query.options.id": {
+    schema: _typebox.Type.String({ pattern: "\\S" }),
+    fixtures: {
+      valid: "customer-report-read",
+      invalid: "",
+      absent: void 0,
+      unresolved: { expression: "operationId" },
+      edition1: "query"
+    },
+    referenceType: "string",
+    required: true,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_tool_request_invalid",
+    description: "Stable operation identity for Customer DB query recovery.",
+    errorMessage: "ctx.customerDb.query options.id must be a non-empty stable string."
+  },
+  "ctx.customerDb.query.options.staleAfterSeconds": {
+    schema: _typebox.Type.Literal(0),
+    fixtures: {
+      valid: 0,
+      invalid: 1,
+      absent: void 0,
+      unresolved: { expression: "ttl" },
+      edition1: 0
+    },
+    referenceType: "number | null",
+    required: false,
+    resolution: "runtime-dynamic",
+    issueCode: "play_authoring_durable_policy_invalid",
+    description: "Customer DB queries always execute with freshness 0.",
+    errorMessage: "Customer DB queries must use staleAfterSeconds: 0."
+  },
   "ctx.customerDb.query.options.maxRows": {
     schema: _typebox.Type.Integer({ minimum: 1 }),
     fixtures: {
@@ -1598,18 +1660,18 @@ var PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "export type DatasetColumnRunInput<Row, Value> = { readonly row: Row; readonly ctx: DeeplinePlayRuntimeContext; readonly index: number; readonly previousCell?: PreviousCell<Value> };",
   "export type DatasetColumnDefinition<Row, Value> = { readonly run: (input: DatasetColumnRunInput<Row, Value>) => Value | Promise<Value>; readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean> };",
   "export type ConditionalStepResolver<Row, Value, Else = null> = { readonly kind: 'conditional'; readonly when: (row: Row, index: number) => boolean | Promise<boolean>; readonly run: StepResolver<Row, Value>; readonly elseValue: Else; else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>; };",
-  "export type StepOptions<Row, Value = unknown> = { readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: number };",
+  "export type StepOptions<Row, Value = unknown> = { readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: DurableCallStaleAfterSeconds };",
   "export type StepProgramOptions = { readonly continueOnProviderUnavailable?: boolean };",
   "export type StepProgram<Input, Output, Return = Output> = { readonly kind: 'steps'; readonly steps: readonly PlayStepProgramStep[]; readonly returnResolver?: StepResolver<Output, Return>; readonly continueOnProviderUnavailable?: boolean; readonly __inputType?: (input: Input) => void; step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>; step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output, Value>): StepProgram<Input, Output & Record<Name, Value | null>, Return>; return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>; };",
   "export type StepProgramResolver<Input, Return> = { readonly kind: 'steps'; readonly steps: readonly PlayStepProgramStep[]; readonly returnResolver?: StepResolver<never, Return>; readonly __inputType?: (input: Input) => void };",
   "export type RunnableStepProgram<Input, Return> = Pick<StepProgram<Input, never, Return>, 'kind' | 'steps' | 'returnResolver' | '__inputType'>;",
   "export type RunnableColumnStepProgram<Return> = Pick<StepProgramResolver<unknown, Return>, 'kind' | 'steps' | 'returnResolver'>;",
-  "export type PlayStepProgramStep = { readonly name: string; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: number; readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown> };",
+  "export type PlayStepProgramStep = { readonly name: string; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: DurableCallStaleAfterSeconds; readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown> };",
   "export type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | RunnableColumnStepProgram<Value>;",
   "export type StepProgramOutput<TProgram> = TProgram extends StepProgram<unknown, infer Output, unknown> ? Output : never;",
   "export type DatasetRowKey<InputRow extends object> = (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);",
   "export type DatasetDefinitionOptions<InputRow extends object> = { key?: DatasetRowKey<InputRow> };",
-  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType("ctx.dataset.run.description")}; key?: DatasetRowKey<InputRow>; onRowError?: ${cloudReferenceType("ctx.dataset.run.onRowError")}; mode?: ${cloudReferenceType("ctx.dataset.run.mode")}; undrawnColumns?: ${cloudReferenceType("ctx.dataset.run.undrawnColumns")} };`,
+  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType("ctx.dataset.run.description")}; key?: DatasetRowKey<InputRow>; rowIdentity?: ${cloudReferenceType("ctx.dataset.run.rowIdentity")}; onRowError?: ${cloudReferenceType("ctx.dataset.run.onRowError")}; mode?: ${cloudReferenceType("ctx.dataset.run.mode")}; undrawnColumns?: ${cloudReferenceType("ctx.dataset.run.undrawnColumns")} };`,
   "export type DatasetBuilder<InputRow extends object, OutputRow extends object> = {",
   "  withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;",
   "  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value> & { readonly runIf: (row: OutputRow, index: number) => boolean | Promise<boolean> }): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;",
@@ -1629,8 +1691,8 @@ var PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "  readonly run: { readonly id: string };",
   `  runSteps<TInput extends Record<string, unknown>, TOutput>(program: RunnableStepProgram<TInput, TOutput>, input: TInput, options?: { description?: ${cloudReferenceType("ctx.runSteps.options.description")} }): Promise<TOutput>;`,
   "  tools: { execute<K extends string>(request: ToolExecutionRequest<K>): Promise<ToolExecutionOutput<K>> };",
-  `  customerDb: { query<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: SqlQuery, options?: { maxRows?: ${cloudReferenceType("ctx.customerDb.query.options.maxRows")}; timeoutMs?: ${cloudReferenceType("ctx.customerDb.query.options.timeoutMs")} }): Promise<TRow[]> };`,
-  `  tool<K extends string>(key: ${cloudReferenceType("ctx.tool.key")}, toolId: K, input: ${cloudReferenceType("ctx.tool.input")}, options?: { description?: ${cloudReferenceType("ctx.tool.options.description")} }): Promise<ToolExecutionOutput<K>>;`,
+  `  customerDb: { query<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: SqlQuery, options?: { id?: ${cloudReferenceType("ctx.customerDb.query.options.id")}; staleAfterSeconds?: ${cloudReferenceType("ctx.customerDb.query.options.staleAfterSeconds")}; maxRows?: ${cloudReferenceType("ctx.customerDb.query.options.maxRows")}; timeoutMs?: ${cloudReferenceType("ctx.customerDb.query.options.timeoutMs")} }): Promise<TRow[]> };`,
+  `  tool<K extends string>(key: ${cloudReferenceType("ctx.tool.key")}, toolId: K, input: ${cloudReferenceType("ctx.tool.input")}, options?: { description?: ${cloudReferenceType("ctx.tool.options.description")}; staleAfterSeconds?: DurableCallStaleAfterSeconds }): Promise<ToolExecutionOutput<K>>;`,
   "  step<T>(id: string, run: () => T | Promise<T>, options?: RuntimeStepOptions): Promise<T>;",
   "  fetch(key: string, url: string | URL, init?: RequestInit & { headers?: HeadersInit & { 'Idempotency-Key'?: string; 'X-Idempotency-Key'?: string }; auth?: SecretAuthInput }, options?: FetchOptions): Promise<PlayFetchResponse>;",
   "  secrets: { get(name: string): SecretPromise; bearer(secret: string | SecretPromise | SecretHandle): SecretAuth; header(header: string, secret: string | SecretPromise | SecretHandle): SecretAuth };",

package/dist/cli/{chunk-RV6ALZIX.js → chunk-KGNTKMRG.js}

@@ -3,7 +3,8 @@
 
 
 
-var _chunkWMS5U6YBjs = require('./chunk-WMS5U6YB.js');
+var _chunkCS6RAIVYjs = require('./chunk-CS6RAIVY.js');
+
 
 
 var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
@@ -225,8 +226,8 @@ var BROWSER_OPEN_COOLDOWN_MS = 3e4;
 var SAME_URL_BROWSER_OPEN_COOLDOWN_MS = 5 * 6e4;
 var defaultBrowserCommandRunner = childProcess;
 function getAuthedHttpClient() {
-  const config = _chunkWMS5U6YBjs.resolveConfig.call(void 0, );
-  return { config, http: new (0, _chunkWMS5U6YBjs.HttpClient)(config) };
+  const config = _chunkCS6RAIVYjs.resolveConfig.call(void 0, );
+  return { config, http: new (0, _chunkCS6RAIVYjs.HttpClient)(config) };
 }
 function stableOsUserId() {
   try {
@@ -566,7 +567,7 @@ function collectLocalEnvInfo() {
     os: `${process.platform} ${process.arch}`,
     node_version: process.version,
     home_dir: homeDir,
-    agent_runtime: _chunkWMS5U6YBjs.detectAgentRuntime.call(void 0, )
+    agent_runtime: _chunkCS6RAIVYjs.detectAgentRuntime.call(void 0, )
   };
   const env = process.env;
   const optional = {
@@ -813,9 +814,9 @@ function markdownTableFromRows(rows, preferredColumns = []) {
 }
 function withAgentCommandContext(value) {
   const valueRecord = value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
-  return _chunkWMS5U6YBjs.detectAgentRuntime.call(void 0, ) !== "unknown" && valueRecord && !Object.prototype.hasOwnProperty.call(valueRecord, "command_context") ? {
+  return _chunkCS6RAIVYjs.detectAgentRuntime.call(void 0, ) !== "unknown" && valueRecord && !Object.prototype.hasOwnProperty.call(valueRecord, "command_context") ? {
     ...valueRecord,
-    command_context: _chunkWMS5U6YBjs.resolveCliCommandContext.call(void 0, )
+    command_context: _chunkCS6RAIVYjs.resolveCliCommandContext.call(void 0, )
   } : value;
 }
 function printJson(value, fields) {
@@ -828,8 +829,30 @@ function printCompactJson(value) {
   process.stdout.write(`${JSON.stringify(withAgentCommandContext(value))}
 `);
 }
+function cliToolExecutionFailure(error) {
+  const failure = _chunk7P5AA3SNjs.serializeToolExecutionFailure.call(void 0, error);
+  if (!failure) return null;
+  const { publicDetails: _publicDetails, ...facts } = failure;
+  return facts;
+}
+function formatToolExecutionErrorDiagnostic(error) {
+  const failure = cliToolExecutionFailure(error);
+  if (!failure) return null;
+  const lines = [
+    `Tool: ${failure.toolId}${failure.provider ? `; provider: ${failure.provider}` : ""}${failure.operation ? `; operation: ${failure.operation}` : ""}.`,
+    `Failure: ${failure.origin} / ${failure.category}. Same-call retry: ${failure.retryable ? `safe${failure.retryAfterMs === null ? "" : ` after ${failure.retryAfterMs}ms`}` : "unsafe"}.`
+  ];
+  if (failure.networkKind || failure.networkScope) {
+    lines.push(
+      `Network: ${_nullishCoalesce(failure.networkKind, () => ( "unknown"))}${failure.networkScope ? ` (${failure.networkScope})` : ""}.`
+    );
+  }
+  if (failure.requestId) lines.push(`Request: ${failure.requestId}.`);
+  return lines.join("\n");
+}
 function errorToJsonPayload(error) {
   const message = error instanceof Error ? error.message : String(error);
+  const toolFailure = cliToolExecutionFailure(error);
   const maybeRecord = error && typeof error === "object" ? error : null;
   const code = typeof _optionalChain([maybeRecord, 'optionalAccess', _22 => _22.code]) === "string" ? maybeRecord.code : error instanceof SyntaxError ? "INVALID_JSON" : "CLI_ERROR";
   const details = {};
@@ -868,6 +891,7 @@ function errorToJsonPayload(error) {
     error: {
       message,
       code,
+      ...toolFailure ? { tool_error: toolFailure } : {},
       ...Object.keys(details).length > 0 ? { details } : {}
     }
   };
@@ -975,4 +999,5 @@ function printCommandEnvelope(envelope, options = {}) {
 
 
 
-exports.parseJsonFields = parseJsonFields; exports.jsonFieldArgs = jsonFieldArgs; exports.describeArgs = describeArgs; exports.getAuthedHttpClient = getAuthedHttpClient; exports.openInBrowser = openInBrowser; exports.sleep = sleep; exports.collectLocalEnvInfo = collectLocalEnvInfo; exports.readCsvRows = readCsvRows; exports.csvStringFromRows = csvStringFromRows; exports.csvSafeJsonString = csvSafeJsonString; exports.recordRows = recordRows; exports.dataExportRows = dataExportRows; exports.dataExportColumns = dataExportColumns; exports.dataExportCsvString = dataExportCsvString; exports.markdownTableFromRows = markdownTableFromRows; exports.printJson = printJson; exports.printCompactJson = printCompactJson; exports.errorToJsonPayload = errorToJsonPayload; exports.formatProviderConcurrencyDiagnostic = formatProviderConcurrencyDiagnostic; exports.printJsonError = printJsonError; exports.shouldEmitJson = shouldEmitJson; exports.argsWantJson = argsWantJson; exports.createTimestampedName = createTimestampedName; exports.clip = clip; exports.renderCommandEnvelopeText = renderCommandEnvelopeText; exports.printCommandEnvelope = printCommandEnvelope;
+
+exports.parseJsonFields = parseJsonFields; exports.jsonFieldArgs = jsonFieldArgs; exports.describeArgs = describeArgs; exports.getAuthedHttpClient = getAuthedHttpClient; exports.openInBrowser = openInBrowser; exports.sleep = sleep; exports.collectLocalEnvInfo = collectLocalEnvInfo; exports.readCsvRows = readCsvRows; exports.csvStringFromRows = csvStringFromRows; exports.csvSafeJsonString = csvSafeJsonString; exports.recordRows = recordRows; exports.dataExportRows = dataExportRows; exports.dataExportColumns = dataExportColumns; exports.dataExportCsvString = dataExportCsvString; exports.markdownTableFromRows = markdownTableFromRows; exports.printJson = printJson; exports.printCompactJson = printCompactJson; exports.formatToolExecutionErrorDiagnostic = formatToolExecutionErrorDiagnostic; exports.errorToJsonPayload = errorToJsonPayload; exports.formatProviderConcurrencyDiagnostic = formatProviderConcurrencyDiagnostic; exports.printJsonError = printJsonError; exports.shouldEmitJson = shouldEmitJson; exports.argsWantJson = argsWantJson; exports.createTimestampedName = createTimestampedName; exports.clip = clip; exports.renderCommandEnvelopeText = renderCommandEnvelopeText; exports.printCommandEnvelope = printCommandEnvelope;