deepline 0.3.451 → 0.3.453

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

@@ -1285,6 +1285,18 @@ export type MonitorsListOptions = {
  * plans, dependents) and it must not require an SDK bump to evolve.
  */
 export type MonitorCheckResult = Record<string, unknown>;
+
+export type MonitorPreviewOptions = {
+  /** Sample size, 1-3. The server default is 3. */
+  limit?: number;
+  /** Reuse to recover one preview's result; a new key is a new, paid preview. */
+  idempotencyKey?: string;
+};
+
+/** A preview's sample and charge, plus the key that identifies it. */
+export type MonitorPreviewResult = Record<string, unknown> & {
+  idempotency_key: string;
+};
 export type MonitorDeployResult = Record<string, unknown>;
 /** Field-level monitor capability spec returned by `client.monitors.get(...)`. */
 export type MonitorSpec = {
@@ -1868,6 +1880,15 @@ export type MonitorsNamespace = {
   ) => Promise<MonitorsAvailableResult>;
   /** Validate a monitor definition without deploying it (no spend). */
   check: (definition: MonitorDefinition) => Promise<MonitorCheckResult>;
+  /**
+   * Sample a few recent matches for a definition before deploying it. Spends
+   * Deepline credits per returned update. Reuse `idempotencyKey` to recover a
+   * lost result without paying again; omit it for a new preview.
+   */
+  preview: (
+    definition: MonitorDefinition,
+    options?: MonitorPreviewOptions,
+  ) => Promise<MonitorPreviewResult>;
   /** Deploy a monitor from a definition. May spend Deepline credits. */
   deploy: (
     definition: MonitorDefinition,
@@ -2850,6 +2871,8 @@ export class DeeplineClient {
       available: (toolIdOrOptions, options) =>
         this.getMonitorsAvailable(toolIdOrOptions, options),
       check: (definition) => this.checkMonitor(definition),
+      preview: (definition, options) =>
+        this.previewMonitor(definition, options),
       deploy: (definition, options) => this.deployMonitor(definition, options),
       sync: (definition, options) =>
         options?.dryRun
@@ -6686,6 +6709,48 @@ export class DeeplineClient {
     });
   }
 
+  /**
+   * Run one paid preview. Prefer `client.monitors.preview(...)`.
+   *
+   * The key is fixed before the request is sent and returned on the result
+   * and on any error (`error.idempotencyKey`), so a caller that loses the
+   * response can repeat the call with it and get the original result without
+   * a second charge. The submission is never replayed automatically.
+   */
+  async previewMonitor(
+    definition: MonitorDefinition,
+    options?: MonitorPreviewOptions,
+  ): Promise<MonitorPreviewResult> {
+    const idempotencyKey =
+      options?.idempotencyKey ??
+      `monitor-preview-${
+        globalThis.crypto?.randomUUID?.() ??
+        `${Date.now()}-${Math.random().toString(36).slice(2)}`
+      }`;
+    try {
+      const result = await this.http.request<Record<string, unknown>>(
+        '/api/v2/monitors/preview',
+        {
+          method: 'POST',
+          body: {
+            ...definition,
+            ...(options?.limit === undefined ? {} : { limit: options.limit }),
+          },
+          headers: { 'Idempotency-Key': idempotencyKey },
+          maxRetries: 0,
+          exactUrlOnly: true,
+          preserveRateLimitResponse: true,
+        },
+      );
+      return { ...result, idempotency_key: idempotencyKey };
+    } catch (error) {
+      if (error && typeof error === 'object') {
+        Object.assign(error, { idempotencyKey });
+      }
+      throw error;
+    }
+  }
+
   /**
    * Deploy a monitor from a definition. `dryRun` validates via the check
    * endpoint and returns the plan without deploying. Prefer

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

@@ -1036,7 +1036,8 @@ function isMonitorRateLimitEnvelope(parsed: unknown): boolean {
   const response = asRecord(parsed);
   const error = asRecord(response?.error);
   return (
-    error?.code === 'monitor_upstream_rate_limited' &&
+    (error?.code === 'monitor_upstream_rate_limited' ||
+      error?.code === 'monitor_preview_rate_limited') &&
     typeof error.message === 'string'
   );
 }

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

@@ -140,6 +140,8 @@ export type {
   LegacyMonitorStatusFilter,
   MonitorListEntry,
   MonitorCheckResult,
+  MonitorPreviewOptions,
+  MonitorPreviewResult,
   MonitorDeployResult,
   MonitorDetail,
   MonitorSpec,

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

@@ -205,7 +205,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.451',
+  version: '0.3.453',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-capability.ts

@@ -286,6 +286,15 @@ export type ProviderMonitorCapabilityDefinition = {
       maxIds: number;
       rateLimitId: string;
     };
+    /**
+     * Optional paid sample: a few recent matches for the definition being
+     * considered, with nothing created. Only payloads whose `payloadField`
+     * value is listed can be previewed; every other payload of this capability,
+     * and every capability without this field, has no preview. `action` must
+     * also appear in `supportActions`, which is what registers it for
+     * execution.
+     */
+    preview?: ProviderMonitorPreviewDescriptor;
     // Declares that this monitor delivers data to Deepline via an inbound
     // webhook callback (handled by the provider-callbacks route). Webhook
     // subscription monitors are inherently inbound; native monitors must set
@@ -349,6 +358,43 @@ const UNLOCKED_ENTITLEMENT_STATUS: ProviderMonitorCapabilityEntitlementStatus =
     locked: false,
   };
 
