deepline 0.3.228 → 0.3.229

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

@@ -26,6 +26,7 @@ import {
   serializePlayDatasetCell,
 } from '../plays/dataset';
 import type { PlayDataset, PlayDatasetInput } from '../plays/dataset';
+import type { PlayDatasetColumnTypes } from '../play-data-plane/contracts';
 import {
   compileRequestsWithStrategy,
   executeChunkedRequests,
@@ -203,6 +204,10 @@ import {
   TOOL_EXECUTE_PROVIDER_RATE_RETRY_SNAPSHOT_HEADER,
   classifyToolExecuteHttpFailure,
   createToolExecuteHttpFailureAttemptTracker,
+  TOOL_EXECUTE_BARE_RATE_LIMIT_MAX_ATTEMPTS,
+  TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS,
+  TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS,
+  TOOL_EXECUTE_RATE_LIMIT_RETRY_DELAY_MAX_MS,
   parseToolExecuteRetryAfterMs,
   parseToolExecuteRetryAtMs,
   parseToolExecuteAuthScopeChangedError,
@@ -680,7 +685,7 @@ async function runCtxFetchPhase<T>(input: {
   callerSignal?: AbortSignal | null;
   controller: AbortController;
   deadline: CtxFetchDeadline;
-  phase: 'headers' | 'body';
+  phase: 'headers' | 'body' | 'total';
   run: () => Promise<T>;
 }): Promise<T> {
   const remainingMs = remainingCtxFetchMs(input.deadline);
@@ -695,7 +700,9 @@ async function runCtxFetchPhase<T>(input: {
   const phaseLimitMs =
     input.phase === 'headers'
       ? input.deadline.headersMs
-      : input.deadline.bodyMs;
+      : input.phase === 'body'
+        ? input.deadline.bodyMs
+        : remainingMs;
   const timeoutMs = Math.min(phaseLimitMs, remainingMs);
   const timeoutPhase = timeoutMs >= remainingMs ? 'total' : input.phase;
   let timeout: ReturnType<typeof setTimeout> | null = null;
@@ -744,19 +751,42 @@ async function sleepWithinCtxFetchDeadline(input: {
   delayMs: number;
 }): Promise<void> {
   const controller = new AbortController();
-  await runCtxFetchPhase({
-    callerSignal: input.callerSignal,
-    controller,
-    deadline: input.deadline,
-    phase: 'headers',
-    run: () =>
-      new Promise<void>((resolve) => {
-        setTimeout(
-          resolve,
-          Math.min(input.delayMs, remainingCtxFetchMs(input.deadline)),
-        );
-      }),
-  });
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await runCtxFetchPhase({
+      callerSignal: input.callerSignal,
+      controller,
+      deadline: input.deadline,
+      phase: 'total',
+      run: () =>
+        new Promise<void>((resolve) => {
+          timer = setTimeout(resolve, input.delayMs);
+        }),
+    });
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+}
+
+function isCtxFetchBackpressure(response: Response, bodyText: string): boolean {
+  if (response.status === 429) return true;
+  if (response.status !== 503) return false;
+  // This Salesforce endpoint reports a rejected burst as 503. Match the final
+  // destination and exact response contract; arbitrary 503s remain failures.
+  try {
+    const destination = new URL(response.url);
+    const body: unknown = JSON.parse(bodyText);
+    return (
+      destination.protocol === 'https:' &&
+      destination.hostname.endsWith('.salesforce-sites.com') &&
+      body !== null &&
+      typeof body === 'object' &&
+      !Array.isArray(body) &&
+      (body as Record<string, unknown>).status === 'burst_circuit_open'
+    );
+  } catch {
+    return false;
+  }
 }
 
 async function readCtxFetchBody(input: {
@@ -1673,6 +1703,69 @@ function rowsFromUnknown(value: unknown): Record<string, unknown>[] {
   );
 }
 
+function customerDbColumnTypes(
+  columns: unknown,
+  rows: readonly Record<string, unknown>[],
+): PlayDatasetColumnTypes | undefined {
+  if (!Array.isArray(columns)) return undefined;
+  // Core PostgreSQL OIDs only. Extension/domain identities are database-local,
+  // and source SQL types never authorize coercing the values returned by a tool.
+  const coreValueTypes: Record<
+    number,
+    PlayDatasetColumnTypes[string]['valueType']
+  > = {
+    16: 'boolean',
+    20: 'string',
+    21: 'number',
+    23: 'number',
+    25: 'string',
+    114: 'json',
+    700: 'number',
+    701: 'number',
+    1042: 'string',
+    1043: 'string',
+    1082: 'string',
+    1083: 'string',
+    1114: 'string',
+    1184: 'string',
+    1266: 'string',
+    1700: 'string',
+    2950: 'string',
+    3802: 'json',
+  };
+  const entries: Array<[string, PlayDatasetColumnTypes[string]]> = [];
+  for (const value of columns) {
+    const column = recordOrNull(value);
+    const postgresTypeId = column?.data_type_id;
+    if (
+      typeof column?.name !== 'string' ||
+      typeof postgresTypeId !== 'number' ||
+      !Object.hasOwn(coreValueTypes, postgresTypeId)
+    )
+      continue;
+    const observed = new Set<PlayDatasetColumnTypes[string]['valueType']>();
+    for (const row of rows) {
+      const cell = row[column.name];
+      if (cell === null || cell === undefined) continue;
+      observed.add(
+        typeof cell === 'boolean'
+          ? 'boolean'
+          : typeof cell === 'string'
+            ? 'string'
+            : typeof cell === 'number' && Number.isFinite(cell)
+              ? 'number'
+              : 'json',
+      );
+    }
+    const valueType =
+      postgresTypeId === 114 || postgresTypeId === 3802 || observed.size > 1
+        ? 'json'
+        : ([...observed][0] ?? coreValueTypes[postgresTypeId]!);
+    entries.push([column.name, { postgresTypeId, valueType }]);
+  }
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
 function finiteNonNegativeInteger(value: unknown): number | null {
   if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
     return null;
@@ -7914,6 +8007,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         rows.length >= effectiveCount ? rows.slice(0, effectiveCount) : null,
       sourceLabel: 'query result rows',
       tableNamespace: null,
+      columnTypes: isCustomerDbDatasetTool(toolId)
+        ? customerDbColumnTypes(raw?.columns, rows)
+        : undefined,
       resolvers: {
         count: async () => Math.min(totalRows, datasetLimit),
         at: async (index) => (await fetchPage(index, 1))[0],
@@ -8472,6 +8568,18 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     let itemsToProcess: Array<Record<string, unknown>> = [];
     let itemOriginalIndexes: number[] = [];
     const datasetColumnNames = Object.keys(input);
+    // Generated fields no longer describe the source column, even when they
+    // retain its name. Every writer still validates the actual incoming values.
+    const inputColumnTypes = isPlayDataset(items)
+      ? items.columnTypes
+      : undefined;
+    const unchangedColumnTypes = inputColumnTypes
+      ? Object.fromEntries(
+          Object.entries(inputColumnTypes).filter(
+            ([field]) => !datasetColumnNames.includes(field),
+          ),
+        )
+      : undefined;
     const stripFieldOutputs = (row: Record<string, unknown>) => {
       const stripped = cloneCsvAliasedRow(row);
       for (const fieldName of datasetColumnNames) {
@@ -8863,6 +8971,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
             inputOffset: page.offset,
             mode: options?.mode,
+            columnTypes: unchangedColumnTypes,
           },
         );
         resolvedTableNamespace = normalizeTableNamespace(
@@ -9424,6 +9533,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             ? immediateMaterializedRows
             : null,
         tableNamespace: resolvedTableNamespace,
+        columnTypes: unchangedColumnTypes,
         workProgress: {
           total: totalInputCount,
           executed: executedCount,
@@ -9666,6 +9776,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           staticPipeline: this.currentStaticPipeline,
           forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
           mode: options?.mode,
+          columnTypes: unchangedColumnTypes,
         },
       );
       resolvedTableNamespace = normalizeTableNamespace(
@@ -10175,6 +10286,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         .map((row) => this.toMaterializedOutputRow(row)),
       residentRows: terminalRows,
       tableNamespace: resolvedTableNamespace,
+      columnTypes: unchangedColumnTypes,
       workProgress: {
         total: totalInputCount,
         executed: executedCount,
@@ -14991,16 +15103,30 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           let response: Response | null = null;
           let bodyText: string | null = null;
           try {
-            const canRetryTransport = ['GET', 'HEAD', 'OPTIONS'].includes(
-              method,
-            );
+            // Only replay a body whose bytes are stable. In particular, a
+            // consumed ReadableStream cannot be retried even with a write key.
+            const replayableBody =
+              init.body == null || typeof init.body === 'string';
+            const canRetryTransport =
+              replayableBody && ['GET', 'HEAD', 'OPTIONS'].includes(method);
             const { safePublicFetch } = await loadSafeFetch();
-            for (
-              let attempt = 1;
-              attempt <= FETCH_TRANSPORT_MAX_ATTEMPTS;
-              attempt += 1
-            ) {
+            let transportAttempt = 1;
+            let rateLimitAttempt = 0;
+            while (true) {
               const attemptController = new AbortController();
+              let permit: Awaited<
+                ReturnType<RuntimeResourceGovernor['acquireProviderPermit']>
+              > | null = null;
+              let dispatched = false;
+              const releasePhysicalPermit = async () => {
+                const current = permit;
+                permit = null;
+                if (!current) return;
+                if (dispatched) current.release();
+                else await current.cancel();
+                dispatched = false;
+              };
+              let transportRetry = false;
               try {
                 const attemptInit = {
                   ...fetchInit,
@@ -15012,10 +15138,53 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   callerSignal: init.signal,
                   controller: attemptController,
                   deadline: fetchDeadline,
-                  phase: 'headers',
+                  phase: 'total',
                   run: () =>
                     safePublicFetch(url, attemptInit, {
-                      fetchImpl: this.#options.fetchImpl,
+                      // safePublicFetch validates each URL before invoking this
+                      // wrapper. Redirect hops are physical dispatches too.
+                      fetchImpl: async (physicalUrl, physicalInit) => {
+                        await releasePhysicalPermit();
+                        const signal = attemptInit.signal;
+                        permit = await runCtxFetchPhase({
+                          callerSignal: init.signal,
+                          controller: attemptController,
+                          deadline: fetchDeadline,
+                          phase: 'total',
+                          run: async () => {
+                            for (;;) {
+                              const acquired =
+                                await this.resourceGovernor.acquireProviderPermit(
+                                  { toolId: CTX_FETCH_EGRESS_TOOL_ID, signal },
+                                );
+                              try {
+                                signal.throwIfAborted();
+                                const valid =
+                                  !acquired.validate ||
+                                  (await acquired.validate());
+                                signal.throwIfAborted();
+                                if (valid) return acquired;
+                              } catch (error) {
+                                await acquired.cancel();
+                                throw error;
+                              }
+                              await acquired.cancel();
+                            }
+                          },
+                        });
+                        return await runCtxFetchPhase({
+                          callerSignal: init.signal,
+                          controller: attemptController,
+                          deadline: fetchDeadline,
+                          phase: 'headers',
+                          run: () => {
+                            dispatched = true;
+                            return (
+                              this.#options.fetchImpl ?? globalThis.fetch
+                            )(physicalUrl, physicalInit);
+                          },
+                        });
+                      },
                       sensitiveHeaders: Object.keys(secretHeaderMarkers),
                       stripHeadersOnCrossOriginRedirect: true,
                       headersOnCrossOriginRedirect: {
@@ -15029,7 +15198,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   deadline: fetchDeadline,
                   response,
                 });
-                break;
               } catch (error) {
                 void response?.body?.cancel(error).catch(() => undefined);
                 response = null;
@@ -15045,22 +15213,67 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   error instanceof Error ? error.message : String(error);
                 if (
                   canRetryTransport &&
-                  attempt < FETCH_TRANSPORT_MAX_ATTEMPTS
+                  transportAttempt < FETCH_TRANSPORT_MAX_ATTEMPTS
                 ) {
                   this.runtimeLog(
-                    `ctx.fetch(${method} ${url}) transport failed on attempt ${attempt}/${FETCH_TRANSPORT_MAX_ATTEMPTS}; retrying: ${message}`,
+                    `ctx.fetch(${method} ${url}) transport failed on attempt ${transportAttempt}/${FETCH_TRANSPORT_MAX_ATTEMPTS}; retrying: ${message}`,
+                  );
+                  transportRetry = true;
+                } else {
+                  throw new Error(
+                    `ctx.fetch(${method} ${url}) failed on attempt ${transportAttempt}/${FETCH_TRANSPORT_MAX_ATTEMPTS}: ${message}`,
                   );
-                  await sleepWithinCtxFetchDeadline({
-                    callerSignal: init.signal,
-                    deadline: fetchDeadline,
-                    delayMs: FETCH_TRANSPORT_RETRY_DELAY_MS * attempt,
-                  });
-                  continue;
                 }
-                throw new Error(
-                  `ctx.fetch(${method} ${url}) failed on attempt ${attempt}/${FETCH_TRANSPORT_MAX_ATTEMPTS}: ${message}`,
-                );
+              } finally {
+                await releasePhysicalPermit();
               }
+              if (transportRetry) {
+                await sleepWithinCtxFetchDeadline({
+                  callerSignal: init.signal,
+                  deadline: fetchDeadline,
+                  delayMs: FETCH_TRANSPORT_RETRY_DELAY_MS * transportAttempt,
+                });
+                transportAttempt += 1;
+                continue;
+              }
+              if (
+                !response ||
+                bodyText === null ||
+                !replayableBody ||
+                !isCtxFetchBackpressure(response, bodyText)
+              )
+                break;
+              rateLimitAttempt += 1;
+              const retryAfter = response.headers.get('retry-after');
+              const attemptCap = retryAfter?.trim()
+                ? TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS
+                : TOOL_EXECUTE_BARE_RATE_LIMIT_MAX_ATTEMPTS;
+              if (rateLimitAttempt >= attemptCap) break;
+              const delayMs = Math.max(
+                parseToolExecuteRetryAfterMs(retryAfter),
+                Math.min(
+                  TOOL_EXECUTE_RATE_LIMIT_RETRY_DELAY_MAX_MS,
+                  TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS * rateLimitAttempt,
+                ),
+              );
+              this.runtimeLog(
+                `[runtime.ctx_fetch_backpressure] ${JSON.stringify({
+                  key: normalizedKey,
+                  method,
+                  origin: new URL(response.url || url).origin,
+                  http_status: response.status,
+                  attempt: rateLimitAttempt,
+                  max_attempts: attemptCap,
+                  retry_delay_ms: delayMs,
+                })}`,
+              );
+              // Destination feedback must not cool the shared generic_http
+              // bucket used by unrelated websites. Pace this logical request.
+              await sleepWithinCtxFetchDeadline({
+                callerSignal: init.signal,
+                deadline: fetchDeadline,
+                delayMs,
+              });
             }
             if (!response) {
               throw new Error(

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -7,6 +7,7 @@ import type {
 } from './cell-provenance';
 import type { PlayBundleArtifact } from '../plays/artifact-types';
 import type { PlayRunContractSnapshot } from '../plays/contracts';
+import type { PlayDatasetColumnTypes } from '../play-data-plane/contracts';
 import type { PlayStructuredDefinition } from '../plays/definition';
 import type { PlayStaticPipeline } from '../plays/static-pipeline';
 import type {
@@ -891,6 +892,7 @@ export interface ContextOptions {
       forceRefresh?: boolean;
       inputOffset?: number;
       mode?: RuntimeDatasetRunOptions['mode'];
+      columnTypes?: PlayDatasetColumnTypes;
     },
   ) => Promise<MapStartResult>;
   /**

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -41,6 +41,7 @@ import {
   runtimeLimitExceededFailure,
 } from '../run-failure';
 import { createPlayContext } from '../context';
+import { augmentSheetContractWithDatasetFields } from '../../play-data-plane/sheet-contract';
 import type { RuntimeApiResponseMeta } from '../app-runtime-api';
 import { onMemoryPressure } from '../memory-pressure-signal';
 import {
@@ -2452,7 +2453,11 @@ async function run(
               playName,
               tableNamespace,
               playInput: runtimeInputObject,
-              sheetContract,
+              sheetContract: augmentSheetContractWithDatasetFields({
+                contract: sheetContract,
+                rows: items,
+                columnTypes: mapContext.columnTypes,
+              }),
               rows: items,
               inputOffset: mapContext.inputOffset,
               mode: mapContext.mode,