deepline 0.3.59 → 0.3.61

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

@@ -2057,6 +2057,9 @@ export class DeeplineClient {
       currentPublishedVersion:
         play.currentPublishedVersion ?? play.liveRevision?.version ?? null,
       latestRunId: play.latestRunId ?? detail.latestRuns[0]?.workflowId ?? null,
+      ...(play.triggerMetadata
+        ? { triggerMetadata: play.triggerMetadata }
+        : {}),
       ...(play.runtimeLimit ? { runtimeLimit: play.runtimeLimit } : {}),
       ...(play.activeScheduledPlays
         ? { activeScheduledPlays: play.activeScheduledPlays }

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

@@ -94,6 +94,27 @@ export type ProjectPinTarget =
       candidates: string[];
     };
 
+/**
+ * Where the CLI obtained the credentials for the current invocation.
+ *
+ * This is provenance only. SDK consumers may intentionally use host-level
+ * credentials, so CLI-only safety policy must be enforced by the CLI command
+ * dispatcher rather than by {@link resolveConfig}.
+ */
+export type CliAuthProvenance = {
+  scope: 'env' | 'folder' | 'global';
+  project:
+    | {
+        state: 'project';
+        dir: string;
+        pinPath: string;
+        source: 'marker' | 'cowork' | 'folder';
+      }
+    | { state: 'not_project' }
+    | { state: 'ambiguous_cowork_project'; candidates: string[] };
+  folderAuthPath: string | null;
+};
+
 /**
  * Convert a base URL to a filesystem-safe slug for per-host config storage.
  *
@@ -676,6 +697,75 @@ export function getActiveProjectAuthSource(
   return loadProjectEnvCandidates(startDir)[0] ?? null;
 }
 
+function findNearestProjectMarkerDir(startDir: string): string | null {
+  let current = resolve(startDir);
+  while (true) {
+    if (
+      COWORK_PROJECT_MARKERS.some((marker) => existsSync(join(current, marker)))
+    ) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+/**
+ * Resolve credential provenance and whether the command is being run from a
+ * project. A project is a marked checkout, a Cowork-mounted project, or a
+ * folder that already carries Deepline project auth.
+ *
+ * The result intentionally does not expose an API key. It lets the CLI reject
+ * cloud mutations which would otherwise inherit a different project's shared
+ * host-level organization selection.
+ */
+export function resolveCliAuthProvenance(
+  config: Pick<ResolvedConfig, 'baseUrl' | 'apiKey'>,
+  startDir: string = process.cwd(),
+): CliAuthProvenance {
+  const envApiKey = process.env[API_KEY_ENV]?.trim();
+  const folderAuth = getResolvedProjectAuthSource(
+    config.baseUrl,
+    config.apiKey,
+    startDir,
+  );
+  const pinTarget = resolveProjectPinTarget(startDir);
+  const markerDir = findNearestProjectMarkerDir(startDir);
+  const project = !pinTarget.ok
+    ? {
+        state: 'ambiguous_cowork_project' as const,
+        candidates: pinTarget.candidates,
+      }
+    : folderAuth
+      ? {
+          state: 'project' as const,
+          dir: dirname(folderAuth.filePath),
+          pinPath: folderAuth.filePath,
+          source: 'folder' as const,
+        }
+      : pinTarget.source === 'cowork'
+        ? {
+            state: 'project' as const,
+            dir: pinTarget.dir,
+            pinPath: join(pinTarget.dir, PROJECT_DEEPLINE_ENV_FILE),
+            source: 'cowork' as const,
+          }
+        : markerDir
+          ? {
+              state: 'project' as const,
+              dir: markerDir,
+              pinPath: join(markerDir, PROJECT_DEEPLINE_ENV_FILE),
+              source: 'marker' as const,
+            }
+          : { state: 'not_project' as const };
+  return {
+    scope: envApiKey ? 'env' : folderAuth ? 'folder' : 'global',
+    project,
+    folderAuthPath: folderAuth?.filePath ?? null,
+  };
+}
+
 export {
   baseUrlSlug,
   loadCliEnv,

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

@@ -241,7 +241,8 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *
  * @sdkReference runtime 030
  */
-export type PlayBindings = PlayAuthoringBindings;
+export type PlayBindings<TInput = Record<string, unknown>> =
+  PlayAuthoringBindings<TInput>;
 export type SqlListenerOperation = PlaySqlListenerOperation;
 export type SqlListenerFilterScalar = PlaySqlListenerFilterScalar;
 export type SqlListenerFilterOperator = PlaySqlListenerFilterOperator;
@@ -873,14 +874,28 @@ export type DefinedPlay<
   DeeplineNamedPlay<TInput, TOutput>
 >;
 
-type PlayMetadata = {
+type PlayHandlerInput<THandler> = THandler extends (
+  context: DeeplinePlayRuntimeContext,
+  input: infer TInput,
+) => Promise<PlayReturnObject>
+  ? TInput
+  : never;
+
+type PlayHandlerOutput<THandler> = THandler extends (
+  context: DeeplinePlayRuntimeContext,
+  input: unknown,
+) => Promise<infer TOutput extends PlayReturnObject>
+  ? TOutput
+  : never;
+
+type PlayMetadata<TInput = Record<string, unknown>> = {
   name: string;
   description?: string;
-  bindings?: PlayBindings;
+  bindings?: PlayBindings<TInput>;
   inputSchema?: Record<string, unknown>;
-  billing?: PlayBindings['billing'];
-  runtime?: PlayBindings['runtime'];
-  compatibility?: PlayBindings['compatibility'];
+  billing?: PlayBindings<TInput>['billing'];
+  runtime?: PlayBindings<TInput>['runtime'];
+  compatibility?: PlayBindings<TInput>['compatibility'];
 };
 
 const PLAY_METADATA_SYMBOL = Symbol.for('deepline.play.metadata');
@@ -1608,6 +1623,18 @@ export function defineInput<TInput>(
 export function definePlay<TInput, TOutput extends PlayReturnObject>(
   config: DefinePlayConfig<TInput, TOutput>,
 ): DefinedPlay<TInput, TOutput>;
+/** @internal Contextually type unannotated monitor-event handlers as unknown. */
+export function definePlay<TOutput extends PlayReturnObject>(
+  name: string,
+  fn: (
+    context: DeeplinePlayRuntimeContext,
+    input: unknown,
+  ) => Promise<TOutput>,
+  bindings: PlayBindings<never> & {
+    readonly sqlListeners: readonly SqlListenerDeclaration[];
+  },
+): DefinedPlay<unknown, TOutput>;
+/* eslint-disable @typescript-eslint/no-explicit-any -- This constraint must infer a concrete contravariant handler input. */
 /**
  * Define a play with a name and function.
  *
@@ -1616,11 +1643,17 @@ export function definePlay<TInput, TOutput extends PlayReturnObject>(
  * @param bindings - Play configuration, including runtime limits and triggers.
  * @returns Play handle.
  */
-export function definePlay<TInput, TOutput extends PlayReturnObject>(
+export function definePlay<
+  THandler extends (
+    context: DeeplinePlayRuntimeContext,
+    input: any,
+  ) => Promise<PlayReturnObject>,
+>(
   name: string,
-  fn: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>,
-  bindings?: PlayBindings,
-): DefinedPlay<TInput, TOutput>;
+  fn: THandler,
+  bindings?: PlayBindings<NoInfer<PlayHandlerInput<THandler>>>,
+): DefinedPlay<PlayHandlerInput<THandler>, PlayHandlerOutput<THandler>>;
+/* eslint-enable @typescript-eslint/no-explicit-any */
 /**
  * @sdkReference runtime 010
  */
@@ -1630,7 +1663,7 @@ export function definePlay<TInput, TOutput extends PlayReturnObject>(
     ctx: DeeplinePlayRuntimeContext,
     input: TInput,
   ) => Promise<TOutput>,
-  maybeBindings?: PlayBindings,
+  maybeBindings?: PlayBindings<TInput>,
 ): DefinedPlay<TInput, TOutput> {
   const config =
     typeof nameOrConfig === 'string'
@@ -1690,7 +1723,7 @@ export function definePlay<TInput, TOutput extends PlayReturnObject>(
     );
   }
 
-  const metadata: PlayMetadata = {
+  const metadata: PlayMetadata<TInput> = {
     name,
     ...(description ? { description } : {}),
     ...(bindings ? { bindings } : {}),

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

@@ -199,7 +199,7 @@ export const SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: '0.3.59',
+  version: '0.3.61',
   updateSummary:
     'Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.',
   packageCapabilities: {

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

@@ -1089,6 +1089,20 @@ export interface PlayDefinitionDetail {
   liveRevision?: PlayRevisionSummary | null;
   /** `true` if the working revision differs from the live revision. */
   isDraftDirty?: boolean;
+  /** Live trigger state. This is operational state, not a source declaration. */
+  triggerStatus?: PlayTriggerStatus;
+  /**
+   * Additive scheduler metadata for human/UI rendering. Values are absent for
+   * plays with no cron binding and must never be inferred from source alone.
+   */
+  triggerMetadata?: {
+    cronSchedule?: string | null;
+    cronTimezone?: string | null;
+    nextScheduledAt?: number | null;
+    lastScheduledAt?: number | null;
+    blockedReason?: string | null;
+    [key: string]: unknown;
+  } | null;
   /** Effective sandbox limit from the live revision, or the working draft before first publish. */
   runtimeLimit?: PlayRuntimeLimit | null;
   /** Present for a Play with a cron trigger. Advisory only; publish remains authoritative. */
@@ -1125,11 +1139,14 @@ export interface PlayListItem {
   currentRevision?: PlayRevisionSummary | null;
   liveRevision?: PlayRevisionSummary | null;
   aliases?: string[];
-  triggerStatus?: {
-    cron: string | null;
-    webhook: string | null;
-    blockedReason: string | null;
-  };
+  triggerStatus?: PlayTriggerStatus;
+}
+
+/** Additive live trigger state shared by list, get, and describe. */
+export interface PlayTriggerStatus {
+  cron: string | null;
+  webhook: string | null;
+  blockedReason: string | null;
 }
 
 export interface ProductNotificationEventDefinition {
@@ -1202,11 +1219,9 @@ export interface PlayDescription {
    */
   liveVersion?: number | null;
   /** Whether this play's cron and webhook triggers are armed. */
-  triggerStatus?: {
-    cron: string | null;
-    webhook: string | null;
-    blockedReason: string | null;
-  };
+  triggerStatus?: PlayTriggerStatus;
+  /** Additive cron timing metadata for an operational description. */
+  triggerMetadata?: PlayDefinitionDetail['triggerMetadata'];
   isDraftDirty?: boolean;
   latestRunId?: string | null;
   /** Effective sandbox limit from the revision named runs use. */
@@ -1512,7 +1527,12 @@ export interface PlayCheckSqlListenerEventSummary {
 export interface PlayCheckTriggersSummary {
   sqlListeners?: PlayCheckSqlListenerTrigger[];
   sqlListenerEvent?: PlayCheckSqlListenerEventSummary;
-  cron?: { schedule: string; timezone?: string };
+  cron?: {
+    schedule: string;
+    timezone?: string;
+    /** Static input supplied to every run started by this cron binding. */
+    input?: Record<string, unknown>;
+  };
   webhook?: true;
 }
 

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

@@ -113,6 +113,7 @@ import {
 import {
   isProviderUnavailable,
   serializeToolExecutionFailure,
+  ToolExecutionError,
   TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
   TOOL_EXECUTION_ERROR_SCHEMA_HEADER,
   type ToolExecutionErrorSchemaVersion,
@@ -2036,6 +2037,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   private readonly toolDispatchQueuedAtByLane = new Map<string, number>();
   private readonly toolDispatcherWakeWaiters = new Set<() => void>();
   private toolDispatcherFailure: unknown | null = null;
+  /**
+   * Deepline's own zero-credit denial is run-fatal. Keep it independently of
+   * customer control flow so a broad `try/catch` cannot turn it into a
+   * successful Play result. Provider account capacity remains a normal typed
+   * waterfall miss.
+   */
+  private deeplineInsufficientCreditsFailure: ToolExecutionError | null = null;
   private toolCallResolvers = new Map<
     string,
     { resolve: (value: unknown) => void; reject: (reason: unknown) => void }
@@ -2218,10 +2226,30 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 : {}),
             }
           : undefined,
-      ) as Promise<TOutput>;
+      ).catch((error: unknown) => {
+        this.recordDeeplineInsufficientCreditsFailure(error);
+        throw error;
+      }) as Promise<TOutput>;
     },
   };
 
+  private recordDeeplineInsufficientCreditsFailure(error: unknown): void {
+    if (
+      error instanceof ToolExecutionError &&
+      error.origin === 'deepline' &&
+      error.code === 'INSUFFICIENT_CREDITS'
+    ) {
+      this.deeplineInsufficientCreditsFailure ??= error;
+    }
+  }
+
+  /** Called by the runner after customer code returns, before a success settles. */
+  assertNoDeeplineInsufficientCreditsFailure(): void {
+    if (this.deeplineInsufficientCreditsFailure) {
+      throw this.deeplineInsufficientCreditsFailure;
+    }
+  }
+
   async tool<TOutput = unknown>(
     key: string,
     toolId: string,
@@ -13258,14 +13286,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 ...(requestsDurableInvocationFence
                   ? { canonical_operation: canonicalOperation }
                   : {}),
-                // This is deliberately the provider receipt, rather than the
-                // worker-owned response cache receipt. It keeps a newer
-                // worker wire-compatible with an already active Vercel app
-                // while its runtime cache can still partition by response
-                // representation.
-                ...(providerIdempotencyReceiptKey
+                // The worker-owned receipt coordinates this physical durable
+                // call. Provider idempotency is carried separately below so
+                // exact-payload reuse never replaces batch receipt ownership.
+                ...(durableCallReceiptKey
                   ? {
-                      durable_call_receipt_key: providerIdempotencyReceiptKey,
+                      durable_call_receipt_key: durableCallReceiptKey,
                       ...(executionAuthScopeDigest
                         ? {
                             execution_auth_scope_digest:
@@ -13274,6 +13300,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                         : {}),
                     }
                   : {}),
+                ...(providerIdempotencyReceiptKey
+                  ? {
+                      provider_idempotency_receipt_key:
+                        providerIdempotencyReceiptKey,
+                    }
+                  : {}),
                 ...(options?.customerDbDataset
                   ? {
                       query_result_dataset: {

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

@@ -237,29 +237,6 @@ function isHardBillingFailurePayload(
   );
 }
 
-/**
- * A normalized provider 402 is fatal only when the integration boundary has
- * declared it account-level capacity. A raw 402 never reaches this function as
- * proof by itself: providers use that status inconsistently.
- */
-function isProviderAccountCapacityFailurePayload(
-  payload: Record<string, unknown> | null,
-): payload is Record<string, unknown> {
-  if (!payload) return false;
-  const code = String(payload.code ?? payload.error_code ?? '').toUpperCase();
-  const category = String(
-    payload.error_category ?? payload.errorCategory ?? '',
-  ).toLowerCase();
-  const origin = String(
-    payload.failure_origin ?? payload.failureOrigin ?? '',
-  ).toLowerCase();
-  return (
-    code === 'PROVIDER_ACCOUNT_CAPACITY' &&
-    category === 'provider_account' &&
-    (origin === 'provider' || origin === 'provider_account')
-  );
-}
-
 function normalizeHardBillingPayload(
   payload: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -299,18 +276,11 @@ function formatHardBillingFailureMessage(input: {
   maxAttempts: number;
 }): string {
   const code = getStringField(input.billing, 'code');
-  const providerCapacity = isProviderAccountCapacityFailurePayload(
-    input.billing,
-  );
   const message =
     getStringField(input.billing, 'message') ??
     getStringField(input.billing, 'error') ??
-    (providerCapacity
-      ? 'Provider account capacity blocked execution.'
-      : 'Deepline billing cap exceeded.');
-  const headline = providerCapacity
-    ? 'Provider account capacity blocked execution.'
-    : 'Deepline billing cap exceeded.';
+    'Deepline billing cap exceeded.';
+  const headline = '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}`;
 }
 
@@ -478,12 +448,8 @@ export function normalizeToolHttpErrorMessage(input: {
     ? normalizeHardBillingPayload(billing)
     : isHardBillingFailurePayload(parsed)
       ? normalizeHardBillingPayload(parsed)
-      : isProviderAccountCapacityFailurePayload(parsed)
-        ? parsed
-        : null;
+      : null;
   if (hardBillingPayload) {
-    const providerCapacity =
-      isProviderAccountCapacityFailurePayload(hardBillingPayload);
     return createToolHttpError(
       schemaVersion,
       formatHardBillingFailureMessage({
@@ -498,15 +464,9 @@ export function normalizeToolHttpErrorMessage(input: {
       'terminal',
       {
         ...publicOptions,
-        origin: providerCapacity ? 'provider' : 'deepline',
-        // `provider_account` is the integration-boundary category. The
-        // portable ToolExecutionError taxonomy canonically represents it as
-        // provider-owned authentication; the code retains the precise
-        // account-capacity reason.
-        category: providerCapacity ? 'authentication' : 'billing',
-        code: providerCapacity
-          ? 'PROVIDER_ACCOUNT_CAPACITY'
-          : publicOptions.code,
+        origin: 'deepline',
+        category: 'billing',
+        code: publicOptions.code,
         retryable: false,
       },
     );
@@ -536,19 +496,15 @@ export function isHardBillingToolHttpError(error: unknown): boolean {
   if (
     error instanceof ToolHttpError &&
     (isInsufficientCreditsBilling(error.billing) ||
-      isHardBillingFailurePayload(error.billing) ||
-      isProviderAccountCapacityFailurePayload(error.billing))
+      isHardBillingFailurePayload(error.billing))
   ) {
     return true;
   }
   return (
     error instanceof ToolExecutionError &&
-    ((error.origin === 'deepline' &&
-      error.category === 'billing' &&
-      error.code !== 'BILLING_UNAVAILABLE') ||
-      (error.origin === 'provider' &&
-        error.category === 'authentication' &&
-        error.code === 'PROVIDER_ACCOUNT_CAPACITY'))
+    error.origin === 'deepline' &&
+    error.category === 'billing' &&
+    error.code !== 'BILLING_UNAVAILABLE'
   );
 }