+export type ProviderMonitorPreviewDescriptor = {
+  action: string;
+  payloadField: string;
+  supportedValues: readonly string[];
+  defaultLimit: number;
+  maxLimit: number;
+};
+
+export type ProviderMonitorPreviewResolution =
+  | { available: true; descriptor: ProviderMonitorPreviewDescriptor }
+  | { available: false; reason: string };
+
+/**
+ * Whether this payload of this capability can be previewed. `null` means the
+ * capability declares no preview at all, so callers omit preview entirely
+ * rather than saying "unavailable" for every monitor.
+ */
+export function resolveProviderMonitorPreview(input: {
+  capability: Pick<
+    ProviderMonitorCapabilityDefinition,
+    'providerCapability' | 'runtime'
+  >;
+  payload: Record<string, unknown>;
+}): ProviderMonitorPreviewResolution | null {
+  const descriptor = input.capability.runtime.preview;
+  if (!descriptor) return null;
+  const value = input.payload[descriptor.payloadField];
+  if (typeof value === 'string' && descriptor.supportedValues.includes(value)) {
+    return { available: true, descriptor };
+  }
+  const label = typeof value === 'string' && value ? value : 'this payload';
+  return {
+    available: false,
+    reason: `Preview isn't available for ${label} yet. Run monitors check, then deploy.`,
+  };
+}
+
 export type ProviderMonitorCapabilitySerializable = {
   provider: string;
   tool: string;
@@ -381,6 +427,11 @@ export type ProviderMonitorCapabilitySerializable = {
     included_active_monitors?: number | null;
     reason?: string;
   };
+  /** Present only when the capability declares a paid preview. */
+  preview?: {
+    available_for: Record<string, string[]>;
+    max_limit: number;
+  };
   next_commands: string[];
 };
 
@@ -604,6 +655,18 @@ export function serializeProviderMonitorCapability(
         : {}),
       ...(entitlement.reason ? { reason: entitlement.reason } : {}),
     },
+    ...(capability.runtime.preview
+      ? {
+          preview: {
+            available_for: {
+              [capability.runtime.preview.payloadField]: [
+                ...capability.runtime.preview.supportedValues,
+              ],
+            },
+            max_limit: capability.runtime.preview.maxLimit,
+          },
+        }
+      : {}),
     next_commands: [],
   };
 }

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

