libmodulor 0.21.0 → 0.23.0

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

@@ -36,6 +36,9 @@ let MistralAILLMManager = class MistralAILLMManager {
                 if ('message' in error) {
                     return error.message;
                 }
+                if (typeof error.detail === 'string') {
+                    return error.detail;
+                }
                 return error.detail.map((d) => d.msg).join('\n');
             },
             method: 'POST',
@@ -43,6 +46,15 @@ let MistralAILLMManager = class MistralAILLMManager {
                 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 () => `${MistralAILLMManager_1.BASE_URL}/chat/completions`,
         });
     }

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

@@ -1,7 +1,11 @@
 import type { URL } from '../../dt/index.js';
 import type { HTTPAPICaller } from '../HTTPAPICaller.js';
-import type { LLMManager, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
+import type { LLMManager, LLMManagerSendOpts, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
 import type { Configurable, Settings, SettingsManager } from '../SettingsManager.js';
+interface OllamaGenerateRes {
+    done: boolean;
+    response: string;
+}
 /**
  * Unlike the "commercial" APIs, Ollama does not secure the API with an API key
  * @see https://github.com/ollama/ollama/issues/849
@@ -15,6 +19,7 @@ export declare class OllamaLLMManager implements Configurable<S>, LLMManager {
     private settingsManager;
     constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
     s(): OllamaLLMManagerSettings;
-    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+    send(req: LLMManagerSendReq, opts?: LLMManagerSendOpts): Promise<LLMManagerSendRes>;
+    toRes(stream: LLMManagerSendReq['stream'], res: OllamaGenerateRes): LLMManagerSendRes;
 }
 export {};

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 }, abortController, 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,43 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             return JSON.stringify(error);
         }
     }
-    async processResGood({ opts, outputBuilder, }, isFormURLEncoded, isJSON, isXML, response) {
+    async processResGood({ opts, outputBuilder, stream, }, abortController, 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({
+                abortController,
+                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({
+                abortController,
+                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 +240,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 +254,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/client/consts.js

@@ -2,6 +2,7 @@
  * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
  */
 export const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS = {
+    server_cookies_name_auth: 'auth',
     server_public_api_key: 'PublicApiKeyToBeChangedWhenDeploying',
     server_public_api_key_header_name: 'X-API-Key',
     server_public_url: 'http://localhost:7443',

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

@@ -1,20 +1,21 @@
 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';
 import type { RenderUCExecTouchable } from './touchable.js';
-type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Pick<UCPanelCtx<I, OPI0, OPI1>, 'clearAfterExec' | 'uc'> & {
-    autoExec?: boolean;
-    onDone?: UCPanelOnDone<I, OPI0, OPI1>;
-    onInit?: UCPanelOnInit<I, OPI0, OPI1>;
-    onError?: UCPanelOnError;
-    onStartSubmitting?: UCPanelOnStartSubmitting;
+export type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Pick<UCPanelCtx<I, OPI0, OPI1>, 'clearAfterExec' | 'uc'> & {
+    autoExec?: boolean | undefined;
+    onDone?: UCPanelOnDone<I, OPI0, OPI1> | undefined;
+    onInit?: UCPanelOnInit<I, OPI0, OPI1> | undefined;
+    onError?: UCPanelOnError | undefined;
+    onStartSubmitting?: UCPanelOnStartSubmitting | undefined;
     renderAutoExecLoader: RenderUCAutoExecLoader;
     renderExecTouchable: RenderUCExecTouchable<I, OPI0, OPI1>;
     renderForm: RenderUCForm<I, OPI0, OPI1>;
-    sleepInMs?: UIntDuration;
+    sleepInMs?: UIntDuration | undefined;
+    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 {};
+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;

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/react/useUC.js

@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
 import { UC, } from '../../../uc/index.js';
 /**
  * This hook provides utilities to init a use case and perform actions on it in a React way
@@ -21,6 +21,16 @@ export function useUC(appManifest, def, auth, opts) {
         }
         return v;
     });
+    // biome-ignore lint/correctness/useExhaustiveDependencies(appManifest): avoid infinite re-rendering
+    // biome-ignore lint/correctness/useExhaustiveDependencies(def): avoid infinite re-rendering
+    // biome-ignore lint/correctness/useExhaustiveDependencies(opts?.fillWith): avoid infinite re-rendering
+    useEffect(() => {
+        const v = new UC(appManifest, def, auth);
+        if (opts?.fillWith) {
+            v.fill(opts?.fillWith);
+        }
+        setUC(v);
+    }, [auth]);
     /**
      * Get a new `UC` based on the initial one
      * @param i

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

@@ -27,6 +27,7 @@ export interface ServerManagerSettings extends ServerManagerAuthSettings, Settin
     server_ssl_fullchain_path: FilePath | null;
     server_ssl_key_path: FilePath | null;
     server_static_dir_path: DirPath | null;
+    server_stop_mode: 'aggressive' | 'patient';
     server_tmp_path: FilePath;
 }
 export interface ServerManager extends Initializable {

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/consts.js

@@ -19,5 +19,6 @@ export const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS = {
     server_ssl_fullchain_path: null,
     server_ssl_key_path: null,
     server_static_dir_path: null,
+    server_stop_mode: 'patient',
     server_tmp_path: 'tmp',
 };

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

@@ -1,12 +1,49 @@
 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 () => {
+                            throw new Error('execOpts.stream.onClose needs to be set in the UC ServerMain');
+                        },
+                        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 () => {
+                    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 +53,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/target/lib/server-node/funcs.d.ts

@@ -1,5 +1,5 @@
 import type { Logger, SettingsManager } from '../../../std/index.js';
 import type { EntrypointsBuilder } from '../server/EntrypointsBuilder.js';
-import type { ListenSettings, Server } from './types.js';
+import type { ListenSettings, Server, StopSettings } from './types.js';
 export declare function listen(server: Server, entrypointsBuilder: EntrypointsBuilder, logger: Logger, settingsManager: SettingsManager<ListenSettings>): void;
-export declare function stop(server: Server): Promise<void>;
+export declare function stop(server: Server, settingsManager: SettingsManager<StopSettings>): Promise<void>;