deepline 0.2.39 → 0.2.41

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

@@ -36,6 +36,7 @@
 import { resolveConfig } from './config.js';
 import { DeeplineError } from './errors.js';
 import { HttpClient } from './http.js';
+import { PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES } from '../../shared_libs/product-notifications/contract.js';
 import {
   STREAM_HEALTHY_CONNECTION_MS,
   isTransientPlayStreamError,
@@ -58,6 +59,7 @@ import type {
   PlayRunPackage,
   PlayLiveEvent,
   PlayListItem,
+  ProductNotificationSettings,
   PlayDescription,
   StopPlayRunResult,
   StopAllPlayRunsResult,
@@ -84,10 +86,7 @@ import type { PlayStagedFileRef } from './plays/local-file-discovery.js';
 import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-manifest.js';
 import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
 import { RUNTIME_ENVIRONMENT_TOKEN_HEADER } from '../../shared_libs/play-runtime/coordinator-headers.js';
-import {
-  THEIRSTACK_SLOW_JOB_SEARCH_CLIENT_TIMEOUT_MS,
-  usesExtendedTheirstackJobSearchBudget,
-} from '../../shared_libs/integrations/theirstack-execution-policy.js';
+import { resolveTheirstackClientTimeoutMs } from '../../shared_libs/integrations/theirstack-execution-policy.js';
 import {
   normalizePlayRuntimeEnvironment,
   normalizePlayRuntimeNamespace,
@@ -422,9 +421,11 @@ function resolveToolExecuteTimeoutMs(
   // Provider-specific slow-request policies live in shared modules so the SDK
   // and server classify the same payloads. If more providers need this, replace
   // these individual checks with a shared policy registry, not a wider default.
-  if (usesExtendedTheirstackJobSearchBudget(normalized, input)) {
-    return THEIRSTACK_SLOW_JOB_SEARCH_CLIENT_TIMEOUT_MS;
-  }
+  const theirstackTimeoutMs = resolveTheirstackClientTimeoutMs(
+    normalized,
+    input,
+  );
+  if (theirstackTimeoutMs !== null) return theirstackTimeoutMs;
   return normalized === 'deeplineagent' ||
     normalized === 'deeplineagent_deeplineagent' ||
     normalized === 'ai_inference' ||
@@ -3742,6 +3743,145 @@ export class DeeplineClient {
     return response.plays ?? [];
   }
 
+  /** Read product-notification destinations, subscriptions, event catalog, and DLQ health. */
+  async getNotificationSettings(): Promise<ProductNotificationSettings> {
+    return this.http.get('/api/v2/settings/notifications');
+  }
+
+  /** Start the Slack OAuth flow required by product notifications. */
+  async connectNotificationSlack(options?: {
+    successUrl?: string;
+    failureUrl?: string;
+  }): Promise<{ ok: boolean; redirect_url: string }> {
+    return this.http.post('/api/v2/integrations/connect', {
+      provider: 'slack',
+      scopes: [...PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES],
+      ...(options?.successUrl ? { success_url: options.successUrl } : {}),
+      ...(options?.failureUrl ? { failure_url: options.failureUrl } : {}),
+    });
+  }
+
+  /** List Slack channels visible to the connected Deepline Slack app. */
+  async listNotificationSlackChannels(query?: string): Promise<{
+    identity: { teamId: string; teamName?: string };
+    channels: Array<{ id: string; name: string; isPrivate: boolean }>;
+  }> {
+    const suffix = query ? `?query=${encodeURIComponent(query)}` : '';
+    return this.http.get(`/api/v2/settings/notifications/channels${suffix}`);
+  }
+
+  /** Select the Slack channel used for product notifications. */
+  async setNotificationSlack(channel: string) {
+    return this.http.put('/api/v2/settings/notifications', { channel });
+  }
+
+  /** Send one synchronous test ping and return Slack's delivery result. */
+  async testNotificationSlack(): Promise<{
+    ok: boolean;
+    deliveryId: string;
+    state: string;
+    message: string;
+  }> {
+    return this.http.post('/api/v2/settings/notifications/test', {});
+  }
+
+  /** Disable Slack product notifications without deleting the OAuth connection. */
+  async disableNotificationSlack() {
+    return this.http.delete('/api/v2/settings/notifications');
+  }
+
+  /** Enable or disable event IDs from the server-provided notification catalog. */
+  async setNotificationSubscriptions(eventTypes: string[], enabled: boolean) {
+    return this.http.patch('/api/v2/settings/notifications/subscriptions', {
+      eventTypes,
+      enabled,
+    });
+  }
+
+  /** List exhausted deliveries. Dead-lettered messages never replay automatically. */
+  async listNotificationDlq(limit = 25) {
+    return this.http.get(
+      `/api/v2/settings/notifications/dlq?limit=${encodeURIComponent(String(limit))}`,
+    );
+  }
+
+  /** Inspect one exhausted notification delivery. */
+  async getNotificationDlqDelivery(deliveryId: string) {
+    return this.http.get(
+      `/api/v2/settings/notifications/dlq/${encodeURIComponent(deliveryId)}`,
+    );
+  }
+
+  /** Explicitly retry or archive one dead-lettered notification delivery. */
+  async updateNotificationDlqDelivery(
+    deliveryId: string,
+    action: 'retry' | 'archive',
+  ) {
+    return this.http.post(
+      `/api/v2/settings/notifications/dlq/${encodeURIComponent(deliveryId)}`,
+      { action },
+    );
+  }
+
+  /** List the workspace's named notification rules. */
+  async getNotifications(): Promise<ProductNotificationSettings> {
+    return this.http.get('/api/v2/notifications');
+  }
+
+  /** List Slack channels available to an already-connected Slack integration. */
+  async listNotificationChannels(query?: string): Promise<{
+    identity: { teamId: string; teamName?: string };
+    channels: Array<{ id: string; name: string; isPrivate: boolean }>;
+  }> {
+    const suffix = query ? `?search=${encodeURIComponent(query)}` : '';
+    return this.http.get(`/api/v2/notifications/slack/channels${suffix}`);
+  }
+
+  /** Create a named notification routed through an existing provider integration. */
+  async createNotification(input: {
+    name: string;
+    provider: 'slack';
+    channel: string;
+    eventTypes: string[];
+  }) {
+    return this.http.post('/api/v2/notifications', input);
+  }
+
+  /** Update a notification's target, event selection, or enabled state. */
+  async updateNotification(
+    notificationId: string,
+    input:
+      | { enabled: boolean }
+      | { name: string; channel: string; eventTypes: string[] },
+  ) {
+    return this.http.patch(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}`,
+      input,
+    );
+  }
+
+  /** Send a validation ping to one notification. */
+  async testNotification(notificationId: string): Promise<{
+    ok: boolean;
+    deliveryId: string;
+    state: string;
+    message: string;
+  }> {
+    return this.http.post(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}/test`,
+      {},
+    );
+  }
+
+  /** Archive one notification without touching its provider integration. */
+  async deleteNotification(
+    notificationId: string,
+  ): Promise<{ deleted: boolean; id: string }> {
+    return this.http.delete(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}`,
+    );
+  }
+
   /**
    * Search callable plays and return compact play descriptions.
    *

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

@@ -720,6 +720,14 @@ export class HttpClient {
     });
   }
 
+  async put<T = unknown>(
+    path: string,
+    body?: unknown,
+    headers?: Record<string, string>,
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'PUT', body, headers });
+  }
+
   /**
    * Send a DELETE request.
    *

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

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.39',
+  version: '0.2.41',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -1084,6 +1084,48 @@ export interface PlayListItem {
   currentRevision?: PlayRevisionSummary | null;
   liveRevision?: PlayRevisionSummary | null;
   aliases?: string[];
+  triggerStatus?: {
+    cron: string | null;
+    webhook: string | null;
+    blockedReason: string | null;
+  };
+}
+
+export interface ProductNotificationEventDefinition {
+  id: string;
+  label: string;
+  description: string;
+  source: 'cron' | 'webhook';
+  outcome: 'succeeded' | 'failed';
+  defaultEnabled: boolean;
+}
+
+export interface ProductNotificationSettings {
+  contractVersion: number;
+  catalog: ProductNotificationEventDefinition[];
+  notifications?: ProductNotification[];
+  providers?: Array<{ kind: string; targetLabel: string }>;
+  destinations: Array<Record<string, unknown>>;
+  subscriptions: Array<{
+    eventType: string;
+    enabled: boolean;
+    destinationId: string;
+  }>;
+  dlq: { count: number; capped: boolean };
+  slackConnection?: { connected: boolean; status: string };
+}
+
+export interface ProductNotification {
+  id: string;
+  name: string;
+  provider: string;
+  target: { id: string; name: string };
+  enabled: boolean;
+  status: string;
+  eventTypes: string[];
+  lastTestedAt?: number;
+  lastTestStatus?: string;
+  lastErrorMessage?: string;
 }
 
 export interface PlayDescription {

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

@@ -23,6 +23,14 @@ export const THEIRSTACK_SLOW_JOB_SEARCH_PROVIDER_TIMEOUT_MS = 135_000;
 export const THEIRSTACK_SLOW_JOB_SEARCH_CLIENT_TIMEOUT_MS =
   60_000 + THEIRSTACK_SLOW_JOB_SEARCH_PROVIDER_TIMEOUT_MS + 15_000;
 
+/**
+ * TheirStack company search is synchronous but can spend the full upstream
+ * request window before returning a large result set. The SDK default is only
+ * 60 seconds, so keep it alive through the server's 120-second provider
+ * deadline plus the same permit and response grace used for slow job search.
+ */
+export const THEIRSTACK_COMPANY_SEARCH_CLIENT_TIMEOUT_MS = 210_000;
+
 const LONG_JOB_SEARCH_WINDOW_MS = 365 * 24 * 60 * 60 * 1_000;
 const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -95,3 +103,16 @@ export function usesExtendedTheirstackJobSearchBudget(
     ? true
     : usesLongExplicitDateWindow(payload);
 }
+
+/** SDK-only timeout selection. Provider request timeouts remain action-local. */
+export function resolveTheirstackClientTimeoutMs(
+  endpointId: string,
+  payload: Record<string, unknown>,
+): number | null {
+  if (endpointId === 'theirstack_company_search') {
+    return THEIRSTACK_COMPANY_SEARCH_CLIENT_TIMEOUT_MS;
+  }
+  return usesExtendedTheirstackJobSearchBudget(endpointId, payload)
+    ? THEIRSTACK_SLOW_JOB_SEARCH_CLIENT_TIMEOUT_MS
+    : null;
+}

package/dist/bundling-sources/shared_libs/play-runtime/receipt-sql.ts

@@ -77,7 +77,16 @@ export function workReceiptClaimConflictPredicateSql(input: {
   const forceFailedRefreshSql = input.forceFailedRefreshSql ?? 'false';
   return `${table}.status = ANY(${input.claimableStatusesSql}::smallint[])
             AND (
-              ${input.forceRefreshSql}::boolean
+              (
+                ${input.forceRefreshSql}::boolean
+                AND (
+                  ${table}.status NOT IN (
+                    ${RECEIPT_STATUS_CODE.completed}::smallint,
+                    ${RECEIPT_STATUS_CODE.skipped}::smallint
+                  )
+                  OR ${table}.run_id IS DISTINCT FROM ${input.claimantRunIdSql}
+                )
+              )
               OR (
                 ${forceFailedRefreshSql}::boolean
                 AND ${table}.status = ${RECEIPT_STATUS_CODE.failed}::smallint
@@ -111,6 +120,7 @@ export function workReceiptClaimConflictPredicateSql(input: {
                   ${RECEIPT_STATUS_CODE.completed}::smallint,
                   ${RECEIPT_STATUS_CODE.skipped}::smallint
                 )
+                AND ${table}.run_id IS DISTINCT FROM ${input.claimantRunIdSql}
                 AND (
                   (
                     ${table}.lease_id IS NULL

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

@@ -4402,8 +4402,8 @@ export async function claimRuntimeWorkReceipt(
       }
       if (
         latest &&
-        input.forceRefresh !== true &&
-        isReusableWorkReceipt(latest)
+        isReusableWorkReceipt(latest) &&
+        (input.forceRefresh !== true || latest.runId === input.runId)
       ) {
         return { disposition: 'reused', receipt: latest };
       }
@@ -4697,7 +4697,10 @@ export async function claimRuntimeWorkReceipts(
           });
           continue;
         }
-        if (input.forceRefresh !== true && isReusableWorkReceipt(receipt)) {
+        if (
+          isReusableWorkReceipt(receipt) &&
+          (input.forceRefresh !== true || receipt.runId === input.runId)
+        ) {
           claimsByKey.set(receipt.key, {
             disposition: 'reused',
             receipt,

package/dist/bundling-sources/shared_libs/play-runtime/work-receipt-state-machine.ts

@@ -277,6 +277,22 @@ export function decideWorkReceiptClaim(input: {
 }): WorkReceiptClaimDecision {
   if (!input.receipt) return { kind: 'claim' };
   const state = classifyWorkReceiptState(input.receipt, input.nowMs);
+  const sameLogicalRun =
+    normalize(input.claimantRunId) !== null &&
+    normalize(input.claimantRunId) === normalize(input.receipt.runId);
+  const sameRunNewerLeaseAttempt =
+    state.reusable &&
+    state.lease.kind === 'active' &&
+    state.lease.ownerRunId === normalize(input.claimantRunId) &&
+    state.lease.ownerAttempt < normalizeAttempt(input.claimantRunAttempt);
+  // Force refresh means new intent across runs. Within one run it is a replay,
+  // so reuse terminal output instead of creating a second terminal payload
+  // under the run's existing Runtime Sheet write version. A newer lease
+  // generation is the exception: it is a new attempt and retains the existing
+  // stale-owner fence semantics.
+  if (state.reusable && sameLogicalRun && !sameRunNewerLeaseAttempt) {
+    return { kind: 'reuse_terminal' };
+  }
   if (state.reusable && input.forceRefresh !== true) {
     return { kind: 'reuse_terminal' };
   }

package/dist/bundling-sources/shared_libs/product-notifications/contract.ts

@@ -0,0 +1,134 @@
+export const PRODUCT_NOTIFICATION_CONTRACT_VERSION = 1 as const;
+
+export const PRODUCT_NOTIFICATION_EVENT_CATALOG = [
+  {
+    id: 'play.cron.succeeded',
+    label: 'Cron success',
+    description: 'A scheduled Play run completed successfully.',
+    source: 'cron',
+    outcome: 'succeeded',
+    defaultEnabled: true,
+  },
+  {
+    id: 'play.cron.failed',
+    label: 'Cron failure',
+    description:
+      'A scheduled Play could not start or its run reached a failed terminal state.',
+    source: 'cron',
+    outcome: 'failed',
+    defaultEnabled: true,
+  },
+  {
+    id: 'play.webhook.succeeded',
+    label: 'Webhook success',
+    description: 'An accepted webhook-triggered Play completed successfully.',
+    source: 'webhook',
+    outcome: 'succeeded',
+    defaultEnabled: true,
+  },
+  {
+    id: 'play.webhook.failed',
+    label: 'Webhook failure',
+    description:
+      'An accepted webhook-triggered Play reached a failed terminal state.',
+    source: 'webhook',
+    outcome: 'failed',
+    defaultEnabled: true,
+  },
+] as const;
+
+export type ProductNotificationEventDefinition =
+  (typeof PRODUCT_NOTIFICATION_EVENT_CATALOG)[number];
+export type ProductNotificationEventType =
+  ProductNotificationEventDefinition['id'];
+export type ProductNotificationSource =
+  ProductNotificationEventDefinition['source'];
+export type ProductNotificationOutcome =
+  ProductNotificationEventDefinition['outcome'];
+
+const PRODUCT_NOTIFICATION_EVENT_TYPE_SET = new Set<string>(
+  PRODUCT_NOTIFICATION_EVENT_CATALOG.map((event) => event.id),
+);
+
+export function isProductNotificationEventType(
+  value: unknown,
+): value is ProductNotificationEventType {
+  return (
+    typeof value === 'string' && PRODUCT_NOTIFICATION_EVENT_TYPE_SET.has(value)
+  );
+}
+
+export function getProductNotificationEventDefinition(
+  eventType: string,
+): ProductNotificationEventDefinition | null {
+  return (
+    PRODUCT_NOTIFICATION_EVENT_CATALOG.find(
+      (definition) => definition.id === eventType,
+    ) ?? null
+  );
+}
+
+export function defaultProductNotificationEventTypes(): ProductNotificationEventType[] {
+  return PRODUCT_NOTIFICATION_EVENT_CATALOG.filter(
+    (definition) => definition.defaultEnabled,
+  ).map((definition) => definition.id);
+}
+
+export const PRODUCT_NOTIFICATION_DESTINATION_KINDS = ['slack'] as const;
+export const PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES = [
+  'channels:read',
+  'chat:write',
+  'groups:read',
+] as const;
+export type ProductNotificationDestinationKind =
+  (typeof PRODUCT_NOTIFICATION_DESTINATION_KINDS)[number];
+
+export const PRODUCT_NOTIFICATION_DELIVERY_STATES = [
+  'pending',
+  'delivering',
+  'delivered',
+  'retry_scheduled',
+  'dead_lettered',
+  'expired',
+  'suppressed',
+] as const;
+export type ProductNotificationDeliveryState =
+  (typeof PRODUCT_NOTIFICATION_DELIVERY_STATES)[number];
+
+/** Immediate send plus four bounded retries. */
+export const PRODUCT_NOTIFICATION_RETRY_DELAYS_MS = [
+  0,
+  60_000,
+  5 * 60_000,
+  15 * 60_000,
+  60 * 60_000,
+] as const;
+export const PRODUCT_NOTIFICATION_MAX_ATTEMPTS =
+  PRODUCT_NOTIFICATION_RETRY_DELAYS_MS.length;
+/** A claimed delivery must finish within this window or a recovery attempt may claim it. */
+export const PRODUCT_NOTIFICATION_DELIVERY_LEASE_MS = 2 * 60_000;
+
+export const PRODUCT_NOTIFICATION_PENDING_LIMIT_PER_DESTINATION = 100;
+export const PRODUCT_NOTIFICATION_DLQ_REPLAY_LIMIT = 25;
+export const PRODUCT_NOTIFICATION_SUCCESS_TTL_MS = 15 * 60_000;
+export const PRODUCT_NOTIFICATION_FAILURE_TTL_MS = 24 * 60 * 60_000;
+
+export function productNotificationEventTypeFor(input: {
+  source: ProductNotificationSource;
+  outcome: ProductNotificationOutcome;
+}): ProductNotificationEventType {
+  return `play.${input.source}.${input.outcome}` as ProductNotificationEventType;
+}
+
+export function productNotificationEventExpiresAt(input: {
+  eventType: ProductNotificationEventType;
+  occurredAt: number;
+}): number {
+  const definition = getProductNotificationEventDefinition(input.eventType);
+  return (
+    input.occurredAt +
+    (definition?.outcome === 'succeeded'
+      ? PRODUCT_NOTIFICATION_SUCCESS_TTL_MS
+      : PRODUCT_NOTIFICATION_FAILURE_TTL_MS)
+  );
+}