deepline 0.3.389 → 0.3.391

package/dist/bundling-sources/sdk/src/agent-runtime.ts

@@ -41,7 +41,7 @@ const AGENT_SESSION_ID_VARIABLES = [
  * one. Every command that needs the session ID reads it here.
  */
 export function agentSessionIdFromEnvironment(
-  env: NodeJS.ProcessEnv = process.env,
+  env: Readonly<Record<string, string | undefined>> = process.env,
 ): string | null {
   for (const variable of AGENT_SESSION_ID_VARIABLES) {
     const sessionId = env[variable]?.trim();
@@ -63,35 +63,40 @@ export function isCoworkLikeSandbox(): boolean {
 }
 
 export function detectAgentRuntime(
-  options: { defaultRuntime?: string; detectCowork?: boolean } = {},
+  options: {
+    defaultRuntime?: string;
+    detectCowork?: boolean;
+    env?: Readonly<Record<string, string | undefined>>;
+  } = {},
 ): string {
-  const explicit = normalizeAgentRuntime(process.env.DEEPLINE_AGENT_RUNTIME);
+  const env = options.env ?? process.env;
+  const explicit = normalizeAgentRuntime(env.DEEPLINE_AGENT_RUNTIME);
   if (explicit) return explicit;
-  if (process.env.CODEX_THREAD_ID?.trim()) return 'codex';
+  if (env.CODEX_THREAD_ID?.trim()) return 'codex';
   if (options.detectCowork !== false && isCoworkLikeSandbox()) {
     return 'claude_cowork';
   }
-  if (process.env.CLAUDECODE?.trim() === '1') return 'claude_code';
-  if (process.env.CLINE_ACTIVE?.trim().toLowerCase() === 'true') return 'cline';
-  if (process.env.CURSOR_TRACE_ID?.trim() || process.env.CURSOR_AGENT?.trim()) {
+  if (env.CLAUDECODE?.trim() === '1') return 'claude_code';
+  if (env.CLINE_ACTIVE?.trim().toLowerCase() === 'true') return 'cline';
+  if (env.CURSOR_TRACE_ID?.trim() || env.CURSOR_AGENT?.trim()) {
     return 'cursor';
   }
-  if (process.env.WINDSURF?.trim() || process.env.CASCADE?.trim()) {
+  if (env.WINDSURF?.trim() || env.CASCADE?.trim()) {
     return 'windsurf';
   }
   if (
-    process.env.ANTIGRAVITY?.trim() ||
-    process.env.ANTIGRAVITY_CLI?.trim() ||
-    process.env.ANTIGRAVITY_AGENT?.trim() ||
-    process.env.ANTIGRAVITY_WORKSPACE?.trim()
+    env.ANTIGRAVITY?.trim() ||
+    env.ANTIGRAVITY_CLI?.trim() ||
+    env.ANTIGRAVITY_AGENT?.trim() ||
+    env.ANTIGRAVITY_WORKSPACE?.trim()
   ) {
     return 'antigravity';
   }
   if (
-    process.env.GEMINI_CLI?.trim() ||
-    process.env.GEMINI_CLI_VERSION?.trim() ||
-    process.env.GEMINI_SANDBOX?.trim() ||
-    process.env.GEMINI_CONFIG_DIR?.trim()
+    env.GEMINI_CLI?.trim() ||
+    env.GEMINI_CLI_VERSION?.trim() ||
+    env.GEMINI_SANDBOX?.trim() ||
+    env.GEMINI_CONFIG_DIR?.trim()
   ) {
     return 'gemini';
   }

package/dist/bundling-sources/sdk/src/billing-idempotency.ts

@@ -1,4 +1,4 @@
-import { DeeplineError } from './errors.js';
+import { DeeplineError } from './errors';
 
 export function requireBillingIdempotencyKey(value: string): string {
   const normalized = value.trim();

package/dist/bundling-sources/sdk/src/cli-invocation-id.ts

@@ -1,4 +1,4 @@
-import { DeeplineError } from './errors.js';
+import { DeeplineError } from './errors';
 
 const CLI_INVOCATION_ID_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

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

@@ -13,9 +13,9 @@ import type {
 // Value import from the dependency-free module: the client is bundled into
 // authored Plays, where `zod` (the contract's schemas) cannot resolve.
 import { playTriggerConfigPath } from '../../shared_libs/plays/trigger-config-route';
-import { CSV_HEADER_MATCHING_NOTE } from './csv-header-matching.js';
-import { iterateCursorPages } from './pagination.js';
-import { playInputExampleArgs } from './plays/input-example.js';
+import { CSV_HEADER_MATCHING_NOTE } from './csv-header-matching';
+import { iterateCursorPages } from './pagination';
+import { playInputExampleArgs } from './plays/input-example';
 /**
  * The main API client for interacting with the Deepline platform.
  *
@@ -51,28 +51,28 @@ import { playInputExampleArgs } from './plays/input-example.js';
  *
  * @module
  */
-import { resolveConfig } from './config.js';
-import { DeeplineError } from './errors.js';
-import { requireBillingIdempotencyKey as requireTargetBillingIdempotencyKey } from './billing-idempotency.js';
+import { resolveConfig } from './config';
+import { DeeplineError } from './errors';
+import { requireBillingIdempotencyKey as requireTargetBillingIdempotencyKey } from './billing-idempotency';
 import {
   planCustomerDbQuery,
   queryCustomerDatabase,
   type CustomerDbQueryOptions,
   type CustomerDbQueryPlan,
-} from './db/query.js';
+} from './db/query';
 import {
   ToolCalls,
   type ExecuteToolRawOptions,
   type ExecutionByKeyResult,
   type ToolExecution,
-} from './tool-calls.js';
-import { validateCliInvocationId } from './cli-invocation-id.js';
+} from './tool-calls';
+import { validateCliInvocationId } from './cli-invocation-id';
 export type {
   ExecutionRecovery,
   ExecutionByKeyResult,
   ToolExecution,
-} from './tool-calls.js';
-import { HttpClient } from './http.js';
+} from './tool-calls';
+import { HttpClient } from './http';
 import { PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES } from '../../shared_libs/product-notifications/contract.js';
 import {
   DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING,
@@ -84,8 +84,8 @@ import {
   type EffectiveProductNotificationGroup,
   type ProductNotificationGroupDraft,
 } from '../../shared_libs/product-notifications/configuration.js';
-import { watchRunEvents as pollRunSnapshotEvents } from './runs/watch-polling.js';
-import { encodeRunLogsCursor, parseRunLogsCursor } from './runs/log-cursor.js';
+import { watchRunEvents as pollRunSnapshotEvents } from './runs/watch-polling';
+import { encodeRunLogsCursor, parseRunLogsCursor } from './runs/log-cursor';
 import {
   normalizeRunEventOperationRequest,
   RunEventQueryInputError,
@@ -143,11 +143,11 @@ import type {
   ChildRunSummary,
   SearchOptions,
   SearchResult,
-} from './types.js';
-import { isStopAllPlayRunsDryRunResult } from './types.js';
-import type { MonitorDefinition } from './monitors.js';
-import type { MonitorFleetDefinition } from './monitor-fleets.js';
-import type { PlayStagedFileRef } from './plays/local-file-discovery.js';
+} from './types';
+import { isStopAllPlayRunsDryRunResult } from './types';
+import type { MonitorDefinition } from './monitors';
+import type { MonitorFleetDefinition } from './monitor-fleets';
+import type { PlayStagedFileRef } from './plays/local-file-discovery';
 import {
   buildPlayRunStartBody,
   isPlayRunPackage,
@@ -160,7 +160,7 @@ import {
   type ResolvedStartPlayRunRequest,
 } from './plays/run-request';
 import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-manifest.js';
-import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
+import type { EnrichCompiledConfig } from './cli/enrich-play-compiler';
 import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
   RUNTIME_ENVIRONMENT_TOKEN_HEADER,
@@ -333,16 +333,20 @@ function normalizePlayRunIntegrationMode(
   return undefined;
 }
 
+type ClientEnvironment = Readonly<Record<string, string | undefined>>;
+
 function resolvePlayRunIntegrationMode(
   request: StartPlayRunRequest,
+  env: ClientEnvironment,
 ): 'live' | 'eval_stub' | 'fixture' | undefined {
   return normalizePlayRunIntegrationMode(
-    request.integrationMode ?? process.env.DEEPLINE_EVAL_INTEGRATION_MODE,
+    request.integrationMode ?? env.DEEPLINE_EVAL_INTEGRATION_MODE,
   );
 }
 
 function resolvePlayRunRuntimeSelection(
   request: StartPlayRunRequest,
+  env: ClientEnvironment,
 ): PlayRuntimeSelection | undefined {
   if (request.runtime !== undefined) {
     const runtime = normalizePlayRuntimeSelection(request.runtime);
@@ -360,12 +364,12 @@ function resolvePlayRunRuntimeSelection(
   // opts into remote preview routing, namespace names the isolated lane, and
   // the token only authorizes that selection. Omitting all three leaves the
   // app free to use its native runtime (local for a local app, prod for prod).
-  const configured = process.env.DEEPLINE_RUNTIME_ENVIRONMENT?.trim();
-  const configuredNamespace = process.env.DEEPLINE_RUNTIME_NAMESPACE?.trim();
+  const configured = env.DEEPLINE_RUNTIME_ENVIRONMENT?.trim();
+  const configuredNamespace = env.DEEPLINE_RUNTIME_NAMESPACE?.trim();
   const configuredToken =
-    process.env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
+    env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
   const configuredPlacementPolicy =
-    process.env.DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY?.trim();
+    env.DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY?.trim();
   if (!configured) {
     if (configuredNamespace || configuredToken || configuredPlacementPolicy) {
       // Name the variables that are actually set. This branch is almost always
@@ -409,7 +413,7 @@ function resolvePlayRunRuntimeSelection(
     );
   }
   const configuredBackendValue =
-    process.env.DEEPLINE_PLAY_RUNNER_BACKEND?.trim();
+    env.DEEPLINE_PLAY_RUNNER_BACKEND?.trim();
   const configuredBackend =
     configuredBackendValue === 'daytona' || configuredBackendValue === 'modal'
       ? configuredBackendValue
@@ -447,14 +451,17 @@ function resolvePlayRunRuntimeSelection(
  * order the SDK has always validated them. The shared body builder in
  * `plays/run-request` never reads the environment.
  */
-function resolveStartPlayRunRequest(request: StartPlayRunRequest): {
+function resolveStartPlayRunRequest(
+  request: StartPlayRunRequest,
+  env: ClientEnvironment,
+): {
   request: ResolvedStartPlayRunRequest;
   runtime: PlayRuntimeSelection | undefined;
 } {
-  const integrationMode = resolvePlayRunIntegrationMode(request);
+  const integrationMode = resolvePlayRunIntegrationMode(request, env);
   const testPolicyOverrides =
-    request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
-  const runtime = resolvePlayRunRuntimeSelection(request);
+    request.testPolicyOverrides ?? parseEnvTestPolicyOverrides(env);
+  const runtime = resolvePlayRunRuntimeSelection(request, env);
   const resolved: ResolvedStartPlayRunRequest = { ...request };
   delete resolved.integrationMode;
   delete resolved.runtime;
@@ -467,11 +474,12 @@ function resolveStartPlayRunRequest(request: StartPlayRunRequest): {
 
 function runtimeSelectionHeaders(
   runtime: PlayRuntimeSelection | undefined,
+  env: ClientEnvironment,
 ): Record<string, string> | undefined {
   if (!runtime) return undefined;
   // Keep the credential out of the typed runtime payload. The app consumes it
   // at the HTTP boundary and never forwards it to Fly, Absurd, or Daytona.
-  const token = process.env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
+  const token = env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
   if (!token) {
     throw new DeeplineError(
       'DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN is required for explicit preview runtime selection.',
@@ -480,7 +488,7 @@ function runtimeSelectionHeaders(
     );
   }
   const receivers =
-    process.env.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim();
+    env.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim();
   return {
     [RUNTIME_ENVIRONMENT_TOKEN_HEADER]: token,
     ...(receivers ? { [RETAINED_PIPELINE_RECEIVERS_HEADER]: receivers } : {}),
@@ -488,18 +496,18 @@ function runtimeSelectionHeaders(
 }
 
 /** The isolated PR estate needs its existing internal credential to read its pinned scheduler scope. */
-function isolatedCiRuntimeEventReadHeaders():
-  | Record<string, string>
-  | undefined {
-  const schema = process.env.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA?.trim();
+function isolatedCiRuntimeEventReadHeaders(
+  env: ClientEnvironment,
+): Record<string, string> | undefined {
+  const schema = env.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA?.trim();
   if (
-    process.env.DEEPLINE_SYNTHETIC_RUN?.trim() !== '1' ||
+    env.DEEPLINE_SYNTHETIC_RUN?.trim() !== '1' ||
     !schema ||
     !/^fly_absurd_pr_\d+_\d+(?:_\d+)?$/.test(schema)
   ) {
     return undefined;
   }
-  const token = process.env.DEEPLINE_INTERNAL_TOKEN?.trim();
+  const token = env.DEEPLINE_INTERNAL_TOKEN?.trim();
   if (!token) {
     throw new DeeplineError(
       'DEEPLINE_INTERNAL_TOKEN is required for isolated CI runtime event reads.',
@@ -524,11 +532,10 @@ function normalizeTestPolicyOverrides(
   );
 }
 
-function parseEnvTestPolicyOverrides(): Record<string, unknown> | undefined {
-  const raw =
-    typeof process !== 'undefined'
-      ? process.env?.DEEPLINE_TEST_POLICY_OVERRIDES
-      : undefined;
+function parseEnvTestPolicyOverrides(
+  env: ClientEnvironment,
+): Record<string, unknown> | undefined {
+  const raw = env.DEEPLINE_TEST_POLICY_OVERRIDES;
   const trimmed = raw?.trim();
   if (!trimmed) return undefined;
   let parsed: unknown;
@@ -2846,6 +2853,7 @@ export class DeeplineClient {
   private readonly http: HttpClient;
   private readonly toolCalls: ToolCalls;
   private readonly config: ResolvedConfig;
+  private readonly environment: ClientEnvironment;
   /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
   readonly runs: RunsNamespace;
   /** Current mutable customer database namespace backed by `/api/v2/db/query`. */
@@ -2868,6 +2876,7 @@ export class DeeplineClient {
    */
   constructor(options?: DeeplineClientOptions) {
     this.config = resolveConfig(options);
+    this.environment = this.config.environment ?? process.env;
     this.http = new HttpClient(this.config);
     this.toolCalls = new ToolCalls(
       this.http,
@@ -3556,11 +3565,11 @@ export class DeeplineClient {
    * ```
    */
   async startPlayRun(request: StartPlayRunRequest): Promise<PlayRunStart> {
-    const resolved = resolveStartPlayRunRequest(request);
+    const resolved = resolveStartPlayRunRequest(request, this.environment);
     return startPlayRun(
       this.http,
       resolved.request,
-      runtimeSelectionHeaders(resolved.runtime),
+      runtimeSelectionHeaders(resolved.runtime, this.environment),
     );
   }
 
@@ -3581,14 +3590,14 @@ export class DeeplineClient {
     request: StartPlayRunRequest,
     options?: { signal?: AbortSignal },
   ): AsyncGenerator<PlayLiveEvent> {
-    const resolved = resolveStartPlayRunRequest(request);
+    const resolved = resolveStartPlayRunRequest(request, this.environment);
     const body = buildPlayRunStartBody(resolved.request);
     for await (const event of this.http.streamSse<PlayLiveEvent>(
       PLAY_RUN_START_STREAM_PATH,
       {
         method: 'POST',
         body,
-        headers: runtimeSelectionHeaders(resolved.runtime),
+        headers: runtimeSelectionHeaders(resolved.runtime, this.environment),
         signal: options?.signal,
       },
     )) {
@@ -3806,7 +3815,7 @@ export class DeeplineClient {
     }>;
   }): Promise<PlayCheckResult> {
     const integrationMode = normalizePlayRunIntegrationMode(
-      input.integrationMode ?? process.env.DEEPLINE_EVAL_INTEGRATION_MODE,
+      input.integrationMode ?? this.environment.DEEPLINE_EVAL_INTEGRATION_MODE,
     );
     return this.http.post('/api/v2/plays/check', {
       ...input,
@@ -4943,10 +4952,10 @@ export class DeeplineClient {
       params.set('runtime', 'preview');
       params.set('namespace', runtime.namespace);
       if (runtime.backend) params.set('backend', runtime.backend);
-      headers = runtimeSelectionHeaders(runtime);
+      headers = runtimeSelectionHeaders(runtime, this.environment);
       selectedRuntime = runtime;
     } else {
-      headers = isolatedCiRuntimeEventReadHeaders();
+      headers = isolatedCiRuntimeEventReadHeaders(this.environment);
     }
     const suffix = params.size > 0 ? `?${params.toString()}` : '';
     const result = await this.http.post<T>(
@@ -5015,9 +5024,9 @@ export class DeeplineClient {
       params.set('runtime', 'preview');
       params.set('namespace', runtime.namespace);
       if (runtime.backend) params.set('backend', runtime.backend);
-      headers = runtimeSelectionHeaders(runtime);
+      headers = runtimeSelectionHeaders(runtime, this.environment);
     } else {
-      headers = isolatedCiRuntimeEventReadHeaders();
+      headers = isolatedCiRuntimeEventReadHeaders(this.environment);
     }
     return this.http.get<RunsEventSearchResult>(
       `/api/v2/runs/events?${params.toString()}`,
@@ -7330,6 +7339,20 @@ export class DeeplineClient {
     }
   }
 
+  /**
+   * The workspace and user this client's API key authenticates as.
+   *
+   * @example
+   * ```typescript
+   * const status = await client.authStatus();
+   * ```
+   */
+  async authStatus(): Promise<Record<string, unknown>> {
+    return this.http.post<Record<string, unknown>>('/api/v2/auth/cli/status', {
+      api_key: this.config.apiKey,
+    });
+  }
+
   /**
    * Check API connectivity and server health.
    *
@@ -7361,4 +7384,4 @@ export class DeeplineClient {
   }
 }
 
-export type { PlayRunListItem, PlayStatus } from './types.js';
+export type { PlayRunListItem, PlayStatus } from './types';

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

@@ -42,8 +42,8 @@ import {
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
-import type { DeeplineClientOptions, ResolvedConfig } from './types.js';
-import { ConfigError } from './errors.js';
+import type { DeeplineClientOptions, ResolvedConfig } from './types';
+import { ConfigError } from './errors';
 
 export const HOST_URL_ENV = 'DEEPLINE_HOST_URL';
 export const API_KEY_ENV = 'DEEPLINE_API_KEY';
@@ -659,6 +659,7 @@ export function resolveConfig(options?: DeeplineClientOptions): ResolvedConfig {
     // Pass through untouched: the transport owns case-insensitive merging so
     // there is exactly one place that decides which header wins.
     ...(options?.headers ? { headers: { ...options.headers } } : {}),
+    ...(options?.environment ? { environment: options.environment } : {}),
   };
 }
 

package/dist/bundling-sources/sdk/src/db/query.ts

@@ -1,9 +1,9 @@
 import {
   CustomerDbQueryOutcomeUnknownError,
   DeeplineError,
-} from '../errors.js';
-import type { HttpClient } from '../http.js';
-import type { CustomerDbQueryResult } from '../types.js';
+} from '../errors';
+import type { HttpClient } from '../http';
+import type { CustomerDbQueryResult } from '../types';
 
 export type CustomerDbQueryOptions = {
   sql: string;

package/dist/bundling-sources/sdk/src/deployment-protection.ts

@@ -1,9 +1,11 @@
 /** Headers shared by SDK requests and the CLI's directory deployment body. */
-export function deploymentProtectionHeaders(): Record<string, string> {
-  const token =
-    typeof process !== 'undefined'
-      ? process.env?.VERCEL_PROTECTION_BYPASS_TOKEN
-      : undefined;
+export function deploymentProtectionHeaders(
+  env: Readonly<Record<string, string | undefined>> = typeof process !==
+  'undefined'
+    ? process.env
+    : {},
+): Record<string, string> {
+  const token = env.VERCEL_PROTECTION_BYPASS_TOKEN;
   return token ? { 'x-vercel-protection-bypass': token } : {};
 }
 

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

@@ -20,29 +20,29 @@
  *
  * @module
  */
-import type { ResolvedConfig } from './types.js';
+import type { ResolvedConfig } from './types';
 import {
   AuthError,
   DeeplineError,
   RateLimitError,
   ToolExecutionError,
   ToolRateLimitError,
-} from './errors.js';
+} from './errors';
 import {
   deserializeToolExecutionFailure,
   serializeToolExecutionFailure,
   TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
 } from '../../shared_libs/plays/tool-execution-error';
-import { SDK_API_CONTRACT, SDK_VERSION } from './version.js';
+import { SDK_API_CONTRACT, SDK_VERSION } from './version';
 import { apiErrorCodeFromResponse, apiErrorMessage } from './api-error';
-import type { LiveEventEnvelope } from './types.js';
+import type { LiveEventEnvelope } from './types';
 import {
   agentSessionIdFromEnvironment,
   detectAgentRuntime,
   isCoworkLikeSandbox,
-} from './agent-runtime.js';
-import { readSdkSkillsLocalVersion } from './skills-version.js';
-import { deploymentProtectionHeaders } from './deployment-protection.js';
+} from './agent-runtime';
+import { readSdkSkillsLocalVersion } from './skills-version';
+import { deploymentProtectionHeaders } from './deployment-protection';
 import {
   ABSURD_RELEASE_OVERRIDE_HEADER,
   RETAINED_PIPELINE_RECEIVERS_HEADER,
@@ -268,9 +268,16 @@ export class HttpClient {
     return normalized || null;
   }
 
+  private environment(): Readonly<Record<string, string | undefined>> {
+    return (
+      this.config.environment ??
+      (typeof process !== 'undefined' ? process.env : {})
+    );
+  }
+
   private readSkillsVersionHeader(): string | null {
     const explicit = this.cleanDiagnosticHeader(
-      process.env.DEEPLINE_SKILLS_VERSION,
+      this.environment().DEEPLINE_SKILLS_VERSION,
     );
     if (explicit) return explicit;
     try {
@@ -283,63 +290,52 @@ export class HttpClient {
   }
 
   private authHeaders(extra?: Record<string, string>): Record<string, string> {
+    const env = this.environment();
     const transportHeaders: Record<string, string> = {
       Authorization: `Bearer ${this.config.apiKey}`,
       'User-Agent': `deepline-ts-sdk/${SDK_VERSION}`,
       'X-Deepline-Client-Family': 'sdk',
       'X-Deepline-CLI-Family': 'sdk',
-      'X-Deepline-Agent-Runtime': detectAgentRuntime(),
+      'X-Deepline-Agent-Runtime': detectAgentRuntime(
+        this.config.environment ? { env, detectCowork: false } : {},
+      ),
       'X-Deepline-CLI-Version': SDK_VERSION,
       'X-Deepline-SDK-Version': SDK_VERSION,
       'X-Deepline-API-Contract': SDK_API_CONTRACT,
       'X-Deepline-Run-Result-Shape': 'canonical',
     };
-    const headers = deploymentProtectionHeaders();
+    const headers = deploymentProtectionHeaders(env);
     const skillsVersion = this.readSkillsVersionHeader();
     if (skillsVersion) {
       headers['X-Deepline-Skills-Version'] = skillsVersion;
     }
-    const agentSessionId = agentSessionIdFromEnvironment();
+    const agentSessionId = agentSessionIdFromEnvironment(env);
     if (agentSessionId) {
       headers['X-Deepline-Agent-Session-Id'] = agentSessionId;
     }
     const playArtifactR2Prefix =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_PLAY_ARTIFACT_R2_PREFIX
-        : undefined;
+      env.DEEPLINE_PLAY_ARTIFACT_R2_PREFIX;
     if (playArtifactR2Prefix) {
       headers['x-deepline-play-artifact-r2-prefix'] = playArtifactR2Prefix;
     }
     const coordinatorUrl =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_COORDINATOR_URL
-        : undefined;
+      env.DEEPLINE_COORDINATOR_URL;
     const coordinatorInternalToken =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_INTERNAL_TOKEN
-        : undefined;
+      env.DEEPLINE_INTERNAL_TOKEN;
     const absurdReleaseOverride =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_ABSURD_RELEASE
-        : undefined;
+      env.DEEPLINE_ABSURD_RELEASE;
     const preferredReceiptGatewayMachineId =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_PREFERRED_RECEIPT_GATEWAY_MACHINE_ID
-        : undefined;
+      env.DEEPLINE_PREFERRED_RECEIPT_GATEWAY_MACHINE_ID;
     if (coordinatorUrl?.trim()) {
       headers[COORDINATOR_URL_OVERRIDE_HEADER] = coordinatorUrl.trim();
     }
     const workerCallbackUrl =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_WORKER_CALLBACK_URL
-        : undefined;
+      env.DEEPLINE_WORKER_CALLBACK_URL;
     if (workerCallbackUrl?.trim()) {
       headers[WORKER_CALLBACK_URL_OVERRIDE_HEADER] = workerCallbackUrl.trim();
     }
     const runtimeSchedulerSchema =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA
-        : undefined;
+      env.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA;
     if (runtimeSchedulerSchema?.trim()) {
       headers[RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER] =
         runtimeSchedulerSchema.trim();
@@ -348,25 +344,19 @@ export class HttpClient {
     // so their intentionally failing plays do not page the SDK CLI error
     // channel. Honored server-side only in non-prod (see plays/run route).
     const syntheticRun =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_SYNTHETIC_RUN
-        : undefined;
+      env.DEEPLINE_SYNTHETIC_RUN;
     if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== '0') {
       headers[SYNTHETIC_RUN_HEADER] = '1';
     }
     // Test-only runtime seam. The server validates both environment and value
     // before honoring this header.
     const runtimeTestFault =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_TEST_RUNTIME_FAULT
-        : undefined;
+      env.DEEPLINE_TEST_RUNTIME_FAULT;
     if (runtimeTestFault?.trim()) {
       headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
     }
     const retainedReceivers =
-      typeof process !== 'undefined'
-        ? process.env?.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim()
-        : undefined;
+      env.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim();
     if (retainedReceivers && coordinatorInternalToken?.trim()) {
       headers[RETAINED_PIPELINE_RECEIVERS_HEADER] = retainedReceivers;
       headers[COORDINATOR_INTERNAL_TOKEN_HEADER] =