deepline 0.3.459 → 0.3.461

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.459',
+  version: '0.3.461',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/monitors/billing/state.ts

@@ -285,6 +285,34 @@ export function monitorBillingStateWithProviderRenewal(input: {
   };
 }
 
+/**
+ * An active, paid provider subscription that no renewal pass can ever select.
+ *
+ * Subscription renewal ranges only on the indexed `cancelBeforeAt` copy, and a
+ * periodic renewal only on `nextRenewalAt`. A paid monitor that carries a
+ * provider-subscription receipt (`provider_next_charge_at` or
+ * `cancel_before_at` in its billing JSON) but neither indexed anchor is never
+ * charged again while the provider keeps billing Deepline (KAR-103). Only a
+ * subscription can carry that receipt: an update-priced create refuses a
+ * provider `next_charge_at` outright, so the receipt is the discriminator and
+ * no billing-policy lookup is needed here.
+ */
+export function paidSubscriptionLacksRenewalAnchor(row: {
+  status: string;
+  cancelBeforeAt?: string | null;
+  nextRenewalAt?: string | null;
+  billingState: unknown;
+}): boolean {
+  if (row.status !== 'active') return false;
+  if (row.cancelBeforeAt || row.nextRenewalAt) return false;
+  const state = parseStoredMonitorBillingState(row.billingState);
+  if (state.state !== 'active' && state.state !== 'billing_pending') {
+    return false;
+  }
+  if (state.lifecycle_charge_credits <= 0) return false;
+  return Boolean(state.provider_next_charge_at || state.cancel_before_at);
+}
+
 export function defaultMonitorBillingState(): StoredMonitorBillingState {
   return {
     state: 'billing_pending',

package/dist/bundling-sources/shared_libs/monitors/signal-radars/inbound-dead-letter.ts

@@ -1,6 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { isRepairableTenantDataPlaneError } from '@deepline/ingestion-v2/tenant-data-plane-errors';
 import type { SignalRadarInboundMessage } from '@deepline/monitors/signal-radars/inbound-message';
+import {
+  hasMonitorSdkValidationIssues,
+  MONITOR_SDK_VALIDATION_ERROR_CODE,
+} from '@deepline/monitors/validation';
 
 // Minimal pg client seam shared with the ingestion stack: a `query(sql, args)`
 // that returns `{ rows }`. Deliberately structural so PGlite (tests) and the
@@ -73,8 +77,28 @@ export function classifyInboundFailure(error: unknown): InboundFailureClass {
   ]);
   if (code && transientCodes.has(code)) return 'transient';
 
+  // A lifecycle fence is temporary contention, including while recording a
+  // billing suspension. Preserve the callback until its owner finishes; do
+  // not classify unrelated validation failures as retryable.
+  if (
+    code === MONITOR_SDK_VALIDATION_ERROR_CODE &&
+    hasMonitorSdkValidationIssues(error) &&
+    error.issues.length > 0 &&
+    error.issues.every(
+      (issue) =>
+        issue?.code === 'provider_monitor_operation_in_progress' ||
+        issue?.code === 'provider_monitor_delete_in_progress',
+    )
+  ) {
+    return 'transient';
+  }
+
   const message = errorMessage(error);
   const transientPatterns = [
+    // pg reports subsequent operations on a client whose connection failed
+    // without retaining the original socket error's code. A fresh delivery
+    // acquires a usable client; this is infrastructure failure, not poison.
+    /client has encountered a connection error and is not queryable/i,
     /connection (?:terminated|refused|reset|closed|failure)/i,
     /could not connect to server/i,
     /connection to server .* failed/i,

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

@@ -250,6 +250,7 @@ import {
   parseToolExecuteExactProviderRetryAtMs,
   parseToolExecuteAuthScopeChangedError,
   ToolExecuteAuthScopeChangedError,
+  toolExecuteBillingRetryIdentity,
   type ToolExecuteHttpFailureOutcome,
 } from './tool-execute-retry-policy';
 import {
@@ -18917,11 +18918,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               ? savedProviderRetryCursor?.legacyProviderOperationForceRefreshIdentities
               : options?.providerOperationForceRefreshIdentities;
           const executionRequestNonce = crypto.randomUUID();
-          // Transport ambiguity must retain the billing identity. An ordinary
-          // (unfenced) call advances it after a definite rejection released
-          // that attempt's reservation. A proven app pacing refusal also
-          // renews fenced billing attribution, keeping its invocation and
-          // provider-operation identities unchanged. Ambiguous deliveries retain it.
+          // Transport ambiguity must retain the billing identity. Only a
+          // definite release of the reservation renews it; see
+          // toolExecuteBillingRetryIdentity.
           let deeplineRequestId = `ctx-tool-${stableDigest(executionRequestNonce).slice(0, 32)}`;
           // The provider operation has a semantic identity independent of
           // the response receipt. Its key is supplied by the caller that owns
@@ -20786,21 +20785,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   remainingProviderWaitMs !== null,
                 );
                 logProvider429RetryPhase('retry_sleep_completed');
-                if (
-                  failure.reason === 'provider_pacing_wait' ||
-                  (!usesDurableInvocationFence &&
-                    (failure.backpressureDelayMs !== null ||
-                      (failure.reason === 'rate_limit' &&
-                        failure.knownNotDispatched)))
-                ) {
-                  // These refusals release the prior reservation. App pacing
-                  // does not advance invocationAttempt, so use its own HTTP
-                  // failure count to avoid reusing a released retry reservation.
-                  // Durable result and provider-operation keys stay unchanged.
-                  const billingRetryIdentity =
-                    failure.reason === 'provider_pacing_wait'
-                      ? `app-pacing-refusal:${httpFailureAttempt}`
-                      : `provider-rate-limit-retry:${invocationAttempt}`;
+                const billingRetryIdentity = toolExecuteBillingRetryIdentity({
+                  failure,
+                  executionFenced: usesDurableInvocationFence,
+                  httpFailureAttempt,
+                  invocationAttempt,
+                });
+                if (billingRetryIdentity) {
                   deeplineRequestId = `ctx-tool-${stableDigest(`${executionRequestNonce}:${billingRetryIdentity}`).slice(0, 32)}`;
                 }
                 this.emitExecutionEvent({

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/receipt-gateway.ts

@@ -204,6 +204,65 @@ export type RuntimeGatewayFailureContext = {
   operation?: 'receipt' | 'runtime_sheet' | 'runtime_durability';
 };
 
+export type RuntimeSheetPersistenceDiagnostics = {
+  sqlState?: string;
+  transportCode?: string;
+};
+
+const RUNTIME_SHEET_SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+const RUNTIME_SHEET_TRANSPORT_CODES = new Set([
+  'ECONNABORTED',
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'EHOSTDOWN',
+  'EHOSTUNREACH',
+  'EPIPE',
+  'ENETUNREACH',
+  'ENOTFOUND',
+  'ETIMEDOUT',
+  'EAI_AGAIN',
+]);
+
+export function isRuntimeSheetSqlState(value: unknown): value is string {
+  return (
+    typeof value === 'string' && RUNTIME_SHEET_SQLSTATE_PATTERN.test(value)
+  );
+}
+
+export function isRuntimeSheetTransportCode(value: unknown): value is string {
+  return typeof value === 'string' && RUNTIME_SHEET_TRANSPORT_CODES.has(value);
+}
+
+export function runtimeSheetPersistenceDiagnostics(
+  error: unknown,
+): RuntimeSheetPersistenceDiagnostics {
+  const diagnostics: RuntimeSheetPersistenceDiagnostics = {};
+  const seen = new Set<object>();
+  let current: unknown = error;
+
+  for (let depth = 0; depth < 8; depth += 1) {
+    if (current === null || typeof current !== 'object' || seen.has(current))
+      break;
+    seen.add(current);
+    let code: unknown;
+    let cause: unknown;
+    try {
+      const candidate = current as { code?: unknown; cause?: unknown };
+      code = candidate.code;
+      cause = candidate.cause;
+    } catch {
+      break;
+    }
+    if (!diagnostics.sqlState && isRuntimeSheetSqlState(code))
+      diagnostics.sqlState = code;
+    if (!diagnostics.transportCode && isRuntimeSheetTransportCode(code))
+      diagnostics.transportCode = code;
+    current = cause;
+  }
+
+  return diagnostics;
+}
+
 export function receiptGatewayFailureResponse(
   error: unknown,
   context: RuntimeGatewayFailureContext = {},
@@ -296,6 +355,10 @@ export function receiptGatewayFailureResponse(
     redactLedgerString(error instanceof Error ? error.message : error) ??
     'Unknown runtime gateway failure.';
   const headerDetail = detail.replace(/[\r\n]+/g, ' ').slice(0, 500);
+  const persistenceDiagnostics =
+    context.operation === 'runtime_sheet'
+      ? runtimeSheetPersistenceDiagnostics(error)
+      : {};
   const unavailableDetail = transientServiceUnavailableDetail(error);
   if (unavailableDetail) {
     return receiptGatewayJsonResponse(
@@ -349,6 +412,15 @@ export function receiptGatewayFailureResponse(
       headers: {
         'x-deepline-error-code': failure.code,
         'x-deepline-error-detail': headerDetail,
+        ...(persistenceDiagnostics.sqlState
+          ? { 'x-deepline-error-sqlstate': persistenceDiagnostics.sqlState }
+          : {}),
+        ...(persistenceDiagnostics.transportCode
+          ? {
+              'x-deepline-error-transport-code':
+                persistenceDiagnostics.transportCode,
+            }
+          : {}),
       },
     },
   );

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -278,8 +278,44 @@ export type ToolExecuteHttpFailureOutcome = ToolExecuteHttpRetryDecision & {
   chargeRetryBudget: boolean;
   /** The response proves the provider request was never dispatched. */
   knownNotDispatched: boolean;
+  /** The response proves this attempt's billing reservation was released. */
+  billingReservationReleased: boolean;
 };
 
+/**
+ * The billing identity a retry must use instead of its current one, or null to
+ * keep it. Admission never reopens a released reservation, so each renewal
+ * follows a refusal that released one. Invocation and provider-operation
+ * identities never change here; ambiguous deliveries keep their identity.
+ */
+export function toolExecuteBillingRetryIdentity(input: {
+  failure: Pick<
+    ToolExecuteHttpFailureOutcome,
+    | 'reason'
+    | 'backpressureDelayMs'
+    | 'knownNotDispatched'
+    | 'billingReservationReleased'
+  >;
+  executionFenced: boolean;
+  httpFailureAttempt: number;
+  invocationAttempt: number;
+}): string | null {
+  const { failure } = input;
+  // App pacing does not advance the invocation attempt, so it counts failures.
+  if (failure.reason === 'provider_pacing_wait') {
+    return `app-pacing-refusal:${input.httpFailureAttempt}`;
+  }
+  if (input.executionFenced) {
+    return failure.billingReservationReleased
+      ? `transient-retry:${input.httpFailureAttempt}`
+      : null;
+  }
+  return failure.backpressureDelayMs !== null ||
+    (failure.reason === 'rate_limit' && failure.knownNotDispatched)
+    ? `provider-rate-limit-retry:${input.invocationAttempt}`
+    : null;
+}
+
 export type ToolExecuteHttpFailureAttemptTracker = {
   next(input: {
     toolId: string;
@@ -804,11 +840,13 @@ export function classifyToolExecuteHttpFailure(input: {
   // 429; ordinary pacing denials retain their established retry semantics.
   const failureBody = parseJsonObject(input.bodyText);
   const flatPublicDetails = failureBody?.details;
+  const providerOriginFailure =
+    error instanceof ToolExecutionError
+      ? error.origin === 'provider'
+      : failureBody?.failure_origin === 'provider';
   const acceptedOperationNeedsRecovery =
     explicitRetryable === false &&
-    (error instanceof ToolExecutionError
-      ? error.origin === 'provider'
-      : failureBody?.failure_origin === 'provider') &&
+    providerOriginFailure &&
     ((error instanceof ToolExecutionError &&
       error.publicDetails?.operationAccepted === true) ||
       (flatPublicDetails !== null &&
@@ -910,6 +948,16 @@ export function classifyToolExecuteHttpFailure(input: {
       retryDecision.reason !== 'concurrency_backpressure' &&
       retryDecision.reason !== 'runtime_scheduler_capacity' &&
       retryDecision.reason !== 'provider_pacing_wait',
+    // The app reported a provider failure and asked for a retry, so it has
+    // already released that attempt's reservation, and admission never reopens
+    // one. BILLING_UNAVAILABLE may follow an authorization whose response was
+    // lost, and an edge failure or unexplained 5xx proves nothing: all three
+    // keep their identity so a retry recovers the existing reservation.
+    billingReservationReleased:
+      shouldRetry &&
+      retryDecision.reason === 'retry_safe_transient_5xx' &&
+      explicitRetryable === true &&
+      providerOriginFailure,
     // Only explicit pre-dispatch refusals permit automatic replay of an
     // operation that does not declare ordinary transient retry safety.
     knownNotDispatched:

package/dist/bundling-sources/shared_libs/play-runtime/tool-http-errors.ts

@@ -323,7 +323,11 @@ function formatHardBillingFailureMessage(input: {
     getStringField(input.billing, 'message') ??
     getStringField(input.billing, 'error') ??
     'Deepline billing cap exceeded.';
-  const headline = 'Deepline billing cap exceeded.';
+  // A closed reservation is not a spending limit; the customer has nothing to raise.
+  const headline =
+    code === 'BILLING_RESERVATION_NOT_OPEN'
+      ? 'Deepline billing reservation closed.'
+      : 'Deepline billing cap exceeded.';
   return `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${headline} Run halted before marking remaining rows processed. ${code ? `code=${code}. ` : ''}${message}`;
 }
 

package/dist/cli/{auth-2RM2ZC6E.mjs → auth-6HJXNWUG.mjs}

@@ -13,13 +13,13 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-ZAJAGMXA.mjs";
-import "./chunk-Y35FCRLQ.mjs";
-import "./chunk-7AGGDRNR.mjs";
+} from "./chunk-MEAIOXJL.mjs";
+import "./chunk-QAJAJPKK.mjs";
+import "./chunk-RY4IVOU3.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-OQW2YP3P.mjs";
+import "./chunk-T3MVIPHG.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-IACERYQH.js

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