@@ -303,7 +303,11 @@ function createPlayRuntimeRequire(): ReturnType<typeof createRequire> {
 }
 const WAIT_CONFIG_POLL_MS = 25;
 const WAIT_CONFIG_TIMEOUT_MS = 120_000;
-export const RUNNER_EXECUTION_ACK_TIMEOUT_MS = 75_000;
+// Outlasts the claim lease, because an unanswered heartbeat says nothing about
+// the park. A stall shorter than the lease keeps this sandbox, and a longer one
+// reaches the heartbeat loop's own guard and is reported as an outage.
+export const RUNNER_EXECUTION_ACK_TIMEOUT_MS =
+  (RUNTIME_RELIABILITY_POLICY.worker.claimLeaseSeconds + 30) * 1_000;
 const RUNNER_RUNTIME_CONTROL_MAX_ATTEMPTS =
   RUNTIME_RELIABILITY_POLICY.gateway.runnerControlMaxAttempts;
 const RUNNER_RUNTIME_CONTROL_RETRY_DELAYS_MS = [100, 250] as const;

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -37,6 +37,12 @@ const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
 const DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS = [
   0, 1_000, 3_000, 6_000, 12_000, 24_000, 36_000,
 ] as const;
+// A reservation can outlive a create that was refused, or one never sent because
+// the scheduler stalled between committing the reservation and acknowledging it.
+// This delay lets a healthy owner finish its create and reconcile ladder first.
+// It is not a fence: a stalled owner can outlast it, so name uniqueness and the
+// attempt fences on abandon and promotion keep custody safe.
+const DAYTONA_ABSENT_OPERATION_RECREATE_AFTER_MS = 3 * 60_000;
 // Explicit runner deadline + scheduler GC own the normal lifecycle. Daytona's
 // inactivity stop is a wider crash backstop measured from sandbox creation, so
 // setup time cannot consume the terminal-flush grace.
@@ -671,6 +677,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
     leaseId: string;
     providerOperationToken: string | null;
     resumeExistingProviderOperation?: boolean;
+    existingProviderOperationAgeMs?: number;
   }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
@@ -700,6 +707,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
     });
     const reservation = await input.reserveSandboxCapacity?.(attempt);
     const sandboxName = daytonaSandboxName(reservation?.providerOperationToken);
+    let recreatedAfter: TimedOutDaytonaSandboxReconcileObserved | null = null;
     if (reservation?.resumeExistingProviderOperation) {
       if (!reservation.providerOperationToken) {
         throw new DaytonaSandboxTransitionPendingError(sandboxName);
@@ -740,17 +748,32 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         );
       }
       // Neither absence nor an ongoing transition proves that create cannot
-      // commit. Retain the durable identity and its capacity reservation. The
-      // detail only records which of the two Daytona reported, for the log.
-      throw new DaytonaSandboxTransitionPendingError(
-        sandboxName,
-        daytonaTransitionPendingLogDetail({
-          phase: 'resume',
-          observed: reconciliation.observed,
-          providerAttempt: attempt,
-          launchOutcome: null,
-        }),
-      );
+      // commit, so inside the create window retain the durable identity and
+      // its capacity reservation. The detail only records which of the two
+      // Daytona reported, for the log.
+      const operationAgeMs = reservation.existingProviderOperationAgeMs ?? 0;
+      if (
+        reconciliation.observed.last.lookup !== 'not_found' ||
+        operationAgeMs < DAYTONA_ABSENT_OPERATION_RECREATE_AFTER_MS
+      ) {
+        throw new DaytonaSandboxTransitionPendingError(
+          sandboxName,
+          daytonaTransitionPendingLogDetail({
+            phase: 'resume',
+            observed: reconciliation.observed,
+            providerAttempt: attempt,
+            launchOutcome: null,
+          }),
+        );
+      }
+      // Daytona's own name uniqueness fences this: the same identity under the
+      // same reservation cannot become a second sandbox. A create that lands
+      // first surfaces as a conflict, which the reconcile below adopts by name.
+      input.emitStage('create:recreate_absent_operation', {
+        attempt,
+        operationAgeMs,
+      });
+      recreatedAfter = reconciliation.observed;
     }
     let sandbox: DaytonaSandbox;
     try {
@@ -895,6 +918,20 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           { cause: error },
         );
       }
