libmodulor 0.21.0 → 0.22.0

package/dist/esm/std/impl/OllamaLLMManager.js

@@ -24,7 +24,7 @@ let OllamaLLMManager = class OllamaLLMManager {
             oll_base_url: this.settingsManager.get()('oll_base_url'),
         };
     }
-    async send(req) {
+    async send(req, opts) {
         const firstMessage = req.messages[0];
         if (!firstMessage) {
             throw new IllegalArgumentError('Please provide at least one message');
@@ -32,20 +32,47 @@ let OllamaLLMManager = class OllamaLLMManager {
         return await this.httpAPICaller.exec({
             errBuilder: async (error) => error.error,
             method: 'POST',
-            outputBuilder: async (res) => ({
-                choices: [{ message: { content: res.response } }],
-            }),
+            outputBuilder: async (res) => this.toRes(req.stream, res),
             req: {
                 builder: async () => ({
                     model: req.model,
                     prompt: firstMessage.content,
-                    stream: false,
+                    stream: req.stream ?? false,
                 }),
                 envelope: 'json',
             },
+            stream: {
+                onData: (res) => {
+                    opts?.stream?.onData?.(res);
+                    // Beware : this won't work if/when we accept multiple choices in the request
+                    if (res.choices[0]?.finish_reason) {
+                        opts?.stream?.onDone();
+                    }
+                },
+            },
             urlBuilder: async () => `${this.s().oll_base_url}/api/generate`,
         });
     }
+    toRes(stream, res) {
+        if (stream) {
+            return {
+                choices: [
+                    {
+                        delta: { content: res.response },
+                        finish_reason: res.done ? 'stop' : null,
+                    },
+                ],
+            };
+        }
+        return {
+            choices: [
+                {
+                    finish_reason: res.done ? 'stop' : null,
+                    message: { content: res.response },
+                },
+            ],
+        };
+    }
 };
 OllamaLLMManager = __decorate([
     injectable(),

package/dist/esm/std/impl/OpenAILLMManager.js

@@ -38,6 +38,15 @@ let OpenAILLMManager = class OpenAILLMManager {
                 builder: async () => req,
                 envelope: 'json',
             },
+            stream: {
+                onData: (res) => {
+                    opts?.stream?.onData?.(res);
+                    // Beware : this won't work if/when we accept multiple choices in the request
+                    if (res.choices[0]?.finish_reason) {
+                        opts?.stream?.onDone();
+                    }
+                },
+            },
             urlBuilder: async () => `${OpenAILLMManager_1.BASE_URL}/chat/completions`,
         });
     }

package/dist/esm/std/impl/SimpleHTTPAPICaller.d.ts

@@ -1,19 +1,23 @@
-import { HTTPRequestBuilder } from '../../utils/index.js';
+import { HTTPRequestBuilder, NDJSONStreamManager, SSEStreamManager } from '../../utils/index.js';
 import type { BufferManager } from '../BufferManager.js';
 import type { HTTPAPICallExecutor, HTTPAPICallExecutorAgentBuilder } from '../HTTPAPICallExecutor.js';
 import type { HTTPAPICaller, HTTPAPICallerInput } from '../HTTPAPICaller.js';
 import type { Logger } from '../Logger.js';
 import type { XMLManager } from '../XMLManager.js';
+export declare const ERR_STREAM_UNAVAILABLE = "The internal HTTP impl (fetch ?) does not implement streaming (React Native ?)";
 export declare class SimpleHTTPAPICaller implements HTTPAPICaller {
     private bufferManager;
     private httpAPICallExecutor;
     private httpAPICallExecutorAgentBuilder;
     private httpRequestBuilder;
     private logger;
+    private ndJSONStreamManager;
+    private sseStreamManager;
     private xmlManager;
-    constructor(bufferManager: BufferManager, httpAPICallExecutor: HTTPAPICallExecutor, httpAPICallExecutorAgentBuilder: HTTPAPICallExecutorAgentBuilder, httpRequestBuilder: HTTPRequestBuilder, logger: Logger, xmlManager: XMLManager);
-    exec<AH extends object | undefined, Req extends object, ResBad, ResGood, O>({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType, errBuilder, method, opts, outputBuilder, req, urlBuilder, unknownErrorMessage, }: HTTPAPICallerInput<AH, Req, ResBad, ResGood, O>): Promise<O>;
+    constructor(bufferManager: BufferManager, httpAPICallExecutor: HTTPAPICallExecutor, httpAPICallExecutorAgentBuilder: HTTPAPICallExecutorAgentBuilder, httpRequestBuilder: HTTPRequestBuilder, logger: Logger, ndJSONStreamManager: NDJSONStreamManager, sseStreamManager: SSEStreamManager, xmlManager: XMLManager);
+    exec<AH extends object | undefined, Req extends object, ResBad, ResGood, O>({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType, errBuilder, method, opts, outputBuilder, registerAbort, req, stream, urlBuilder, unknownErrorMessage, }: HTTPAPICallerInput<AH, Req, ResBad, ResGood, O>): Promise<O>;
     private computeHeaders;
     private processResBad;
     private processResGood;
+    private throwError;
 }

package/dist/esm/std/impl/SimpleHTTPAPICaller.js

@@ -12,23 +12,28 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'inversify';
 import { CustomError, IllegalArgumentError } from '../../error/index.js';
-import { HTTPRequestBuilder } from '../../utils/index.js';
+import { HTTPRequestBuilder, isClientError, NDJSONStreamManager, SSEStreamManager, } from '../../utils/index.js';
+export const ERR_STREAM_UNAVAILABLE = 'The internal HTTP impl (fetch ?) does not implement streaming (React Native ?)';
 let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
     bufferManager;
     httpAPICallExecutor;
     httpAPICallExecutorAgentBuilder;
     httpRequestBuilder;
     logger;
+    ndJSONStreamManager;
+    sseStreamManager;
     xmlManager;
-    constructor(bufferManager, httpAPICallExecutor, httpAPICallExecutorAgentBuilder, httpRequestBuilder, logger, xmlManager) {
+    constructor(bufferManager, httpAPICallExecutor, httpAPICallExecutorAgentBuilder, httpRequestBuilder, logger, ndJSONStreamManager, sseStreamManager, xmlManager) {
         this.bufferManager = bufferManager;
         this.httpAPICallExecutor = httpAPICallExecutor;
         this.httpAPICallExecutorAgentBuilder = httpAPICallExecutorAgentBuilder;
         this.httpRequestBuilder = httpRequestBuilder;
         this.logger = logger;
+        this.ndJSONStreamManager = ndJSONStreamManager;
+        this.sseStreamManager = sseStreamManager;
         this.xmlManager = xmlManager;
     }
-    async exec({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', errBuilder, method, opts, outputBuilder, req, urlBuilder, unknownErrorMessage = CustomError.ERROR_UNKNOWN, }) {
+    async exec({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', errBuilder, method, opts, outputBuilder, registerAbort, req, stream, urlBuilder, unknownErrorMessage = CustomError.ERROR_UNKNOWN, }) {
         const baseURL = await urlBuilder();
         const data = (await req?.builder?.()) || {};
         const { body, url } = await this.httpRequestBuilder.exec({
@@ -46,11 +51,16 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         const agent = this.httpAPICallExecutorAgentBuilder.exec({
             url: new URL(url),
         });
+        const abortController = new AbortController();
+        registerAbort?.(() => {
+            abortController.abort();
+        });
         const response = await this.httpAPICallExecutor.fn()(url, {
             agent,
             body,
             headers: reqHeaders,
             method,
+            signal: abortController.signal,
         });
         const { headers, status } = response;
         this.logger.trace('HTTPAPICaller', {
@@ -66,24 +76,24 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         }
         // Using .startsWith instead of === because the value can look like this 'application/json; charset=utf-8'
         const responseContentType = headers.get('Content-Type');
-        const isJSON = responseContentType?.startsWith('application/json');
         const isFormURLEncoded = responseContentType?.startsWith('application/x-www-form-urlencoded');
+        const isJSON = responseContentType?.startsWith('application/json');
+        const isNDJSON = responseContentType?.startsWith('application/x-ndjson');
+        const isSSE = responseContentType?.startsWith('text/event-stream');
         const isXML = responseContentType?.startsWith('text/xml');
         this.logger.trace('HTTPAPICaller', {
             isFormURLEncoded,
             isJSON,
+            isNDJSON,
+            isSSE,
             isXML,
         });
         const { ok, redirected } = response;
         if (ok || redirected) {
-            return this.processResGood({ opts, outputBuilder }, isFormURLEncoded, isJSON, isXML, response);
-        }
-        const errMsg = await this.processResBad({ errBuilder, opts }, isJSON, isXML, response);
-        const message = errMsg ?? unknownErrorMessage;
-        if (status < 500) {
-            throw new IllegalArgumentError(message);
+            return this.processResGood({ opts, outputBuilder, stream }, isFormURLEncoded, isJSON, isNDJSON, isSSE, isXML, response);
         }
-        throw new Error(message);
+        const message = await this.processResBad({ errBuilder, opts }, isJSON, isXML, response);
+        this.throwError(message ?? unknownErrorMessage, status);
     }
     async computeHeaders({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', req, }) {
         const headers = {};
@@ -163,9 +173,41 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             return JSON.stringify(error);
         }
     }
-    async processResGood({ opts, outputBuilder, }, isFormURLEncoded, isJSON, isXML, response) {
+    async processResGood({ opts, outputBuilder, stream, }, isFormURLEncoded, isJSON, isNDJSON, isSSE, isXML, response) {
         let payload;
-        if (isJSON) {
+        if (isNDJSON && stream) {
+            if (!response.body) {
+                throw new Error(ERR_STREAM_UNAVAILABLE);
+            }
+            await this.ndJSONStreamManager.exec({
+                onData: async (data) => {
+                    if (outputBuilder) {
+                        stream.onData(await outputBuilder(data));
+                    }
+                    else {
+                        stream.onData(data);
+                    }
+                },
+                reader: response.body.getReader(),
+            });
+        }
+        else if (isSSE && stream) {
+            if (!response.body) {
+                throw new Error(ERR_STREAM_UNAVAILABLE);
+            }
+            await this.sseStreamManager.exec({
+                onData: async (data) => {
+                    if (outputBuilder) {
+                        stream.onData(await outputBuilder(data));
+                    }
+                    else {
+                        stream.onData(data);
+                    }
+                },
+                reader: response.body.getReader(),
+            });
+        }
+        else if (isJSON) {
             payload = await response.json();
         }
         else {
@@ -196,6 +238,12 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         }
         return payload;
     }
+    throwError(message, status) {
+        if (isClientError(status)) {
+            throw new IllegalArgumentError(message);
+        }
+        throw new Error(message);
+    }
 };
 SimpleHTTPAPICaller = __decorate([
     injectable(),
@@ -204,7 +252,10 @@ SimpleHTTPAPICaller = __decorate([
     __param(2, inject('HTTPAPICallExecutorAgentBuilder')),
     __param(3, inject(HTTPRequestBuilder)),
     __param(4, inject('Logger')),
-    __param(5, inject('XMLManager')),
-    __metadata("design:paramtypes", [Object, Object, Object, HTTPRequestBuilder, Object, Object])
+    __param(5, inject(NDJSONStreamManager)),
+    __param(6, inject(SSEStreamManager)),
+    __param(7, inject('XMLManager')),
+    __metadata("design:paramtypes", [Object, Object, Object, HTTPRequestBuilder, Object, NDJSONStreamManager,
+        SSEStreamManager, Object])
 ], SimpleHTTPAPICaller);
 export { SimpleHTTPAPICaller };

package/dist/esm/target/lib/cli/CommandExecutor.js

@@ -41,7 +41,15 @@ let CommandExecutor = class CommandExecutor {
             if (!confirmed) {
                 return;
             }
-            const ucor = await this.ucManager.execClient(uc);
+            const ucor = await this.ucManager.execClient(uc, {
+                stream: {
+                    onClose: async () => { },
+                    onData: async (ucor) => {
+                        print(JSON.stringify(ucor.output()));
+                    },
+                    onDone: async () => { },
+                },
+            });
             const output = ucor.output();
             if (output) {
                 print(JSON.stringify(output));

package/dist/esm/target/lib/react/UCPanel.d.ts

@@ -1,6 +1,7 @@
 import { type ReactElement } from 'react';
 import type { UIntDuration } from '../../../dt/index.js';
-import { type UCInput, type UCOPIBase } from '../../../uc/index.js';
+import { type UCInput, type UCOPIBase, type UCOutputReader } from '../../../uc/index.js';
+import { type StreamConfig } from '../../../utils/index.js';
 import type { RenderUCForm } from './form.js';
 import type { RenderUCAutoExecLoader } from './loader.js';
 import type { UCPanelCtx, UCPanelOnDone, UCPanelOnError, UCPanelOnInit, UCPanelOnStartSubmitting } from './panel.js';
@@ -15,6 +16,7 @@ type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | u
     renderExecTouchable: RenderUCExecTouchable<I, OPI0, OPI1>;
     renderForm: RenderUCForm<I, OPI0, OPI1>;
     sleepInMs?: UIntDuration;
+    stream?: StreamConfig<UCOutputReader<I, OPI0, OPI1>> | undefined;
 };
-export declare function UCPanel<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ autoExec, clearAfterExec, onDone, onError, onInit, onStartSubmitting, renderAutoExecLoader, renderForm, renderExecTouchable, sleepInMs, uc, }: Props<I, OPI0, OPI1>): ReactElement;
+export declare function UCPanel<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ autoExec, clearAfterExec, onDone, onError, onInit, onStartSubmitting, renderAutoExecLoader, renderForm, renderExecTouchable, sleepInMs, stream, uc, }: Props<I, OPI0, OPI1>): ReactElement;
 export {};

package/dist/esm/target/lib/react/UCPanel.js

@@ -5,12 +5,12 @@ import { sleep } from '../../../utils/index.js';
 import { useDIContext } from './DIContextProvider.js';
 import { UCContainer } from './UCContainer.js';
 import { useAction } from './useAction.js';
-export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onError, onInit, onStartSubmitting, renderAutoExecLoader, renderForm, renderExecTouchable, sleepInMs, uc, }) {
+export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onError, onInit, onStartSubmitting, renderAutoExecLoader, renderForm, renderExecTouchable, sleepInMs, stream, uc, }) {
     const { container } = useDIContext();
     const [ucManager] = useState(container.get('UCManager'));
     const { exec, execState } = useAction({
         action: async () => {
-            const ucor = await ucManager.execClient(uc);
+            const ucor = await ucManager.execClient(uc, { stream });
             await onDone?.(ucor);
             clear();
         },

package/dist/esm/target/lib/server/ServerRequestHandler.d.ts

@@ -1,7 +1,7 @@
 import type { AppManifest } from '../../../app/index.js';
 import type { HTTPMethod, HTTPStatusNumber, URL, URLPath } from '../../../dt/index.js';
 import type { SettingsManager, Worker } from '../../../std/index.js';
-import { UCBuilder, type UCDef, type UCInput, type UCManager, type UCOPIBase, type UCOutput } from '../../../uc/index.js';
+import { UCBuilder, type UCDef, type UCInput, type UCManager, type UCManagerExecServerOpts, type UCOPIBase, type UCOutput } from '../../../uc/index.js';
 import type { HTTPDataEnvelope, HTTPReqData } from '../../../utils/index.js';
 import { AuthCookieCreator, type Output as AuthCookieCreatorOutput } from './AuthCookieCreator.js';
 import { AuthenticationChecker } from './AuthenticationChecker.js';
@@ -29,6 +29,7 @@ export interface ServerRequestHandlerRes {
 interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
     appManifest: AppManifest;
     envelope: HTTPDataEnvelope;
+    execOpts?: UCManagerExecServerOpts<OPI0, OPI1> | undefined;
     req: ServerRequestHandlerReq;
     res: ServerRequestHandlerRes;
     ucd: UCDef<I, OPI0, OPI1>;
@@ -61,7 +62,7 @@ export declare class ServerRequestHandler implements Worker<Input, Promise<Outpu
     private static X_FORWARDED_PROTO_HEADER_NAME;
     constructor(authCookieCreator: AuthCookieCreator, authenticationChecker: AuthenticationChecker, customerFacingErrorBuilder: CustomerFacingErrorBuilder, publicApiKeyChecker: PublicApiKeyChecker, requestChecker: RequestChecker, requestLogger: RequestLogger, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder);
     s(): S;
-    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, envelope, req, res, ucd, ucManager, }: Input<I, OPI0, OPI1>): Promise<Output<OPI0, OPI1>>;
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, envelope, execOpts, req, res, ucd, ucManager, }: Input<I, OPI0, OPI1>): Promise<Output<OPI0, OPI1>>;
     private fill;
     private applySideEffects;
     private applyClearAuthSideEffect;

package/dist/esm/target/lib/server/ServerRequestHandler.js

@@ -47,7 +47,7 @@ let ServerRequestHandler = class ServerRequestHandler {
             server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
         };
     }
-    async exec({ appManifest, envelope, req, res, ucd, ucManager, }) {
+    async exec({ appManifest, envelope, execOpts, req, res, ucd, ucManager, }) {
         try {
             const { bodyRaw, cookie, header, method, secure, url } = req;
             this.requestLogger.exec({
@@ -79,7 +79,7 @@ let ServerRequestHandler = class ServerRequestHandler {
                 uc.auth = auth;
             }
             await this.fill(req, envelope, uc);
-            const output = await ucManager.execServer(uc);
+            const output = await ucManager.execServer(uc, execOpts);
             const { status } = await this.applySideEffects(res, ucd, output);
             if (status !== undefined) {
                 return {

package/dist/esm/target/lib/server-express/funcs.js

@@ -1,12 +1,48 @@
 import cookieParser from 'cookie-parser';
 import express, {} from 'express';
 import fileUpload from 'express-fileupload';
+import { fmtSingleDataMsg, fmtSSEError, isError, SSE_HEADERS, } from '../../../utils/index.js';
 export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager) {
     const { envelope } = contract;
     const handler = async (req, res) => {
+        const transportType = ucd.ext?.http?.transportType ?? 'standard';
+        let execOpts;
+        switch (transportType) {
+            case 'standard':
+                // Nothing to do
+                break;
+            case 'stream': {
+                execOpts = {
+                    stream: {
+                        onClose: async () => { },
+                        onData: async (output) => {
+                            if (!output) {
+                                return;
+                            }
+                            res.write(fmtSingleDataMsg(output));
+                        },
+                        onDone: async () => {
+                            res.end();
+                        },
+                    },
+                };
+                for (const [k, v] of SSE_HEADERS) {
+                    res.setHeader(k, v);
+                }
+                res.flushHeaders();
+                res.on('close', async () => {
+                    res.end();
+                    await execOpts?.stream?.onClose();
+                });
+                break;
+            }
+            default:
+                ((_) => { })(transportType);
+        }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
             envelope,
+            execOpts,
             req: toReq(req),
             res: toRes(res),
             ucd,
@@ -16,7 +52,22 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
             res.status(status).send();
             return;
         }
-        res.status(status).send(body);
+        switch (transportType) {
+            case 'standard':
+                res.status(status).send(body);
+                return;
+            case 'stream': {
+                if (isError(status)) {
+                    res.write(fmtSSEError({
+                        message: body.message,
+                        status,
+                    }));
+                }
+                return;
+            }
+            default:
+                ((_) => { })(transportType);
+        }
     };
     return handler;
 }

package/dist/esm/target/lib/server-hono/funcs.js

@@ -3,14 +3,60 @@ import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
 import { logger } from 'hono/logger';
 import { secureHeaders } from 'hono/secure-headers';
 import { NotFoundError } from '../../../error/index.js';
-import { fromFormData } from '../../../utils/index.js';
+import { fmtSingleDataMsg, fmtSSEError, fromFormData, isError, SSE_HEADERS, } from '../../../utils/index.js';
 export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager, beforeExec) {
     const { envelope } = contract;
     const handler = async (c) => {
         await beforeExec?.(c);
+        const transportType = ucd.ext?.http?.transportType ?? 'standard';
+        let execOpts;
+        let stream;
+        let controller;
+        switch (transportType) {
+            case 'standard':
+                // Nothing to do
+                break;
+            case 'stream': {
+                stream = new ReadableStream({
+                    start: (ctrl) => {
+                        controller = ctrl;
+                        let closed = false;
+                        const close = () => {
+                            if (closed) {
+                                return;
+                            }
+                            ctrl.close();
+                            closed = true;
+                        };
+                        execOpts = {
+                            stream: {
+                                onClose: async () => { },
+                                onData: async (output) => {
+                                    if (!output || closed) {
+                                        return;
+                                    }
+                                    ctrl.enqueue(fmtSingleDataMsg(output));
+                                },
+                                onDone: async () => {
+                                    close();
+                                },
+                            },
+                        };
+                        c.req.raw.signal.addEventListener('abort', async () => {
+                            close();
+                            await execOpts?.stream?.onClose();
+                        });
+                    },
+                });
+                break;
+            }
+            default:
+                ((_) => { })(transportType);
+        }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
             envelope,
+            execOpts,
             req: toReq(c),
             res: toRes(c),
             ucd,
@@ -19,6 +65,23 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
         if (!body) {
             return c.newResponse(null, status);
         }
+        switch (transportType) {
+            case 'standard':
+                return c.json(body, status);
+            case 'stream': {
+                if (isError(status)) {
+                    controller?.enqueue(fmtSSEError({
+                        message: body.message,
+                        status,
+                    }));
+                }
+                return new Response(stream, {
+                    headers: SSE_HEADERS,
+                });
+            }
+            default:
+                ((_) => { })(transportType);
+        }
         return c.json(body, status);
     };
     return handler;
@@ -50,7 +113,7 @@ export function toReq(c) {
     return {
         bodyFromFormData: async () => fromFormData(await c.req.formData()),
         bodyFromJSON: () => c.req.json(),
-        bodyFromQueryParams: async () => c.req.queries(),
+        bodyFromQueryParams: async () => c.req.query(),
         bodyRaw: c.req.raw,
         cookie: async (name) => getCookie(c, name),
         header: async (name) => c.req.header(name),

package/dist/esm/testing/workers/UCExecutor.js

@@ -13,6 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var UCExecutor_1;
 import { inject, injectable } from 'inversify';
 import { rInput, UCBuilder, } from '../../uc/index.js';
+const ERR_CLIENT_EXPECTED_UCOR = (name) => `${name} client is expected to return an ucor`;
 const ERR_CLIENT_EXPECTED_OUTPUT = (name) => `${name} client is expected to return an output but returned nothing`;
 const ERR_CLIENT_UNEXPECTED_OUTPUT = (name) => `${name} client is expected to return nothing but returned an output`;
 let UCExecutor = class UCExecutor {
@@ -70,7 +71,44 @@ let UCExecutor = class UCExecutor {
         out.io.i = input;
         out.hash = this.cryptoManager.hash(UCExecutor_1.HASH_ALG, [name, JSON.stringify(args), JSON.stringify(input)].join(UCExecutor_1.HASH_SEP), UCExecutor_1.HASH_BTT_ENCODING);
         try {
-            const ucor = await this.ucManager.execClient(uc);
+            let ucor;
+            const transportType = ucd.ext?.http?.transportType ?? 'standard';
+            switch (transportType) {
+                case 'standard':
+                    ucor = await this.ucManager.execClient(uc);
+                    break;
+                case 'stream': {
+                    try {
+                        let abort;
+                        await this.ucManager.execClient(uc, {
+                            registerAbort: (func) => {
+                                abort = func;
+                            },
+                            stream: {
+                                onClose: async () => { },
+                                onData: async (ucor2) => {
+                                    if (!ucor) {
+                                        ucor = ucor2;
+                                        abort();
+                                    }
+                                },
+                                onDone: async () => { },
+                            },
+                        });
+                    }
+                    catch (err) {
+                        if (err.name !== 'AbortError') {
+                            throw err;
+                        }
+                    }
+                    break;
+                }
+                default:
+                    ((_) => { })(transportType);
+            }
+            if (!ucor) {
+                throw new Error(ERR_CLIENT_EXPECTED_UCOR(name));
+            }
             const output = ucor.output();
             if (uc.hasOutputParts() && !output) {
                 throw new Error(ERR_CLIENT_EXPECTED_OUTPUT(name));

package/dist/esm/uc/ext.d.ts

@@ -1,4 +1,4 @@
-import type { HTTPMethod, URLPath } from '../dt/index.js';
+import type { HTTPMethod, TransportType, URLPath } from '../dt/index.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCOutput } from './output.js';
 import type { UCMountingPoint } from './utils/ucMountingPoint.js';
@@ -41,5 +41,11 @@ export interface UCExt<OPI0 extends UCOPIBase | undefined = undefined, OPI1 exte
          * @returns
          */
         transform?: (output: UCOutput<OPI0, OPI1>) => object;
+        /**
+         * The way the output is transported
+         *
+         * By default, it's `standard`.
+         */
+        transportType?: TransportType;
     };
 }

package/dist/esm/uc/impl/HTTPUCTransporter.d.ts

@@ -3,7 +3,7 @@ import type { ServerClientManager, ServerClientManagerSettings } from '../../tar
 import type { UCInput } from '../input.js';
 import type { UCOPIBase } from '../opi.js';
 import type { UCOutputOrNothing } from '../output.js';
-import type { UCTransporter } from '../transporter.js';
+import type { UCTransporter, UCTransporterOpts } from '../transporter.js';
 import type { UC } from '../UC.js';
 type S = Pick<ServerClientManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name'>;
 export declare class HTTPUCTransporter implements Configurable<S>, UCTransporter {
@@ -12,6 +12,6 @@ export declare class HTTPUCTransporter implements Configurable<S>, UCTransporter
     private settingsManager;
     constructor(httpAPICaller: HTTPAPICaller, serverClientManager: ServerClientManager, settingsManager: SettingsManager<S>);
     s(): S;
-    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts: UCTransporterOpts<OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
 }
 export {};

package/dist/esm/uc/impl/HTTPUCTransporter.js

@@ -29,7 +29,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
             server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
         };
     }
-    async send(uc) {
+    async send(uc, opts) {
         const { auth, def: { sec }, } = uc;
         const baseURL = await this.serverClientManager.baseURL({ auth });
         const { contentType, envelope, method, path } = ucHTTPContract(uc);
@@ -96,10 +96,12 @@ let HTTPUCTransporter = class HTTPUCTransporter {
             contentType,
             errBuilder: async (error) => error.message,
             method,
+            registerAbort: opts.registerAbort,
             req: {
                 builder: async () => rInput(uc, { ignoreUndefined: true }),
                 envelope,
             },
+            stream: opts.stream,
             urlBuilder: async () => `${baseURL}${path}`,
         });
         // In case of 204, we get an empty object.

package/dist/esm/uc/impl/SimpleUCManager.d.ts

@@ -7,7 +7,7 @@ import { UCOutputReader } from '../helpers/UCOutputReader.js';
 import type { UCInit } from '../init.js';
 import type { UCInput } from '../input.js';
 import type { UCMain } from '../main.js';
-import type { UCManager, UCManagerPersistOpts } from '../manager.js';
+import type { UCManager, UCManagerExecClientOpts, UCManagerExecServerOpts, UCManagerPersistOpts } from '../manager.js';
 import type { UCOPIBase } from '../opi.js';
 import type { UCOutputOrNothing } from '../output.js';
 import type { UC } from '../UC.js';
@@ -29,8 +29,8 @@ export declare class SimpleUCManager implements UCManager {
     constructor(ucClientConfirmManager: UCClientConfirmManager, clockManager: ClockManager, cryptoManager: CryptoManager, logger: Logger, ucDataStore: UCDataStore, ucExecChecker: UCExecChecker, ucInputFilesProcessor: UCInputFilesProcessor, ucInputValidator: UCInputValidator, ucInitProvider: Provider<UCInit>, ucMainProvider: Provider<UCMain>);
     commitTx(): Promise<void>;
     confirmClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<boolean>;
-    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
-    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCManagerExecClientOpts<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
+    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCManagerExecServerOpts<OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
     initServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<void>;
     startTx(): Promise<void>;
     persist<I extends UCInput | undefined = undefined, D extends UCData | null = null, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, data?: D, opts?: UCManagerPersistOpts): Promise<UCDataStoreRecord<I, D>>;