deepline 0.3.16 → 0.3.18

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

@@ -88,6 +88,10 @@ import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-mani
 import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
 import { RUNTIME_ENVIRONMENT_TOKEN_HEADER } from '../../shared_libs/play-runtime/coordinator-headers.js';
 import { resolveTheirstackClientTimeoutMs } from '../../shared_libs/integrations/theirstack-execution-policy.js';
+import {
+  BETTERCONTACT_LAUNCHER_CLIENT_TIMEOUT_MS,
+  usesExtendedBetterContactLauncherBudget,
+} from '../../shared_libs/integrations/bettercontact-execution-policy.js';
 import {
   normalizePlayRuntimeEnvironment,
   normalizePlayRuntimeNamespace,
@@ -460,6 +464,9 @@ function resolveToolExecuteTimeoutMs(
     input,
   );
   if (theirstackTimeoutMs !== null) return theirstackTimeoutMs;
+  if (usesExtendedBetterContactLauncherBudget(normalized)) {
+    return BETTERCONTACT_LAUNCHER_CLIENT_TIMEOUT_MS;
+  }
   return normalized === 'deeplineagent' ||
     normalized === 'deeplineagent_deeplineagent' ||
     normalized === 'ai_inference' ||

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

@@ -192,7 +192,7 @@ export const SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: '0.3.16',
+  version: '0.3.18',
   updateSummary:
     'New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.',
   contracts: {

package/dist/bundling-sources/shared_libs/integrations/bettercontact-execution-policy.ts

@@ -0,0 +1,29 @@
+/**
+ * BetterContact launchers are upstream-async but Deepline gives callers a
+ * bounded synchronous convenience wait before returning a pollable request
+ * id. Keep the provider and SDK budgets together so the client cannot abandon
+ * a launched job while the server is still inside that documented path.
+ */
+
+/** Per-request upstream timeout used by BetterContact launch and poll calls. */
+export const BETTERCONTACT_UPSTREAM_REQUEST_TIMEOUT_MS = 30_000;
+
+/**
+ * Client budget for a BetterContact launcher response.
+ *
+ * Covers route cold start, the bounded synchronous wait, one in-flight
+ * upstream request, and response serialization without widening unrelated
+ * tool requests.
+ */
+export const BETTERCONTACT_LAUNCHER_CLIENT_TIMEOUT_MS = 120_000;
+
+const BETTERCONTACT_LAUNCHER_TOOL_IDS = new Set([
+  'bettercontact_enrich',
+  'bettercontact_bulk_enrich',
+]);
+
+export function usesExtendedBetterContactLauncherBudget(
+  toolId: string,
+): boolean {
+  return BETTERCONTACT_LAUNCHER_TOOL_IDS.has(toolId.trim().toLowerCase());
+}

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

@@ -52,6 +52,11 @@ import {
 import { vercelProtectionBypassHeaders } from '@shared_libs/play-runtime/vercel-protection';
 import type { RuntimeReceiptAction } from '@shared_libs/play-runtime/runtime-actions';
 import { RUNTIME_CAPACITY_POLICY } from '@shared_libs/play-runtime/runtime-capacity-policy';
+import {
+  DEFAULT_RUNTIME_TRAFFIC_POLICY,
+  isRuntimeTrafficPolicy,
+  type RuntimeTrafficPolicy,
+} from '@shared_libs/play-runtime/runtime-traffic-policy';
 
 export type StoredPlayArtifactPayload = {
   sourceCode: string;
@@ -217,6 +222,7 @@ type RuntimeApiRequest =
   | ({
       action: 'governor_budget_charge';
     } & PlayRunnerBudgetChargeInput)
+  | { action: 'get_runtime_traffic_policy' }
   | RuntimeReceiptAction;
 
 export type WorkerRuntimeApiContext = {
@@ -1472,6 +1478,45 @@ export async function chargeGovernorBudgetViaAppRuntime(
   });
 }
 
+export async function getRuntimeTrafficPolicyViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+): Promise<RuntimeTrafficPolicy> {
+  const response = await postAppRuntimeApi<unknown>(context, {
+    action: 'get_runtime_traffic_policy',
+  });
+  if (isRuntimeTrafficPolicy(response)) return response;
+  // A 200 response is not enough to activate an incident control. A rollout
+  // mismatch or proxy body must behave as a control-plane outage (and use the
+  // caller's visible compiled-default fallback), never as an implicit limit.
+  throw new AppRuntimeApiResponseError({
+    action: 'get_runtime_traffic_policy',
+    status: 502,
+    code: 'runtime_traffic_policy_invalid_response',
+    retryable: true,
+    detail:
+      'Runtime traffic policy response did not match the versioned contract.',
+  });
+}
+
+/**
+ * The incident policy is a load-reduction overlay, never an execution
+ * prerequisite. During an app/Convex rolling deploy or a control-plane outage
+ * it is safer to use the compiled normal policy than to strand every new Play
+ * before sandbox creation. Callers must emit the returned diagnostic; this is
+ * intentionally a visible fail-open, not a silent fallback.
+ */
+export function fallbackRuntimeTrafficPolicyForUnavailableControlPlane(
+  error: unknown,
+): RuntimeTrafficPolicy | null {
+  if (
+    error instanceof AppRuntimeApiTransportError ||
+    (error instanceof AppRuntimeApiResponseError && error.status >= 500)
+  ) {
+    return DEFAULT_RUNTIME_TRAFFIC_POLICY;
+  }
+  return null;
+}
+
 export async function writeStagedFileFromAppRuntime(
   context: WorkerRuntimeApiContext,
   file: Pick<PlayStagedFileRef, 'storageKey'>,

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

@@ -102,16 +102,31 @@ export async function executeChunkedRequests<TRequest, TResult>(input: {
     input.weightOf,
   );
   for (const chunk of chunks) {
+    // notifyChain serializes onChunkComplete calls (the caller's callback can
+    // touch shared, non-concurrency-safe state) without letting one entry's
+    // callback failure skip a sibling's callback. A naive `.then()` chain
+    // would propagate a rejection forward and silently drop every queued
+    // notify() behind it -- for BetterContact/native-batch callers that
+    // means a correlation-mismatch throw on one row would leak the tool
+    // slots of every other row in the same chunk, since their
+    // onChunkComplete (and its `finally { releaseToolSlot() }`) would never
+    // run. Each callback failure is caught and re-thrown only after every
+    // queued entry in the chunk has had its callback invoked.
     let notifyChain: Promise<void> = Promise.resolve();
+    let firstCallbackFailure: unknown;
     const notify = async (
       entry: ChunkExecutionResult<TRequest, TResult>,
     ): Promise<void> => {
       if (input.retainResults !== false) {
         results.push(entry);
       }
-      notifyChain = notifyChain.then(
-        async () => await input.onChunkComplete?.([entry]),
-      );
+      notifyChain = notifyChain.then(async () => {
+        try {
+          await input.onChunkComplete?.([entry]);
+        } catch (error) {
+          firstCallbackFailure ??= error;
+        }
+      });
       await notifyChain;
     };
 
@@ -135,6 +150,7 @@ export async function executeChunkedRequests<TRequest, TResult>(input: {
       }),
     );
     await notifyChain;
+    if (firstCallbackFailure !== undefined) throw firstCallbackFailure;
   }
 
   return results;