deepline 0.1.12 → 0.1.20

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

@@ -1,68 +1,34 @@
-export type ToolResultExecutionMetadata = {
-  idempotent: true;
-  cached: boolean;
-  source: 'live' | 'checkpoint' | 'cache';
-  cacheKey?: string;
-};
-
-export type ToolResultTargetMetadata = {
-  path: string;
-};
-
-export type ToolResultListMetadata = {
-  path: string;
-  count: number | null;
-  keys: Record<string, string>;
-};
-
-export type ToolExtractedValue<T = unknown> = {
-  path: string;
-  get(): T | null;
-};
-
-export type ToolResultEnvelope<
-  TData = unknown,
-  TMeta = Record<string, unknown>,
-> = {
-  data: TData;
-  meta?: TMeta;
-};
-
-export type ToolResultMetadata = {
-  toolId: string;
-  execution: ToolResultExecutionMetadata;
-  targets: Record<string, ToolResultTargetMetadata>;
-  lists: Record<string, ToolResultListMetadata>;
-};
-
-export type ToolResultMetadataInput = {
-  toolId: string;
-  resultIdentityGetters?: Record<string, readonly string[]>;
-  listExtractorPaths?: readonly string[];
-  listIdentityGetters?: Record<string, readonly string[]>;
-};
-
-export type ToolExecuteResult<
-  TData = unknown,
-  TMeta = Record<string, unknown>,
-> = {
-  status: string;
-  result: ToolResultEnvelope<TData, TMeta>;
-  extracted: Record<string, ToolExtractedValue>;
-  lists: Record<
-    string,
-    ToolResultListMetadata & {
-      get(): Record<string, unknown>[];
-    }
-  >;
-};
-
-type PathSegment = string | number;
+export type {
+  ToolExecuteResult,
+  ToolResultExecutionMetadata,
+  ToolResultMetadata,
+  ToolResultMetadataInput,
+  ToolResultListMetadata,
+  ToolResultListAccessor,
+  ToolResultTargetMetadata,
+  ToolResultTargetAccessor,
+} from './tool-result-types';
+
+import type {
+  ToolExecuteResult,
+  ToolResultExecutionMetadata,
+  ToolResultListAccessor,
+  ToolResultListMetadata,
+  ToolResultEnvelope,
+  ToolResultMetadataInput,
+  ToolResultTargetAccessor,
+  ToolResultTargetMetadata,
+} from './tool-result-types';
+
+type PathSegment = string | number | '*';
 
 const TARGET_FALLBACK_KEYS: Record<string, readonly RegExp[]> = {
   email: [/^email$/i, /^address$/i, /email/i],
   phone: [/^phone$/i, /mobile/i, /phone/i, /telephone/i],
   linkedin: [/^linkedin_url$/i, /^linkedin$/i, /linkedin/i],
+  company_linkedin_url: [/company.*linkedin/i, /linkedin.*company/i],
+  company_domain: [/^company_domain$/i, /company.*domain/i],
+  company_name: [/^company_name$/i, /company.*name/i],
   domain: [/^domain$/i, /company_domain/i, /domain/i],
   status: [/^email_status$/i, /^status$/i],
   email_status: [/^email_status$/i, /^status$/i],
@@ -83,12 +49,14 @@ function isMeaningfulValue(value: unknown): boolean {
 function parsePath(path: string): PathSegment[] {
   const segments: PathSegment[] = [];
   for (const rawPart of path.split('.').filter(Boolean)) {
-    const bracketPattern = /([^\[\]]+)|\[(\d+)\]/g;
+    const bracketPattern = /([^\[\]]+)|\[(\d+|\*)\]/g;
     let matched = false;
     for (const match of rawPart.matchAll(bracketPattern)) {
       matched = true;
       if (match[1]) {
         segments.push(match[1]);
+      } else if (match[2] === '*') {
+        segments.push('*');
       } else if (match[2]) {
         segments.push(Number(match[2]));
       }
@@ -105,16 +73,85 @@ function pathToString(segments: readonly PathSegment[]): string {
     .map((segment, index) =>
       typeof segment === 'number'
         ? `[${segment}]`
-        : index === 0
-          ? segment
-          : `.${segment}`,
+        : segment === '*'
+          ? '[*]'
+          : index === 0
+            ? segment
+            : `.${segment}`,
     )
     .join('');
 }
 
+function valuesAtSegments(
+  current: unknown,
+  segments: readonly PathSegment[],
+  path: readonly PathSegment[] = [],
+): Array<{ value: unknown; path: string }> {
+  if (segments.length === 0) {
+    return [{ value: current, path: pathToString(path) }];
+  }
+  const [segment, ...rest] = segments;
+  if (segment === '*') {
+    if (!Array.isArray(current)) return [];
+    return current.flatMap((entry, index) =>
+      valuesAtSegments(entry, rest, [...path, index]),
+    );
+  }
+  if (typeof segment === 'number') {
+    if (!Array.isArray(current)) return [];
+    return valuesAtSegments(current[segment], rest, [...path, segment]);
+  }
+  if (!isRecord(current)) return [];
+  return valuesAtSegments(current[segment], rest, [...path, segment]);
+}
+
+function getValuesAtPath(root: unknown, path: string): unknown[] {
+  return valuesAtSegments(root, parsePath(path)).map((entry) => entry.value);
+}
+
+function toResultEnvelope(value: unknown): ToolResultEnvelope {
+  if (isRecord(value) && 'data' in value) {
+    const envelope: ToolResultEnvelope = { data: value.data };
+    if ('meta' in value) envelope.meta = value.meta as Record<string, unknown>;
+    return envelope;
+  }
+  return { data: value };
+}
+
+function normalizeResultPath(path: string): string {
+  const trimmed = String(path || '')
+    .trim()
+    .replace(/^\./, '');
+  if (!trimmed) return '';
+  return trimmed.startsWith('result.') ? trimmed : `result.${trimmed}`;
+}
+
+function normalizeRelativePath(path: string): string {
+  return String(path || '')
+    .trim()
+    .replace(/^result\./, '')
+    .replace(/^\./, '');
+}
+
+function getFirstMeaningfulValueAtPath(
+  root: unknown,
+  path: string,
+): ToolResultTargetMetadata | null {
+  for (const entry of valuesAtSegments(root, parsePath(path))) {
+    if (isMeaningfulValue(entry.value)) {
+      return { value: entry.value, path: entry.path };
+    }
+  }
+  return null;
+}
+
 function getAtPath(root: unknown, path: string): unknown {
+  const segments = parsePath(path);
+  if (segments.includes('*')) {
+    return getValuesAtPath(root, path).filter(isMeaningfulValue);
+  }
   let current = root;
-  for (const segment of parsePath(path)) {
+  for (const segment of segments) {
     if (typeof segment === 'number') {
       if (!Array.isArray(current)) return undefined;
       current = current[segment];
@@ -126,20 +163,15 @@ function getAtPath(root: unknown, path: string): unknown {
   return current;
 }
 
-function asResultPath(path: string): string {
-  const normalized = path.trim().replace(/^result\./, '');
-  return normalized ? `result.${normalized}` : 'result';
-}
-
-function toResultEnvelope(value: unknown): ToolResultEnvelope {
-  if (isRecord(value) && 'data' in value) {
-    const envelope: ToolResultEnvelope = { data: value.data };
-    if ('meta' in value) {
-      envelope.meta = value.meta as Record<string, unknown>;
-    }
-    return envelope;
+function normalizeString(value: unknown): string | null {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
   }
-  return { data: value };
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
 }
 
 function normalizeRows(value: unknown): Record<string, unknown>[] | null {
@@ -152,14 +184,10 @@ function findFirstTargetByPath(
   paths: readonly string[] | undefined,
 ): ToolResultTargetMetadata | null {
   for (const path of paths ?? []) {
-    const normalizedPath = String(path || '')
-      .trim()
-      .replace(/^result\./, '');
+    const normalizedPath = normalizeResultPath(path);
     if (!normalizedPath) continue;
-    const value = getAtPath(result, normalizedPath);
-    if (isMeaningfulValue(value)) {
-      return { path: asResultPath(normalizedPath) };
-    }
+    const match = getFirstMeaningfulValueAtPath(result, normalizedPath);
+    if (match) return match;
   }
   return null;
 }
@@ -191,7 +219,7 @@ function findFirstTargetByKey(
       patterns.some((pattern) => pattern.test(key)) &&
       isMeaningfulValue(value)
     ) {
-      return { path: asResultPath(pathToString([...path, key])) };
+      return { value, path: pathToString([...path, key]) };
     }
   }
   for (const [key, value] of Object.entries(result)) {
@@ -213,23 +241,32 @@ function resolveListRows(
     { path: string; rows: Record<string, unknown>[] }
   > = {};
   for (const rawPath of listExtractorPaths ?? []) {
-    const path = String(rawPath || '')
-      .trim()
-      .replace(/^result\./, '');
+    const path = normalizeResultPath(rawPath);
     if (!path) continue;
-    let resolvedPath = path;
-    let rows = normalizeRows(getAtPath(result, resolvedPath));
-    if (!rows && !path.startsWith('data.')) {
-      resolvedPath = `data.${path}`;
-      rows = normalizeRows(getAtPath(result, resolvedPath));
+    const candidates = [
+      path,
+      path.replace(/^result\./, 'result.data.'),
+    ].filter(
+      (candidate, index, all) =>
+        candidate && all.indexOf(candidate) === index,
+    );
+    let resolvedPath: string | null = null;
+    let rows: Record<string, unknown>[] | null = null;
+    for (const candidate of candidates) {
+      rows = normalizeRows(getAtPath(result, candidate));
+      if (rows) {
+        resolvedPath = candidate;
+        break;
+      }
     }
     if (!rows) continue;
-    const name = resolvedPath
+    const storedPath = resolvedPath ?? path;
+    const name = storedPath
       .split('.')
       .filter(Boolean)
       .at(-1)
       ?.replace(/\[\d+\]$/, '');
-    lists[name || resolvedPath] = { path: resolvedPath, rows };
+    lists[name || storedPath] = { path: storedPath, rows };
   }
   return lists;
 }
@@ -246,9 +283,7 @@ function deriveListKeys(input: {
   )) {
     const firstPath = paths
       .map((rawPath) =>
-        String(rawPath || '')
-          .trim()
-          .replace(/^result\./, ''),
+        normalizeRelativePath(rawPath),
       )
       .find(Boolean);
     if (firstPath) {
@@ -266,23 +301,29 @@ function deriveListKeys(input: {
     for (const rawPath of paths) {
       const path = String(rawPath || '')
         .trim()
-        .replace(/^result\./, '');
+        .replace(/^\./, '');
       if (!path) continue;
+      const resultPath = normalizeResultPath(path);
       const directPrefix = `${listPrefix}.`;
-      if (path.startsWith(directPrefix)) {
-        keys[target] = path
+      if (resultPath.startsWith(directPrefix)) {
+        keys[target] = resultPath
           .slice(directPrefix.length)
           .replace(/^\[\d+\]\.?/, '');
         break;
       }
       const indexedPrefix = `${listPrefix}[0].`;
-      if (path.startsWith(indexedPrefix)) {
-        keys[target] = path.slice(indexedPrefix.length);
+      if (resultPath.startsWith(indexedPrefix)) {
+        keys[target] = resultPath.slice(indexedPrefix.length);
+        break;
+      }
+      const wildcardPrefix = `${listPrefix}[*].`;
+      if (resultPath.startsWith(wildcardPrefix)) {
+        keys[target] = resultPath.slice(wildcardPrefix.length);
         break;
       }
       const dottedIndexPrefix = `${listPrefix}.0.`;
-      if (path.startsWith(dottedIndexPrefix)) {
-        keys[target] = path.slice(dottedIndexPrefix.length);
+      if (resultPath.startsWith(dottedIndexPrefix)) {
+        keys[target] = resultPath.slice(dottedIndexPrefix.length);
         break;
       }
     }
@@ -332,7 +373,7 @@ function buildLists(
   const resolved = resolveListRows(result, metadata.listExtractorPaths);
   for (const [name, list] of Object.entries(resolved)) {
     lists[name] = {
-      path: asResultPath(list.path),
+      path: list.path,
       count: list.rows.length,
       keys: deriveListKeys({
         listPath: list.path,
@@ -345,29 +386,49 @@ function buildLists(
   return lists;
 }
 
-function attachDescriptorMethods<TResult>(
-  wrapper: ToolExecuteResult<TResult>,
-): ToolExecuteResult<TResult> {
-  for (const descriptor of Object.values(wrapper.extracted)) {
-    Object.defineProperty(descriptor, 'get', {
-      configurable: true,
-      enumerable: false,
-      value: () => {
-        const value = getAtPath(wrapper, descriptor.path);
-        return isMeaningfulValue(value) ? value : null;
-      },
-    });
-  }
-
-  for (const descriptor of Object.values(wrapper.lists)) {
-    Object.defineProperty(descriptor, 'get', {
-      configurable: true,
-      enumerable: false,
-      value: () => normalizeRows(getAtPath(wrapper, descriptor.path)) ?? [],
-    });
-  }
+function buildExtractedAccessors(
+  targets: Record<string, ToolResultTargetMetadata>,
+): Record<string, ToolResultTargetAccessor> {
+  return Object.fromEntries(
+    Object.entries(targets).map(([target, metadata]) => {
+      const accessor = { path: metadata.path } as ToolResultTargetAccessor;
+      Object.defineProperties(accessor, {
+        value: {
+          value: metadata.value,
+          enumerable: false,
+        },
+        get: {
+          value() {
+            return metadata.value ?? null;
+          },
+          enumerable: false,
+        },
+      });
+      return [target, accessor];
+    }),
+  );
+}
 
-  return wrapper;
+function buildListAccessors(
+  result: unknown,
+  lists: Record<string, ToolResultListMetadata>,
+): Record<string, ToolResultListAccessor> {
+  return Object.fromEntries(
+    Object.entries(lists).map(([name, metadata]) => {
+      const accessor = {
+        path: metadata.path,
+        count: metadata.count,
+        keys: metadata.keys,
+      } as ToolResultListAccessor;
+      Object.defineProperty(accessor, 'get', {
+        value() {
+          return normalizeRows(getAtPath(result, metadata.path)) ?? [];
+        },
+        enumerable: false,
+      });
+      return [name, accessor];
+    }),
+  );
 }
 
 export function createToolExecuteResult<TResult = unknown>(input: {
@@ -376,17 +437,30 @@ export function createToolExecuteResult<TResult = unknown>(input: {
   metadata: ToolResultMetadataInput;
   execution: ToolResultExecutionMetadata;
 }): ToolExecuteResult<TResult> {
-  void input.execution;
-  const result = toResultEnvelope(input.result) as ToolResultEnvelope<TResult>;
-  const extracted = buildTargets(result, input.metadata.resultIdentityGetters);
-  const lists = buildLists(result, input.metadata);
-  const wrapper: ToolExecuteResult<TResult> = {
+  const result = toResultEnvelope(input.result);
+  const resultRoot = { result };
+  const targets = buildTargets(
+    resultRoot,
+    input.metadata.resultIdentityGetters,
+  );
+  const lists = buildLists(resultRoot, input.metadata);
+  const metadata = {
+    toolId: input.metadata.toolId,
+    execution: input.execution,
+    targets,
+    lists,
+  };
+  const wrapper = {
     status: input.status,
     result,
-    extracted: extracted as Record<string, ToolExtractedValue>,
-    lists: lists as ToolExecuteResult<TResult>['lists'],
-  };
-  return attachDescriptorMethods(wrapper);
+    extracted: buildExtractedAccessors(targets),
+    lists: buildListAccessors(resultRoot, lists),
+  } as ToolExecuteResult<TResult>;
+  Object.defineProperty(wrapper, '_metadata', {
+    value: metadata,
+    enumerable: false,
+  });
+  return wrapper;
 }
 
 export function isToolExecuteResult(
@@ -395,11 +469,9 @@ export function isToolExecuteResult(
   return (
     isRecord(value) &&
     typeof value.status === 'string' &&
-    'result' in value &&
-    isRecord(value.result) &&
-    'data' in value.result &&
-    'extracted' in value &&
-    isRecord(value.extracted)
+    '_metadata' in value &&
+    isRecord(value._metadata) &&
+    'result' in value
   );
 }
 
@@ -407,6 +479,26 @@ export function cloneToolExecuteResultWithExecution<TResult>(
   value: ToolExecuteResult<TResult>,
   execution: ToolResultExecutionMetadata,
 ): ToolExecuteResult<TResult> {
-  void execution;
-  return attachDescriptorMethods(value);
+  return createToolExecuteResult<TResult>({
+    status: value.status,
+    result: value.result 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]]),
+      ),
+    },
+    execution,
+  });
 }