+      if (recreatedAfter) {
+        // Refusing this send says nothing about an earlier send of the identity,
+        // so keep its reservation and resume the same name.
+        await recordCreateFailure();
+        throw new DaytonaSandboxTransitionPendingError(
+          sandboxName,
+          daytonaTransitionPendingLogDetail({
+            phase: 'resume',
+            observed: recreatedAfter,
+            providerAttempt: attempt,
+            launchOutcome: null,
+          }),
+        );
+      }
       if (reservation) {
         await input.releaseSandboxCapacity?.(reservation.leaseId);
       }
@@ -1098,6 +1135,7 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
     leaseId: string;
     providerOperationToken: string | null;
     resumeExistingProviderOperation?: boolean;
+    existingProviderOperationAgeMs?: number;
   }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   startAdmission?: DaytonaSandboxStartAdmission;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/contract.ts

@@ -245,6 +245,8 @@ export type SandboxExecutionAdmission = {
         providerOperationToken?: string | null;
         /** Resume the existing durable provider operation before any new create. */
         resumeExistingProviderOperation?: boolean;
+        /** Scheduler-clock age of the operation being resumed. */
+        existingProviderOperationAgeMs?: number;
       }
     | { kind: 'pre_code_deferred'; reason: SandboxPreCodeDeferralReason }
   >;
@@ -310,6 +312,8 @@ export type SandboxExecutionLifecycle = {
         providerOperationToken?: string | null;
         /** Resume the existing durable provider operation before any new create. */
         resumeExistingProviderOperation?: boolean;
+        /** Scheduler-clock age of the operation being resumed. */
+        existingProviderOperationAgeMs?: number;
       }
     | { kind: 'pre_code_deferred'; reason: SandboxPreCodeDeferralReason }
   >;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/runner-backend-adapter.ts

