deepline 0.3.463 → 0.3.464

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

@@ -1498,6 +1498,8 @@ function extractorDescriptorRecord(
         .map((entry) => entry.trim())
         .filter(Boolean);
       const emailStatus = emailStatusExtractorConfig(descriptor.emailStatus);
+      const means =
+        typeof descriptor.means === 'string' ? descriptor.means : undefined;
       return [
         [
           key,
@@ -1506,6 +1508,7 @@ function extractorDescriptorRecord(
             ...(transforms.length > 0 ? { transforms } : {}),
             ...(enumValues.length > 0 ? { enum: enumValues } : {}),
             ...(emailStatus ? { emailStatus } : {}),
+            ...(means !== undefined ? { means } : {}),
           },
         ],
       ];

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

@@ -205,7 +205,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.463',
+  version: '0.3.464',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -705,7 +705,9 @@ const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 // broken gateway-to-runner connection, not slow provider work.
 export const TOOL_EXECUTE_RESPONSE_BODY_TIMEOUT_MS = 30_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
-const TOOL_PROVIDER_RESIDENT_WAIT_BUDGET_MS = 5_000;
+// Avoid paying sandbox startup and checkpoint replay for ordinary provider
+// holds. Bound cumulative residency so sustained holds still park durably.
+const TOOL_PROVIDER_RESIDENT_WAIT_BUDGET_MS = 10 * 60_000;
 // The call already waited its whole admission budget in this sandbox, so it
 // rejoins the shared lane promptly instead of adding a fixed delay of its own.
 const PROVIDER_ADMISSION_REQUEUE_DELAY_MS = 1_000;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -4932,6 +4932,20 @@ async function buildRuntimeSheetDatasetStartResult(
       );
       return Object.keys(cells).length ? [{ key, cells }] : [];
     });
