libmodulor 0.20.0 → 0.22.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/NodeFormDataBuilder.js

@@ -19,7 +19,9 @@ let NodeFormDataBuilder = class NodeFormDataBuilder {
                     chunks.push(chunk);
                 });
                 rs.on('end', () => {
-                    fd.append(key, new Blob(chunks, { type: val.type }), basename(val.uri));
+                    fd.append(key, 
+                    // @ts-expect-error
+                    new Blob(chunks, { type: val.type }), basename(val.uri));
                     resolve(null);
                 });
                 rs.on('error', (err) => {

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 }, 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 {
@@ -177,7 +219,7 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
                 payload = {};
                 // TODO : Find a better way to do this (without adding any external dependency because the code must be portable)
                 new URL(`http://localhost?${asText}`).searchParams.forEach((v, k) => {
-                    // @ts-ignore
+                    // @ts-expect-error
                     payload[k] = v;
                 });
             }
@@ -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

@@ -14,7 +14,7 @@ var CommandExecutor_1;
 import { inject, injectable } from 'inversify';
 import { WordingManager } from '../../../i18n/index.js';
 import { FSManagerItemInfoType, } from '../../../std/index.js';
-import { UCInputFieldChangeOperator, ucifMustBeFilledManually, } from '../../../uc/index.js';
+import { ucifMustBeFilledManually, } from '../../../uc/index.js';
 import { print, printError } from './renderer.js';
 let CommandExecutor = class CommandExecutor {
     static { CommandExecutor_1 = this; }
@@ -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));
@@ -89,7 +97,7 @@ let CommandExecutor = class CommandExecutor {
             const invite = `${label}${help}`;
             await this.promptManager.prompt(invite, {
                 validate: async (v) => {
-                    f.setValue(UCInputFieldChangeOperator.SET, v);
+                    f.setVal(v);
                     const validation = f.validate();
                     const violation = validation.get();
                     if (!violation) {

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();
         },
@@ -27,9 +27,6 @@ export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onErr
         },
         sleepInMs,
     });
-    const onChange = (f, op, v) => {
-        f.setValue(op, v);
-    };
     const clear = () => {
         if (!clearAfterExec) {
             return;
@@ -46,7 +43,6 @@ export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onErr
     return (_jsxs(UCContainer, { uc: uc, children: [autoExec && ctx.disabled && renderAutoExecLoader(), !autoExec && (_jsxs(_Fragment, { children: [needsInputFilling &&
                         renderForm({
                             ...ctx,
-                            onChange,
                             onSubmit: exec,
                         }), !needsInputFilling &&
                         renderExecTouchable({

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

@@ -1,13 +1,13 @@
 import type { ReactElement } from 'react';
 import type { DataType, ErrorMessage } from '../../../dt/index.js';
 import type { I18nManager } from '../../../std/index.js';
-import type { UCInput, UCInputField, UCInputFieldChangeOperator, UCInputFieldValue, UCOPIBase } from '../../../uc/index.js';
+import type { UCInput, UCInputField, UCOPIBase } from '../../../uc/index.js';
 import type { UCPanelCtx, UCPanelOnSubmit, UCPanelState } from './panel.js';
-export type UCFormFieldControlOnChange<T extends DataType = DataType> = (f: UCInputField<T>, op: UCInputFieldChangeOperator, v: UCInputFieldValue<T>) => void;
+export type UCFormFieldControlOnChange = () => void;
 export type UCFormFieldControlProps<T extends DataType> = UCPanelState & {
     errMsg?: ErrorMessage | null;
     f: UCInputField<T>;
-    onChange: UCFormFieldControlOnChange<T>;
+    onChange: UCFormFieldControlOnChange;
 };
 export interface UCFormFieldDescProps<T extends DataType> {
     f: UCInputField<T>;
@@ -20,15 +20,14 @@ export interface UCFormFieldLabelProps<T extends DataType> {
 }
 export declare const UC_FORM_FIELD_ELEMENTS: readonly ["control", "desc", "err", "label"];
 export type UCFormFieldElement = (typeof UC_FORM_FIELD_ELEMENTS)[number];
-export type UCFormFieldProps<T extends DataType> = UCFormFieldControlProps<T> & {
+export type UCFormFieldProps<T extends DataType> = Omit<UCFormFieldControlProps<T>, 'onChange'> & {
     only?: UCFormFieldElement[];
 };
 export type UCFormProps<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCPanelCtx<I, OPI0, OPI1> & {
-    onChange: UCFormFieldControlOnChange;
     onSubmit: UCPanelOnSubmit;
 };
 export type UCFormSubmitControlProps<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCPanelCtx<I, OPI0, OPI1> & {
     onPress?: () => Promise<void>;
 };
 export type RenderUCForm<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (props: UCFormProps<I, OPI0, OPI1>) => ReactElement;
-export declare function validateFormField<T extends DataType = DataType>(i18nManager: I18nManager, f: UCInputField<T>, v: UCInputFieldValue<T>): ErrorMessage | null;
+export declare function validateFormField<T extends DataType = DataType>(i18nManager: I18nManager, f: UCInputField<T>): ErrorMessage | null;

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

@@ -5,18 +5,15 @@ export const UC_FORM_FIELD_ELEMENTS = [
     'err',
     'label',
 ];
-export function validateFormField(i18nManager, f, v) {
-    if (isBlank(v)) {
+export function validateFormField(i18nManager, f) {
+    if (isBlank(f.getValue())) {
         return null;
     }
-    const vArr = Array.isArray(v) ? v : [v];
-    for (const vv of vArr) {
-        const validation = f.def.type.assign(vv).validate();
-        const violation = validation.get();
-        if (violation) {
-            const [key, expected] = violation;
-            return i18nManager.t(key, { vars: { expected } });
-        }
+    const validation = f.validate();
+    const violation = validation.get();
+    if (violation) {
+        const [key, expected] = violation;
+        return i18nManager.t(key, { vars: { expected } });
     }
     return null;
 }

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

@@ -1,7 +1,7 @@
-import { type ArgsRecord, UC, type UCDef, type UCInput, type UCOPIBase } from '../../../uc/index.js';
-export type CloneFunc<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (i: Partial<I>) => UC<I, OPI0, OPI1>;
+import { type ArgsRecord, UC, type UCDef, type UCInput, type UCInputPartial, type UCOPIBase } from '../../../uc/index.js';
+export type CloneFunc<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (i: UCInputPartial<I>) => UC<I, OPI0, OPI1>;
 export type DivertFunc<II extends UCInput | undefined = undefined, OOPI0 extends UCOPIBase | undefined = undefined, OOPI1 extends UCOPIBase | undefined = undefined> = (siblingUCD: UCDef) => UC<II, OOPI0, OOPI1>;
-export type RefillFunc<I extends UCInput | undefined = undefined> = (i: Partial<I>) => void;
+export type RefillFunc<I extends UCInput | undefined = undefined> = (i: UCInputPartial<I>) => void;
 /**
  * This hook provides utilities to init a use case and perform actions on it in a React way
  * @param appManifest
@@ -11,7 +11,7 @@ export type RefillFunc<I extends UCInput | undefined = undefined> = (i: Partial<
  * @returns
  */
 export declare function useUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: ArgsRecord<I, OPI0, OPI1>['appManifest'], def: ArgsRecord<I, OPI0, OPI1>['def'], auth: ArgsRecord<I, OPI0, OPI1>['auth'], opts?: {
-    fillWith: Partial<I>;
+    fillWith: UCInputPartial<I>;
 }): [
     UC<I, OPI0, OPI1>,
     {

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;
 }