deepline 0.1.41 → 0.1.45

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

@@ -1,4 +1,5 @@
 export type {
+  SerializedToolExecuteResult,
   ToolExecuteResult,
   ToolResultExecutionMetadata,
   ToolResultMetadata,
@@ -10,8 +11,10 @@ export type {
 } from './tool-result-types';
 
 import type {
+  SerializedToolExecuteResult,
   ToolExecuteResult,
   ToolResultExecutionMetadata,
+  ToolResultExtractorDescriptor,
   ToolResultListAccessor,
   ToolResultListMetadata,
   ToolResultEnvelope,
@@ -22,6 +25,8 @@ import type {
 
 type PathSegment = string | number | '*';
 
+const SERIALIZED_TOOL_EXECUTE_RESULT_KIND = 'deepline.tool_execute_result.v1';
+
 const TARGET_FALLBACK_KEYS: Record<string, readonly RegExp[]> = {
   email: [/^email$/i, /^address$/i, /email/i],
   phone: [/^phone$/i, /mobile/i, /phone/i, /telephone/i],
@@ -91,9 +96,7 @@ export function toV2RawToolOutputPath(path: string): string {
     .replace(/^result\.?/, '')
     .replace(/^data\.?/, '')
     .replace(/^\./, '');
-  return rawPath
-    ? `toolResponse.raw.${rawPath}`
-    : 'toolResponse.raw';
+  return rawPath ? `toolResponse.raw.${rawPath}` : 'toolResponse.raw';
 }
 
 function isMeaningfulValue(value: unknown): boolean {
@@ -195,12 +198,8 @@ function toV2RawToolOutputPathPreservingProviderData(path: string): string {
   ) {
     return normalized;
   }
-  const rawPath = normalized
-    .replace(/^result\.?/, '')
-    .replace(/^\./, '');
-  return rawPath
-    ? `toolResponse.raw.${rawPath}`
-    : 'toolResponse.raw';
+  const rawPath = normalized.replace(/^result\.?/, '').replace(/^\./, '');
+  return rawPath ? `toolResponse.raw.${rawPath}` : 'toolResponse.raw';
 }
 
 function candidateResultPaths(path: string): string[] {
@@ -320,6 +319,61 @@ function findFirstTargetByKey(
   return null;
 }
 
+function normalizeEmailStatus(value: unknown): unknown {
+  const normalized = normalizeString(value)
+    ?.toLowerCase()
+    .replace(/[\s-]+/g, '_');
+  if (!normalized) return 'unknown';
+  if (['deliverable', 'verified', 'ok', 'true'].includes(normalized))
+    return 'valid';
+  if (['undeliverable', 'bad', 'false', 'failed'].includes(normalized))
+    return 'invalid';
+  if (
+    ['accept_all', 'acceptall', 'catchall', 'valid_catch_all'].includes(
+      normalized,
+    )
+  ) {
+    return 'catch_all';
+  }
+  return normalized;
+}
+
+function normalizePhoneStatus(value: unknown): unknown {
+  if (typeof value === 'boolean') return value ? 'valid' : 'invalid';
+  const normalized = normalizeString(value)
+    ?.toLowerCase()
+    .replace(/[\s-]+/g, '_');
+  if (!normalized) return 'unknown';
+  if (['verified', 'ok', 'true', 'active'].includes(normalized)) return 'valid';
+  if (
+    ['bad', 'false', 'failed', 'inactive', 'disconnected'].includes(normalized)
+  ) {
+    return 'invalid';
+  }
+  return normalized;
+}
+
+function applyExtractorTransforms(
+  value: unknown,
+  descriptor: ToolResultExtractorDescriptor,
+): unknown {
+  return (descriptor.transforms ?? []).reduce((current, transform) => {
+    if (transform.endsWith('emailStatus')) return normalizeEmailStatus(current);
+    if (transform.endsWith('phoneStatus')) return normalizePhoneStatus(current);
+    return current;
+  }, value);
+}
+
+function coerceToEnum(
+  value: unknown,
+  descriptor: ToolResultExtractorDescriptor,
+): unknown {
+  if (!descriptor.enum?.length) return value;
+  const normalized = normalizeString(value);
+  if (!normalized) return value;
+  return descriptor.enum.includes(normalized) ? normalized : value;
+}
+
 function resolveListRows(
   result: unknown,
   listExtractorPaths: readonly string[] | undefined,
@@ -331,11 +385,8 @@ function resolveListRows(
   for (const rawPath of listExtractorPaths ?? []) {
     const path = normalizeResultPath(rawPath);
     if (!path) continue;
-    const candidates = [
-      ...candidateResultPaths(rawPath),
-    ].filter(
-      (candidate, index, all) =>
-        candidate && all.indexOf(candidate) === index,
+    const candidates = [...candidateResultPaths(rawPath)].filter(
+      (candidate, index, all) => candidate && all.indexOf(candidate) === index,
     );
     let resolvedPath: string | null = null;
     let rows: Record<string, unknown>[] | null = null;
@@ -361,7 +412,7 @@ function resolveListRows(
 function deriveListKeys(input: {
   listPath: string;
   rows: readonly Record<string, unknown>[];
-  resultIdentityGetters?: Record<string, readonly string[]>;
+  targetGetters?: Record<string, readonly string[]>;
   listIdentityGetters?: Record<string, readonly string[]>;
 }): Record<string, string> {
   const keys: Record<string, string> = {};
@@ -369,9 +420,7 @@ function deriveListKeys(input: {
     input.listIdentityGetters ?? {},
   )) {
     const firstPath = paths
-      .map((rawPath) =>
-        normalizeRelativePath(rawPath),
-      )
+      .map((rawPath) => normalizeRelativePath(rawPath))
       .find(Boolean);
     if (firstPath) {
       keys[target] = firstPath;
@@ -383,7 +432,7 @@ function deriveListKeys(input: {
 
   const listPrefix = input.listPath.replace(/\[\d+\]$/, '');
   for (const [target, paths] of Object.entries(
-    input.resultIdentityGetters ?? {},
+    input.targetGetters ?? {},
   )) {
     for (const rawPath of paths) {
       const path = String(rawPath || '')
@@ -427,14 +476,27 @@ function deriveListKeys(input: {
 
 function buildTargets(
   result: unknown,
-  resultIdentityGetters?: Record<string, readonly string[]>,
+  extractors?: Record<string, ToolResultExtractorDescriptor>,
+  targetGetters?: Record<string, readonly string[]>,
 ): Record<string, ToolResultTargetMetadata> {
   const targets: Record<string, ToolResultTargetMetadata> = {};
-  const metadataTargets = new Set(Object.keys(resultIdentityGetters ?? {}));
+  for (const [target, descriptor] of Object.entries(extractors ?? {})) {
+    const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
+    if (!fromExtractor) continue;
+    targets[target] = {
+      path: fromExtractor.path,
+      value: coerceToEnum(
+        applyExtractorTransforms(fromExtractor.value, descriptor),
+        descriptor,
+      ),
+    };
+  }
+  const metadataTargets = new Set(Object.keys(targetGetters ?? {}));
   for (const target of metadataTargets) {
+    if (targets[target]) continue;
     const fromMetadata = findFirstTargetByPath(
       result,
-      resultIdentityGetters?.[target],
+      targetGetters?.[target],
     );
     if (fromMetadata) {
       targets[target] = fromMetadata;
@@ -455,11 +517,10 @@ function buildTargets(
 }
 
 function buildLists(
-  result: unknown,
+  resolved: Record<string, { path: string; rows: Record<string, unknown>[] }>,
   metadata: ToolResultMetadataInput,
 ): Record<string, ToolResultListMetadata> {
   const lists: Record<string, ToolResultListMetadata> = {};
-  const resolved = resolveListRows(result, metadata.listExtractorPaths);
   for (const [name, list] of Object.entries(resolved)) {
     lists[name] = {
       path: list.path,
@@ -467,7 +528,7 @@ function buildLists(
       keys: deriveListKeys({
         listPath: list.path,
         rows: list.rows,
-        resultIdentityGetters: metadata.resultIdentityGetters,
+        targetGetters: metadata.targetGetters,
         listIdentityGetters: metadata.listIdentityGetters,
       }),
     };
@@ -499,11 +560,12 @@ function buildExtractedAccessors(
 }
 
 function buildListAccessors(
-  result: unknown,
+  resolved: Record<string, { path: string; rows: Record<string, unknown>[] }>,
   lists: Record<string, ToolResultListMetadata>,
 ): Record<string, ToolResultListAccessor> {
   return Object.fromEntries(
     Object.entries(lists).map(([name, metadata]) => {
+      const rows = resolved[name]?.rows ?? [];
       const accessor = {
         path: metadata.path,
         count: metadata.count,
@@ -511,7 +573,7 @@ function buildListAccessors(
       } as ToolResultListAccessor;
       Object.defineProperty(accessor, 'get', {
         value() {
-          return normalizeRows(getAtPath(result, metadata.path)) ?? [];
+          return rows;
         },
         enumerable: false,
       });
@@ -537,13 +599,21 @@ export function createToolExecuteResult<TResult = unknown>(input: {
   };
   const targets = buildTargets(
     resultRoot,
-    input.metadata.resultIdentityGetters,
+    input.metadata.extractors,
+    input.metadata.targetGetters,
   );
-  const lists = buildLists(resultRoot, input.metadata);
+  const resolvedLists = resolveListRows(
+    resultRoot,
+    input.metadata.listExtractorPaths,
+  );
+  const lists = buildLists(resolvedLists, input.metadata);
   const metadata = {
     toolId: input.metadata.toolId,
     execution: input.execution,
     targets,
+    ...(input.metadata.extractors
+      ? { extractors: input.metadata.extractors }
+      : {}),
     lists,
   };
   const toolResponse = {
@@ -551,7 +621,7 @@ export function createToolExecuteResult<TResult = unknown>(input: {
     ...(result.meta ? { meta: result.meta } : {}),
   };
   const extractedValues = buildExtractedAccessors(targets);
-  const extractedLists = buildListAccessors(resultRoot, lists);
+  const extractedLists = buildListAccessors(resolvedLists, lists);
   const wrapper = {
     status: input.status,
     ...(input.jobId ? { job_id: input.jobId } : {}),
@@ -586,6 +656,73 @@ export function isToolExecuteResult(
   );
 }
 
+function metadataInputFromToolExecuteResult(
+  value: ToolExecuteResult,
+): ToolResultMetadataInput {
+  return {
+    toolId: value._metadata.toolId,
+    ...(value._metadata.extractors
+      ? { extractors: value._metadata.extractors }
+      : {}),
+    targetGetters: Object.fromEntries(
+      Object.entries(value._metadata.targets).map(([target, info]) => [
+        target,
+        [info.path],
+      ]),
+    ),
+    listExtractorPaths: Object.values(value._metadata.lists).map(
+      (list) => list.path,
+    ),
+    listIdentityGetters: Object.fromEntries(
+      Object.values(value._metadata.lists)
+        .flatMap((list) => Object.entries(list.keys))
+        .map(([target, path]) => [target, [path]]),
+    ),
+  };
+}
+
+export function serializeToolExecuteResult(
+  value: ToolExecuteResult,
+): SerializedToolExecuteResult {
+  return {
+    __kind: SERIALIZED_TOOL_EXECUTE_RESULT_KIND,
+    status: value.status,
+    toolResponse: {
+      raw: value.toolResponse.raw,
+      ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
+    },
+    metadata: metadataInputFromToolExecuteResult(value),
+    execution: value._metadata.execution,
+  };
+}
+
+export function isSerializedToolExecuteResult(
+  value: unknown,
+): value is SerializedToolExecuteResult {
+  return (
+    isRecord(value) &&
+    value.__kind === SERIALIZED_TOOL_EXECUTE_RESULT_KIND &&
+    typeof value.status === 'string' &&
+    isRecord(value.toolResponse) &&
+    isRecord(value.metadata) &&
+    isRecord(value.execution)
+  );
+}
+
+export function deserializeToolExecuteResult(
+  value: SerializedToolExecuteResult,
+): ToolExecuteResult {
+  return createToolExecuteResult({
+    status: value.status,
+    result: {
+      data: value.toolResponse.raw,
+      ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
+    },
+    metadata: value.metadata,
+    execution: value.execution,
+  });
+}
+
 export function cloneToolExecuteResultWithExecution<TResult>(
   value: ToolExecuteResult<TResult>,
   execution: ToolResultExecutionMetadata,
@@ -600,23 +737,7 @@ export function cloneToolExecuteResultWithExecution<TResult>(
       data: value.toolResponse.raw,
       ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
     } as TResult,
-    metadata: {
-      toolId: value._metadata.toolId,
-      resultIdentityGetters: Object.fromEntries(
-        Object.entries(value._metadata.targets).map(([target, info]) => [
-          target,
-          [info.path],
-        ]),
-      ),
-      listExtractorPaths: Object.values(value._metadata.lists).map(
-        (list) => list.path,
-      ),
-      listIdentityGetters: Object.fromEntries(
-        Object.values(value._metadata.lists)
-          .flatMap((list) => Object.entries(list.keys))
-          .map(([target, path]) => [target, [path]]),
-      ),
-    },
+    metadata: metadataInputFromToolExecuteResult(value),
     execution,
     meta: isRecord(value.meta) ? value.meta : undefined,
   });

package/package.json

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