@nylorun/agents 0.29.1-beta → 0.30.0-beta

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @nylorun/agents
 
+## 0.30.0-beta
+
+### Minor Changes
+
+- 2f3fc06: A skill file can be uploaded from a stream, so a client never holds a large one in memory (ADR-93).
+
+  - **`SkillFileSource.stream()`**, optional: each call opens a new stream of the file's bytes. When a source has it, `client.files.ensure` (and so `agentManifests.save`) sends the stream instead of `read()`'s bytes.
+  - **`client.files.uploadStream(stream, { sha256 })`** sends one file half-duplex, up to the Tenant's skill limit (2 GiB by default). The Runtime already streams the body to its hash.
+  - **A stream is never sent twice by the transport.** After an expired token or a protocol check, `ensure` opens a new stream and sends it once more.
+
+### Patch Changes
+
+- Pin core to the tested release.
+- Updated dependencies [2f3fc06]
+  - @nylorun/core@0.31.0-beta
+
 ## 0.29.1-beta
 
 ### Patch Changes

package/dist/files.d.ts

@@ -17,14 +17,26 @@ export declare class FilesClient {
         signal?: AbortSignal;
     }): Promise<boolean>;
     /**
-     * Uploads one file, at most 2 GiB. The Runtime checks its bytes hash to `sha256` (default:
-     * their hash) and keeps a file it already holds as it is.
+     * Uploads one file, at most the Tenant's skill limit (2 GiB by default). The Runtime checks its
+     * bytes hash to `sha256` (default: their hash) and keeps a file it already holds as it is.
      */
     upload(bytes: Uint8Array, options?: {
         sha256?: string;
         signal?: AbortSignal;
     }): Promise<DefinitionFileView>;
-    /** Uploads each of `files` the Runtime does not hold yet. */
+    /**
+     * Uploads one file from a stream, so a large file never sits in memory (ADR-93). `sha256` is
+     * required: the bytes aren't read before they are sent. The Runtime refuses a body with another
+     * hash and stores nothing.
+     */
+    uploadStream(stream: ReadableStream<Uint8Array>, options: {
+        sha256: string;
+        signal?: AbortSignal;
+    }): Promise<DefinitionFileView>;
+    /**
+     * Uploads each of `files` the Runtime does not hold yet: from its `stream()` when the source has
+     * one, else from `read()`.
+     */
     ensure(files: ReadonlyMap<string, SkillFileSource>, options?: {
         signal?: AbortSignal;
     }): Promise<void>;

package/dist/files.js

@@ -37,8 +37,8 @@ export class FilesClient {
         }
     }
     /**
-     * Uploads one file, at most 2 GiB. The Runtime checks its bytes hash to `sha256` (default:
-     * their hash) and keeps a file it already holds as it is.
+     * Uploads one file, at most the Tenant's skill limit (2 GiB by default). The Runtime checks its
+     * bytes hash to `sha256` (default: their hash) and keeps a file it already holds as it is.
      */
     async upload(bytes, options = {}) {
         const response = await this.transport.request(pathOf(options.sha256 ?? (await definitionFileHash(bytes))), {
@@ -49,12 +49,44 @@ export class FilesClient {
         });
         return (await response.json());
     }
-    /** Uploads each of `files` the Runtime does not hold yet. */
+    /**
+     * Uploads one file from a stream, so a large file never sits in memory (ADR-93). `sha256` is
+     * required: the bytes aren't read before they are sent. The Runtime refuses a body with another
+     * hash and stores nothing.
+     */
+    async uploadStream(stream, options) {
+        const response = await this.transport.request(pathOf(options.sha256), {
+            method: "PUT",
+            body: stream,
+            headers: { "content-type": "application/octet-stream" },
+            // Node's fetch sends a stream body only half-duplex.
+            duplex: "half",
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        return (await response.json());
+    }
+    /**
+     * Uploads each of `files` the Runtime does not hold yet: from its `stream()` when the source has
+     * one, else from `read()`.
+     */
     async ensure(files, options = {}) {
         for (const [sha256, source] of files) {
             if (await this.has(sha256, options))
                 continue;
-            await this.upload(await source.read(), { sha256, ...options });
+            if (!source.stream) {
+                await this.upload(await source.read(), { sha256, ...options });
+                continue;
+            }
+            try {
+                await this.uploadStream(source.stream(), { sha256, ...options });
+            }
+            catch (error) {
+                // The transport doesn't resend a stream: once more with a new one after an expired token
+                // or a protocol check, which the transport has handled for the next request.
+                if (!(error instanceof RuntimeError) || (error.status !== 401 && error.status !== 426))
+                    throw error;
+                await this.uploadStream(source.stream(), { sha256, ...options });
+            }
         }
     }
 }

package/dist/http.js

@@ -138,18 +138,22 @@ export class Transport {
             headers: await this.authHeaders(init),
             redirect: "error",
         });
+        // A stream body can't be sent twice: its caller sends a new one (FilesClient.ensure).
+        const resendable = !(typeof ReadableStream !== "undefined" && init.body instanceof ReadableStream);
         // An expired token: get a new one and try once more.
         if (response.status === 401 && this.token && !options.retried401) {
             const body = (await response.clone().json().catch(() => undefined));
             if (body?.code === "token_expired") {
-                await response.body?.cancel().catch(() => { });
                 this.token.invalidate();
-                return this.request(path, init, { ...options, retried401: true });
+                if (resendable) {
+                    await response.body?.cancel().catch(() => { });
+                    return this.request(path, init, { ...options, retried401: true });
+                }
             }
         }
         if (response.status === 426) {
             this.clearCompatibilityCache();
-            if (!options.retried426) {
+            if (!options.retried426 && resendable) {
                 await this.ensureCompatible(init.signal === null ? undefined : init.signal);
                 return this.request(path, init, { retried426: true });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/agents",
-  "version": "0.29.1-beta",
+  "version": "0.30.0-beta",
   "description": "Nylorun agent definitions and session client",
   "type": "module",
   "license": "Apache-2.0",
@@ -43,7 +43,7 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@nylorun/core": "0.30.0-beta",
+    "@nylorun/core": "0.31.0-beta",
     "gray-matter": "^4.0.3"
   },
   "peerDependencies": {