deepline 0.1.62 → 0.1.64

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.62',
+  version: '0.1.64',
   apiContract: '2026-05-play-bootstrap-dataset-summary',
   supportPolicy: {
-    latest: '0.1.62',
+    latest: '0.1.64',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/sdk/src/tool-output.ts

@@ -86,7 +86,9 @@ function normalizeScalarString(value: unknown): string | null {
  */
 function getByDottedPath(root: unknown, dottedPath: string): unknown {
   let current = root;
-  for (const segment of String(dottedPath || '').split('.').filter(Boolean)) {
+  for (const segment of String(dottedPath || '')
+    .split('.')
+    .filter(Boolean)) {
     if (!isPlainObject(current) || !(segment in current)) {
       return null;
     }
@@ -111,8 +113,12 @@ function normalizeRows(value: unknown): Array<Record<string, unknown>> | null {
  * Generate candidate root objects to search for lists.
  * Tries: raw payload → V2 toolResponse.raw → legacy payload.output.body → legacy payload.result → legacy payload.result.data.
  */
-function candidateRoots(payload: unknown): Array<{ path: string | null; value: unknown }> {
-  const roots: Array<{ path: string | null; value: unknown }> = [{ path: null, value: payload }];
+function candidateRoots(
+  payload: unknown,
+): Array<{ path: string | null; value: unknown }> {
+  const roots: Array<{ path: string | null; value: unknown }> = [
+    { path: null, value: payload },
+  ];
   if (isPlainObject(payload) && isPlainObject(payload.toolResponse)) {
     roots.push({ path: 'toolResponse', value: payload.toolResponse });
     if (Object.prototype.hasOwnProperty.call(payload.toolResponse, 'raw')) {
@@ -150,7 +156,10 @@ function findBestArrayCandidate(
   if (depth > 5) return null;
 
   const directRows = normalizeRows(value);
-  const hasObjectRow = directRows?.some((row) => Object.keys(row).some((key) => key !== 'value')) ?? false;
+  const hasObjectRow =
+    directRows?.some((row) =>
+      Object.keys(row).some((key) => key !== 'value'),
+    ) ?? false;
   let best: { path: string; rows: Array<Record<string, unknown>> } | null =
     directRows && directRows.length > 0 && hasObjectRow
       ? { path: pathPrefix, rows: directRows }
@@ -220,7 +229,10 @@ export function tryConvertToList(
   options?: { listExtractorPaths?: string[] },
 ): ListConversionResult | null {
   const listExtractorPaths = Array.isArray(options?.listExtractorPaths)
-    ? options?.listExtractorPaths.filter((entry): entry is string => typeof entry === 'string' && entry.trim().length > 0)
+    ? options?.listExtractorPaths.filter(
+        (entry): entry is string =>
+          typeof entry === 'string' && entry.trim().length > 0,
+      )
     : [];
 
   if (listExtractorPaths.length > 0) {
@@ -229,7 +241,9 @@ export function tryConvertToList(
         const resolved = getByDottedPath(root.value, extractorPath);
         const rows = normalizeRows(resolved);
         if (rows && rows.length > 0) {
-          const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
+          const sourcePath = root.path
+            ? `${root.path}.${extractorPath}`
+            : extractorPath;
           return { rows, strategy: 'configured_paths', sourcePath };
         }
       }
@@ -322,11 +336,14 @@ export function writeCsvOutputFile(
   }
 
   const escapeCell = (value: unknown): string => {
-    const normalized = value == null
-      ? ''
-      : typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
-        ? String(value)
-        : JSON.stringify(value);
+    const normalized =
+      value == null
+        ? ''
+        : typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean'
+          ? String(value)
+          : JSON.stringify(value);
     if (/[",\n]/.test(normalized)) {
       return `"${normalized.replace(/"/g, '""')}"`;
     }
@@ -345,7 +362,8 @@ export function writeCsvOutputFile(
   const preview = [
     previewColumns.join(','),
     ...previewRows.map((row) =>
-      previewColumns.map((column) => escapeCell(row[column])).join(',')),
+      previewColumns.map((column) => escapeCell(row[column])).join(','),
+    ),
   ].join('\n');
 
   return {
@@ -378,14 +396,16 @@ export function extractSummaryFields(payload: unknown): Record<string, Scalar> {
   const candidates = candidateRoots(payload);
   for (const candidate of candidates) {
     if (!isPlainObject(candidate.value)) continue;
-    const summaryEntries = Object.entries(candidate.value).filter(([, value]) => {
-      return (
-        value == null ||
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean'
-      );
-    });
+    const summaryEntries = Object.entries(candidate.value).filter(
+      ([, value]) => {
+        return (
+          value == null ||
+          typeof value === 'string' ||
+          typeof value === 'number' ||
+          typeof value === 'boolean'
+        );
+      },
+    );
     if (summaryEntries.length === 0) continue;
     return Object.fromEntries(summaryEntries) as Record<string, Scalar>;
   }

package/dist/repo/shared_libs/play-runtime/batch-runtime.ts

@@ -132,7 +132,9 @@ export function compileRequestsWithStrategy<TRequest>(input: {
 export async function executeWaterfallProviders<TRequest, TResult>(input: {
   providers: string[];
   getPendingRequests: () => TRequest[];
-  getCachedResults: (provider: string) => Array<ChunkExecutionResult<TRequest, TResult>> | null;
+  getCachedResults: (
+    provider: string,
+  ) => Array<ChunkExecutionResult<TRequest, TResult>> | null;
   storeCachedResults: (
     provider: string,
     results: Array<ChunkExecutionResult<TRequest, TResult>>,
@@ -177,6 +179,11 @@ export async function executeWaterfallProviders<TRequest, TResult>(input: {
   }
 }
 
-export function resolveWaterfallToolId(provider: string, toolName: string): string {
-  return toolName.startsWith(`${provider}_`) ? toolName : `${provider}_${toolName}`;
+export function resolveWaterfallToolId(
+  provider: string,
+  toolName: string,
+): string {
+  return toolName.startsWith(`${provider}_`)
+    ? toolName
+    : `${provider}_${toolName}`;
 }

package/dist/repo/shared_libs/play-runtime/batching-types.ts

@@ -10,7 +10,10 @@ export type BatchCompileItem<TSingle extends object> = {
   payload: TSingle;
 };
 
-export type BatchCompileResult<TBatch extends object, TSingle extends object> = {
+export type BatchCompileResult<
+  TBatch extends object,
+  TSingle extends object,
+> = {
   batchOperation: string;
   batchPayload: TBatch;
   items: Array<BatchCompileItem<TSingle>>;
@@ -58,7 +61,10 @@ export type AnyBatchOperationStrategy = {
   batchOperation: string;
   kind: BatchStrategyKind;
   maxBatchSize: number;
-  canBatchWith(left: Record<string, unknown>, right: Record<string, unknown>): boolean;
+  canBatchWith(
+    left: Record<string, unknown>,
+    right: Record<string, unknown>,
+  ): boolean;
   toBucketKey(payload: Record<string, unknown>): string;
   toItemKey(payload: Record<string, unknown>): string;
   compile(payloads: Record<string, unknown>[]): {
@@ -81,8 +87,13 @@ export type AnyBatchOperationStrategy = {
 
 export type BatchStrategyMap = Record<string, AnyBatchOperationStrategy>;
 
-type StrictBatchOperationStrategy =
-  BatchOperationStrategy<Record<string, unknown>, Record<string, unknown>, object, unknown, unknown>;
+type StrictBatchOperationStrategy = BatchOperationStrategy<
+  Record<string, unknown>,
+  Record<string, unknown>,
+  object,
+  unknown,
+  unknown
+>;
 
 export function defineBatchStrategyMap<
   TStrategies extends Record<string, StrictBatchOperationStrategy>,

package/dist/repo/shared_libs/play-runtime/coordinator-headers.ts

@@ -31,7 +31,8 @@ function resolveInternalCoordinatorToken(): string | null {
   // Read lazily so the helper is safe to import in environments without
   // env access (e.g. workerd build-time bundling).
   const fromEnv =
-    (typeof process !== 'undefined' && process?.env?.DEEPLINE_INTERNAL_TOKEN?.trim()) ||
+    (typeof process !== 'undefined' &&
+      process?.env?.DEEPLINE_INTERNAL_TOKEN?.trim()) ||
     null;
   if (fromEnv) return fromEnv;
   if (!warnedAboutMissingInternalToken) {

package/dist/repo/shared_libs/play-runtime/default-batch-strategies.ts

@@ -109,10 +109,9 @@ const testRateLimitBatchStrategy: BatchOperationStrategy<
   },
 };
 
-export const DEFAULT_PLAY_RUNTIME_BATCH_STRATEGIES =
-  defineBatchStrategyMap({
-    test_rate_limit: testRateLimitBatchStrategy,
-  });
+export const DEFAULT_PLAY_RUNTIME_BATCH_STRATEGIES = defineBatchStrategyMap({
+  test_rate_limit: testRateLimitBatchStrategy,
+});
 
 export function getDefaultPlayRuntimeBatchStrategy(
   operation: string | null | undefined,

package/dist/repo/shared_libs/play-runtime/run-failure.ts

@@ -27,9 +27,7 @@ export function isCloudflareDurableObjectCodeUpdatedError(
   );
 }
 
-export function normalizePlayRunFailure(
-  error: unknown,
-): PlayRunFailureDetails {
+export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
   const cause = toErrorText(error);
   if (isCloudflareDurableObjectCodeUpdatedError(cause)) {
     return {

package/dist/repo/shared_libs/play-runtime/step-lifecycle-tracker.ts

@@ -24,7 +24,10 @@ export class PlayStepLifecycleTracker {
 
   constructor(
     private readonly nodes: readonly PlayStepLifecycleNode[],
-    private readonly getProgress: () => Record<string, PlayStepLifecycleProgress>,
+    private readonly getProgress: () => Record<
+      string,
+      PlayStepLifecycleProgress
+    >,
     private readonly emit: (event: PlayStepLifecycleEvent) => void,
     private readonly now: () => number = Date.now,
   ) {}

package/dist/repo/shared_libs/play-runtime/tool-batch-executor.ts

@@ -55,7 +55,10 @@ export function createToolBatchExecutor(
 ): ToolBatchExecutor {
   return {
     async executeToolBatch(request) {
-      const providerBatchSize = Math.max(1, Math.floor(request.providerBatchSize));
+      const providerBatchSize = Math.max(
+        1,
+        Math.floor(request.providerBatchSize),
+      );
       const batches = chunkToolBatchItems(request.items, providerBatchSize);
       const results: ToolBatchItemResult[] = [];
       for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {

package/dist/repo/shared_libs/play-runtime/tool-result.ts

@@ -454,19 +454,14 @@ function deriveListKeys(input: {
   }
 
   const listPrefix = input.listPath.replace(/\[\d+\]$/, '');
-  for (const [target, paths] of Object.entries(
-    input.targetGetters ?? {},
-  )) {
+  for (const [target, paths] of Object.entries(input.targetGetters ?? {})) {
     for (const rawPath of paths) {
       const path = String(rawPath || '')
         .trim()
         .replace(/^\./, '');
       if (!path) continue;
       const firstRow = input.rows[0];
-      if (
-        firstRow &&
-        Object.prototype.hasOwnProperty.call(firstRow, path)
-      ) {
+      if (firstRow && Object.prototype.hasOwnProperty.call(firstRow, path)) {
         keys[target] = path;
         break;
       }
@@ -514,21 +509,20 @@ function buildTargets(
   for (const [target, descriptor] of Object.entries(extractors ?? {})) {
     const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
     if (!fromExtractor) continue;
+    const transformed = coerceToEnum(
+      applyExtractorTransforms(fromExtractor.value, descriptor),
+      descriptor,
+    );
+    const override = findExtractorOverride(result, descriptor);
     targets[target] = {
       path: fromExtractor.path,
-      value: coerceToEnum(
-        applyExtractorTransforms(fromExtractor.value, descriptor),
-        descriptor,
-      ),
+      value: override?.value ?? transformed,
     };
   }
   const metadataTargets = new Set(Object.keys(targetGetters ?? {}));
   for (const target of metadataTargets) {
     if (targets[target]) continue;
-    const fromMetadata = findFirstTargetByPath(
-      result,
-      targetGetters?.[target],
-    );
+    const fromMetadata = findFirstTargetByPath(result, targetGetters?.[target]);
     if (fromMetadata) {
       targets[target] = fromMetadata;
       continue;
@@ -547,6 +541,25 @@ function buildTargets(
   return targets;
 }
 
+function findExtractorOverride(
+  result: unknown,
+  descriptor: ToolResultExtractorDescriptor,
+): { value: string | number | boolean | null } | null {
+  for (const override of descriptor.overrides ?? []) {
+    const expected = Object.prototype.hasOwnProperty.call(override, 'equals')
+      ? override.equals
+      : true;
+    for (const path of override.paths) {
+      const match = findFirstTargetByPath(result, [path]);
+      if (!match) continue;
+      if (match.value === expected) {
+        return { value: override.value };
+      }
+    }
+  }
+  return null;
+}
+
 function buildLists(
   resolved: Record<string, { path: string; rows: Record<string, unknown>[] }>,
   metadata: ToolResultMetadataInput,

package/dist/repo/shared_libs/plays/dataset.ts

@@ -172,8 +172,8 @@ function inferPreviewColumns<T>(rows: readonly T[]): string[] | undefined {
 export function isPlayDataset<T>(value: unknown): value is PlayDataset<T> {
   return Boolean(
     value &&
-      typeof value === 'object' &&
-      (value as Record<PropertyKey, unknown>)[PLAY_DATASET_BRAND] === true,
+    typeof value === 'object' &&
+    (value as Record<PropertyKey, unknown>)[PLAY_DATASET_BRAND] === true,
   );
 }
 
@@ -182,13 +182,13 @@ export function isSerializedPlayDataset<T>(
 ): value is SerializedPlayDataset<T> {
   return Boolean(
     value &&
-      typeof value === 'object' &&
-      !Array.isArray(value) &&
-      (value as Record<string, unknown>).kind === 'dataset' &&
-      typeof (value as Record<string, unknown>).datasetKind === 'string' &&
-      typeof (value as Record<string, unknown>).datasetId === 'string' &&
-      typeof (value as Record<string, unknown>).count === 'number' &&
-      Array.isArray((value as Record<string, unknown>).preview),
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    (value as Record<string, unknown>).kind === 'dataset' &&
+    typeof (value as Record<string, unknown>).datasetKind === 'string' &&
+    typeof (value as Record<string, unknown>).datasetId === 'string' &&
+    typeof (value as Record<string, unknown>).count === 'number' &&
+    Array.isArray((value as Record<string, unknown>).preview),
   );
 }
 
@@ -506,8 +506,7 @@ export function createPlayDataset<T>(
     tableNamespace: metadata?.tableNamespace ?? null,
     resolvers: {
       count: async () => materializedRows.length,
-      peek: async (limit) =>
-        materializedRows.slice(0, Math.max(0, limit)),
+      peek: async (limit) => materializedRows.slice(0, Math.max(0, limit)),
       materialize: async (limit) =>
         limit === undefined
           ? [...materializedRows]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {