apify-client 3.0.0-beta.54 → 3.0.0-beta.56

package/dist/generated/api.d.ts

@@ -10298,7 +10298,8 @@ export interface operations {
                 version: string;
                 /**
                  * @description If `true` or `1`, the system will use a cache to speed up the build
-                 *     process. By default, cache is not used.
+                 *     process. Pass `false` or `0` to build without the cache. By default,
+                 *     cache is used.
                  */
                 useCache?: boolean;
                 /**

package/dist/resource_clients/log.d.ts

@@ -81,7 +81,8 @@ export declare class StreamedLog {
      */
     start(): void;
     /**
-     * Stop log redirection. Waits up to one second for lines already in flight, then aborts the log stream request.
+     * Stop log redirection. Waits up to one second for lines already in flight, then aborts the log stream request. If
+     * no stream has delivered anything yet, reads the whole log in one request instead.
      */
     stop(): Promise<void>;
 }

package/dist/resource_clients/log.js

@@ -3,7 +3,15 @@ import { z } from 'zod';
 import log, { Logger, LogLevel } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
 import { timeoutOptionsShape } from '../timeouts.js';
-import { cast, catchNotFoundForResourceOrThrow, concatBytes, parseArgument } from '../utils.js';
+import { cast, catchNotFoundForResourceOrThrow, concatBytes, parseArgument, sleep } from '../utils.js';
+/**
+ * Pause before the first reopen of a log stream that ended before the run logged anything. Each further reopen doubles
+ * the pause up to `EMPTY_LOG_STREAM_MAX_RETRY_MILLIS`, which bounds the request rate while a run waits long to start,
+ * for example for free memory.
+ */
+const EMPTY_LOG_STREAM_RETRY_MILLIS = 500;
+/** Upper bound on the pause between reopens of an empty log stream. */
+const EMPTY_LOG_STREAM_MAX_RETRY_MILLIS = 5_000;
 const logOptionsSchema = z.strictObject({ raw: z.boolean().optional(), ...timeoutOptionsShape });
 /** How long `StreamedLog.stop()` waits for lines already in flight before aborting the log stream request. */
 const STOP_GRACE_MILLIS = 1000;
@@ -144,6 +152,7 @@ export class StreamedLog {
     #streamingTask = null;
     #stopLogging = false;
     #stopController = new AbortController();
+    #wakeController = new AbortController();
     constructor(options) {
         const { toLog, logClient, fromStart = true, signal } = options;
         this.#destinationLog = toLog;
@@ -160,16 +169,19 @@ export class StreamedLog {
         }
         this.#stopLogging = false;
         this.#stopController = new AbortController();
+        this.#wakeController = new AbortController();
         this.#streamingTask = this.#streamLog();
     }
     /**
-     * Stop log redirection. Waits up to one second for lines already in flight, then aborts the log stream request.
+     * Stop log redirection. Waits up to one second for lines already in flight, then aborts the log stream request. If
+     * no stream has delivered anything yet, reads the whole log in one request instead.
      */
     async stop() {
         if (!this.#streamingTask) {
             throw new Error('Streaming task is not active');
         }
         this.#stopLogging = true;
+        this.#wakeController.abort();
         const stopController = this.#stopController;
         const abortTimeout = setTimeout(() => stopController.abort(), STOP_GRACE_MILLIS);
         try {
@@ -193,11 +205,41 @@ export class StreamedLog {
             ? AbortSignal.any([this.#signal, this.#stopController.signal])
             : this.#stopController.signal;
         try {
-            const logStream = await this.#logClient.stream({ raw: true, signal });
-            if (!logStream) {
-                return;
+            let lastChunkRemainder;
+            let retryMillis = EMPTY_LOG_STREAM_RETRY_MILLIS;
+            // The API serves the log of a run that has not logged anything yet as an empty stream that ends at once,
+            // so reopen it until the first bytes arrive. If stopped before any bytes arrive, fetch it in one request.
+            while (!lastChunkRemainder) {
+                if (this.#stopLogging) {
+                    // `signal` is aborted once the stop grace period ends, which would cut this read short.
+                    const logContent = await this.#logClient.get({ raw: true, signal: this.#signal });
+                    lastChunkRemainder = await this.#logStreamChunks([new TextEncoder().encode(logContent ?? '')], signal);
+                    break;
+                }
+                let logStream;
+                try {
+                    logStream = await this.#logClient.stream({ raw: true, signal });
+                }
+                catch (err) {
+                    // The stop grace period ended while the stream was connecting, so read the log in one request.
+                    if (this.#stopLogging && !this.#signal?.aborted)
+                        continue;
+                    throw err;
+                }
+                if (!logStream) {
+                    return;
+                }
+                // A stream opened during stop() would be cut after its first chunk, so read the log in one request.
+                if (this.#stopLogging) {
+                    logStream.destroy();
+                    continue;
+                }
+                lastChunkRemainder = await this.#logStreamChunks(logStream, signal);
+                if (!lastChunkRemainder) {
+                    await sleep(retryMillis, AbortSignal.any([signal, this.#wakeController.signal]));
+                    retryMillis = Math.min(retryMillis * 2, EMPTY_LOG_STREAM_MAX_RETRY_MILLIS);
+                }
             }
-            const lastChunkRemainder = await this.#logStreamChunks(logStream, signal);
             // Process whatever is left when exiting. Maybe it is incomplete, maybe it is last log without EOL.
             const lastMessage = this.#decoder.decode(lastChunkRemainder).trim();
             if (lastMessage.length) {
@@ -210,13 +252,18 @@ export class StreamedLog {
             log.warning(`Log redirection stopped due to error`, err);
         }
     }
+    /**
+     * Redirect every complete message in the chunks and return the incomplete rest, or `undefined` when there were no
+     * chunks at all.
+     */
     async #logStreamChunks(logStream, signal) {
         // Chunk may be incomplete. Keep remainder for next chunk.
-        let previousChunkRemainder = new Uint8Array();
+        let previousChunkRemainder;
         try {
             for await (const chunk of logStream) {
                 // Handle possible leftover incomplete line from previous chunk.
                 // Everything before last end of line is complete.
+                previousChunkRemainder ??= new Uint8Array();
                 const chunkWithPreviousRemainder = new Uint8Array(previousChunkRemainder.length + chunk.length);
                 chunkWithPreviousRemainder.set(previousChunkRemainder, 0);
                 chunkWithPreviousRemainder.set(chunk, previousChunkRemainder.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.54",
+  "version": "3.0.0-beta.56",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.13.0"
@@ -59,7 +59,7 @@
   ],
   "apify": {
     "openapiSpec": {
-      "version": "v2-2026-10-01T153946Z"
+      "version": "v2-2026-10-08T073338Z"
     }
   },
   "dependencies": {