deepline 0.3.89 → 0.3.90

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

@@ -0,0 +1,197 @@
+/**
+ * Package-owned types for Shareable Play Pages.
+ *
+ * These types are imported by Convex functions (`packages/convex/playSharePages.ts`),
+ * Next.js API routes, and the public landing page. They are the single,
+ * bounded contract for everything that crosses the public boundary.
+ *
+ * See docs/shareable-play-pages-plan.md.
+ */
+// This Module is bundled by Convex through its workspace dependency graph.
+import type { PlayStaticSubstep } from '../static-pipeline';
+
+/** SEO indexing posture for a share page or a specific version URL. */
+export type PlayShareSeoIndexing = 'index' | 'noindex';
+
+/**
+ * Generated landing-page copy, tied to one immutable Play Revision.
+ *
+ * Every field is plain human/agent-readable text. Nothing here may contain
+ * provider spend, secrets, raw runtime internals, or unpublished source.
+ */
+export type PlayShareGeneratedCopy = {
+  /** Concrete, job-focused landing title. */
+  title: string;
+  /** One paragraph, plain English. */
+  shortDescription: string;
+  /** The job the Play performs (jobs-to-be-done). */
+  jtbd: string;
+  /** 3-5 bullets describing when to reach for this Play. */
+  whenToUse: string[];
+  /** Concrete required inputs. */
+  inputs: string[];
+  /** Concrete produced outputs. */
+  outputs: string[];
+  /** Paste-ready Claude Code/Cursor/Codex instruction. */
+  agentPrompt: string;
+  /** Explicit, readable summary for LLM ingestion. */
+  llmSummary: string;
+  /** Search-result title. */
+  seoTitle: string;
+  /** Search-result description. */
+  seoDescription: string;
+};
+
+/** Owner overrides merge over generated copy at read time. */
+export type PlayShareCopyOverrides = Partial<PlayShareGeneratedCopy>;
+
+/**
+ * A single node in the bounded pipeline preview. Never includes source code,
+ * params, secrets, or provider spend — only a shape and a human label.
+ */
+export type PlaySharePreviewStep = {
+  /** Human-readable action, e.g. "search people by domain". */
+  label: string;
+  /** Provider name backing this step, when known. */
+  provider: string | null;
+};
+
+export type PlaySharePreviewNode = {
+  type:
+    | 'csv'
+    | 'dataset'
+    | 'tool'
+    | 'waterfall'
+    | 'step_suite'
+    | 'control_flow'
+    | 'play_call'
+    | 'play_launch'
+    | 'run_javascript'
+    | 'code';
+  /** Human-readable label, e.g. "Apollo" or "Dataset rows". */
+  label: string;
+  /** Optional provider name when this node calls a provider. */
+  provider?: string | null;
+  /** Optional secondary line, e.g. an input field or step kind. */
+  detail?: string | null;
+  /** Ordered sub-steps for waterfall / step-suite nodes (bounded). */
+  steps?: PlaySharePreviewStep[];
+};
+
+/** Bounded static-pipeline summary safe for public display. */
+export type PlayShareStaticPipelineSummary = {
+  stepCount: number;
+  providerCount: number;
+  hasMap: boolean;
+  previewNodes: PlaySharePreviewNode[];
+};
+
+/** Bounded, safe representation of the revision's input/output shape. */
+export type PlayShareSchemaShape = {
+  fields: string[];
+} | null;
+
+/**
+ * The ONLY object consumed by the public page and the public share API.
+ * Everything here is safe to expose to anyone with the unlisted link.
+ */
+export type PublishedPlayPagePackage = {
+  page: {
+    /** Internal stable record id. Never a public URL — pages are namespaced. */
+    shareSlug: string;
+    /** Org URL handle; the public page lives at `/p/:orgSlug/:playName`. */
+    orgSlug: string;
+    visibility: 'unlisted';
+    seoIndexing: PlayShareSeoIndexing;
+    /** Canonical path, e.g. `/p/:orgSlug/:playName/v/:publishedVersion`. */
+    canonicalPath: string;
+    /** Whether the requested URL is the currently-published version. */
+    isPublishedVersion: boolean;
+    /** When this version's public page was last published/updated. */
+    publishedAt: number;
+  };
+  definition: {
+    name: string;
+    ownerDisplayName: string | null;
+  };
+  revision: {
+    id: string;
+    version: number;
+    graphHash: string | null;
+    staticPipelineSummary: PlayShareStaticPipelineSummary;
+    /** Sanitized top-level substeps for the real v2 step-graph render. */
+    substeps: PlayStaticSubstep[];
+    inputSchema: PlayShareSchemaShape;
+    outputSchema: PlayShareSchemaShape;
+  };
+  copy: PlayShareGeneratedCopy;
+  publicMetrics: PublishedPlayPageMetrics;
+};
+
+/**
+ * Which cost denominator is comparable across runs of different input sizes,
+ * derived from the play's map shape. See `classifyCostBasis`.
+ */
+export type PlayCostBasis = 'run' | 'row' | 'none';
+
+/** Public, credit-only metrics. Provider spend is never present. */
+export type PublishedPlayPageMetrics = {
+  averageDeeplineCostCredits: number | null;
+  averageCostPerInputRowCredits: number | null;
+  averageCostPerOutputLeadCredits: number | null;
+  averageLatencyMs: number | null;
+  sampleRunCount: number;
+  /**
+   * The only cost denominator that is comparable across runs of different input
+   * sizes, derived from the play's map shape: `'run'` (flat play), `'row'`
+   * (single dataset over input rows), or `'none'` (multiple/nested datasets — no honest
+   * denominator, so cost is suppressed). Drives which credit metric the page
+   * renders, if any.
+   */
+  costBasis: PlayCostBasis;
+};
+
+/**
+ * Authenticated owner view of a share page (returned by GET/POST/PATCH
+ * `/api/v2/plays/:name/share`). Includes management metadata not exposed
+ * to the public read model.
+ */
+export type PlaySharePageOwnerView = {
+  shareSlug: string;
+  /** Org URL handle; the public page lives at `/p/:orgSlug/:playName`. */
+  orgSlug: string;
+  publishedRevisionId: string;
+  publishedVersion: number;
+  visibility: 'unlisted';
+  seoIndexing: PlayShareSeoIndexing;
+  showAverageDeeplineCost: boolean;
+  showAverageLatency: boolean;
+  publicPath: string;
+  canonicalPath: string;
+  createdAt: number;
+  updatedAt: number;
+};
+
+/**
+ * One row in the byte-bounded owner-facing version picker. The status response
+ * includes recent revisions plus any older working, live, public, or explicitly
+ * selected dashboard revision.
+ */
+export type PlaySharePageRevisionOption = {
+  revisionId: string;
+  version: number;
+  hasMap: boolean;
+  createdAt: number;
+  isLive: boolean;
+  isWorking: boolean;
+  isPublished: boolean;
+  hasCard: boolean;
+};
+
+/** Full payload for GET `/api/v2/plays/:name/share`. */
+export type PlaySharePageStatusResponse = {
+  playName: string;
+  share: PlaySharePageOwnerView | null;
+  publishedCopy: PlayShareGeneratedCopy | null;
+  revisions: PlaySharePageRevisionOption[];
+};

