deepline 0.1.301 → 0.1.302

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -3,6 +3,7 @@ import {
   normalizeToolHttpErrorMessage,
   type ToolHttpError,
 } from './tool-http-errors';
+import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
 
 export const TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS = 2;
 // A provider may need to finish the original request before it can replay the
@@ -296,6 +297,7 @@ export function classifyToolExecuteHttpFailure(input: {
   status: number;
   attempt: number;
   bodyText: string;
+  schemaVersion?: ToolExecutionErrorSchemaVersion;
   retryAfterHeader?: string | null;
   transientHttpRetrySafe?: boolean;
   providerLatencyMs?: number;
@@ -318,12 +320,20 @@ export function classifyToolExecuteHttpFailure(input: {
     hasRetryAfterHeader,
     transientHttpRetrySafe,
   });
+  const retryAfterMs = parseToolExecuteRetryAfterMs(
+    input.retryAfterHeader,
+    input.nowMs,
+  );
   const error = normalizeToolHttpErrorMessage({
     toolId: input.toolId,
     status: input.status,
     attempt: input.attempt,
     maxAttempts: initialRetryDecision.attemptCap,
     bodyText: input.bodyText,
+    schemaVersion: input.schemaVersion,
+    retryable: initialRetryDecision.retryable,
+    retryAfterMs:
+      input.status === 429 && hasRetryAfterHeader ? retryAfterMs : null,
   });
   if (
     typeof input.providerLatencyMs === 'number' &&
@@ -355,10 +365,6 @@ export function classifyToolExecuteHttpFailure(input: {
   ) {
     error.receiptFailureKind = 'repairable';
   }
-  const retryAfterMs = parseToolExecuteRetryAfterMs(
-    input.retryAfterHeader,
-    input.nowMs,
-  );
   const retryDelayMs =
     input.status === 429
       ? Math.min(
@@ -369,14 +375,14 @@ export function classifyToolExecuteHttpFailure(input: {
           ),
         )
       : retryDecision.reason === 'idempotency_in_progress' &&
-            !hasRetryAfterHeader
-        ? idempotencyInProgressRetryDelayMs(input.attempt)
-        : retryDecision.reason === 'gateway_invocation_in_progress' &&
           !hasRetryAfterHeader
         ? idempotencyInProgressRetryDelayMs(input.attempt)
-        : retryAfterMs > 0
-          ? Math.min(TOOL_EXECUTE_RETRY_DELAY_MAX_MS, retryAfterMs)
-          : TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+        : retryDecision.reason === 'gateway_invocation_in_progress' &&
+            !hasRetryAfterHeader
+          ? idempotencyInProgressRetryDelayMs(input.attempt)
+          : retryAfterMs > 0
+            ? Math.min(TOOL_EXECUTE_RETRY_DELAY_MAX_MS, retryAfterMs)
+            : TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
   return {
     ...retryDecision,
     error,
@@ -395,7 +401,6 @@ export function classifyToolExecuteHttpFailure(input: {
           : TOOL_EXECUTE_BARE_RATE_LIMIT_BACKPRESSURE_MS
         : null,
     chargeRetryBudget:
-      shouldRetry &&
-      retryDecision.reason !== 'gateway_invocation_in_progress',
+      shouldRetry && retryDecision.reason !== 'gateway_invocation_in_progress',
   };
 }

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

@@ -1,5 +1,50 @@
 import type { WorkReceiptFailureKind } from './work-receipts';
+import {
+  LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+  ToolExecutionError,
+  deserializeToolExecutionFailure,
+  isProviderTransientFailure,
+  normalizeToolExecutionCategory,
+  normalizeToolExecutionOrigin,
+  type ToolExecutionErrorSchemaVersion,
+  type ToolExecutionErrorOptions,
+} from '../tool-execution-error';
 
+const TOOL_HTTP_ERROR_BRAND = Symbol.for('deepline.tool-http-error.v1');
+
+type ToolHttpErrorConstructorInput = {
+  message: string;
+  billing: Record<string, unknown> | null;
+  status: number;
+  receiptFailureKind: WorkReceiptFailureKind;
+  options: Partial<ToolExecutionErrorOptions>;
+};
+
+function applyToolHttpErrorFields(
+  error: {
+    name: string;
+    billing: Record<string, unknown> | null;
+    status: number;
+    receiptFailureKind: WorkReceiptFailureKind;
+  },
+  input: ToolHttpErrorConstructorInput,
+): void {
+  error.name = 'ToolHttpError';
+  error.billing = input.billing;
+  error.status = input.status;
+  error.receiptFailureKind = input.receiptFailureKind;
+  Object.defineProperty(error, TOOL_HTTP_ERROR_BRAND, {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: true,
+  });
+}
+
+/**
+ * Historical play-runtime HTTP error. Existing artifacts must keep this exact
+ * Error prototype; typed errors are an explicit artifact-contract opt-in.
+ */
 export class ToolHttpError extends Error {
   readonly billing: Record<string, unknown> | null;
   /** HTTP status of the failed tool-execute response (e.g. 429, 502). */
@@ -11,15 +56,89 @@ export class ToolHttpError extends Error {
     billing: Record<string, unknown> | null,
     status: number,
     receiptFailureKind: WorkReceiptFailureKind = 'terminal',
+    _options: Partial<ToolExecutionErrorOptions> = {},
   ) {
     super(message);
-    this.name = 'ToolHttpError';
     this.billing = billing;
     this.status = status;
     this.receiptFailureKind = receiptFailureKind;
+    applyToolHttpErrorFields(this, {
+      message,
+      billing,
+      status,
+      receiptFailureKind,
+      options: _options,
+    });
+  }
+
+  static [Symbol.hasInstance](value: unknown): boolean {
+    return Boolean(
+      value &&
+      typeof value === 'object' &&
+      (value as Record<symbol, unknown>)[TOOL_HTTP_ERROR_BRAND] === true,
+    );
   }
 }
 
+class StructuredToolHttpError extends ToolExecutionError {
+  readonly billing: Record<string, unknown> | null;
+  readonly status: number;
+  receiptFailureKind: WorkReceiptFailureKind;
+
+  constructor(input: ToolHttpErrorConstructorInput) {
+    super(input.message, {
+      toolId: input.options.toolId ?? 'unknown_tool',
+      provider: input.options.provider ?? null,
+      operation: input.options.operation ?? null,
+      code: input.options.code ?? null,
+      origin: input.options.origin ?? 'unknown',
+      category: input.options.category ?? 'unknown',
+      retryable: input.options.retryable === true,
+      statusCode:
+        input.options.statusCode === undefined
+          ? input.status
+          : input.options.statusCode,
+      requestId: input.options.requestId ?? null,
+      retryAfterMs: input.options.retryAfterMs ?? null,
+      networkKind: input.options.networkKind ?? null,
+      networkScope: input.options.networkScope ?? null,
+    });
+    this.billing = input.billing;
+    this.status = input.status;
+    this.receiptFailureKind = input.receiptFailureKind;
+    applyToolHttpErrorFields(this, input);
+    this.name = isProviderTransientFailure(this)
+      ? 'ProviderTransientError'
+      : 'ToolExecutionError';
+  }
+}
+
+export function createToolHttpError(
+  schemaVersion: ToolExecutionErrorSchemaVersion,
+  message: string,
+  billing: Record<string, unknown> | null,
+  status: number,
+  receiptFailureKind: WorkReceiptFailureKind = 'terminal',
+  options: Partial<ToolExecutionErrorOptions> = {},
+): ToolHttpError {
+  if (schemaVersion === LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION) {
+    return new ToolHttpError(
+      message,
+      billing,
+      status,
+      receiptFailureKind,
+      options,
+    );
+  }
+  return new StructuredToolHttpError({
+    message,
+    billing,
+    status,
+    receiptFailureKind,
+    options,
+  }) as ToolHttpError;
+}
+
 function formatCreditAmount(value: unknown): string {
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     return String(value ?? '-');
@@ -222,7 +341,12 @@ export function normalizeToolHttpErrorMessage(input: {
   attempt: number;
   maxAttempts: number;
   bodyText: string;
+  retryable?: boolean;
+  retryAfterMs?: number | null;
+  schemaVersion?: ToolExecutionErrorSchemaVersion;
 }): ToolHttpError {
+  const schemaVersion =
+    input.schemaVersion ?? LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION;
   let parsed: Record<string, unknown> | null = null;
   try {
     const candidate = JSON.parse(input.bodyText);
@@ -230,9 +354,64 @@ export function normalizeToolHttpErrorMessage(input: {
   } catch {
     parsed = null;
   }
+  const serializedFailure = parsed?.tool_error;
+  const hydratedFailure = deserializeToolExecutionFailure(
+    '',
+    serializedFailure,
+    schemaVersion,
+  );
+  const provider =
+    getStringField(parsed, 'provider') ??
+    hydratedFailure?.provider ??
+    input.toolId.split(/[._:./-]+/)[0]?.trim() ??
+    null;
+  const operation =
+    getStringField(parsed, 'operation') ??
+    hydratedFailure?.operation ??
+    input.toolId;
+  const code = getStringField(parsed, 'code') ?? hydratedFailure?.code ?? null;
+  const rawOrigin =
+    getStringField(parsed, 'failure_origin') ?? hydratedFailure?.origin;
+  const rawCategory =
+    getStringField(parsed, 'error_category') ?? hydratedFailure?.category;
+  const origin = normalizeToolExecutionOrigin(rawOrigin, {
+    provider,
+    operation,
+  });
+  const category = normalizeToolExecutionCategory(rawCategory);
+  const trustworthy = origin !== 'unknown' && category !== 'unknown';
+  const publicOptions: Partial<ToolExecutionErrorOptions> = {
+    toolId: input.toolId,
+    provider,
+    operation,
+    code,
+    origin,
+    category,
+    retryable: trustworthy
+      ? (hydratedFailure?.retryable ?? input.retryable === true)
+      : false,
+    statusCode: input.status,
+    requestId:
+      getStringField(parsed, 'request_id') ??
+      getStringField(parsed, 'requestId') ??
+      hydratedFailure?.requestId ??
+      null,
+    retryAfterMs: hydratedFailure?.retryAfterMs ?? input.retryAfterMs ?? null,
+    networkKind:
+      hydratedFailure?.networkKind ??
+      (category === 'network' && code?.toUpperCase().includes('TIMEOUT')
+        ? 'timeout'
+        : null),
+    networkScope:
+      hydratedFailure?.networkScope ??
+      (origin === 'provider' && category === 'network'
+        ? 'deepline_to_provider'
+        : null),
+  };
   const billing = getObjectField(parsed, 'billing');
   if (isInsufficientCreditsBilling(billing)) {
-    return new ToolHttpError(
+    return createToolHttpError(
+      schemaVersion,
       `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${formatInsufficientCreditsMessage(
         {
           billing,
@@ -241,6 +420,14 @@ export function normalizeToolHttpErrorMessage(input: {
       )}`,
       billing,
       input.status,
+      'terminal',
+      {
+        ...publicOptions,
+        origin: 'deepline',
+        category: 'billing',
+        code: publicOptions.code ?? 'INSUFFICIENT_CREDITS',
+        retryable: false,
+      },
     );
   }
   const hardBillingPayload = isHardBillingFailurePayload(billing)
@@ -249,7 +436,8 @@ export function normalizeToolHttpErrorMessage(input: {
       ? normalizeHardBillingPayload(parsed)
       : null;
   if (hardBillingPayload) {
-    return new ToolHttpError(
+    return createToolHttpError(
+      schemaVersion,
       formatHardBillingFailureMessage({
         billing: hardBillingPayload,
         toolId: input.toolId,
@@ -259,9 +447,17 @@ export function normalizeToolHttpErrorMessage(input: {
       }),
       hardBillingPayload,
       input.status,
+      'terminal',
+      {
+        ...publicOptions,
+        origin: 'deepline',
+        category: 'billing',
+        retryable: false,
+      },
     );
   }
-  return new ToolHttpError(
+  return createToolHttpError(
+    schemaVersion,
     `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${formatPublicToolErrorPayload(
       {
         parsed,
@@ -271,6 +467,7 @@ export function normalizeToolHttpErrorMessage(input: {
     billing,
     input.status,
     receiptFailureKindForToolErrorPayload(parsed),
+    publicOptions,
   );
 }
 
@@ -281,10 +478,18 @@ export function extractErrorBilling(
 }
 
 export function isHardBillingToolHttpError(error: unknown): boolean {
-  return (
+  if (
     error instanceof ToolHttpError &&
     (isInsufficientCreditsBilling(error.billing) ||
       isHardBillingFailurePayload(error.billing))
+  ) {
+    return true;
+  }
+  return (
+    error instanceof ToolExecutionError &&
+    error.origin === 'deepline' &&
+    error.category === 'billing' &&
+    error.code !== 'BILLING_UNAVAILABLE'
   );
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/work-receipts.ts

@@ -1,4 +1,5 @@
 import { isReusableWorkReceiptState } from './work-receipt-state-machine';
+import type { ToolExecutionFailureV1 } from '../tool-execution-error';
 
 export type WorkReceiptFailureKind = 'terminal' | 'repairable';
 
@@ -37,6 +38,7 @@ export type WorkReceipt = {
   status: WorkReceiptStatus;
   output?: unknown;
   error?: string | null;
+  errorPayload?: ToolExecutionFailureV1 | null;
   failureKind?: WorkReceiptFailureKind | null;
   runId?: string | null;
   leaseId?: string | null;
@@ -89,6 +91,7 @@ export type WorkReceiptBatchFailCommand = {
     runId: string;
     key: string;
     error: string;
+    errorPayload?: ToolExecutionFailureV1 | null;
     failureKind?: WorkReceiptFailureKind | null;
     leaseId?: string | null;
     runAttempt?: number | null;
@@ -161,6 +164,7 @@ export type WorkReceiptStore = {
   failReceipt(
     input: WorkReceiptCommand & {
       error: string;
+      errorPayload?: ToolExecutionFailureV1 | null;
       failureKind?: WorkReceiptFailureKind | null;
     },
   ): Promise<WorkReceipt | null>;

package/dist/bundling-sources/shared_libs/plays/artifact-contract-version.ts

@@ -0,0 +1,6 @@
+/**
+ * Immutable Play artifact ABI version shared by bundling and SDK release
+ * policy. Keep this module dependency-free: shared Play code must not import
+ * the SDK release manifest or create a package cycle.
+ */
+export const CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION = 2 as const;

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

@@ -1,3 +1,5 @@
+import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
+
 export type PlayPackageImport = {
   name: string;
   version: string | null;
@@ -21,6 +23,8 @@ export type PlayArtifactCompatibility = {
   minRunnerVersion: number;
   runtimeFeatures: PlayRuntimeFeature[];
   runtimeBackend?: string | null;
+  /** Missing preserves the legacy schema used before this field existed. */
+  toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
 };
 
 /** The only executable Play artifact contract. */

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

@@ -28,10 +28,13 @@ import type {
   PlayRuntimeFeature,
 } from '../artifact-types';
 import { buildPlayContractCompatibility } from '../contracts';
+import type { ToolExecutionErrorSchemaVersion } from '../../tool-execution-error';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
 import { MAX_PLAY_BUNDLE_BYTES } from './limits';
 
-const PLAY_BUNDLE_CACHE_VERSION = 25;
+// The authored tool-error schema is part of the artifact bytes. Do not reuse a
+// local bundle cached before compatibility selection entered graph analysis.
+const PLAY_BUNDLE_CACHE_VERSION = 27;
 const PLAY_ARTIFACT_CACHE_DIR = join(
   tmpdir(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`,
@@ -152,6 +155,7 @@ type SourceGraphAnalysis = {
   importPolicy: PlayImportPolicy;
   playName: string | null;
   playDescription: string | null;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion | null;
   importedPlayDependencies: ImportedPlayDependency[];
 };
 
@@ -501,6 +505,8 @@ type PlayMetadataExtractionContext = {
 type ExtractedPlayMetadata = {
   name: string | null;
   description: string | null;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion | null;
+  toolErrorSchemaVersionUnknown: boolean;
 };
 
 const TypeScriptParser = Parser.extend(
@@ -795,9 +801,13 @@ function staticStringFromExpression(
 }
 
 function propertyNameFromKey(property: AstNode): string | null {
-  if (property.computed) return null;
   const key = isAstNode(property.key) ? property.key : null;
   if (!key) return null;
+  if (property.computed) {
+    return key.type === 'Literal' && typeof key.value === 'string'
+      ? key.value
+      : null;
+  }
   if (key.type === 'Identifier' && typeof key.name === 'string') {
     return key.name;
   }
@@ -826,6 +836,109 @@ function objectExpressionFromNode(
   );
 }
 
+type StaticPropertyResolution =
+  | { kind: 'absent' }
+  | { kind: 'found'; value: AstNode }
+  | { kind: 'unknown' };
+
+function resolveStaticProperty(
+  node: AstNode | null | undefined,
+  propertyName: string,
+  context: PlayMetadataExtractionContext,
+  ancestors = new Set<AstNode>(),
+): StaticPropertyResolution {
+  if (!node) return { kind: 'absent' };
+  const object = objectExpressionFromNode(node, context);
+  if (!object) return { kind: 'unknown' };
+  if (ancestors.has(object)) return { kind: 'unknown' };
+  const nextAncestors = new Set(ancestors).add(object);
+
+  let resolution: StaticPropertyResolution = { kind: 'absent' };
+  for (const property of astArray(object.properties)) {
+    if (property.type === 'SpreadElement') {
+      const spreadResolution = resolveStaticProperty(
+        isAstNode(property.argument) ? property.argument : null,
+        propertyName,
+        context,
+        nextAncestors,
+      );
+      if (spreadResolution.kind !== 'absent') {
+        resolution = spreadResolution;
+      }
+      continue;
+    }
+    if (property.type !== 'Property') continue;
+    const resolvedPropertyName = propertyNameFromKey(property);
+    if (resolvedPropertyName !== propertyName) {
+      if (property.computed && resolvedPropertyName === null) {
+        resolution = { kind: 'unknown' };
+      }
+      continue;
+    }
+    const propertyValue = property.shorthand ? property.key : property.value;
+    resolution = isAstNode(propertyValue)
+      ? { kind: 'found', value: propertyValue }
+      : { kind: 'unknown' };
+  }
+  return resolution;
+}
+
+function staticNumberFromExpression(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+  seen = new Set<string>(),
+): number | null {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === 'Literal' && typeof expression.value === 'number') {
+    return expression.value;
+  }
+
+  const identifier = getIdentifierName(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return staticNumberFromExpression(
+    context.declarations.get(identifier),
+    context,
+    seen,
+  );
+}
+
+function toolErrorSchemaVersionFromOptions(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+): ToolExecutionErrorSchemaVersion | null | undefined {
+  const directCompatibility = resolveStaticProperty(
+    node,
+    'compatibility',
+    context,
+  );
+  if (directCompatibility.kind === 'unknown') return null;
+
+  const bindings = resolveStaticProperty(node, 'bindings', context);
+  if (bindings.kind === 'unknown') return null;
+  const bindingCompatibility =
+    bindings.kind === 'found'
+      ? resolveStaticProperty(bindings.value, 'compatibility', context)
+      : ({ kind: 'absent' } satisfies StaticPropertyResolution);
+  if (bindingCompatibility.kind === 'unknown') return null;
+
+  const compatibility =
+    directCompatibility.kind === 'found'
+      ? directCompatibility
+      : bindingCompatibility;
+  if (compatibility.kind === 'absent') return undefined;
+  const schema = resolveStaticProperty(
+    compatibility.value,
+    'toolErrorSchemaVersion',
+    context,
+  );
+  if (schema.kind !== 'found') return null;
+  const schemaVersion = staticNumberFromExpression(schema.value, context);
+  if (schemaVersion === 0 || schemaVersion === 1) return schemaVersion;
+  return null;
+}
+
 function stringPropertyFromObjectExpression(
   node: AstNode | null | undefined,
   propertyName: string,
@@ -895,12 +1008,16 @@ function playMetadataFromDefinePlayCall(
 
   const args = astArray(expression.arguments);
   const firstArg = args[0] ?? null;
+  const isObjectForm =
+    args.length === 1 || objectExpressionFromNode(firstArg, context) !== null;
   const objectName = stringPropertyFromObjectExpression(
     firstArg,
     'id',
     context,
   );
-  const name = objectName ?? staticStringFromExpression(firstArg, context);
+  const name = isObjectForm
+    ? objectName
+    : staticStringFromExpression(firstArg, context);
 
   let description =
     stringPropertyFromObjectExpression(firstArg, 'description', context) ??
@@ -913,8 +1030,27 @@ function playMetadataFromDefinePlayCall(
     );
   }
 
-  if (!name && !description) return null;
-  return { name, description };
+  const options = isObjectForm ? firstArg : (args[2] ?? null);
+  const toolErrorSchemaVersion = toolErrorSchemaVersionFromOptions(
+    options,
+    context,
+  );
+  const toolErrorSchemaVersionUnknown = toolErrorSchemaVersion === null;
+
+  if (
+    !name &&
+    !description &&
+    toolErrorSchemaVersion === undefined &&
+    !toolErrorSchemaVersionUnknown
+  ) {
+    return null;
+  }
+  return {
+    name,
+    description,
+    toolErrorSchemaVersion: toolErrorSchemaVersion ?? null,
+    toolErrorSchemaVersionUnknown,
+  };
 }
 
 function resolveExportExpression(
@@ -1397,14 +1533,18 @@ async function analyzeSourceGraph(
         .sort((left, right) => left.filePath.localeCompare(right.filePath)),
     }),
   );
-  const playName =
-    extractDefinedPlayNameForExport(sourceCode, exportName) ??
-    (exportName === 'default' ? extractDefinedPlayName(sourceCode) : null);
-  const playDescription =
-    extractDefinedPlayDescriptionForExport(sourceCode, exportName) ??
+  const metadata =
+    extractDefinedPlayMetadata(sourceCode, exportName) ??
     (exportName === 'default'
-      ? extractDefinedPlayDescription(sourceCode)
+      ? extractDefinedPlayMetadata(sourceCode, null)
       : null);
+  if (metadata?.toolErrorSchemaVersionUnknown) {
+    throw new Error(
+      'definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1.',
+    );
+  }
+  const playName = metadata?.name ?? null;
+  const playDescription = metadata?.description ?? null;
 
   return {
     sourceCode,
@@ -1424,6 +1564,7 @@ async function analyzeSourceGraph(
     },
     playName,
     playDescription,
+    toolErrorSchemaVersion: metadata?.toolErrorSchemaVersion ?? null,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath),
     ),
@@ -1672,6 +1813,10 @@ export async function bundlePlayFile(
           entryFile: absolutePath,
           sourceHash: analysis.sourceHash,
           importPolicy: analysis.importPolicy,
+          compatibility: buildPlayContractCompatibility({
+            toolErrorSchemaVersion:
+              analysis.toolErrorSchemaVersion ?? undefined,
+          }),
           cacheHit: true,
         },
         sourceCode: analysis.sourceCode,
@@ -1736,7 +1881,9 @@ export async function bundlePlayFile(
       bundledCode: executableCode,
       sourceMap: normalizedSourceMap,
       importPolicy: analysis.importPolicy,
-      compatibility: buildPlayContractCompatibility(),
+      compatibility: buildPlayContractCompatibility({
+        toolErrorSchemaVersion: analysis.toolErrorSchemaVersion ?? undefined,
+      }),
       generatedAt: Date.now(),
       cacheHit: false,
     };