@@ -188,6 +188,12 @@ function createRunnerCallbacks(input: {
         ...(outcome.resumeExistingProviderOperation === true
           ? { resumeExistingProviderOperation: true }
           : {}),
+        ...(outcome.existingProviderOperationAgeMs === undefined
+          ? {}
+          : {
+              existingProviderOperationAgeMs:
+                outcome.existingProviderOperationAgeMs,
+            }),
       };
     },
     releaseSandboxCapacity: async (leaseId) => {

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -4338,13 +4338,15 @@ async function executeAssignedAbsurdAttempt(input: {
                     providerOperationToken: reserved.providerOperationToken,
                     resumeExistingProviderOperation:
                       reserved.resumeExistingProviderOperation,
+                    existingProviderOperationAgeMs:
+                      reserved.existingProviderOperationAgeMs,
                   };
                 },
                 async releaseCapacity({ leaseId }) {
                   await deps.runWithClient((client) =>
                     abandonRuntimeSandboxOperationReservation(
                       client,
-                      { operationKey: leaseId },
+                      { operationKey: leaseId, attempt: generation },
                       options,
                     ),
                   );

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/runtime-sandbox-capacity.ts

@@ -286,6 +286,11 @@ export async function reserveRuntimeSandboxCapacityLease(
       activeLeases: number;
       wouldDefer: boolean;
       resumeExistingProviderOperation: boolean;
+      /**
+       * Database-clock age of a resumed operation. Absent on a same-key race and
+       * once the lease expires, when a new sandbox could no longer be promoted.
+       */
+      existingProviderOperationAgeMs?: number;
     }
   | { granted: false; limit: number; activeLeases: number }
 > {
@@ -316,6 +321,7 @@ export async function reserveRuntimeSandboxCapacityLease(
       provider_operation_token: string | null;
       attempt: number;
       environment: 'preview' | 'production';
+      age_ms: number | null;
     }>;
     existing_operation: {
       org_id: string;
@@ -361,7 +367,10 @@ export async function reserveRuntimeSandboxCapacityLease(
           SELECT jsonb_agg(pending)
           FROM (
             SELECT lease.lease_id, operation.provider_operation_token,
-                   operation.attempt, operation.environment
+                   operation.attempt, operation.environment,
+                   CASE WHEN lease.expires_at > clock_timestamp() THEN
+                     extract(epoch FROM clock_timestamp() - operation.created_at) * 1000
+                   END AS age_ms
             FROM ${operations} AS operation
             JOIN ${leases} AS lease ON lease.lease_id = operation.operation_key
             WHERE $6::boolean
@@ -503,6 +512,9 @@ export async function reserveRuntimeSandboxCapacityLease(
         activeLeases,
         wouldDefer,
         resumeExistingProviderOperation: true,
+        ...(pendingOperation.age_ms === null
+          ? {}
+          : { existingProviderOperationAgeMs: Number(pendingOperation.age_ms) }),
       };
     }
   }
@@ -874,7 +886,8 @@ export async function releaseRuntimeSandboxCapacityLease(
  */
 export async function abandonRuntimeSandboxOperationReservation(
   client: PostgresSchedulerQueryClient,
-  input: { operationKey: string },
+  /** With `attempt`, an operation a newer attempt has adopted is left alone. */
+  input: { operationKey: string; attempt?: number },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<boolean> {
   const { leases, operations, runs } = schemaTables(options);
@@ -899,6 +912,7 @@ export async function abandonRuntimeSandboxOperationReservation(
             updated_at = clock_timestamp()
         WHERE operation.operation_key = $1
           AND operation.state = $3
+          AND ($4::integer IS NULL OR operation.attempt <= $4)
           AND EXISTS (SELECT 1 FROM eligible_lease)
         RETURNING operation.operation_key
       ), released AS (
@@ -915,6 +929,7 @@ export async function abandonRuntimeSandboxOperationReservation(
       assertId(input.operationKey, 'operationKey'),
       RuntimeSandboxOperationState.Abandoned,
       RuntimeSandboxOperationState.Reserved,
+      input.attempt ?? null,
     ],
   );
   return result.rows.length === 1;

package/dist/cli/{auth-YLBWEMRW.mjs → auth-6CXS55CN.mjs}

@@ -13,13 +13,13 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-BJOVX7EB.mjs";
-import "./chunk-XLOXUW5Y.mjs";
-import "./chunk-PJYTV24I.mjs";
+} from "./chunk-7557D4FM.mjs";
+import "./chunk-FS2RMEJ7.mjs";
+import "./chunk-X2LUT22I.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-ZPV7DMAA.mjs";
+import "./chunk-IXVABCNA.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-AICIA232.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkRNCIPLU5js = require('./chunk-RNCIPLU5.js');
+require('./chunk-WTTHH2K3.js');
+require('./chunk-RTR2KUU6.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-RG644LJU.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkRNCIPLU5js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkRNCIPLU5js.authStatusLine; exports.clearPendingClaim = _chunkRNCIPLU5js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkRNCIPLU5js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkRNCIPLU5js.handleRegister; exports.handleStatus = _chunkRNCIPLU5js.handleStatus; exports.handleWait = _chunkRNCIPLU5js.handleWait; exports.httpJson = _chunkRNCIPLU5js.httpJson; exports.readPendingAuthClaim = _chunkRNCIPLU5js.readPendingAuthClaim; exports.readStatusBanner = _chunkRNCIPLU5js.readStatusBanner; exports.registerAuthCommands = _chunkRNCIPLU5js.registerAuthCommands; exports.reportSetupCompleted = _chunkRNCIPLU5js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkRNCIPLU5js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkRNCIPLU5js.statusBannerLine;