+  // History readers (`datasetRowInput: current_run`) seed rows from authored
+  // input plus `__deepline*` runtime fields only and read stored output through
+  // `previousCells`. Merging that output into the rows too would send every
+  // completed cell twice and can push a resume admission past its byte budget.
+  const rowFieldsForReader = (
+    data: Record<string, unknown>,
+  ): Record<string, unknown> =>
+    input.includePreviousCells
+      ? Object.fromEntries(
+          Object.entries(data).filter(([field]) =>
+            field.startsWith('__deepline'),
+          ),
+        )
+      : data;
   const buildFreshRow = (entry: RuntimeDatasetRowEntry) => {
     const row: Record<string, unknown> = {
       ...sanitizePostgresJsonValue(entry.row),
@@ -5024,7 +5038,7 @@ async function buildRuntimeSheetDatasetStartResult(
         }
         completedRows.push({
           ...entry.row,
-          ...stored,
+          ...rowFieldsForReader(stored),
           __deeplineRowKey: entry.key,
         });
       } else if (disposition === 'blocked') {
@@ -5056,7 +5070,7 @@ async function buildRuntimeSheetDatasetStartResult(
   const buildMergedRow = (entry: RuntimeDatasetRowEntry) => {
     const merged = { ...entry.row };
     for (const [field, value] of Object.entries(
-      persistedRowsByKey.get(entry.key) ?? {},
+      rowFieldsForReader(persistedRowsByKey.get(entry.key) ?? {}),
     )) {
       if (
         value !== null ||

package/dist/bundling-sources/shared_libs/play-runtime/tool-result.ts

@@ -32,6 +32,12 @@ import {
   type JobChangeGetterValue,
   type JobChangeStatus,
 } from '../plays/extractor-targets';
+import {
+  fieldOfName,
+  fieldPaths,
+  resolveFieldName,
+  type FieldBinding,
+} from '../plays/field-catalog';
 import type {
   BasicToolExecuteResult,
   BasicToolResultListAccessor,
@@ -520,6 +526,10 @@ function parseExecuteToolMetadata(
             !Array.isArray(recordEntry.emailStatus)
               ? (recordEntry.emailStatus as EmailStatusExtractorConfig)
               : undefined;
+          const means =
+            typeof recordEntry.means === 'string'
+              ? recordEntry.means
+              : undefined;
           return [
             [
               key,
@@ -544,6 +554,7 @@ function parseExecuteToolMetadata(
                   : {}),
                 ...(overrides.length > 0 ? { overrides } : {}),
                 ...(emailStatus ? { emailStatus } : {}),
+                ...(means !== undefined ? { means } : {}),
               },
             ],
           ];
@@ -1540,6 +1551,71 @@ function listTableNamespace(
   }
 }
 
+/**
+ * The outputs of a result that are catalog fields: declared extractors whose
+ * meaning is known, from the tool's own `means` or the name's one meaning.
+ * Values found by guessing at keys are never bindings.
+ */
+function resultFieldBindings(
+  result: ToolExecuteResult | BasicToolExecuteResult,
+): FieldBinding[] {
+  const extractors = result._metadata.extractors ?? {};
+  return Object.entries(extractors).flatMap(([name, descriptor]) => {
+    if (!result.extractedValues[name]) return [];
+    const id = fieldOfName(name, descriptor.means);
+    return id ? [{ name, id }] : [];
+  });
+}
+
+function resultOutputNames(
+  result: ToolExecuteResult | BasicToolExecuteResult,
+): string[] {
+  return [
+    ...Object.keys(result._metadata.extractors ?? {}),
+    ...Object.keys(result.extractedLists),
+  ];
+}
+
+function readResultField(
+  result: ToolExecuteResult | BasicToolExecuteResult,
+  name: string,
+): unknown {
+  const bindings = resultFieldBindings(result);
+  const binding = resolveFieldName(name, bindings, resultOutputNames(result));
+  if (!binding) {
+    const ids = [...new Set(bindings.map((known) => known.id))];
+    throw new Error(
+      `${result._metadata.toolId} has no field "${name}". ${ids.length > 0 ? `Its fields: ${ids.join(', ')}.` : 'It declares no catalog fields.'} Other values are in result.response.`,
+    );
+  }
+  return result.extractedValues[binding.name]!.get();
+}
+
+/** `result.fields`, laid out by `fieldPaths`; each value reads on access. */
+function buildResultFields(
+  result: ToolExecuteResult | BasicToolExecuteResult,
+): Record<string, unknown> {
+  const tree: Record<string, unknown> = {};
+  const lists = Object.keys(result.extractedLists);
+  for (const entry of fieldPaths(
+    resultFieldBindings(result),
+    resultOutputNames(result),
+    lists,
+  )) {
+    let node = tree;
+    for (const key of entry.path.slice(0, -1)) {
+      node = (node[key] ??= {}) as Record<string, unknown>;
+    }
+    Object.defineProperty(node, entry.path[entry.path.length - 1]!, {
+      get: entry.list
+        ? () => result.extractedLists[entry.name]!.get()
+        : () => readResultField(result, entry.name),
+      enumerable: true,
+    });
+  }
+  return tree;
+}
+
 export function createToolExecuteResult<TResult = unknown>(input: {
   status: string;
   jobId?: string;
@@ -1614,11 +1690,33 @@ export function createToolExecuteResult<TResult = unknown>(input: {
     extractedValues,
     extractedLists,
   } as ToolExecuteResult<TResult>;
+  // Read through `this`, so copies made from these descriptors (the edition
+  // projection, native batch views) read their own values.
   Object.defineProperties(wrapper, {
     toolOutput: {
       value: toolResponse,
       enumerable: false,
     },
+    response: {
+      get(this: ToolExecuteResult) {
+        return Object.hasOwn(this.toolResponse, 'rawV2')
+          ? this.toolResponse.rawV2
+          : this.toolResponse.raw;
+      },
+      enumerable: false,
+    },
+    fields: {
+      get(this: ToolExecuteResult) {
+        return buildResultFields(this);
+      },
+      enumerable: false,
+    },
+    field: {
+      value(this: ToolExecuteResult, name: string) {
+        return readResultField(this, name);
+      },
+      enumerable: false,
+    },
   });
   Object.defineProperty(wrapper, '_metadata', {
     value: metadata,