deepline 0.1.181 → 0.1.183

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-receipts.ts

@@ -6,11 +6,13 @@ import {
 export type WorkerToolReceiptSelection = {
   claimableReceiptKey: string | null;
   forceDurableRefresh: boolean;
+  forceFailedDurableRefresh: boolean;
 };
 
 export type WorkerToolReceiptGroup<TRequest> = {
   claimableReceiptKey: string;
   forceDurableRefresh: boolean;
+  forceFailedDurableRefresh: boolean;
   requests: TRequest[];
 };
 
@@ -155,6 +157,7 @@ export function selectWorkerToolReceipt(input: {
   durableReceiptKey?: string | null;
   localRetryCacheKey: string;
   force: boolean;
+  forceFailed?: boolean;
   allowLocalRetryReceipts: boolean;
 }): WorkerToolReceiptSelection {
   const durableReceiptKey = input.durableReceiptKey?.trim() || null;
@@ -165,6 +168,10 @@ export function selectWorkerToolReceipt(input: {
   return {
     claimableReceiptKey: durableReceiptKey ?? localRetryReceiptKey,
     forceDurableRefresh: input.force === true && durableReceiptKey !== null,
+    forceFailedDurableRefresh:
+      input.force !== true &&
+      input.forceFailed === true &&
+      durableReceiptKey !== null,
   };
 }
 
@@ -176,17 +183,21 @@ export function planWorkerToolReceiptGroups<TRequest>(
       durableReceiptKey?: string | null;
       localRetryCacheKey: string;
       force: boolean;
+      forceFailed?: boolean;
     };
   },
 ): WorkerToolReceiptGroupPlan<TRequest> {
   const localRequests: TRequest[] = [];
   const groupsByKey = new Map<string, WorkerToolReceiptGroup<TRequest>>();
   for (const request of requests) {
-    const { claimableReceiptKey, forceDurableRefresh } =
-      selectWorkerToolReceipt({
-        ...input.getReceiptInput(request),
-        allowLocalRetryReceipts: input.allowLocalRetryReceipts,
-      });
+    const {
+      claimableReceiptKey,
+      forceDurableRefresh,
+      forceFailedDurableRefresh,
+    } = selectWorkerToolReceipt({
+      ...input.getReceiptInput(request),
+      allowLocalRetryReceipts: input.allowLocalRetryReceipts,
+    });
     if (!claimableReceiptKey) {
       localRequests.push(request);
       continue;
@@ -194,10 +205,12 @@ export function planWorkerToolReceiptGroups<TRequest>(
     const group = groupsByKey.get(claimableReceiptKey) ?? {
       claimableReceiptKey,
       forceDurableRefresh: false,
+      forceFailedDurableRefresh: false,
       requests: [],
     };
     group.requests.push(request);
     group.forceDurableRefresh ||= forceDurableRefresh;
+    group.forceFailedDurableRefresh ||= forceFailedDurableRefresh;
     groupsByKey.set(claimableReceiptKey, group);
   }
   return {

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/work-budget.ts

@@ -0,0 +1,130 @@
+import { WORKER_PLATFORM_YIELD_LIMITS } from './worker-platform-budget';
+
+export type WorkerWorkBudgetEventKind =
+  | 'tool'
+  | 'provider'
+  | 'receipt'
+  | 'heartbeat'
+  | 'sheet'
+  | 'log'
+  | 'egress';
+
+export type WorkerWorkBudgetSnapshot = {
+  startedAt: number;
+  updatedAt: number;
+  elapsedMs: number;
+  counts: Record<WorkerWorkBudgetEventKind, number>;
+  elapsedMsByKind: Record<WorkerWorkBudgetEventKind, number>;
+};
+
+export type WorkerWorkBudgetYieldReason =
+  | 'elapsed'
+  | 'subrequest'
+  | 'provider'
+  | 'tool'
+  | 'receipt'
+  | 'heartbeat'
+  | 'sheet'
+  | 'log'
+  | 'egress';
+
+export type WorkerWorkBudgetYieldDecision = {
+  shouldYield: boolean;
+  reason: WorkerWorkBudgetYieldReason | null;
+  snapshot: WorkerWorkBudgetSnapshot;
+};
+
+export type WorkerWorkBudgetYieldLimits = Partial<
+  Record<WorkerWorkBudgetYieldReason, number>
+>;
+
+export type WorkerWorkBudgetMeter = {
+  count(kind: WorkerWorkBudgetEventKind, amount?: number): void;
+  snapshot(): WorkerWorkBudgetSnapshot;
+  resetWindow(): void;
+};
+
+const WORK_BUDGET_EVENT_KINDS: WorkerWorkBudgetEventKind[] = [
+  'tool',
+  'provider',
+  'receipt',
+  'heartbeat',
+  'sheet',
+  'log',
+  'egress',
+];
+
+function zeroCounters(): Record<WorkerWorkBudgetEventKind, number> {
+  return Object.fromEntries(
+    WORK_BUDGET_EVENT_KINDS.map((kind) => [kind, 0]),
+  ) as Record<WorkerWorkBudgetEventKind, number>;
+}
+
+export function createWorkerWorkBudgetMeter(input?: {
+  nowMs?: () => number;
+}): WorkerWorkBudgetMeter {
+  const nowMs = input?.nowMs ?? Date.now;
+  let startedAt = nowMs();
+  let updatedAt = startedAt;
+  let counts = zeroCounters();
+  let elapsedMsByKind = zeroCounters();
+
+  return {
+    count(kind, amount = 1) {
+      counts[kind] += amount;
+      updatedAt = nowMs();
+    },
+    snapshot() {
+      const now = nowMs();
+      return {
+        startedAt,
+        updatedAt,
+        elapsedMs: Math.max(0, now - startedAt),
+        counts: { ...counts },
+        elapsedMsByKind: { ...elapsedMsByKind },
+      };
+    },
+    resetWindow() {
+      startedAt = nowMs();
+      updatedAt = startedAt;
+      counts = zeroCounters();
+      elapsedMsByKind = zeroCounters();
+    },
+  };
+}
+
+export const WORKER_WORK_BUDGET_YIELD_LIMITS = WORKER_PLATFORM_YIELD_LIMITS;
+
+export function shouldYieldWorkerWorkBudget(input: {
+  meter: WorkerWorkBudgetMeter;
+  limits?: WorkerWorkBudgetYieldLimits;
+  projectedSubrequests?: number;
+}): WorkerWorkBudgetYieldDecision {
+  const snapshot = input.meter.snapshot();
+  const limits = {
+    ...WORKER_WORK_BUDGET_YIELD_LIMITS,
+    ...(input.limits ?? {}),
+  };
+  if (snapshot.elapsedMs >= limits.elapsed) {
+    return { shouldYield: true, reason: 'elapsed', snapshot };
+  }
+  const subrequests =
+    snapshot.counts.provider +
+    snapshot.counts.receipt +
+    snapshot.counts.heartbeat +
+    snapshot.counts.sheet +
+    snapshot.counts.egress;
+  const projectedSubrequests = Math.max(
+    0,
+    Math.floor(input.projectedSubrequests ?? 0),
+  );
+  if (subrequests + projectedSubrequests >= limits.subrequest) {
+    return { shouldYield: true, reason: 'subrequest', snapshot };
+  }
+  for (const kind of WORK_BUDGET_EVENT_KINDS) {
+    if (snapshot.counts[kind] >= limits[kind]) {
+      return { shouldYield: true, reason: kind, snapshot };
+    }
+  }
+  return { shouldYield: false, reason: null, snapshot };
+}

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/worker-platform-budget.ts

@@ -0,0 +1,39 @@
+import type { WorkerWorkBudgetYieldLimits } from './work-budget';
+
+// Preview accounts can still enforce the free/internal-service subrequest
+// ceiling even when wrangler config asks for more. This is a planner budget,
+// not the advertised platform ceiling: unbatched tool chunks also spend
+// subrequests on sheet writes, progress/ledger flushes, service-binding hops,
+// and workflow replay around the visible provider calls. Individual log lines
+// are buffered and batched into those flushes; they are not one subrequest each.
+// Keep real headroom here;
+// paid deployments may raise it only once the active account limit is proven by
+// an E2E run, not by config alone.
+export const WORKER_PLATFORM_SUBREQUEST_SOFT_LIMIT = 700;
+
+// Fresh unbatched tool calls spend more than the visible provider RPC:
+// durable receipt claim/complete, provider execution, route/service-binding
+// hops, and row progress/sheet writes all share the Worker subrequest pool.
+export const WORKER_PLATFORM_SUBREQUESTS_PER_UNBATCHED_TOOL_CALL = 8;
+
+export const WORKER_PLATFORM_YIELD_LIMITS: Required<WorkerWorkBudgetYieldLimits> =
+  {
+    elapsed: 45_000,
+    subrequest: WORKER_PLATFORM_SUBREQUEST_SOFT_LIMIT,
+    provider: WORKER_PLATFORM_SUBREQUEST_SOFT_LIMIT,
+    tool: 1_500,
+    receipt: 2_000,
+    heartbeat: 1_000,
+    sheet: 800,
+    log: 1_500,
+    egress: 1_000,
+  };
+
+export function estimateUnbatchedToolCallSubrequests(input: {
+  toolCalls: number;
+}): number {
+  return (
+    Math.max(0, Math.floor(input.toolCalls)) *
+    WORKER_PLATFORM_SUBREQUESTS_PER_UNBATCHED_TOOL_CALL
+  );
+}

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-retry-state.ts

@@ -27,6 +27,7 @@ export type WorkflowRetryParamsRef = {
 
 export type WorkflowRetryPlayParams = {
   runId: string;
+  runAttempt?: number;
   playId: string;
   playName: string;
   artifactStorageKey: string;
@@ -72,6 +73,7 @@ export type WorkflowRetryPlayParams = {
   totalRows?: number;
   coordinatorUrl?: string | null;
   coordinatorInternalToken?: string | null;
+  runtimeTestFaultHeader?: string | null;
 };
 
 export type WorkflowRetryStatePayload<TParams = WorkflowRetryPlayParams> =

package/dist/bundling-sources/sdk/src/client.ts

@@ -109,6 +109,41 @@ function resolvePlayRunIntegrationMode(
   );
 }
 
+function normalizeTestPolicyOverrides(
+  value: unknown,
+  source: string,
+): Record<string, unknown> {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  throw new DeeplineError(
+    `${source} must be a JSON object.`,
+    undefined,
+    'INVALID_TEST_POLICY_OVERRIDES',
+  );
+}
+
+function parseEnvTestPolicyOverrides(): Record<string, unknown> | undefined {
+  const raw =
+    typeof process !== 'undefined'
+      ? process.env?.DEEPLINE_TEST_POLICY_OVERRIDES
+      : undefined;
+  const trimmed = raw?.trim();
+  if (!trimmed) return undefined;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    const detail = error instanceof Error ? ` ${error.message}` : '';
+    throw new DeeplineError(
+      `DEEPLINE_TEST_POLICY_OVERRIDES must be valid JSON.${detail}`,
+      undefined,
+      'INVALID_TEST_POLICY_OVERRIDES',
+    );
+  }
+  return normalizeTestPolicyOverrides(parsed, 'DEEPLINE_TEST_POLICY_OVERRIDES');
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -202,7 +237,8 @@ function chunkRegisterPlayArtifacts<T>(artifacts: T[]): T[][] {
 
 type ExecuteToolRawOptions = {
   includeToolMetadata?: boolean;
-  responseIntent?: 'raw' | 'row_artifact';
+  responseIntent?: 'dataset' | 'raw' | 'row_artifact';
+  metadata?: Record<string, unknown>;
   timeout?: number;
   maxRetries?: number;
 };
@@ -1310,13 +1346,14 @@ export class DeeplineClient {
       ...(options?.includeToolMetadata
         ? { [INCLUDE_TOOL_METADATA_HEADER]: 'true' }
         : {}),
-      ...(options?.responseIntent
-        ? { [EXECUTE_RESPONSE_INTENT_HEADER]: options.responseIntent }
-        : {}),
+      [EXECUTE_RESPONSE_INTENT_HEADER]: options?.responseIntent ?? 'raw',
     };
     return this.http.post<ToolExecution<TData, TMeta>>(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
-      { payload: input },
+      {
+        payload: input,
+        ...(options?.metadata ? { metadata: options.metadata } : {}),
+      },
       headers,
       {
         forbiddenAsApiError: true,
@@ -1424,6 +1461,8 @@ export class DeeplineClient {
    */
   async startPlayRun(request: StartPlayRunRequest): Promise<PlayRunStart> {
     const integrationMode = resolvePlayRunIntegrationMode(request);
+    const testPolicyOverrides =
+      request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
     const forceToolRefresh = request.forceToolRefresh === true;
     const response = await this.http.post<Record<string, unknown>>(
       '/api/v2/plays/run',
@@ -1468,6 +1507,7 @@ export class DeeplineClient {
         // different profile pass `request.profile` explicitly.
         ...(request.profile ? { profile: request.profile } : {}),
         ...(integrationMode ? { integrationMode } : {}),
+        ...(testPolicyOverrides ? { testPolicyOverrides } : {}),
       },
     );
     return normalizePlayRunStart(response);
@@ -1489,6 +1529,8 @@ export class DeeplineClient {
     options?: { signal?: AbortSignal },
   ): AsyncGenerator<PlayLiveEvent> {
     const integrationMode = resolvePlayRunIntegrationMode(request);
+    const testPolicyOverrides =
+      request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
     const forceToolRefresh = request.forceToolRefresh === true;
     const body = {
       ...(request.name ? { name: request.name } : {}),
@@ -1528,6 +1570,7 @@ export class DeeplineClient {
         : {}),
       ...(request.profile ? { profile: request.profile } : {}),
       ...(integrationMode ? { integrationMode } : {}),
+      ...(testPolicyOverrides ? { testPolicyOverrides } : {}),
     };
     for await (const event of this.http.streamSse<PlayLiveEvent>(
       '/api/v2/plays/run?stream=true',

package/dist/bundling-sources/sdk/src/http.ts

@@ -34,6 +34,7 @@ import {
   SYNTHETIC_RUN_HEADER,
   WORKER_CALLBACK_URL_OVERRIDE_HEADER,
 } from '../../shared_libs/play-runtime/coordinator-headers.js';
+import { PLAY_RUNTIME_TEST_FAULT_HEADER } from '../../shared_libs/play-runtime/test-runtime-seams.js';
 
 const MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
 const COWORK_NETWORK_HINT =
@@ -240,16 +241,12 @@ export class HttpClient {
       typeof process !== 'undefined'
         ? process.env?.DEEPLINE_COORDINATOR_URL
         : undefined;
+    const coordinatorInternalToken =
+      typeof process !== 'undefined'
+        ? process.env?.DEEPLINE_INTERNAL_TOKEN
+        : undefined;
     if (coordinatorUrl?.trim()) {
       headers[COORDINATOR_URL_OVERRIDE_HEADER] = coordinatorUrl.trim();
-      const coordinatorInternalToken =
-        typeof process !== 'undefined'
-          ? process.env?.DEEPLINE_INTERNAL_TOKEN
-          : undefined;
-      if (coordinatorInternalToken?.trim()) {
-        headers[COORDINATOR_INTERNAL_TOKEN_HEADER] =
-          coordinatorInternalToken.trim();
-      }
     }
     const workerCallbackUrl =
       typeof process !== 'undefined'
@@ -276,6 +273,24 @@ export class HttpClient {
     if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== '0') {
       headers[SYNTHETIC_RUN_HEADER] = '1';
     }
+    // Test-only runtime seam. The server validates both environment and value
+    // before honoring this header.
+    const runtimeTestFault =
+      typeof process !== 'undefined'
+        ? process.env?.DEEPLINE_TEST_RUNTIME_FAULT
+        : undefined;
+    if (runtimeTestFault?.trim()) {
+      headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
+    }
+    if (
+      coordinatorInternalToken?.trim() &&
+      (coordinatorUrl?.trim() ||
+        workerCallbackUrl?.trim() ||
+        runtimeTestFault?.trim())
+    ) {
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] =
+        coordinatorInternalToken.trim();
+    }
     return headers;
   }
 

package/dist/bundling-sources/sdk/src/play.ts

@@ -74,11 +74,20 @@
  */
 import { DeeplineClient } from './client.js';
 import { DeeplineError } from './errors.js';
-import { createToolExecuteResult } from '../../shared_libs/play-runtime/tool-result.js';
+import {
+  attachToolResultListDataset,
+  createToolExecuteResult,
+} from '../../shared_libs/play-runtime/tool-result.js';
 export {
   readValue,
   readList,
 } from '../../shared_libs/play-runtime/tool-result.js';
+import { createDeferredPlayDataset } from '../../shared_libs/plays/dataset.js';
+import {
+  QUERY_RESULT_DATASET_PAGE_SIZE,
+  isCustomerDbDatasetTool,
+  isQueryResultDatasetTool,
+} from '../../shared_libs/play-runtime/query-result-dataset.js';
 import type {
   PlayDataset,
   PlayDatasetInput,
@@ -1473,8 +1482,12 @@ export class DeeplineContext {
       ): Promise<ToolExecuteResult> => {
         const response = await this.client.executeTool(toolId, input, {
           includeToolMetadata: true,
+          responseIntent: 'dataset',
+        });
+        return toolExecutionEnvelopeToResult(toolId, response, {
+          client: this.client,
+          input,
         });
-        return toolExecutionEnvelopeToResult(toolId, response);
       },
     };
   }
@@ -1724,9 +1737,163 @@ function extractorDescriptorRecord(
   );
 }
 
+function rowsFromUnknown(value: unknown): Record<string, unknown>[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((row) => (isRecord(row) ? row : { value: row }));
+}
+
+function finiteNonNegativeInteger(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+    return null;
+  }
+  return Math.floor(value);
+}
+
+function finitePositiveInteger(value: unknown): number | null {
+  const integer = finiteNonNegativeInteger(value);
+  return integer !== null && integer > 0 ? integer : null;
+}
+
+function stableHash(value: string): string {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = Math.imul(31, hash) + value.charCodeAt(index);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+function attachSdkQueryResultDatasetResult(
+  toolId: string,
+  result: ToolExecuteResult,
+  options?: {
+    client: DeeplineClient;
+    input: Record<string, unknown>;
+  },
+): ToolExecuteResult {
+  if (!options || !isQueryResultDatasetTool(toolId)) return result;
+  const raw = isRecord(result.toolResponse.raw)
+    ? result.toolResponse.raw
+    : null;
+  const dataset = isRecord(raw?.dataset) ? raw.dataset : null;
+  const totalRows = finiteNonNegativeInteger(dataset?.total_rows);
+  const sql =
+    typeof options.input.sql === 'string'
+      ? options.input.sql
+      : typeof options.input.query === 'string'
+        ? options.input.query
+        : typeof raw?.sql === 'string'
+          ? raw.sql
+          : null;
+  if (!dataset || totalRows === null || !sql) {
+    return result;
+  }
+  const datasetLimit =
+    finitePositiveInteger(dataset.returned_limit) ?? totalRows;
+  const previewRows = rowsFromUnknown(raw?.rows).slice(0, 25);
+  const fetchPage = async (
+    offset: number,
+    limit: number,
+  ): Promise<Record<string, unknown>[]> => {
+    if (limit <= 0 || offset >= totalRows) return [];
+    const response = await options.client.executeTool(toolId, options.input, {
+      includeToolMetadata: true,
+      responseIntent: 'dataset',
+      metadata: {
+        query_result_dataset: {
+          limit: datasetLimit,
+          offset,
+          page_size: Math.min(limit, QUERY_RESULT_DATASET_PAGE_SIZE),
+          total_rows: totalRows,
+        },
+        ...(isCustomerDbDatasetTool(toolId)
+          ? {
+              customer_db_dataset: {
+                limit: datasetLimit,
+                offset,
+                page_size: Math.min(limit, QUERY_RESULT_DATASET_PAGE_SIZE),
+                total_rows: totalRows,
+              },
+            }
+          : {}),
+      },
+    });
+    const pageRaw = isRecord(response.toolResponse?.raw)
+      ? response.toolResponse.raw
+      : null;
+    return rowsFromUnknown(pageRaw?.rows);
+  };
+  const collectRows = async (
+    limit: number | undefined,
+  ): Promise<Record<string, unknown>[]> => {
+    const target = Math.min(limit ?? totalRows, totalRows, datasetLimit);
+    const collected: Record<string, unknown>[] = [];
+    for (
+      let offset = 0;
+      offset < target;
+      offset += QUERY_RESULT_DATASET_PAGE_SIZE
+    ) {
+      collected.push(
+        ...(await fetchPage(
+          offset,
+          Math.min(QUERY_RESULT_DATASET_PAGE_SIZE, target - offset),
+        )),
+      );
+    }
+    return collected.slice(0, target);
+  };
+  const executionNonce =
+    typeof result.job_id === 'string' && result.job_id.trim()
+      ? result.job_id.trim()
+      : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  const safeNonce = executionNonce
+    .replace(/[^A-Za-z0-9_.:-]/g, '_')
+    .slice(0, 64);
+  const datasetScope = `${options.client.baseUrl}:${toolId}:${sql}:${datasetLimit}`;
+  const playDataset = createDeferredPlayDataset({
+    datasetKind: 'csv',
+    datasetId: `sdk-tool-list:${toolId}:${stableHash(datasetScope)}:${datasetLimit}:${safeNonce}`,
+    count: Math.min(totalRows, datasetLimit),
+    previewRows,
+    sourceLabel: 'query result rows',
+    tableNamespace: null,
+    resolvers: {
+      count: async () => Math.min(totalRows, datasetLimit),
+      peek: async (limit) => collectRows(limit),
+      materialize: async (limit) => collectRows(limit),
+      iterate: () =>
+        ({
+          async *[Symbol.asyncIterator]() {
+            const count = Math.min(totalRows, datasetLimit);
+            for (
+              let offset = 0;
+              offset < count;
+              offset += QUERY_RESULT_DATASET_PAGE_SIZE
+            ) {
+              yield* await fetchPage(
+                offset,
+                Math.min(QUERY_RESULT_DATASET_PAGE_SIZE, count - offset),
+              );
+            }
+          },
+        }) as AsyncIterable<Record<string, unknown>>,
+    },
+  });
+  return attachToolResultListDataset(result, {
+    name: 'rows',
+    path: 'toolResponse.raw.rows',
+    dataset: playDataset,
+    count: Math.min(totalRows, datasetLimit),
+  });
+}
+
 function toolExecutionEnvelopeToResult(
   fallbackToolId: string,
   response: ToolExecution,
+  options?: {
+    client: DeeplineClient;
+    input: Record<string, unknown>;
+  },
 ): ToolExecuteResult {
   const raw = response.toolResponse?.raw ?? null;
   const meta = response.toolResponse?.meta;
@@ -1735,30 +1902,37 @@ function toolExecutionEnvelopeToResult(
     : null;
   const toolMetadata = isRecord(metadata) ? metadata : {};
 
-  return createToolExecuteResult({
-    status: typeof response.status === 'string' ? response.status : 'completed',
-    jobId: typeof response.job_id === 'string' ? response.job_id : undefined,
-    result: {
-      data: raw,
-      ...(isRecord(meta) ? { meta } : {}),
-    },
-    metadata: {
-      toolId:
-        typeof toolMetadata.toolId === 'string'
-          ? toolMetadata.toolId
-          : fallbackToolId,
-      extractors: extractorDescriptorRecord(toolMetadata.extractors),
-      targetGetters: stringArrayRecord(toolMetadata.targetGetters),
-      listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
-      listIdentityGetters: stringArrayRecord(toolMetadata.listIdentityGetters),
-    },
-    execution: {
-      idempotent: true,
-      cached: false,
-      source: 'live',
-    },
-    meta: isRecord(response.meta) ? response.meta : undefined,
-  });
+  return attachSdkQueryResultDatasetResult(
+    fallbackToolId,
+    createToolExecuteResult({
+      status:
+        typeof response.status === 'string' ? response.status : 'completed',
+      jobId: typeof response.job_id === 'string' ? response.job_id : undefined,
+      result: {
+        data: raw,
+        ...(isRecord(meta) ? { meta } : {}),
+      },
+      metadata: {
+        toolId:
+          typeof toolMetadata.toolId === 'string'
+            ? toolMetadata.toolId
+            : fallbackToolId,
+        extractors: extractorDescriptorRecord(toolMetadata.extractors),
+        targetGetters: stringArrayRecord(toolMetadata.targetGetters),
+        listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
+        listIdentityGetters: stringArrayRecord(
+          toolMetadata.listIdentityGetters,
+        ),
+      },
+      execution: {
+        idempotent: true,
+        cached: false,
+        source: 'live',
+      },
+      meta: isRecord(response.meta) ? response.meta : undefined,
+    }),
+    options,
+  );
 }
 
 export function defineInput<TInput>(