deepline 0.2.74 → 0.3.0

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

@@ -75,7 +75,7 @@ export type ToolResultEnvelope<
   meta?: TMeta;
 };
 
-export type SerializedToolExecuteResult = {
+export type SerializedToolExecuteResultV1 = {
   __kind: 'deepline.tool_execute_result.v1';
   status: string;
   job_id?: string;
@@ -98,11 +98,36 @@ export type SerializedToolExecuteResult = {
   execution: ToolResultExecutionMetadata;
 };
 
+/**
+ * Canonical receipt form. Provider data is stored once as `rawV2`; the legacy
+ * raw/meta view is recreated from the payload-free projection descriptor.
+ */
+export type SerializedToolExecuteResultV2 = Omit<
+  SerializedToolExecuteResultV1,
+  '__kind' | 'toolResponse'
+> & {
+  __kind: 'deepline.tool_execute_result.v2';
+  toolResponse: {
+    rawV2: unknown;
+    view: 'data' | 'rawV2';
+    /** Deepline-owned additions not already represented in `rawV2.meta`. */
+    responseMeta?: Record<string, unknown>;
+  };
+};
+
+export type SerializedToolExecuteResult =
+  | SerializedToolExecuteResultV1
+  | SerializedToolExecuteResultV2;
+
 export type ToolResponseEnvelope<
   TData = unknown,
   TMeta = Record<string, unknown>,
 > = {
   raw: TData;
+  /** Complete parsed and scrubbed provider response, materialized from raw-v2. */
+  rawV2?: unknown;
+  /** Durable descriptor for deriving the legacy raw view from `rawV2`. */
+  view?: 'data' | 'rawV2';
   meta?: TMeta;
 };
 
@@ -156,8 +181,9 @@ export type ToolExecuteResultAccessors<
  * Canonical result returned by Deepline tool execution.
  *
  * The top-level object is Deepline-owned execution metadata and semantic
- * extraction state. Raw tool/provider data lives under `toolResponse.raw`;
- * response metadata lives under `toolResponse.meta`. Semantic single-value
+ * 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
  * getters live under `extractedValues.<name>.get()`, and list getters live
  * under `extractedLists.<name>.get()`.
  *

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

@@ -49,10 +49,18 @@ import {
 } from '../plays/dataset';
 import { normalizeTableNamespace, sha256Hex } from '../plays/row-identity';
 import { listNameFromDeclaredPath } from './tool-result-paths';
+import {
+  legacyRawFromToolResponseRawV2,
+  providerMetaFromToolResponseRawV2,
+  type ToolResponseView,
+} from './tool-response-contract';
 
 type PathSegment = string | number | '*';
 
-const SERIALIZED_TOOL_EXECUTE_RESULT_KIND = 'deepline.tool_execute_result.v1';
+const SERIALIZED_TOOL_EXECUTE_RESULT_V1_KIND =
+  'deepline.tool_execute_result.v1';
+const SERIALIZED_TOOL_EXECUTE_RESULT_V2_KIND =
+  'deepline.tool_execute_result.v2';
 const SERIALIZED_TOOL_RESULT_LIST_PREVIEW_LIMIT = 5;
 const LIVE_TOOL_RESULT_LIST_DATASET_REGISTRY_LIMIT = 256;
 const SERIALIZED_TOOL_LIST_ROWS = Symbol('deepline.serialized_tool_list_rows');
@@ -123,6 +131,8 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 type V2ToolExecuteOutput = {
   raw: unknown;
+  rawV2?: unknown;
+  view?: ToolResponseView;
   meta?: Record<string, unknown>;
 };
 
@@ -131,12 +141,35 @@ function parseV2ToolExecuteOutput(
 ): V2ToolExecuteOutput | null {
   const toolResponse = data.toolResponse;
   if (isRecord(toolResponse)) {
-    const meta = isRecord(toolResponse.meta) ? toolResponse.meta : undefined;
+    const rawV2 = Object.prototype.hasOwnProperty.call(toolResponse, 'rawV2')
+      ? toolResponse.rawV2
+      : undefined;
+    const view =
+      toolResponse.view === 'data' || toolResponse.view === 'rawV2'
+        ? toolResponse.view
+        : undefined;
+    const providerMeta = providerMetaFromToolResponseRawV2(
+      rawV2,
+      view ?? 'rawV2',
+    );
+    const responseMeta = isRecord(toolResponse.responseMeta)
+      ? toolResponse.responseMeta
+      : undefined;
+    const meta = {
+      ...(isRecord(toolResponse.meta) ? toolResponse.meta : {}),
+      ...(providerMeta ?? {}),
+      ...(responseMeta ?? {}),
+    };
+    const raw = Object.prototype.hasOwnProperty.call(toolResponse, 'raw')
+      ? toolResponse.raw
+      : rawV2 === undefined
+        ? null
+        : legacyRawFromToolResponseRawV2(rawV2, view ?? 'rawV2', responseMeta);
     return {
-      raw: Object.prototype.hasOwnProperty.call(toolResponse, 'raw')
-        ? toolResponse.raw
-        : null,
-      ...(meta ? { meta } : {}),
+      raw,
+      ...(rawV2 !== undefined ? { rawV2 } : {}),
+      ...(view ? { view } : {}),
+      ...(Object.keys(meta).length > 0 ? { meta } : {}),
     };
   }
   return null;
@@ -181,7 +214,10 @@ export type ParsedToolExecuteResponse = {
   meta?: Record<string, unknown>;
   toolResponse?: {
     raw?: unknown;
+    rawV2?: unknown;
+    view?: 'data' | 'rawV2';
     meta?: Record<string, unknown>;
+    responseMeta?: Record<string, unknown>;
   };
   /** Legacy `{ data, meta }` envelope consumed by createToolExecuteResult. */
   result: unknown;
@@ -204,9 +240,17 @@ export function parseToolExecuteResponse(
     status,
     jobId: typeof body.job_id === 'string' ? body.job_id : undefined,
     meta: isRecord(body.meta) ? body.meta : undefined,
-    toolResponse: isRecord(body.toolResponse)
-      ? (body.toolResponse as ParsedToolExecuteResponse['toolResponse'])
-      : undefined,
+    toolResponse: (() => {
+      const output = parseV2ToolExecuteOutput(body);
+      return output
+        ? {
+            raw: output.raw,
+            ...(output.rawV2 !== undefined ? { rawV2: output.rawV2 } : {}),
+            ...(output.view ? { view: output.view } : {}),
+            ...(output.meta ? { meta: output.meta } : {}),
+          }
+        : undefined;
+    })(),
     result,
     metadata: parseExecuteToolMetadata(toolId, body),
   };
@@ -1135,11 +1179,20 @@ export function createToolExecuteResult<TResult = unknown>(input: {
   metadata: ToolResultMetadataInput;
   execution: ToolResultExecutionMetadata;
   meta?: Record<string, unknown>;
+  response?: {
+    rawV2?: unknown;
+    view?: 'data' | 'rawV2';
+    meta?: Record<string, unknown>;
+  };
 }): ToolExecuteResult<TResult> {
   const result = toResultEnvelope(input.result);
   const resultRoot = {
     toolResponse: {
       raw: result.data,
+      ...(input.response && 'rawV2' in input.response
+        ? { rawV2: input.response.rawV2 }
+        : {}),
+      ...(input.response?.view ? { view: input.response.view } : {}),
       ...(result.meta ? { meta: result.meta } : {}),
     },
   };
@@ -1165,6 +1218,10 @@ export function createToolExecuteResult<TResult = unknown>(input: {
   };
   const toolResponse = {
     raw: result.data,
+    ...(input.response && 'rawV2' in input.response
+      ? { rawV2: input.response.rawV2 }
+      : {}),
+    ...(input.response?.view ? { view: input.response.view } : {}),
     ...(result.meta ? { meta: result.meta } : {}),
   };
   const extractedValues = buildExtractedAccessors(targets);
@@ -1634,6 +1691,17 @@ function applySerializedListDatasets(
       listDatasets,
       listRows,
     });
+    if (Object.prototype.hasOwnProperty.call(result.toolResponse, 'rawV2')) {
+      const view = result.toolResponse.view ?? 'rawV2';
+      if (view === 'data' && isRecord(result.toolResponse.rawV2)) {
+        result.toolResponse.rawV2 = {
+          ...result.toolResponse.rawV2,
+          data: result.toolResponse.raw,
+        };
+      } else {
+        result.toolResponse.rawV2 = result.toolResponse.raw;
+      }
+    }
     Object.defineProperty(result, SERIALIZED_TOOL_LIST_ROWS, {
       value: listRows,
       enumerable: false,
@@ -1695,6 +1763,47 @@ function metadataInputFromToolExecuteResult(
   };
 }
 
+function sameJsonValue(left: unknown, right: unknown): boolean {
+  if (left === right) return true;
+  try {
+    return JSON.stringify(left) === JSON.stringify(right);
+  } catch {
+    return false;
+  }
+}
+
+function responseMetaOutsideRawV2(input: {
+  rawV2: unknown;
+  view: 'data' | 'rawV2';
+  meta: Record<string, unknown> | undefined;
+}): Record<string, unknown> | undefined {
+  if (!input.meta) return undefined;
+  const providerMeta =
+    input.view === 'data' && isRecord(input.rawV2) && isRecord(input.rawV2.meta)
+      ? input.rawV2.meta
+      : undefined;
+  if (!providerMeta) return input.meta;
+  const responseMeta = Object.fromEntries(
+    Object.entries(input.meta).filter(
+      ([key, value]) =>
+        !Object.prototype.hasOwnProperty.call(providerMeta, key) ||
+        !sameJsonValue(providerMeta[key], value),
+    ),
+  );
+  return Object.keys(responseMeta).length > 0 ? responseMeta : undefined;
+}
+
+function rawV2WithSerializedRawPreview(input: {
+  rawV2: unknown;
+  view: 'data' | 'rawV2';
+  raw: unknown;
+}): unknown {
+  if (input.view === 'data' && isRecord(input.rawV2)) {
+    return { ...input.rawV2, data: input.raw };
+  }
+  return input.raw;
+}
+
 export function serializeToolExecuteResult(
   value: ToolExecuteResult,
 ): SerializedToolExecuteResult {
@@ -1706,17 +1815,54 @@ export function serializeToolExecuteResult(
     metadata,
   });
   const targetValues = serializedTargetValuesFromResult(value);
+  const serializedRaw = serializedRawWithListPreviews({
+    raw: value.toolResponse.raw,
+    metadata,
+    listDatasets,
+  });
+  if (Object.prototype.hasOwnProperty.call(value.toolResponse, 'rawV2')) {
+    const view = value.toolResponse.view ?? 'rawV2';
+    const rawV2 = rawV2WithSerializedRawPreview({
+      rawV2: value.toolResponse.rawV2,
+      view,
+      raw:
+        view === 'data'
+          ? serializedRaw
+          : serializedRawWithListPreviews({
+              raw: value.toolResponse.rawV2,
+              metadata,
+              listDatasets,
+            }),
+    });
+    const responseMeta = responseMetaOutsideRawV2({
+      rawV2: value.toolResponse.rawV2,
+      view,
+      meta: value.toolResponse.meta,
+    });
+    return {
+      __kind: SERIALIZED_TOOL_EXECUTE_RESULT_V2_KIND,
+      status: value.status,
+      ...(typeof value.job_id === 'string' ? { job_id: value.job_id } : {}),
+      ...(isRecord(value.meta) ? { meta: value.meta } : {}),
+      toolResponse: {
+        rawV2,
+        view,
+        ...(responseMeta ? { responseMeta } : {}),
+      },
+      ...(listDatasets ? { listDatasets } : {}),
+      ...(listRows ? { listRows } : {}),
+      ...(targetValues ? { targetValues } : {}),
+      metadata,
+      execution: value._metadata.execution,
+    };
+  }
   return {
-    __kind: SERIALIZED_TOOL_EXECUTE_RESULT_KIND,
+    __kind: SERIALIZED_TOOL_EXECUTE_RESULT_V1_KIND,
     status: value.status,
     ...(typeof value.job_id === 'string' ? { job_id: value.job_id } : {}),
     ...(isRecord(value.meta) ? { meta: value.meta } : {}),
     toolResponse: {
-      raw: serializedRawWithListPreviews({
-        raw: value.toolResponse.raw,
-        metadata,
-        listDatasets,
-      }),
+      raw: serializedRaw,
       ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
     },
     ...(listDatasets ? { listDatasets } : {}),
@@ -1732,7 +1878,8 @@ export function isSerializedToolExecuteResult(
 ): value is SerializedToolExecuteResult {
   return (
     isRecord(value) &&
-    value.__kind === SERIALIZED_TOOL_EXECUTE_RESULT_KIND &&
+    (value.__kind === SERIALIZED_TOOL_EXECUTE_RESULT_V1_KIND ||
+      value.__kind === SERIALIZED_TOOL_EXECUTE_RESULT_V2_KIND) &&
     typeof value.status === 'string' &&
     isRecord(value.toolResponse) &&
     isRecord(value.metadata) &&
@@ -1743,6 +1890,46 @@ export function isSerializedToolExecuteResult(
 export function deserializeToolExecuteResult(
   value: SerializedToolExecuteResult,
 ): ToolExecuteResult {
+  if (value.__kind === SERIALIZED_TOOL_EXECUTE_RESULT_V2_KIND) {
+    const view = value.toolResponse.view;
+    const rawV2 = value.toolResponse.rawV2;
+    const providerMeta =
+      view === 'data' && isRecord(rawV2) && isRecord(rawV2.meta)
+        ? rawV2.meta
+        : undefined;
+    const meta = {
+      ...(providerMeta ?? {}),
+      ...(value.toolResponse.responseMeta ?? {}),
+    };
+    const raw = legacyRawFromToolResponseRawV2(
+      rawV2,
+      view,
+      value.toolResponse.responseMeta,
+    );
+    return applySerializedListDatasets(
+      applySerializedTargetValues(
+        createToolExecuteResult({
+          status: value.status,
+          jobId: value.job_id,
+          result: {
+            data: raw,
+            ...(Object.keys(meta).length > 0 ? { meta } : {}),
+          },
+          response: {
+            rawV2,
+            view,
+            ...(Object.keys(meta).length > 0 ? { meta } : {}),
+          },
+          metadata: value.metadata,
+          execution: value.execution,
+          meta: value.meta,
+        }),
+        value.targetValues,
+      ),
+      value.listDatasets,
+      value.listRows,
+    );
+  }
   return applySerializedListDatasets(
     applySerializedTargetValues(
       createToolExecuteResult({

package/dist/bundling-sources/shared_libs/plays/artifact-types.ts

@@ -1,4 +1,5 @@
 import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
+import type { ToolResponseContract } from '../play-runtime/tool-response-contract';
 import type { PlayAuthoringContractEdition } from './authoring-contract';
 
 export type PlayPackageImport = {
@@ -28,6 +29,8 @@ export type PlayArtifactCompatibility = {
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   /** Missing preserves edition 1 for artifacts created before authoring contracts were pinned. */
   authoringContractEdition?: PlayAuthoringContractEdition;
+  /** Missing preserves the raw-only V2 execute response contract. */
+  toolResponseContract?: ToolResponseContract;
 };
 
 /** The only executable Play artifact contract. */

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

@@ -10,6 +10,11 @@ import {
   type PlayAuthoringContractEdition,
   type AdmittedPlayAuthoringContract,
 } from './authoring-contract';
+import {
+  normalizeToolResponseContract,
+  RAW_V2_TOOL_RESPONSE_CONTRACT,
+  type ToolResponseContract,
+} from '../play-runtime/tool-response-contract';
 
 export type PlayContractSource = 'ad_hoc' | 'draft' | 'published';
 
@@ -39,12 +44,15 @@ export type PlayContractCompatibilitySnapshot = {
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   /** Missing preserves edition 1 for artifacts stored before authoring contracts were pinned. */
   authoringContractEdition?: PlayAuthoringContractEdition;
+  /** Immutable execute-result transport selected when the artifact is built. */
+  toolResponseContract?: ToolResponseContract;
 };
 
 export type NormalizedPlayContractCompatibilitySnapshot =
   PlayContractCompatibilitySnapshot & {
     toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
     authoringContractEdition: PlayAuthoringContractEdition;
+    toolResponseContract: ToolResponseContract;
   };
 
 export class UnsupportedPlayToolErrorSchemaVersionError extends Error {
@@ -94,6 +102,9 @@ export function normalizePlayContractCompatibility(
   return {
     ...compatibility,
     toolErrorSchemaVersion: TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+    toolResponseContract: normalizeToolResponseContract(
+      compatibility.toolResponseContract,
+    ),
     authoringContractEdition: normalizePlayAuthoringContractEdition(
       compatibility.authoringContractEdition,
     ),
@@ -104,6 +115,7 @@ export function buildPlayContractCompatibility(input?: {
   runtimeBackend?: string | null;
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   authoringContractEdition?: PlayAuthoringContractEdition;
+  toolResponseContract?: ToolResponseContract;
 }): PlayContractCompatibilitySnapshot {
   return {
     apiVersion: PLAY_PUBLIC_API_VERSION,
@@ -115,6 +127,8 @@ export function buildPlayContractCompatibility(input?: {
       input?.toolErrorSchemaVersion ?? TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
     authoringContractEdition:
       input?.authoringContractEdition ?? PLAY_AUTHORING_CONTRACT_EDITION,
+    toolResponseContract:
+      input?.toolResponseContract ?? RAW_V2_TOOL_RESPONSE_CONTRACT,
   };
 }
 

package/dist/cli/index.js

@@ -1044,7 +1044,11 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.74",
+  // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
+  // available at toolResponse.rawV2 while toolResponse.raw and all declared
+  // getters keep their established compatibility behavior.
+  version: "0.3.0",
+  updateSummary: "New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -3759,12 +3763,33 @@ function normalizePlayRuntimeEnvironment(value) {
   return typeof value === "string" && PLAY_RUNTIME_ENVIRONMENTS.includes(value) ? value : null;
 }
 
+// ../shared_libs/play-runtime/tool-response-contract.ts
+var RAW_V2_TOOL_RESPONSE_CONTRACT = "raw-v2";
+function legacyRawFromToolResponseRawV2(rawV2, view, responseMeta) {
+  const legacyRaw = view === "data" && rawV2 && typeof rawV2 === "object" && !Array.isArray(rawV2) ? rawV2.data : rawV2;
+  const deeplineBilling = responseMeta?.deepline_billing;
+  if (view === "rawV2" && deeplineBilling !== void 0 && legacyRaw && typeof legacyRaw === "object" && !Array.isArray(legacyRaw)) {
+    return {
+      ...legacyRaw,
+      deepline_billing: deeplineBilling
+    };
+  }
+  return legacyRaw;
+}
+function providerMetaFromToolResponseRawV2(rawV2, view) {
+  if (view !== "data" || !rawV2 || typeof rawV2 !== "object" || Array.isArray(rawV2)) {
+    return void 0;
+  }
+  const meta = rawV2.meta;
+  return meta && typeof meta === "object" && !Array.isArray(meta) ? meta : void 0;
+}
+
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
 var EXECUTE_RESPONSE_INTENT_HEADER = "x-deepline-execute-response-intent";
-var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-response";
+var RAW_V2_EXECUTE_RESPONSE_CONTRACT = RAW_V2_TOOL_RESPONSE_CONTRACT;
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
@@ -3979,6 +4004,50 @@ function requireTargetBillingIdempotencyKey(value) {
 function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function materializeToolExecutionResponse(response) {
+  const toolResponse = response.toolResponse;
+  if (!toolResponse && isRecord7(response.result)) {
+    const legacyResult = response.result;
+    if (Object.prototype.hasOwnProperty.call(legacyResult, "data")) {
+      const legacyMeta = isRecord7(legacyResult.meta) ? legacyResult.meta : void 0;
+      return {
+        ...response,
+        toolResponse: {
+          raw: legacyResult.data,
+          ...legacyMeta ? { meta: legacyMeta } : {}
+        }
+      };
+    }
+  }
+  if (!toolResponse || Object.prototype.hasOwnProperty.call(toolResponse, "raw")) {
+    return response;
+  }
+  const rawV2 = toolResponse.rawV2;
+  const view = toolResponse.view;
+  const providerMeta = providerMetaFromToolResponseRawV2(
+    rawV2,
+    view ?? "rawV2"
+  );
+  const responseMeta = isRecord7(toolResponse.responseMeta) ? toolResponse.responseMeta : void 0;
+  return {
+    ...response,
+    toolResponse: {
+      ...toolResponse,
+      raw: legacyRawFromToolResponseRawV2(
+        rawV2,
+        view ?? "rawV2",
+        responseMeta
+      ),
+      ...toolResponse.meta || providerMeta || responseMeta ? {
+        meta: {
+          ...toolResponse.meta ?? {},
+          ...providerMeta ?? {},
+          ...responseMeta ?? {}
+        }
+      } : {}
+    }
+  };
+}
 function isPrebuiltPlayDescription(play) {
   return play.origin === "prebuilt" || play.ownerType === "deepline";
 }
@@ -4528,14 +4597,14 @@ var DeeplineClient = class {
    */
   async executeTool(toolId, input2, options) {
     const headers = {
-      [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
+      [EXECUTE_RESPONSE_CONTRACT_HEADER]: RAW_V2_EXECUTE_RESPONSE_CONTRACT,
       [TOOL_EXECUTION_ERROR_SCHEMA_HEADER]: String(
         TOOL_EXECUTION_ERROR_SCHEMA_VERSION
       ),
       ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {},
       [EXECUTE_RESPONSE_INTENT_HEADER]: options?.responseIntent ?? "raw"
     };
-    return this.http.post(
+    const response = await this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       {
         payload: input2,
@@ -4549,6 +4618,7 @@ var DeeplineClient = class {
         toolId
       }
     );
+    return materializeToolExecutionResponse(response);
   }
   /**
    * Back-compatible alias for {@link executeTool}.
@@ -40754,9 +40824,7 @@ function shouldSkipSelfUpdate() {
 function parseSemver(version) {
   const trimmed = version?.trim();
   if (!trimmed) return null;
-  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(
-    trimmed
-  );
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(trimmed);
   if (!match) return null;
   return {
     major: Number(match[1]),
@@ -40847,7 +40915,12 @@ async function maybeAutoUpdateAndRelaunch(response) {
     );
     return false;
   }
-  process.stderr.write("Deepline SDK/CLI updated; rerunning command.\n");
+  const updateSummary = response.update_summary ? `
+What changed in ${response.update_summary.version}: ${response.update_summary.summary}` : "";
+  process.stderr.write(
+    `Deepline SDK/CLI updated; rerunning command.${updateSummary}
+`
+  );
   const exitCode = await relaunchCurrentCommand(plan);
   process.exit(exitCode);
   return true;