deepline 0.2.9 → 0.2.11

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

@@ -902,6 +902,66 @@ export type BillingInvoicesResult = {
   entries: BillingInvoiceEntry[];
 };
 
+export type TargetBillingOperation = {
+  id: string;
+  state: string;
+  version: number;
+  next_action?: string | null;
+};
+
+export type TargetBillingPlan = {
+  sku: 'payg-v1' | 'builder-v1' | 'team-v1';
+  name: string;
+  recurring_price_usd: number;
+  interval: 'month';
+  included_credits: number;
+  purchased_credit_price_usd: number;
+};
+
+export type TargetBillingPlansResult = {
+  org_id: string;
+  plans: TargetBillingPlan[];
+  current_plan_sku: string;
+  pending_plan_sku: string | null;
+  acquisition_enabled: boolean;
+};
+
+export type TargetBillingStatusResult = {
+  org_id: string;
+  plan: {
+    sku: string;
+    name: string;
+    recurring_price_usd: number | null;
+    interval: string | null;
+    included_credits: number | null;
+  };
+  state: string;
+  changes_allowed: boolean;
+  payment_state: string;
+  recharge_state: string;
+  next_action: string | null;
+  pending_plan_sku: string | null;
+  as_of: string | null;
+};
+
+export type TargetBillingMutationResult = {
+  data: Record<string, unknown>;
+  operation: TargetBillingOperation;
+  request_id?: string;
+};
+
+export type TargetBillingPlanTransitionOptions =
+  | {
+      action: 'start_or_change';
+      targetPlanSku: 'payg-v1' | 'builder-v1' | 'team-v1';
+      idempotencyKey: string;
+    }
+  | {
+      action: 'cancel' | 'undo_cancel';
+      targetPlanSku?: never;
+      idempotencyKey: string;
+    };
+
 /** Saved payment method details returned by one-click billing top-up. */
 export type BillingPaymentMethodSummary = {
   brand?: string | null;
@@ -977,9 +1037,8 @@ export type BillingPlansResult = {
 /**
  * Public billing namespace exposed as `client.billing`.
  *
- * Carries the durable Deepline billing product model — plans, subscription
- * state, period-end cancellation, and invoice/receipt history — so CLI
- * commands and programmatic callers share the same surface.
+ * Carries plans, subscription state, cancellation, and invoice/receipt history
+ * so CLI commands and programmatic callers share one surface.
  *
  * @sdkReference client 030 client.billing
  */
@@ -1006,8 +1065,39 @@ export type BillingNamespace = {
     /** Subscription invoices plus credit purchase receipts, newest first. */
     list: (options?: { limit?: number }) => Promise<BillingInvoicesResult>;
   };
+  /** Metronome-authored target catalog and current Contract projection. */
+  targetPlans: () => Promise<TargetBillingPlansResult>;
+  /** Normalized target billing state. */
+  targetStatus: () => Promise<TargetBillingStatusResult>;
+  /** Buy Deepline credits through a payment-gated Metronome commit. */
+  purchaseCredits: (options: {
+    credits: number;
+    idempotencyKey: string;
+  }) => Promise<TargetBillingMutationResult>;
+  /** Start, change, cancel, or undo a target plan transition. */
+  transitionPlan: (
+    options: TargetBillingPlanTransitionOptions,
+  ) => Promise<TargetBillingMutationResult>;
+  /** Create a Stripe-hosted billing Portal session. */
+  portalSession: () => Promise<{ url: string }>;
 };
 
+function requireTargetBillingIdempotencyKey(value: string): string {
+  const normalized = value.trim();
+  if (
+    normalized.length === 0 ||
+    normalized.length > 200 ||
+    normalized !== value
+  ) {
+    throw new DeeplineError(
+      'Billing idempotencyKey must contain 1–200 characters with no leading or trailing whitespace.',
+      undefined,
+      'INVALID_BILLING_IDEMPOTENCY_KEY',
+    );
+  }
+  return normalized;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -1495,6 +1585,11 @@ export class DeeplineClient {
       invoices: {
         list: (options) => this.listBillingInvoices(options),
       },
+      targetPlans: () => this.getTargetBillingPlans(),
+      targetStatus: () => this.getTargetBillingStatus(),
+      purchaseCredits: (options) => this.purchaseTargetBillingCredits(options),
+      transitionPlan: (options) => this.transitionTargetBillingPlan(options),
+      portalSession: () => this.createTargetBillingPortalSession(),
     };
     this.monitors = {
       status: () => this.getMonitorsAccess(),
@@ -4016,6 +4111,67 @@ export class DeeplineClient {
     );
   }
 
+  /** List the reviewed target plans and whether new acquisition is enabled. */
+  async getTargetBillingPlans(): Promise<TargetBillingPlansResult> {
+    return this.http.get<TargetBillingPlansResult>('/api/v2/billing/plans');
+  }
+
+  /** Read the workspace's normalized target plan, payment, and balance state. */
+  async getTargetBillingStatus(): Promise<TargetBillingStatusResult> {
+    return this.http.get<TargetBillingStatusResult>('/api/v2/billing/status');
+  }
+
+  /**
+   * Purchase target-billing credits through the durable commercial operation
+   * flow. The caller supplies an idempotency key for safe retries.
+   */
+  async purchaseTargetBillingCredits(options: {
+    credits: number;
+    idempotencyKey: string;
+  }): Promise<TargetBillingMutationResult> {
+    const idempotencyKey = requireTargetBillingIdempotencyKey(
+      options.idempotencyKey,
+    );
+    return this.http.post<TargetBillingMutationResult>(
+      '/api/v2/billing/credit-purchases',
+      { credits: options.credits },
+      { 'Idempotency-Key': idempotencyKey },
+      { maxRetries: 0, exactUrlOnly: true },
+    );
+  }
+
+  /**
+   * Start, change, cancel, or restore a target plan through one idempotent
+   * commercial operation.
+   */
+  async transitionTargetBillingPlan(
+    options: TargetBillingPlanTransitionOptions,
+  ): Promise<TargetBillingMutationResult> {
+    const idempotencyKey = requireTargetBillingIdempotencyKey(
+      options.idempotencyKey,
+    );
+    return this.http.post<TargetBillingMutationResult>(
+      '/api/v2/billing/plan-transitions',
+      {
+        action: options.action,
+        ...(options.targetPlanSku
+          ? { target_plan_sku: options.targetPlanSku }
+          : {}),
+      },
+      { 'Idempotency-Key': idempotencyKey },
+      { maxRetries: 0, exactUrlOnly: true },
+    );
+  }
+
+  /** Create a Stripe-hosted portal session for payment recovery and invoices. */
+  async createTargetBillingPortalSession(): Promise<{ url: string }> {
+    const response = await this.http.post<{
+      data: { url: string };
+      request_id?: string;
+    }>('/api/v2/billing/portal-sessions', {});
+    return response.data;
+  }
+
   // ——————————————————————————————————————————————————————————
   // Monitors
   // ——————————————————————————————————————————————————————————

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.9',
+  version: '0.2.11',
   contracts: {
     api: {
       name: 'sdk-http-api',

package/dist/bundling-sources/shared_libs/play-runtime/activity-observation.ts

@@ -328,6 +328,7 @@ type ProjectionStep = {
   nodeId: string;
   status?: string;
   label?: string;
+  artifactTableNamespace?: string | null;
   updatedAt?: number | null;
   progress?: PlayActivityProgress | null;
 };
@@ -490,6 +491,19 @@ export function projectPlayRunActivity(input: {
     )
     .sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
   if (pendingDataset) {
+    const activeDatasetStep = input.nodeStates?.find(
+      (candidate) =>
+        candidate.nodeId === input.activeNodeId &&
+        candidate.status === 'running' &&
+        candidate.artifactTableNamespace === pendingDataset.tableNamespace,
+    );
+    const datasetStep =
+      activeDatasetStep ??
+      input.nodeStates?.find(
+        (candidate) =>
+          candidate.artifactTableNamespace === pendingDataset.tableNamespace,
+      );
+    const datasetProgress = datasetStep?.progress ?? null;
     return projection(
       {
         schemaVersion: 1,
@@ -502,17 +516,20 @@ export function projectPlayRunActivity(input: {
         state: {
           kind: 'active',
           progress: {
-            completed: pendingDataset.persistedRows,
+            completed:
+              datasetProgress?.completed ?? pendingDataset.persistedRows,
             total:
-              typeof pendingDataset.succeededRows === 'number' ||
+              datasetProgress?.total ??
+              (typeof pendingDataset.succeededRows === 'number' ||
               typeof pendingDataset.failedRows === 'number'
                 ? (pendingDataset.succeededRows ?? 0) +
                   (pendingDataset.failedRows ?? 0)
-                : undefined,
-            failed: pendingDataset.failedRows,
+                : undefined),
+            failed: datasetProgress?.failed ?? pendingDataset.failedRows,
           },
         },
-        observedAt: pendingDataset.updatedAt ?? observedAt,
+        observedAt:
+          datasetStep?.updatedAt ?? pendingDataset.updatedAt ?? observedAt,
       },
       now,
     );

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

@@ -367,17 +367,8 @@ function isRetryableAppRuntimeResponse(input: {
   // The app runtime may explicitly classify an otherwise-client-error status
   // as transient. Keep the structured delivery contract authoritative rather
   // than reducing every 4xx to permanent at the worker boundary.
-  try {
-    const parsed = JSON.parse(input.body) as unknown;
-    if (
-      parsed &&
-      typeof parsed === 'object' &&
-      !Array.isArray(parsed) &&
-      (parsed as { retryable?: unknown }).retryable === true
-    ) {
-      return true;
-    }
-  } catch {}
+  const explicitRetryable = appRuntimeExplicitRetryable(input.body);
+  if (explicitRetryable !== null) return explicitRetryable;
   if (
     input.action === 'append_run_events' &&
     input.status === 500 &&
@@ -391,6 +382,19 @@ function isRetryableAppRuntimeResponse(input: {
   return isRetryableAppRuntimeResponseStatus(input.status);
 }
 
+function appRuntimeExplicitRetryable(body: string): boolean | null {
+  try {
+    const parsed = JSON.parse(body) as unknown;
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return null;
+    }
+    const retryable = (parsed as { retryable?: unknown }).retryable;
+    return typeof retryable === 'boolean' ? retryable : null;
+  } catch {
+    return null;
+  }
+}
+
 function isRetryableAppRuntimeResponseStatus(status: number): boolean {
   return (
     status === 429 ||
@@ -1158,15 +1162,14 @@ async function postAppRuntimeApi<TResponse>(
       status: response.status,
       code,
       requestId,
-      // Immediate request retries are intentionally selective, but durable
-      // delivery must never classify an unrecognized upstream 5xx as poison.
-      retryable:
-        response.status >= 500 ||
-        isRetryableAppRuntimeResponse({
-          action: body.action,
-          status: response.status,
-          body: responseText,
-        }),
+      // The structured response is authoritative even for a 5xx. Retrying an
+      // explicitly deterministic database failure here turns one rejected SQL
+      // statement into an unbounded outer-writer loop.
+      retryable: isRetryableAppRuntimeResponse({
+        action: body.action,
+        status: response.status,
+        body: responseText,
+      }),
       detail: summarizeAppRuntimeErrorBody(responseText),
       boundaryLabel,
     });