@discomedia/utils 1.0.65 → 1.0.67

package/dist/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.0.65",
+  "version": "1.0.67",
   "author": "Disco Media",
   "description": "Utility functions used in Disco Media apps",
   "always-build-npm": true,
@@ -32,11 +32,11 @@
     "test": "npm run build && node dist/test.js"
   },
   "dependencies": {
-    "dotenv": "^17.3.1",
-    "openai": "^6.32.0",
+    "dotenv": "^17.4.2",
+    "openai": "^6.34.0",
     "p-limit": "^7.3.0",
     "tslib": "^2.8.1",
-    "ws": "^8.19.0",
+    "ws": "^8.20.0",
     "zod": "^4.3.6"
   },
   "license": "ISC",
@@ -47,7 +47,7 @@
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/ws": "^8.18.1",
     "lightweight-charts": "^5.1.0",
-    "rollup": "^4.59.0",
-    "typescript": "^5.9.3"
+    "rollup": "^4.60.2",
+    "typescript": "^6.0.3"
   }
 }

package/dist/test.js

@@ -2,7 +2,7 @@ import require$$0$3, { EventEmitter } from 'events';
 import require$$1 from 'https';
 import require$$2 from 'http';
 import require$$3$1 from 'net';
-import require$$4$1 from 'tls';
+import require$$4 from 'tls';
 import require$$3 from 'crypto';
 import require$$0$2 from 'stream';
 import require$$7 from 'url';
@@ -1563,6 +1563,37 @@ class InvalidWebhookSignatureError extends Error {
         super(message);
     }
 }
+/**
+ * Error thrown by the API server during OAuth token exchange.
+ * Can have status codes 400, 401, or 403.
+ * Other status codes from OAuth endpoints are raised as normal APIError types.
+ */
+class OAuthError extends APIError {
+    constructor(status, error, headers) {
+        let finalMessage = 'OAuth2 authentication error';
+        let error_code = undefined;
+        if (error && typeof error === 'object') {
+            const errorData = error;
+            error_code = errorData['error'];
+            const description = errorData['error_description'];
+            if (description && typeof description === 'string') {
+                finalMessage = description;
+            }
+            else if (error_code) {
+                finalMessage = error_code;
+            }
+        }
+        super(status, error, finalMessage, headers);
+        this.error_code = error_code;
+    }
+}
+class SubjectTokenProviderError extends OpenAIError {
+    constructor(message, provider, cause) {
+        super(message);
+        this.provider = provider;
+        this.cause = cause;
+    }
+}
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 // https://url.spec.whatwg.org/#url-scheme-string
@@ -1615,7 +1646,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '6.32.0'; // x-release-please-version
+const VERSION = '6.34.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -2996,6 +3027,91 @@ class ConversationCursorPage extends AbstractPage {
     }
 }
 
