deepline 0.1.32 → 0.1.35

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/config.ts
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
 
@@ -39,13 +39,12 @@ var ConfigError = class extends DeeplineError {
 };
 
 // src/config.ts
+var HOST_URL_ENV = "DEEPLINE_HOST_URL";
+var API_KEY_ENV = "DEEPLINE_API_KEY";
 var PROD_URL = "https://code.deepline.com";
 var DEFAULT_TIMEOUT = 6e4;
 var DEFAULT_MAX_RETRIES = 3;
-var ACTIVE_DEEPLINE_ENV_FILE = ".env.deepline";
-function projectEnvStartDir() {
-  return process.env.DEEPLINE_PROJECT_ENV_DIR?.trim() || process.cwd();
-}
+var PROJECT_DEEPLINE_ENV_FILE = ".env.deepline";
 function baseUrlSlug(baseUrl) {
   let url;
   try {
@@ -54,7 +53,7 @@ function baseUrlSlug(baseUrl) {
     return "unknown";
   }
   const host = url.hostname || "unknown";
-  const port = url.port ? parseInt(url.port, 10) : null;
+  const port = url.port ? Number.parseInt(url.port, 10) : null;
   let slug = host.replace(/[^a-zA-Z0-9]/g, "-");
   if (port && port !== 80 && port !== 443) {
     slug = `${slug}-${port}`;
@@ -81,109 +80,84 @@ function parseEnvFile(filePath) {
   }
   return env;
 }
-function findNearestEnvFile(names, startDir = process.cwd()) {
+function findNearestEnvFile(name, startDir = process.cwd()) {
   let current = resolve(startDir);
   while (true) {
-    for (const name of names) {
-      const filePath = join(current, name);
-      if (existsSync(filePath)) return filePath;
-    }
+    const filePath = join(current, name);
+    if (existsSync(filePath)) return filePath;
     const parent = dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
-function findNearestEnv(names, startDir = process.cwd()) {
-  const filePath = findNearestEnvFile(names, startDir);
+function loadProjectDeeplineEnv(startDir = process.cwd()) {
+  const filePath = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
   return filePath ? parseEnvFile(filePath) : {};
 }
-function findNearestWorktreeEnv(startDir = process.cwd()) {
-  return findNearestEnv([".env.worktree"], startDir);
-}
-function resolveProfileEnvFileNames() {
-  const explicitProfile = process.env.DEEPLINE_ENV_PROFILE?.trim() || process.env.DEEPLINE_PROFILE?.trim() || "";
-  const names = [];
-  if (explicitProfile) names.push(`.env.deepline.${explicitProfile}`);
-  const nodeEnv = process.env.NODE_ENV?.trim();
-  if (nodeEnv === "production") names.push(".env.deepline.prod");
-  else if (nodeEnv === "staging") names.push(".env.deepline.staging");
-  names.push(ACTIVE_DEEPLINE_ENV_FILE);
-  return names;
-}
-function resolveProjectAppEnvFileNames() {
-  const nodeEnv = process.env.NODE_ENV?.trim();
-  const names = [];
-  if (nodeEnv === "production") names.push(".env.prod");
-  if (nodeEnv === "staging") names.push(".env.staging");
-  names.push(".env.local", ".env");
-  return names;
-}
-function resolveBaseUrlFromEnvValues(env) {
-  return env.DEEPLINE_ORIGIN_URL?.trim() || env.DEEPLINE_API_BASE_URL?.trim() || "";
-}
-function loadProjectDeeplineEnv() {
-  return findNearestEnv(resolveProfileEnvFileNames(), projectEnvStartDir());
-}
-function loadProjectAppEnv() {
-  return findNearestEnv(resolveProjectAppEnvFileNames(), projectEnvStartDir());
-}
-function normalizeWorktreeBaseUrl(baseUrl, worktreeEnv = findNearestWorktreeEnv()) {
-  const trimmed = baseUrl.trim().replace(/\/$/, "");
-  if (!trimmed) return trimmed;
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
-    if (parsed.hostname.endsWith(".localhost") && parsed.port === "1355") {
-      const port = worktreeEnv.WORKTREE_APP_PORT || worktreeEnv.PORT;
-      if (port) return `${parsed.protocol}//localhost:${port}`;
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "";
     }
+    return parsed.toString().replace(/\/+$/, "");
   } catch {
+    return "";
   }
-  return trimmed;
 }
-function resolveWorktreeBaseUrl() {
-  const worktreeEnv = findNearestWorktreeEnv();
-  const declared = worktreeEnv.DEEPLINE_API_BASE_URL || worktreeEnv.WORKTREE_PUBLIC_APP_URL || worktreeEnv.APP_URL || "";
-  if (declared) return normalizeWorktreeBaseUrl(declared, worktreeEnv);
-  const port = worktreeEnv.WORKTREE_APP_PORT || worktreeEnv.PORT || "";
-  return port ? `http://localhost:${port}` : "";
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
 }
-function sdkCliEnvFilePath(baseUrl) {
+function sdkCliConfigDir(baseUrl) {
   const home = process.env.HOME?.trim() || homedir();
-  return join(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL), ".env");
+  return join(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
+}
+function sdkCliEnvFilePath(baseUrl) {
+  return join(sdkCliConfigDir(baseUrl), ".env");
 }
 function loadCliEnv(baseUrl = PROD_URL) {
-  const envPath = sdkCliEnvFilePath(baseUrl);
-  return parseEnvFile(envPath);
+  return parseEnvFile(sdkCliEnvFilePath(baseUrl));
 }
 function loadGlobalCliEnv() {
   return loadCliEnv(PROD_URL);
 }
 function autoDetectBaseUrl() {
-  const envOrigin = process.env.DEEPLINE_ORIGIN_URL?.trim();
-  if (envOrigin) return normalizeWorktreeBaseUrl(envOrigin);
-  const envBase = process.env.DEEPLINE_API_BASE_URL?.trim();
-  if (envBase) return normalizeWorktreeBaseUrl(envBase);
-  const projectDeeplineBaseUrl = resolveBaseUrlFromEnvValues(loadProjectDeeplineEnv());
-  if (projectDeeplineBaseUrl) return normalizeWorktreeBaseUrl(projectDeeplineBaseUrl);
-  const projectAppBaseUrl = resolveBaseUrlFromEnvValues(loadProjectAppEnv());
-  if (projectAppBaseUrl) return normalizeWorktreeBaseUrl(projectAppBaseUrl);
-  const worktreeBaseUrl = resolveWorktreeBaseUrl();
-  if (worktreeBaseUrl) return worktreeBaseUrl;
+  const projectEnv = loadProjectDeeplineEnv();
   const globalEnv = loadGlobalCliEnv();
-  const globalOrigin = globalEnv.DEEPLINE_ORIGIN_URL?.trim();
-  if (globalOrigin) return normalizeWorktreeBaseUrl(globalOrigin);
-  return PROD_URL;
+  return normalizeBaseUrl(process.env[HOST_URL_ENV] ?? "") || normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? "") || normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? "") || PROD_URL;
+}
+function resolveApiKeyForBaseUrl(baseUrl, explicitApiKey) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const projectEnv = loadProjectDeeplineEnv();
+  const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
+  const projectBaseUrl = normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? "");
+  const projectKeyApplies = projectBaseUrl === normalizedBaseUrl;
+  return firstNonEmpty(
+    explicitApiKey,
+    process.env[API_KEY_ENV],
+    projectKeyApplies ? projectEnv[API_KEY_ENV] : "",
+    cliEnv[API_KEY_ENV]
+  );
 }
 function resolveConfig(options) {
-  const requestedBaseUrl = options?.baseUrl?.trim() || autoDetectBaseUrl();
-  const baseUrl = normalizeWorktreeBaseUrl(requestedBaseUrl);
-  const cliEnv = loadCliEnv(baseUrl);
-  const projectDeeplineEnv = loadProjectDeeplineEnv();
-  const projectAppEnv = loadProjectAppEnv();
-  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || projectDeeplineEnv.DEEPLINE_API_KEY || projectAppEnv.DEEPLINE_API_KEY || cliEnv.DEEPLINE_API_KEY || "";
+  const baseUrl = normalizeBaseUrl(
+    options?.baseUrl?.trim() || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl, options?.apiKey);
   if (!apiKey) {
     throw new ConfigError(
-      `No API key found. Set DEEPLINE_API_KEY env var, pass apiKey option, or run: deepline auth register`
+      `No API key found. Set ${API_KEY_ENV}, add it to .env.deepline, or run: deepline auth register`
     );
   }
   return {
@@ -195,8 +169,8 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.32";
-var SDK_API_CONTRACT = "2026-05-generic-play-input-flags";
+var SDK_VERSION = "0.1.35";
+var SDK_API_CONTRACT = "2026-05-v2-tool-result-contract";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
@@ -278,7 +252,7 @@ var HttpClient = class {
           const response = await fetch(candidateUrl, {
             method,
             headers,
-            body: options?.formData !== void 0 ? options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+            body: options?.formData !== void 0 ? typeof options.formData === "function" ? options.formData() : options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
             signal: controller.signal
           });
           clearTimeout(timeoutId);
@@ -361,10 +335,13 @@ var HttpClient = class {
           throw new AuthError();
         }
         if (!response.ok) {
+          const body = await response.text();
+          const parsed = parseResponseBody(body);
           throw new DeeplineError(
-            `HTTP ${response.status}`,
+            apiErrorMessage(parsed, response.status),
             response.status,
-            "API_ERROR"
+            "API_ERROR",
+            { response: parsed }
           );
         }
         if (!response.body) {
@@ -414,6 +391,26 @@ var HttpClient = class {
     return this.request(path, { method: "DELETE" });
   }
 };
+function parseResponseBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+}
+function apiErrorMessage(parsed, status) {
+  const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
+  if (typeof errorValue === "string") {
+    return errorValue;
+  }
+  if (errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string") {
+    return errorValue.message;
+  }
+  if (typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string") {
+    return parsed.message;
+  }
+  return `HTTP ${status}`;
+}
 function parseRetryAfter(response) {
   const header = response.headers.get("retry-after");
   if (header) {
@@ -483,6 +480,8 @@ function sleep(ms) {
 // 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 V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-execution-result";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -751,13 +750,16 @@ var DeeplineClient = class {
   /**
    * Execute a tool and return the standard execution envelope.
    *
-   * The `result.data` field contains the provider payload. `result.meta`
-   * contains provider/upstream metadata such as HTTP status or paging details.
+   * The `toolExecutionResult.toolOutput.raw` field contains the raw tool output.
+   * `toolExecutionResult.toolOutput.meta` contains tool/provider metadata.
    * Top-level fields such as `status`, `job_id`, and `billing` describe the
-   * Deepline execution.
+   * Deepline execution envelope.
    */
   async executeTool(toolId, input, options) {
-    const headers = options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : void 0;
+    const headers = {
+      [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
+      ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {}
+    };
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input },
@@ -1055,34 +1057,37 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
-    const formData = new FormData();
-    formData.set(
-      "metadata",
-      JSON.stringify({
-        files: files.map((file, index) => ({
-          index,
-          logicalPath: file.logicalPath,
-          contentHash: file.contentHash,
-          contentType: file.contentType,
-          bytes: file.bytes
-        }))
-      })
-    );
-    for (const [index, file] of files.entries()) {
-      const bytes = decodeBase64Bytes(file.contentBase64);
-      const body = bytes.buffer.slice(
-        bytes.byteOffset,
-        bytes.byteOffset + bytes.byteLength
-      );
+    const buildFormData = () => {
+      const formData = new FormData();
       formData.set(
-        `file:${index}`,
-        new Blob([body], { type: file.contentType }),
-        file.logicalPath
+        "metadata",
+        JSON.stringify({
+          files: files.map((file, index) => ({
+            index,
+            logicalPath: file.logicalPath,
+            contentHash: file.contentHash,
+            contentType: file.contentType,
+            bytes: file.bytes
+          }))
+        })
       );
-    }
+      for (const [index, file] of files.entries()) {
+        const bytes = decodeBase64Bytes(file.contentBase64);
+        const body = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
+        formData.set(
+          `file:${index}`,
+          new Blob([body], { type: file.contentType }),
+          file.logicalPath
+        );
+      }
+      return formData;
+    };
     const response = await this.http.postFormData(
       "/api/v2/plays/files/stage",
-      formData
+      buildFormData
     );
     return response.files;
   }
@@ -1556,6 +1561,383 @@ var DeeplineClient = class {
   }
 };
 
+// ../shared_libs/play-runtime/tool-result.ts
+var TARGET_FALLBACK_KEYS = {
+  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]
+};
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toV2RawToolOutputPath(path) {
+  const normalized = String(path || "").trim().replace(/^\./, "");
+  if (!normalized) return "toolExecutionResult.toolOutput.raw";
+  if (normalized === "toolExecutionResult.toolOutput.raw" || normalized.startsWith("toolExecutionResult.toolOutput.raw.")) {
+    return normalized;
+  }
+  const rawPath = normalized.replace(/^result\.data\.?/, "").replace(/^result\.?/, "").replace(/^data\.?/, "").replace(/^\./, "");
+  return rawPath ? `toolExecutionResult.toolOutput.raw.${rawPath}` : "toolExecutionResult.toolOutput.raw";
+}
+function isMeaningfulValue(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function parsePath(path) {
+  const segments = [];
+  for (const rawPart of path.split(".").filter(Boolean)) {
+    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]));
+      }
+    }
+    if (!matched) {
+      segments.push(rawPart);
+    }
+  }
+  return segments;
+}
+function pathToString(segments) {
+  return segments.map(
+    (segment, index) => typeof segment === "number" ? `[${segment}]` : segment === "*" ? "[*]" : index === 0 ? segment : `.${segment}`
+  ).join("");
+}
+function valuesAtSegments(current, segments, path = []) {
+  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 (!isRecord2(current)) return [];
+  return valuesAtSegments(current[segment], rest, [...path, segment]);
+}
+function getValuesAtPath(root, path) {
+  return valuesAtSegments(root, parsePath(path)).map((entry) => entry.value);
+}
+function toResultEnvelope(value) {
+  if (isRecord2(value) && "data" in value) {
+    const envelope = { data: value.data };
+    if ("meta" in value) envelope.meta = value.meta;
+    return envelope;
+  }
+  return { data: value };
+}
+function normalizeResultPath(path) {
+  const trimmed = String(path || "").trim().replace(/^\./, "");
+  if (!trimmed) return "";
+  return toV2RawToolOutputPath(trimmed);
+}
+function toV2RawToolOutputPathPreservingProviderData(path) {
+  const normalized = String(path || "").trim().replace(/^\./, "");
+  if (!normalized) return "toolExecutionResult.toolOutput.raw";
+  if (normalized === "toolExecutionResult.toolOutput.raw" || normalized.startsWith("toolExecutionResult.toolOutput.raw.")) {
+    return normalized;
+  }
+  const rawPath = normalized.replace(/^result\.?/, "").replace(/^\./, "");
+  return rawPath ? `toolExecutionResult.toolOutput.raw.${rawPath}` : "toolExecutionResult.toolOutput.raw";
+}
+function candidateResultPaths(path) {
+  const candidates = [
+    normalizeResultPath(path),
+    toV2RawToolOutputPathPreservingProviderData(path)
+  ];
+  return candidates.filter(
+    (candidate, index, all) => candidate.length > 0 && all.indexOf(candidate) === index
+  );
+}
+function normalizeRelativePath(path) {
+  return String(path || "").trim().replace(/^result\./, "").replace(/^\./, "");
+}
+function getFirstMeaningfulValueAtPath(root, path) {
+  for (const entry of valuesAtSegments(root, parsePath(path))) {
+    if (isMeaningfulValue(entry.value)) {
+      return { value: entry.value, path: entry.path };
+    }
+  }
+  return null;
+}
+function getAtPath(root, path) {
+  const segments = parsePath(path);
+  if (segments.includes("*")) {
+    return getValuesAtPath(root, path).filter(isMeaningfulValue);
+  }
+  let current = root;
+  for (const segment of segments) {
+    if (typeof segment === "number") {
+      if (!Array.isArray(current)) return void 0;
+      current = current[segment];
+      continue;
+    }
+    if (!isRecord2(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function normalizeRows(value) {
+  if (!Array.isArray(value)) return null;
+  return value.map((entry) => isRecord2(entry) ? entry : { value: entry });
+}
+function findFirstTargetByPath(result, paths) {
+  for (const path of paths ?? []) {
+    for (const candidate of candidateResultPaths(path)) {
+      const match = getFirstMeaningfulValueAtPath(result, candidate);
+      if (match) return match;
+    }
+  }
+  return null;
+}
+function findFirstTargetByKey(result, target, depth = 0, path = []) {
+  if (depth > 6) return null;
+  if (Array.isArray(result)) {
+    for (let index = 0; index < result.length; index += 1) {
+      const found = findFirstTargetByKey(result[index], target, depth + 1, [
+        ...path,
+        index
+      ]);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (!isRecord2(result)) return null;
+  const patterns = TARGET_FALLBACK_KEYS[target] ?? [
+    new RegExp(`^${target}$`, "i")
+  ];
+  for (const [key, value] of Object.entries(result)) {
+    if (patterns.some((pattern) => pattern.test(key)) && isMeaningfulValue(value)) {
+      return { value, path: pathToString([...path, key]) };
+    }
+  }
+  for (const [key, value] of Object.entries(result)) {
+    const found = findFirstTargetByKey(value, target, depth + 1, [
+      ...path,
+      key
+    ]);
+    if (found) return found;
+  }
+  return null;
+}
+function resolveListRows(result, listExtractorPaths) {
+  const lists = {};
+  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
+    );
+    let resolvedPath = null;
+    let rows = null;
+    for (const candidate of candidates) {
+      rows = normalizeRows(getAtPath(result, candidate));
+      if (rows) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+    if (!rows) continue;
+    const storedPath = resolvedPath ?? path;
+    const name = storedPath.split(".").filter(Boolean).at(-1)?.replace(/\[\d+\]$/, "");
+    lists[name || storedPath] = { path: storedPath, rows };
+  }
+  return lists;
+}
+function deriveListKeys(input) {
+  const keys = {};
+  for (const [target, paths] of Object.entries(
+    input.listIdentityGetters ?? {}
+  )) {
+    const firstPath = paths.map(
+      (rawPath) => normalizeRelativePath(rawPath)
+    ).find(Boolean);
+    if (firstPath) {
+      keys[target] = firstPath;
+    }
+  }
+  if (Object.keys(keys).length > 0) {
+    return keys;
+  }
+  const listPrefix = input.listPath.replace(/\[\d+\]$/, "");
+  for (const [target, paths] of Object.entries(
+    input.resultIdentityGetters ?? {}
+  )) {
+    for (const rawPath of paths) {
+      const path = String(rawPath || "").trim().replace(/^\./, "");
+      if (!path) continue;
+      for (const resultPath of candidateResultPaths(path)) {
+        const directPrefix = `${listPrefix}.`;
+        if (resultPath.startsWith(directPrefix)) {
+          keys[target] = resultPath.slice(directPrefix.length).replace(/^\[\d+\]\.?/, "");
+          break;
+        }
+        const indexedPrefix = `${listPrefix}[0].`;
+        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 (resultPath.startsWith(dottedIndexPrefix)) {
+          keys[target] = resultPath.slice(dottedIndexPrefix.length);
+          break;
+        }
+      }
+      if (keys[target]) break;
+    }
+  }
+  if (Object.keys(keys).length === 0 && input.rows[0]) {
+    for (const key of Object.keys(input.rows[0])) {
+      keys[key] = key;
+    }
+  }
+  return keys;
+}
+function buildTargets(result, resultIdentityGetters) {
+  const targets = {};
+  const metadataTargets = new Set(Object.keys(resultIdentityGetters ?? {}));
+  for (const target of metadataTargets) {
+    const fromMetadata = findFirstTargetByPath(
+      result,
+      resultIdentityGetters?.[target]
+    );
+    if (fromMetadata) {
+      targets[target] = fromMetadata;
+      continue;
+    }
+    const fallback = findFirstTargetByKey(result, target);
+    if (fallback) {
+      targets[target] = fallback;
+    }
+  }
+  if (metadataTargets.size > 0) return targets;
+  for (const target of ["email", "phone", "linkedin", "domain", "status"]) {
+    const found = findFirstTargetByKey(result, target);
+    if (found) targets[target] = found;
+  }
+  return targets;
+}
+function buildLists(result, metadata) {
+  const lists = {};
+  const resolved = resolveListRows(result, metadata.listExtractorPaths);
+  for (const [name, list] of Object.entries(resolved)) {
+    lists[name] = {
+      path: list.path,
+      count: list.rows.length,
+      keys: deriveListKeys({
+        listPath: list.path,
+        rows: list.rows,
+        resultIdentityGetters: metadata.resultIdentityGetters,
+        listIdentityGetters: metadata.listIdentityGetters
+      })
+    };
+  }
+  return lists;
+}
+function buildExtractedAccessors(targets) {
+  return Object.fromEntries(
+    Object.entries(targets).map(([target, metadata]) => {
+      const accessor = { path: metadata.path };
+      Object.defineProperties(accessor, {
+        value: {
+          value: metadata.value,
+          enumerable: false
+        },
+        get: {
+          value() {
+            return metadata.value ?? null;
+          },
+          enumerable: false
+        }
+      });
+      return [target, accessor];
+    })
+  );
+}
+function buildListAccessors(result, lists) {
+  return Object.fromEntries(
+    Object.entries(lists).map(([name, metadata]) => {
+      const accessor = {
+        path: metadata.path,
+        count: metadata.count,
+        keys: metadata.keys
+      };
+      Object.defineProperty(accessor, "get", {
+        value() {
+          return normalizeRows(getAtPath(result, metadata.path)) ?? [];
+        },
+        enumerable: false
+      });
+      return [name, accessor];
+    })
+  );
+}
+function createToolExecuteResult(input) {
+  const result = toResultEnvelope(input.result);
+  const resultRoot = {
+    toolExecutionResult: {
+      toolOutput: {
+        raw: result.data,
+        ...result.meta ? { meta: result.meta } : {}
+      }
+    }
+  };
+  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,
+    toolOutput: {
+      raw: result.data,
+      ...result.meta ? { meta: result.meta } : {}
+    },
+    meta: input.execution,
+    extractedValues: buildExtractedAccessors(targets),
+    extractedLists: buildListAccessors(resultRoot, lists)
+  };
+  Object.defineProperty(wrapper, "_metadata", {
+    value: metadata,
+    enumerable: false
+  });
+  return wrapper;
+}
+
 // src/play.ts
 var DeeplineConditionalStepResolver = class _DeeplineConditionalStepResolver {
   constructor(when2, run, elseValue) {
@@ -1692,10 +2074,10 @@ var DeeplineContext = class {
    *
    * @example
    * ```typescript
-   * const tools = await ctx.tools.list();
-   * const meta = await ctx.tools.get('apollo_people_search');
-   * const companyLookup = await ctx.tools.execute('test_company_search', { domain: 'stripe.com' });
-   * const company = companyLookup.result.data;
+   * const tools = await deepline.tools.list();
+   * const meta = await deepline.tools.get('apollo_people_search');
+   * const companyLookup = await deepline.tools.execute('test_company_search', { domain: 'stripe.com' });
+   * const company = companyLookup.toolOutput.raw;
    * ```
    */
   get tools() {
@@ -1705,11 +2087,14 @@ var DeeplineContext = class {
       /** Get detailed metadata for a tool. */
       get: (toolId) => this.client.getTool(toolId),
       /** Execute a tool and return the standard execution envelope. */
-      execute: async (toolId, input) => this.client.executeTool(
-        toolId,
-        input,
-        { includeToolMetadata: true }
-      )
+      execute: async (toolId, input) => {
+        const response = await this.client.executeTool(
+          toolId,
+          input,
+          { includeToolMetadata: true }
+        );
+        return toolExecutionEnvelopeToResult(toolId, response);
+      }
     };
   }
   get plays() {
@@ -1804,6 +2189,47 @@ var Deepline = class {
     return new DeeplineContext(options);
   }
 };
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringArrayRecord(value) {
+  if (!isRecord3(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).map(([key, paths]) => [
+      key,
+      Array.isArray(paths) ? paths.map(String) : []
+    ])
+  );
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map(String) : [];
+}
+function toolExecutionEnvelopeToResult(fallbackToolId, response) {
+  const raw = response.toolExecutionResult?.toolOutput?.raw ?? null;
+  const meta = response.toolExecutionResult?.toolOutput?.meta;
+  const metadata = isRecord3(response._metadata) ? response._metadata.tool : null;
+  const toolMetadata = isRecord3(metadata) ? metadata : {};
+  return createToolExecuteResult({
+    status: typeof response.status === "string" ? response.status : "completed",
+    result: {
+      data: raw,
+      ...isRecord3(meta) ? { meta } : {}
+    },
+    metadata: {
+      toolId: typeof toolMetadata.toolId === "string" ? toolMetadata.toolId : fallbackToolId,
+      resultIdentityGetters: stringArrayRecord(
+        toolMetadata.resultIdentityGetters
+      ),
+      listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
+      listIdentityGetters: stringArrayRecord(toolMetadata.listIdentityGetters)
+    },
+    execution: {
+      idempotent: true,
+      cached: false,
+      source: "live"
+    }
+  });
+}
 function defineInput(schema) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     throw new Error(
@@ -1930,7 +2356,7 @@ function getByDottedPath(root, dottedPath) {
   }
   return current;
 }
-function normalizeRows(value) {
+function normalizeRows2(value) {
   if (!Array.isArray(value)) return null;
   return value.map((entry) => {
     if (isPlainObject(entry)) return entry;
@@ -1939,6 +2365,25 @@ function normalizeRows(value) {
 }
 function candidateRoots(payload) {
   const roots = [{ path: null, value: payload }];
+  if (isPlainObject(payload) && isPlainObject(payload.toolExecutionResult)) {
+    roots.push({ path: "toolExecutionResult", value: payload.toolExecutionResult });
+    const toolOutput = payload.toolExecutionResult.toolOutput;
+    if (isPlainObject(toolOutput)) {
+      roots.push({ path: "toolExecutionResult.toolOutput", value: toolOutput });
+      if (Object.prototype.hasOwnProperty.call(toolOutput, "raw")) {
+        roots.push({
+          path: "toolExecutionResult.toolOutput.raw",
+          value: toolOutput.raw
+        });
+      }
+    }
+  }
+  if (isPlainObject(payload) && isPlainObject(payload.output)) {
+    roots.push({ path: "output", value: payload.output });
+    if (Object.prototype.hasOwnProperty.call(payload.output, "body")) {
+      roots.push({ path: "output.body", value: payload.output.body });
+    }
+  }
   if (isPlainObject(payload) && isPlainObject(payload.result)) {
     roots.push({ path: "result", value: payload.result });
     if (isPlainObject(payload.result.data)) {
@@ -1949,7 +2394,7 @@ function candidateRoots(payload) {
 }
 function findBestArrayCandidate(value, pathPrefix = "", depth = 0) {
   if (depth > 5) return null;
-  const directRows = normalizeRows(value);
+  const directRows = normalizeRows2(value);
   const hasObjectRow = directRows?.some((row) => Object.keys(row).some((key) => key !== "value")) ?? false;
   let best = directRows && directRows.length > 0 && hasObjectRow ? { path: pathPrefix, rows: directRows } : null;
   if (!isPlainObject(value)) {
@@ -1971,7 +2416,7 @@ function tryConvertToList(payload, options) {
     for (const root of candidateRoots(payload)) {
       for (const extractorPath of listExtractorPaths) {
         const resolved = getByDottedPath(root.value, extractorPath);
-        const rows = normalizeRows(resolved);
+        const rows = normalizeRows2(resolved);
         if (rows && rows.length > 0) {
           const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
           return { rows, strategy: "configured_paths", sourcePath };