deepline 0.3.88 → 0.3.90

package/dist/bundling-sources/shared_libs/play-runtime/zerobounce-batching.ts

@@ -0,0 +1,122 @@
+import {
+  defineBatchStrategyMap,
+  type BatchOperationStrategy,
+} from './batching-types';
+
+type Single = { email?: string; ip_address?: string };
+type Bulk = {
+  email_batch: Array<{ email_address: string; ip_address?: string }>;
+};
+type Verdict = Record<string, unknown> & { address: string; status: string };
+type Results = { email_batch?: unknown[]; errors?: unknown[]; data?: Results };
+
+function emailKey(email: string) {
+  return email.trim().toLowerCase();
+}
+function bucket(payload: Single) {
+  // The response identifies emails, but does not echo the supplied IP.
+  return JSON.stringify([
+    'zerobounce_batch_validate',
+    payload.ip_address ?? null,
+  ]);
+}
+
+export const zerobounceValidateBatchStrategy: BatchOperationStrategy<
+  Single,
+  Bulk,
+  Results,
+  { data: Verdict }
+> = {
+  sourceOperation: 'zerobounce_validate',
+  batchOperation: 'zerobounce_batch_validate',
+  kind: 'identifier_batch',
+  maxBatchSize: 100,
+  bucketKeyPayloadFields: ['ip_address'],
+  canBatchWith: (left, right) => bucket(left) === bucket(right),
+  toBucketKey: bucket,
+  toItemKey: (payload) =>
+    JSON.stringify([emailKey(payload.email ?? ''), payload.ip_address ?? null]),
+  compile(payloads) {
+    const first = payloads[0];
+    if (
+      !first ||
+      payloads.length > 100 ||
+      payloads.some((p) => !p.email?.trim() || bucket(p) !== bucket(first))
+    ) {
+      throw new Error(
+        'ZeroBounce batch requires 1–100 emails with matching IP options.',
+      );
+    }
+    return {
+      // Receipt deduplication may leave one owned email. Keep the bulk operation.
+      batchOperation: 'zerobounce_batch_validate',
+      batchPayload: {
+        email_batch: [...new Set(payloads.map((p) => emailKey(p.email!)))].map(
+          (email_address) => ({
+            email_address,
+            ...(first.ip_address ? { ip_address: first.ip_address } : {}),
+          }),
+        ),
+      },
+      items: payloads.map((payload) => ({
+        itemKey: zerobounceValidateBatchStrategy.toItemKey(payload),
+        payload,
+      })),
+    };
+  },
+  splitResult(fullResult, compiled) {
+    const result = fullResult.data ?? fullResult;
+    if (
+      !Array.isArray(result.email_batch) ||
+      (result.errors !== undefined &&
+        (!Array.isArray(result.errors) || result.errors.length > 0))
+    ) {
+      throw new Error(
+        'ZeroBounce bulk verification returned errors or no result list.',
+      );
+    }
+    const expected = new Set(
+      compiled.batchPayload.email_batch.map((p) => emailKey(p.email_address)),
+    );
+    const byEmail = new Map<string, Verdict>();
+    for (const value of result.email_batch) {
+      const row = value as Verdict | null;
+      if (
+        !row ||
+        typeof row.address !== 'string' ||
+        ![
+          'valid',
+          'invalid',
+          'catch-all',
+          'unknown',
+          'spamtrap',
+          'abuse',
+          'do_not_mail',
+        ].includes(row.status)
+      ) {
+        throw new Error(
+          'ZeroBounce bulk verification returned a malformed verdict.',
+        );
+      }
+      const key = emailKey(row.address);
+      if (!expected.has(key) || byEmail.has(key)) {
+        throw new Error(
+          'ZeroBounce bulk verification returned unexpected or duplicate verdicts.',
+        );
+      }
+      byEmail.set(key, row);
+    }
+    return compiled.items.map((item) => {
+      const row = byEmail.get(emailKey(item.payload.email!));
+      if (!row)
+        throw new Error(
+          'ZeroBounce bulk verification omitted a requested email result.',
+        );
+      return { itemKey: item.itemKey, result: { data: row }, rawResult: row };
+    });
+  },
+};
+
+export const zerobounceBatchStrategies = defineBatchStrategyMap({
+  zerobounce_validate: zerobounceValidateBatchStrategy,
+});

package/dist/bundling-sources/shared_libs/plays/artifact-types.ts

@@ -20,10 +20,13 @@ export type PlayRuntimeFeature =
   | 'packaged_files';
 
 export type PlayArtifactCompatibility = {
-  apiVersion: number;
+  /** Historical marker carried by stored artifacts. Nothing branches on it. */
+  apiVersion?: number;
   artifactVersion: number;
-  minRunnerVersion: number;
-  runtimeFeatures: PlayRuntimeFeature[];
+  /** Historical marker carried by stored artifacts. Every runner reads every artifact. */
+  minRunnerVersion?: number;
+  /** Historical marker carried by stored artifacts. Capabilities are named per operation. */
+  runtimeFeatures?: PlayRuntimeFeature[];
   runtimeBackend?: string | null;
   /** Missing preserves the legacy schema used before this field existed. */
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
@@ -33,6 +36,8 @@ export type PlayArtifactCompatibility = {
   toolResponseContract?: ToolResponseContract;
   /** Missing preserves the receipt namespace of artifacts created before this revision existed. */
   toolResponseReceiptRevision?: string;
+  /** Missing preserves Slack HITL's historical parked timeout behavior. */
+  slackHitlTimeoutOutcome?: 'error';
 };
 
 /** The only executable Play artifact contract. */