+const SUBJECT_TOKEN_TYPES = {
+    jwt: 'urn:ietf:params:oauth:token-type:jwt',
+    id: 'urn:ietf:params:oauth:token-type:id_token',
+};
+const TOKEN_EXCHANGE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:token-exchange';
+class WorkloadIdentityAuth {
+    constructor(config, fetch) {
+        this.cachedToken = null;
+        this.refreshPromise = null;
+        this.tokenExchangeUrl = 'https://auth.openai.com/oauth/token';
+        this.config = config;
+        this.fetch = fetch ?? getDefaultFetch();
+    }
+    async getToken() {
+        if (!this.cachedToken || this.isTokenExpired(this.cachedToken)) {
+            if (this.refreshPromise) {
+                return await this.refreshPromise;
+            }
+            this.refreshPromise = this.refreshToken();
+            try {
+                const token = await this.refreshPromise;
+                return token;
+            }
+            finally {
+                this.refreshPromise = null;
+            }
+        }
+        if (this.needsRefresh(this.cachedToken) && !this.refreshPromise) {
+            this.refreshPromise = this.refreshToken().finally(() => {
+                this.refreshPromise = null;
+            });
+        }
+        return this.cachedToken.token;
+    }
+    async refreshToken() {
+        const subjectToken = await this.config.provider.getToken();
+        const response = await this.fetch(this.tokenExchangeUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                grant_type: TOKEN_EXCHANGE_GRANT_TYPE,
+                client_id: this.config.clientId,
+                subject_token: subjectToken,
+                subject_token_type: SUBJECT_TOKEN_TYPES[this.config.provider.tokenType],
+                identity_provider_id: this.config.identityProviderId,
+                service_account_id: this.config.serviceAccountId,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            let body = undefined;
+            try {
+                body = JSON.parse(errorText);
+            }
+            catch { }
+            if (response.status === 400 || response.status === 401 || response.status === 403) {
+                throw new OAuthError(response.status, body, response.headers);
+            }
+            throw APIError.generate(response.status, body, `Token exchange failed with status ${response.status}`, response.headers);
+        }
+        const tokenResponse = (await response.json());
+        const expiresIn = tokenResponse.expires_in || 3600;
+        const expiresAt = Date.now() + expiresIn * 1000;
+        this.cachedToken = {
+            token: tokenResponse.access_token,
+            expiresAt,
+        };
+        return tokenResponse.access_token;
+    }
+    isTokenExpired(cachedToken) {
+        return Date.now() >= cachedToken.expiresAt;
+    }
+    needsRefresh(cachedToken) {
+        const bufferSeconds = this.config.refreshBufferSeconds ?? 1200;
+        const bufferMs = bufferSeconds * 1000;
+        return Date.now() >= cachedToken.expiresAt - bufferMs;
+    }
+    invalidateToken() {
+        this.cachedToken = null;
+        this.refreshPromise = null;
+    }
+}
+
 const checkFileSupport = () => {
     if (typeof File === 'undefined') {
         const { process } = globalThis;
@@ -8301,6 +8417,7 @@ _Webhooks_instances = new WeakSet(), _Webhooks_validateSecret = function _Webhoo
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 var _OpenAI_instances, _a$1, _OpenAI_encoder, _OpenAI_baseURLOverridden;
+const WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER = 'workload-identity-auth';
 /**
  * API Client for interfacing with the OpenAI API.
  */
@@ -8321,7 +8438,7 @@ class OpenAI {
      * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
      * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
      */
-    constructor({ baseURL = readEnv('OPENAI_BASE_URL'), apiKey = readEnv('OPENAI_API_KEY'), organization = readEnv('OPENAI_ORG_ID') ?? null, project = readEnv('OPENAI_PROJECT_ID') ?? null, webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null, ...opts } = {}) {
+    constructor({ baseURL = readEnv('OPENAI_BASE_URL'), apiKey = readEnv('OPENAI_API_KEY'), organization = readEnv('OPENAI_ORG_ID') ?? null, project = readEnv('OPENAI_PROJECT_ID') ?? null, webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null, workloadIdentity, ...opts } = {}) {
         _OpenAI_instances.add(this);
         _OpenAI_encoder.set(this, void 0);
         /**
@@ -8376,14 +8493,21 @@ class OpenAI {
         this.containers = new Containers(this);
         this.skills = new Skills(this);
         this.videos = new Videos(this);
-        if (apiKey === undefined) {
-            throw new OpenAIError('Missing credentials. Please pass an `apiKey`, or set the `OPENAI_API_KEY` environment variable.');
+        if (workloadIdentity) {
+            if (apiKey && apiKey !== WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER) {
+                throw new OpenAIError('The `apiKey` and `workloadIdentity` arguments are mutually exclusive; only one can be passed at a time.');
+            }
+            apiKey = WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER;
+        }
+        else if (apiKey === undefined) {
+            throw new OpenAIError('Missing credentials. Please pass an `apiKey`, `workloadIdentity`, or set the `OPENAI_API_KEY` environment variable.');
         }
         const options = {
             apiKey,
             organization,
             project,
             webhookSecret,
+            workloadIdentity,
             ...opts,
             baseURL: baseURL || `https://api.openai.com/v1`,
         };
@@ -8405,6 +8529,9 @@ class OpenAI {
         this.fetch = options.fetch ?? getDefaultFetch();
         __classPrivateFieldSet(this, _OpenAI_encoder, FallbackEncoder);
         this._options = options;
+        if (workloadIdentity) {
+            this._workloadIdentityAuth = new WorkloadIdentityAuth(workloadIdentity, this.fetch);
+        }
         this.apiKey = typeof apiKey === 'string' ? apiKey : 'Missing Key';
         this.organization = organization;
         this.project = project;
@@ -8424,6 +8551,7 @@ class OpenAI {
             fetch: this.fetch,
             fetchOptions: this.fetchOptions,
             apiKey: this.apiKey,
+            workloadIdentity: this._options.workloadIdentity,
             organization: this.organization,
             project: this.project,
             webhookSecret: this.webhookSecret,
@@ -8550,7 +8678,7 @@ class OpenAI {
             throw new APIUserAbortError();
         }
         const controller = new AbortController();
-        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+        const response = await this.fetchWithAuth(url, req, timeout, controller).catch(castToError);
         const headersTime = Date.now();
         if (response instanceof globalThis.Error) {
             const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
@@ -8580,6 +8708,9 @@ class OpenAI {
                 durationMs: headersTime - startTime,
                 message: response.message,
             }));
+            if (response instanceof OAuthError || response instanceof SubjectTokenProviderError) {
+                throw response;
+            }
             if (isTimeout) {
                 throw new APIConnectionTimeoutError();
             }
@@ -8591,6 +8722,20 @@ class OpenAI {
             .join('');
         const responseInfo = `[${requestLogID}${retryLogStr}${specialHeaders}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`;
         if (!response.ok) {
+            if (response.status === 401 &&
+                this._workloadIdentityAuth &&
+                !options.__metadata?.['hasStreamingBody'] &&
+                !options.__metadata?.['workloadIdentityTokenRefreshed']) {
+                await CancelReadableStream(response.body);
+                this._workloadIdentityAuth.invalidateToken();
+                return this.makeRequest({
+                    ...options,
+                    __metadata: {
+                        ...options.__metadata,
+                        workloadIdentityTokenRefreshed: true,
+                    },
+                }, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+            }
             const shouldRetry = await this.shouldRetry(response);
             if (retriesRemaining && shouldRetry) {
                 const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
@@ -8641,6 +8786,18 @@ class OpenAI {
         const request = this.makeRequest(options, null, undefined);
         return new PagePromise(this, request, Page);
     }
+    async fetchWithAuth(url, init, timeout, controller) {
+        if (this._workloadIdentityAuth) {
+            const headers = init.headers;
+            const authHeader = headers.get('Authorization');
+            if (!authHeader || authHeader === `Bearer ${WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER}`) {
+                const token = await this._workloadIdentityAuth.getToken();
+                headers.set('Authorization', `Bearer ${token}`);
+            }
+        }
+        const response = await this.fetchWithTimeout(url, init, timeout, controller);
+        return response;
+    }
     async fetchWithTimeout(url, init, ms, controller) {
         const { signal, method, ...options } = init || {};
         const abort = this._makeAbort(controller);
@@ -8737,7 +8894,13 @@ class OpenAI {
         if ('timeout' in options)
             validatePositiveInteger('timeout', options.timeout);
         options.timeout = options.timeout ?? this.timeout;
-        const { bodyHeaders, body } = this.buildBody({ options });
+        const { bodyHeaders, body, isStreamingBody } = this.buildBody({ options });
+        if (isStreamingBody) {
+            inputOptions.__metadata = {
+                ...inputOptions.__metadata,
+                hasStreamingBody: true,
+            };
+        }
         const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
         const req = {
             method,
@@ -8784,9 +8947,18 @@ class OpenAI {
     }
     buildBody({ options: { body, headers: rawHeaders } }) {
         if (!body) {
-            return { bodyHeaders: undefined, body: undefined };
+            return { bodyHeaders: undefined, body: undefined, isStreamingBody: false };
         }
         const headers = buildHeaders([rawHeaders]);
+        const isReadableStream = typeof globalThis.ReadableStream !== 'undefined' &&
+            body instanceof globalThis.ReadableStream;
+        const isRetryableBody = !isReadableStream &&
+            (typeof body === 'string' ||
+                body instanceof ArrayBuffer ||
+                ArrayBuffer.isView(body) ||
+                (typeof globalThis.Blob !== 'undefined' && body instanceof globalThis.Blob) ||
+                body instanceof URLSearchParams ||
+                body instanceof FormData);
         if (
         // Pass raw type verbatim
         ArrayBuffer.isView(body) ||
@@ -8802,23 +8974,28 @@ class OpenAI {
             // `URLSearchParams` -> `application/x-www-form-urlencoded`
             body instanceof URLSearchParams ||
             // Send chunked stream (each chunk has own `length`)
-            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
-            return { bodyHeaders: undefined, body: body };
+            isReadableStream) {
+            return { bodyHeaders: undefined, body: body, isStreamingBody: !isRetryableBody };
         }
         else if (typeof body === 'object' &&
             (Symbol.asyncIterator in body ||
                 (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
-            return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
+            return {
+                bodyHeaders: undefined,
+                body: ReadableStreamFrom(body),
+                isStreamingBody: true,
+            };
         }
         else if (typeof body === 'object' &&
             headers.values.get('content-type') === 'application/x-www-form-urlencoded') {
             return {
                 bodyHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
                 body: this.stringifyQuery(body),
+                isStreamingBody: false,
             };
         }
         else {
-            return __classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
+            return { ...__classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers }), isStreamingBody: false };
         }
     }
 }
@@ -9825,7 +10002,7 @@ class Doc {
     }
 }
 
-const version$1 = {
+const version = {
     major: 4,
     minor: 3,
     patch: 6,
@@ -9836,7 +10013,7 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
     inst ?? (inst = {});
     inst._zod.def = def; // set _def property
     inst._zod.bag = inst._zod.bag || {}; // initialize _bag object
-    inst._zod.version = version$1;
+    inst._zod.version = version;
     const checks = [...(inst._zod.def.checks ?? [])];
     // if inst is itself a checks.$ZodCheck, run it as a check
     if (inst._zod.traits.has("$ZodCheck")) {
@@ -16767,6 +16944,9 @@ function requirePermessageDeflate () {
 	   *     acknowledge disabling of client context takeover
 	   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
 	   *     calls to zlib
+	   * @param {Boolean} [options.isServer=false] Create the instance in either
+	   *     server or client mode
+	   * @param {Number} [options.maxPayload=0] The maximum allowed message length
 	   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
 	   *     use of a custom server window size
 	   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
@@ -16777,16 +16957,13 @@ function requirePermessageDeflate () {
 	   *     deflate
 	   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
 	   *     inflate
-	   * @param {Boolean} [isServer=false] Create the instance in either server or
-	   *     client mode
-	   * @param {Number} [maxPayload=0] The maximum allowed message length
 	   */
-	  constructor(options, isServer, maxPayload) {
-	    this._maxPayload = maxPayload | 0;
+	  constructor(options) {
 	    this._options = options || {};
 	    this._threshold =
 	      this._options.threshold !== undefined ? this._options.threshold : 1024;
-	    this._isServer = !!isServer;
+	    this._maxPayload = this._options.maxPayload | 0;
+	    this._isServer = !!this._options.isServer;
 	    this._deflate = null;
 	    this._inflate = null;
 
@@ -19268,7 +19445,7 @@ function requireWebsocket () {
 	const https = require$$1;
 	const http = require$$2;
 	const net = require$$3$1;
-	const tls = require$$4$1;
+	const tls = require$$4;
 	const { randomBytes, createHash } = require$$3;
 	const { Duplex, Readable } = require$$0$2;
 	const { URL } = require$$7;
@@ -19955,7 +20132,7 @@ function requireWebsocket () {
 	  } else {
 	    try {
 	      parsedUrl = new URL(address);
-	    } catch (e) {
+	    } catch {
 	      throw new SyntaxError(`Invalid URL: ${address}`);
 	    }
 	  }
@@ -20017,11 +20194,11 @@ function requireWebsocket () {
 	  opts.timeout = opts.handshakeTimeout;
 
 	  if (opts.perMessageDeflate) {
-	    perMessageDeflate = new PerMessageDeflate(
-	      opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
-	      false,
-	      opts.maxPayload
-	    );
+	    perMessageDeflate = new PerMessageDeflate({
+	      ...opts.perMessageDeflate,
+	      isServer: false,
+	      maxPayload: opts.maxPayload
+	    });
 	    opts.headers['Sec-WebSocket-Extensions'] = format({
 	      [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
 	    });
@@ -20828,13 +21005,14 @@ function requireStream () {
 
 requireStream();
 
+requireExtension();
+
+requirePermessageDeflate();
+
 requireReceiver();
 
 requireSender();
 
-var websocketExports = requireWebsocket();
-var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
-
 var subprotocol;
 var hasRequiredSubprotocol;
 
@@ -20905,6 +21083,11 @@ function requireSubprotocol () {
 	return subprotocol;
 }
 
+requireSubprotocol();
+
+var websocketExports = requireWebsocket();
+var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
+
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
 var websocketServer;
@@ -21205,11 +21388,11 @@ function requireWebsocketServer () {
 	      this.options.perMessageDeflate &&
 	      secWebSocketExtensions !== undefined
 	    ) {
-	      const perMessageDeflate = new PerMessageDeflate(
-	        this.options.perMessageDeflate,
-	        true,
-	        this.options.maxPayload
-	      );
+	      const perMessageDeflate = new PerMessageDeflate({
+	        ...this.options.perMessageDeflate,
+	        isServer: true,
+	        maxPayload: this.options.maxPayload
+	      });
 
 	      try {
 	        const offers = extension.parse(secWebSocketExtensions);
@@ -21473,10 +21656,6 @@ var config = {};
 
 var main = {exports: {}};
 
-var version = "17.3.1";
-var require$$4 = {
-	version: version};
-
 var hasRequiredMain;
 
 function requireMain () {
@@ -21486,25 +21665,17 @@ function requireMain () {
 	const path = require$$1$1;
 	const os = require$$2$1;
 	const crypto = require$$3;
-	const packageJson = require$$4;
-
-	const version = packageJson.version;
 
 	// Array of tips to display randomly
 	const TIPS = [
-	  '🔐 encrypt with Dotenvx: https://dotenvx.com',
-	  '🔐 prevent committing .env to code: https://dotenvx.com/precommit',
-	  '🔐 prevent building .env in docker: https://dotenvx.com/prebuild',
-	  '🤖 agentic secret storage: https://dotenvx.com/as2',
-	  '⚡️ secrets for agents: https://dotenvx.com/as2',
-	  '🛡️ auth for agents: https://vestauth.com',
-	  '🛠️  run anywhere with `dotenvx run -- yourcommand`',
-	  '⚙️  specify custom .env file path with { path: \'/custom/path/.env\' }',
-	  '⚙️  enable debug logging with { debug: true }',
-	  '⚙️  override existing env vars with { override: true }',
-	  '⚙️  suppress all logs with { quiet: true }',
-	  '⚙️  write to custom object with { processEnv: myObject }',
-	  '⚙️  load multiple .env files with { path: [\'.env.local\', \'.env\'] }'
+	  '◈ encrypted .env [www.dotenvx.com]',
+	  '◈ secrets for agents [www.dotenvx.com]',
+	  '⌁ auth for agents [www.vestauth.com]',
+	  '⌘ custom filepath { path: \'/custom/path/.env\' }',
+	  '⌘ enable debugging { debug: true }',
+	  '⌘ override existing { override: true }',
+	  '⌘ suppress logs { quiet: true }',
+	  '⌘ multiple files { path: [\'.env.local\', \'.env\'] }'
 	];
 
 	// Get a random tip from the tips array
@@ -21612,15 +21783,15 @@ function requireMain () {
 	}
 
 	function _warn (message) {
-	  console.error(`[dotenv@${version}][WARN] ${message}`);
+	  console.error(`⚠ ${message}`);
 	}
 
 	function _debug (message) {
-	  console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	  console.log(`┆ ${message}`);
 	}
 
 	function _log (message) {
-	  console.log(`[dotenv@${version}] ${message}`);
+	  console.log(`◇ ${message}`);
 	}
 
 	function _dotenvKey (options) {
@@ -21714,7 +21885,7 @@ function requireMain () {
 	  const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || (options && options.quiet));
 
 	  if (debug || !quiet) {
-	    _log('Loading env from encrypted .env.vault');
+	    _log('loading env from encrypted .env.vault');
 	  }
 
 	  const parsed = DotenvModule._parseVault(options);
@@ -21743,7 +21914,7 @@ function requireMain () {
 	    encoding = options.encoding;
 	  } else {
 	    if (debug) {
-	      _debug('No encoding is specified. UTF-8 is used by default');
+	      _debug('no encoding is specified (UTF-8 is used by default)');
 	    }
 	  }
 
@@ -21771,7 +21942,7 @@ function requireMain () {
 	      DotenvModule.populate(parsedAll, parsed, options);
 	    } catch (e) {
 	      if (debug) {
-	        _debug(`Failed to load ${path} ${e.message}`);
+	        _debug(`failed to load ${path} ${e.message}`);
 	      }
 	      lastError = e;
 	    }
@@ -21792,13 +21963,13 @@ function requireMain () {
 	        shortPaths.push(relative);
 	      } catch (e) {
 	        if (debug) {
-	          _debug(`Failed to load ${filePath} ${e.message}`);
+	          _debug(`failed to load ${filePath} ${e.message}`);
 	        }
 	        lastError = e;
 	      }
 	    }
 
-	    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+	    _log(`injected env (${keysCount}) from ${shortPaths.join(',')} ${dim(`// tip: ${_getRandomTip()}`)}`);
 	  }
 
 	  if (lastError) {
@@ -21819,7 +21990,7 @@ function requireMain () {
 
 	  // dotenvKey exists but .env.vault file does not exist
 	  if (!vaultPath) {
-	    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+	    _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
 
 	    return DotenvModule.configDotenv(options)
 	  }
@@ -22349,7 +22520,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
             pageCount++;
             const requestParams = {
                 ...params,
-                adjustment: DEFAULT_ADJUSTMENT,
+                adjustment: params.adjustment ?? DEFAULT_ADJUSTMENT,
                 feed: DEFAULT_FEED,
                 ...(pageToken && { page_token: pageToken }),
             };