package/dist/bundling-sources/shared_libs/plays/slack-hitl-timeout-error.ts

@@ -0,0 +1,37 @@
+import { ToolExecutionError } from './tool-execution-error';
+
+/** Stable code for an unanswered `slack_message_with_hitl` approval. */
+export const SLACK_HITL_TIMEOUT_ERROR_CODE = 'SLACK_HITL_TIMEOUT' as const;
+
+/**
+ * A Slack human-in-the-loop approval reached its deadline without a decision.
+ *
+ * Deepline first confirms that it replaced the Slack card with “Interaction
+ * timed out.” and removed its controls. The error is non-retryable and
+ * runner-fatal: an authored `try/catch` may observe it, but cannot settle the
+ * Play successfully or start another durable operation. Retry the Play only
+ * after changing its input or timeout policy.
+ *
+ */
+export class SlackHitlTimeoutError extends ToolExecutionError {
+  constructor(message?: string) {
+    const detail =
+      message?.trim() ||
+      'Slack approval timed out before a human decision was received.';
+    super(`${SLACK_HITL_TIMEOUT_ERROR_CODE}: ${detail}`, {
+      toolId: 'slack_message_with_hitl',
+      provider: 'slack',
+      operation: 'slack_message_with_hitl',
+      code: SLACK_HITL_TIMEOUT_ERROR_CODE,
+      origin: 'deepline',
+      category: 'conflict',
+      retryable: false,
+      statusCode: 408,
+      requestId: null,
+      retryAfterMs: null,
+      networkKind: null,
+      networkScope: null,
+    });
+    this.name = 'SlackHitlTimeoutError';
+  }
+}

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -442,7 +442,12 @@ function truncateStaticSubstepsForStorage(
         columns: base.columns
           ? base.columns.map((column) => ({
               ...column,
-              producers: column.producers.map((producer) => ({
+              // `producers` was added after some persisted runtime Sheet
+              // contracts already existed. It is descriptive provenance, not
+              // required to identify or persist a Sheet column, so normalize
+              // a legacy omission to its semantic empty value while retaining
+              // the original column contract.
+              producers: (column.producers ?? []).map((producer) => ({
                 ...omitUndefinedProperties({ ...producer }),
                 sourceRange: cloneStorageSafeSourceRange(producer.sourceRange),
                 steps: producer.steps

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -5,7 +5,7 @@ import type { PlayDataset, SerializedPlayDataset } from './dataset';
 export type ToolResultExecutionMetadata = {
   idempotent: true;
   cached: boolean;
-  source: 'live' | 'checkpoint' | 'cache' | 'in_flight';
+  source: 'live' | 'checkpoint' | 'cache' | 'in_flight' | 'source_run';
   cacheKey?: string;
   receiptRole?: 'owner' | 'follower';
   receiptKey?: string;

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

@@ -72,10 +72,16 @@ export type ProductNotificationTrigger =
 export type ProductNotificationDeliveryTiming =
   | { mode: 'immediate' }
   | {
-      mode: 'immediate_first' | 'digest_only';
+      mode: 'immediate_first' | 'digest_only' | 'rolling_limit';
       windowMs: number;
     };
 
+export const DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING: ProductNotificationDeliveryTiming =
+  {
+    mode: 'rolling_limit',
+    windowMs: 3_600_000,
+  };
+
 export type ProductNotificationRepeatMode = 'on_enter' | 'every_match';
 
 export type ProductNotificationDefaultPolicy = {

package/dist/bundling-sources/shared_libs/product-notifications/default-policy.ts

@@ -3,6 +3,7 @@ import {
   validateProductNotificationRuleDefinition,
 } from './catalog';
 import {
+  DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING,
   resolveEffectiveProductNotificationConfiguration,
   validateProductNotificationDeliveryTiming,
   type ProductNotificationDefaultPolicy,
@@ -13,13 +14,13 @@ import {
  * they create sparse copy-on-write overrides.
  */
 export const CURRENT_PRODUCT_NOTIFICATION_DEFAULT_POLICY = {
-  version: 4,
+  version: 5,
   groups: [
     {
       groupKey: 'default',
       name: 'Default Notifications',
       enabled: true,
-      deliveryTiming: { mode: 'immediate' },
+      deliveryTiming: DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING,
     },
   ],
   destinations: [

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

@@ -0,0 +1,18 @@
+export const NOTIFICATION_GROUP_WINDOW_MS = 60 * 60_000;
+export const NOTIFICATION_GROUP_HOURLY_LIMIT = 10;
+const DIGEST_ITEM_LIMIT = 100;
+// Bound the whole preview so 100 entries fit within a Convex document.
+const DIGEST_PREVIEW_CHARACTERS = 1_000;
+
+type OverflowItem = { ruleKey: string; summary: string };
+
+export function appendGroupOverflowItem(
+  previous: readonly OverflowItem[],
+  item: OverflowItem,
+): OverflowItem[] {
+  const summary =
+    item.summary.length <= DIGEST_PREVIEW_CHARACTERS
+      ? item.summary
+      : `${item.summary.slice(0, DIGEST_PREVIEW_CHARACTERS - 1)}…`;
+  return [...previous, { ...item, summary }].slice(-DIGEST_ITEM_LIMIT);
+}

package/dist/bundling-sources/shared_libs/product-notifications/rolling-limit.ts

@@ -0,0 +1,24 @@
+export const NOTIFICATION_RULE_IMMEDIATE_LIMIT = 10;
+
+/** Admit below the rolling limit; otherwise anchor the digest to its oldest admission. */
+export function admitRollingNotification(
+  admittedAt: readonly number[],
+  now: number,
+  windowMs: number,
+  limit: number,
+): { admittedAt: number[]; digestAt: number | null } {
+  const history = [...admittedAt].sort((left, right) => left - right);
+  const inWindow = history.filter((time) => time > now - windowMs);
+  if (inWindow.length >= limit) {
+    return {
+      admittedAt: history,
+      digestAt: inWindow[inWindow.length - limit]! + windowMs,
+    };
+  }
+  return {
+    admittedAt: [...history, now]
+      .sort((left, right) => left - right)
+      .slice(-limit),
+    digestAt: null,
+  };
+}