@praxisui/dynamic-form 9.0.0-beta.9 → 9.0.0-beta.90

package/fesm2022/{praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-CmFfx-VR.mjs → praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-w9V0aQ9B.mjs}

@@ -1,21 +1,22 @@
-import { firstValueFrom } from 'rxjs';
+import { Observable } from 'rxjs';
+import { withAuthoringScopePolicy } from '@praxisui/ai';
 
 class DynamicFormAgenticAuthoringTurnFlow {
     adapter;
-    aiApi;
+    turnClient;
     mode = 'agentic-authoring';
-    constructor(adapter, aiApi) {
+    constructor(adapter, turnClient) {
         this.adapter = adapter;
-        this.aiApi = aiApi;
+        this.turnClient = turnClient;
     }
-    async submit(request) {
+    submit(request) {
         const prompt = (request.prompt ?? '').trim();
         if (!prompt) {
-            return {
+            return Promise.resolve({
                 state: 'listening',
                 phase: 'capture',
                 statusText: '',
-            };
+            });
         }
         const componentId = this.adapter.componentId || request.componentId || 'praxis-dynamic-form';
         const componentType = this.adapter.componentType || request.componentType || 'form';
@@ -23,25 +24,207 @@ class DynamicFormAgenticAuthoringTurnFlow {
         const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
         const contextHints = this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.optionalJsonObject(request.action?.contextHints));
         if (this.shouldRestrictToInlineHelp(contextHints)) {
-            return this.toInlineHelpOnlyResult(prompt, request, contextHints);
+            return Promise.resolve(this.toInlineHelpOnlyResult(prompt, request, contextHints));
         }
-        const response = await firstValueFrom(this.aiApi.getPatch({
-            componentId,
-            componentType,
-            userPrompt: prompt,
-            sessionId: request.sessionId,
-            clientTurnId: request.clientTurnId,
-            messages: this.toChatMessages(request.messages, prompt),
-            currentState,
-            currentStateDigest: this.buildCurrentStateDigest(currentState, runtimeState),
-            uiContextRef: {
+        const buildRequest = async () => {
+            await this.adapter.prepareAuthoringContext?.();
+            const preparedRuntimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.()) ?? runtimeState;
+            const preparedContextHints = this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.optionalJsonObject(request.action?.contextHints));
+            const dataProfile = this.optionalJsonObject(this.adapter.getDataProfile?.());
+            const schemaFields = this.adapter.getSchemaFields?.()
+                ?.map((field) => this.toAiJsonObject(field))
+                .filter((field) => Object.keys(field).length > 0);
+            const patchRequest = withAuthoringScopePolicy({
+                componentId,
+                componentType,
+                userPrompt: prompt,
+                sessionId: request.sessionId,
+                clientTurnId: request.clientTurnId,
+                messages: this.toChatMessages(request.messages, prompt),
+                currentState,
+                currentStateDigest: this.buildCurrentStateDigest(currentState, preparedRuntimeState),
+                uiContextRef: {
+                    componentId,
+                    componentType,
+                },
+                ...(dataProfile ? { dataProfile } : {}),
+                ...(preparedRuntimeState ? { runtimeState: preparedRuntimeState } : {}),
+                ...(schemaFields?.length ? { schemaFields } : {}),
+                ...(preparedContextHints ? { contextHints: preparedContextHints } : {}),
+            }, {
                 componentId,
                 componentType,
-            },
-            ...(runtimeState ? { runtimeState } : {}),
-            ...(contextHints ? { contextHints } : {}),
+                componentLabel: this.adapter.componentName || 'formulário',
+            });
+            return {
+                ...patchRequest,
+                targetApp: 'praxis-ui-angular',
+                targetComponentId: componentId,
+                currentPage: currentState,
+                conversationMessages: this.toConversationMessages(request.messages),
+                pendingClarification: this.toPendingClarification(request),
+                attachmentSummaries: this.toAttachmentSummaries(request),
+                activeSemanticDecision: this.optionalJsonObject(request.activeSemanticDecision ?? request.action?.activeSemanticDecision),
+                contextHints: patchRequest.contextHints ?? null,
+            };
+        };
+        return this.submitViaAgenticStream(request, buildRequest);
+    }
+    submitViaAgenticStream(request, buildRequest) {
+        return new Observable((subscriber) => {
+            let closed = false;
+            let subscription = null;
+            const close = () => {
+                closed = true;
+                subscription?.unsubscribe();
+                subscription = null;
+            };
+            void buildRequest()
+                .then((turnRequest) => {
+                if (closed)
+                    return;
+                subscription = this.turnClient.streamEvents(turnRequest, {
+                    initialStatusText: 'Preparando o contexto seguro do formulário.',
+                    resultTimeoutMs: 90_000,
+                    streamTimeoutMs: 90_000,
+                }).subscribe({
+                    next: (event) => {
+                        if (closed)
+                            return;
+                        const result = this.toAgenticStreamTurnResult(event, request);
+                        subscriber.next(result);
+                        if (result.state !== 'processing') {
+                            subscriber.complete();
+                            close();
+                        }
+                    },
+                    error: (error) => {
+                        if (closed)
+                            return;
+                        subscriber.next(this.toAssistantErrorResult(error));
+                        subscriber.complete();
+                        close();
+                    },
+                });
+            })
+                .catch((error) => {
+                if (closed)
+                    return;
+                subscriber.next(this.toAssistantErrorResult(error));
+                subscriber.complete();
+                close();
+            });
+            return () => close();
+        });
+    }
+    toAgenticStreamTurnResult(event, request) {
+        if (event.kind === 'stream-started') {
+            return {
+                state: 'processing',
+                phase: 'contextualize',
+                statusText: 'Analisando o formulário e suas capacidades.',
+                sessionId: event.start.threadId,
+                clientTurnId: request.clientTurnId ?? event.start.turnId,
+                observationId: event.start.observationId ?? null,
+                canApply: false,
+            };
+        }
+        if (event.kind === 'stream-lifecycle') {
+            return {
+                state: 'processing',
+                phase: 'contextualize',
+                statusText: event.statusText,
+                sessionId: event.start.threadId,
+                clientTurnId: request.clientTurnId ?? event.start.turnId,
+                observationId: event.start.observationId ?? null,
+                canApply: false,
+                diagnostics: event.diagnostics
+                    ? { streamLifecycle: { phase: event.phase, ...event.diagnostics } }
+                    : undefined,
+            };
+        }
+        if (event.event.type === 'result') {
+            const payload = this.toRecord(event.event.payload) ?? {};
+            const rawResponse = this.toRecord(payload['response']) ?? payload;
+            const response = this.normalizeAgenticResponse(rawResponse);
+            return {
+                ...this.toTurnResult(this.compileAdapterResponse(response), request),
+                sessionId: event.event.threadId || request.sessionId,
+                clientTurnId: request.clientTurnId ?? event.event.turnId,
+            };
+        }
+        return this.turnClient.toTurnResult(event.event, request.clientTurnId);
+    }
+    normalizeAgenticResponse(response) {
+        const type = response['type'];
+        const normalizedType = type === 'patch'
+            || type === 'clarification'
+            || type === 'error'
+            || type === 'info'
+            ? type
+            : this.toRecord(response['patch']) || this.toRecord(response['compiledPatch'])
+                ? 'patch'
+                : 'info';
+        const patch = this.toRecord(response['patch']) ?? this.toRecord(response['compiledPatch']) ?? undefined;
+        const message = typeof response['message'] === 'string'
+            ? response['message']
+            : typeof response['assistantMessage'] === 'string'
+                ? response['assistantMessage']
+                : undefined;
+        return {
+            ...response,
+            type: normalizedType,
+            ...(patch ? { patch } : {}),
+            ...(message ? { message } : {}),
+        };
+    }
+    toConversationMessages(messages) {
+        return (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            id: message.id,
+            role: message.role,
+            text: message.text,
+        }))
+            .filter((message) => message.text.trim().length > 0);
+    }
+    toPendingClarification(request) {
+        const pending = request.pendingClarification;
+        if (!pending?.sourcePrompt?.trim())
+            return null;
+        return {
+            sourcePrompt: pending.sourcePrompt,
+            questions: pending.questions.map((question) => question.label).filter(Boolean),
+            assistantMessage: pending.assistantMessage ?? null,
+            clientTurnId: pending.clientTurnId ?? null,
+            diagnostics: this.optionalJsonObject(pending.diagnostics) ?? null,
+        };
+    }
+    toAttachmentSummaries(request) {
+        return (request.attachments ?? []).map((attachment) => ({
+            id: attachment.id,
+            name: attachment.name,
+            kind: attachment.kind,
+            mimeType: attachment.mimeType ?? null,
+            sizeBytes: attachment.sizeBytes ?? null,
+            source: attachment.source ?? null,
+            hasPreview: !!attachment.previewUrl,
         }));
-        return this.toTurnResult(this.compileAdapterResponse(response), request);
+    }
+    toAssistantErrorResult(error) {
+        const message = error instanceof Error
+            ? error.message
+            : typeof error === 'string' && error.trim()
+                ? error
+                : 'Não foi possível concluir o pedido do formulário.';
+        return {
+            state: 'error',
+            phase: 'capture',
+            assistantMessage: `Não consegui concluir este pedido. ${message}`,
+            errorText: message,
+            canApply: false,
+            pendingPatch: null,
+        };
     }
     async apply(request) {
         const contextHints = this.optionalJsonObject(this.adapter.getAuthoringContext?.());