@praxisui/ai 8.0.0-beta.11 → 8.0.0-beta.13

package/README.md

@@ -196,6 +196,24 @@ Notes:
 - `currentState` must be the config root (not wrapped under `config`).
 - Clarifications may return `{ type: "clarification", message, options }`.
 
+### Agentic authoring manifest tools
+- `GET /api/praxis/config/ai/authoring/manifests/{componentId}`
+- `GET /api/praxis/config/ai/authoring/manifests/{componentId}/editable-targets`
+- `GET /api/praxis/config/ai/authoring/manifests/{componentId}/operations`
+- `POST /api/praxis/config/ai/authoring/manifests/{componentId}/resolve-target`
+- `POST /api/praxis/config/ai/authoring/manifests/{componentId}/validate-plan`
+- `POST /api/praxis/config/ai/authoring/manifests/{componentId}/compile-patch`
+
+`AiBackendApiService` exposes these endpoints through typed methods so hosts can inspect the executable manifest, resolve targets, validate a component edit plan and compile a backend-owned patch without routing by local keywords.
+
+### Agentic authoring turn streaming
+- `POST /api/praxis/config/ai/authoring/turn/stream/start`
+- `GET /api/praxis/config/ai/authoring/turn/stream/{streamId}`
+- `GET /api/praxis/config/ai/authoring/turn/stream/{streamId}/probe`
+- `POST /api/praxis/config/ai/authoring/turn/stream/{streamId}/cancel`
+
+`AiBackendApiService.startAgenticAuthoringTurnStream`, `connectAgenticAuthoringTurnStream` and `cancelAgenticAuthoringTurnStream` use the same SSE envelope contract as patch streaming. Browser `EventSource` cannot send custom headers, so signed stream tokens returned by the backend should be passed to `connectAgenticAuthoringTurnStream` and `cancelAgenticAuthoringTurnStream` when the backend uses signed-url stream auth.
+
 ## Assistant local history (UI)
 
 The assistant stores a lightweight local history in the browser using `localStorage`. It is scoped by

package/fesm2022/praxisui-ai.mjs

@@ -65,8 +65,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
  * Do not edit manually. Run praxis-config-starter/tools/contracts/generate-ai-contract-bindings.js.
  */
 const AI_CONTRACT_VERSION = 'v1.1';
-const AI_CONTRACT_SCHEMA_HASH = 'dacaba8fa7ec21ee9ae31bab7057614837d2d1320d784d0ee61fb840efe55a35';
+const AI_CONTRACT_SCHEMA_HASH = 'de47da5e091f33ba0e885ab6d679fd498b0bcee30479aaa98eb35b2166736311';
 const AI_STREAM_EVENT_SCHEMA_VERSION = 'v1';
+const AI_DOMAIN_CATALOG_CONTEXT_HINT_SCHEMA_VERSION = 'praxis.ai.context-hints.domain-catalog/v0.1';
 const AI_STREAM_EVENT_TYPES = ['status', 'thought.step', 'heartbeat', 'result', 'error', 'cancelled'];
 
 /**
@@ -786,6 +787,94 @@ class AiBackendApiService {
             withCredentials: true,
         });
     }
+    startAgenticAuthoringTurnStream(request) {
+        return this.http.post(`${this.baseUrl}/authoring/turn/stream/start`, request, {
+            headers: this.buildHeaders(),
+            withCredentials: true,
+        });
+    }
+    connectAgenticAuthoringTurnStream(streamId, lastEventId, accessToken) {
+        const queryParams = [];
+        if (lastEventId?.trim()) {
+            queryParams.push(`lastEventId=${encodeURIComponent(lastEventId.trim())}`);
+        }
+        if (accessToken?.trim()) {
+            queryParams.push(`accessToken=${encodeURIComponent(accessToken.trim())}`);
+        }
+        const query = queryParams.length > 0 ? `?${queryParams.join('&')}` : '';
+        const streamPath = `${this.baseUrl}/authoring/turn/stream/${encodeURIComponent(streamId)}`;
+        const endpoint = `${streamPath}${query}`;
+        const probeEndpoint = `${streamPath}/probe${accessToken?.trim()
+            ? `?accessToken=${encodeURIComponent(accessToken.trim())}`
+            : ''}`;
+        let source = null;
+        const events$ = new Observable((subscriber) => {
+            let disposed = false;
+            const openStream = async () => {
+                if (typeof EventSource === 'undefined') {
+                    subscriber.error(new AiPatchStreamConnectionError('unsupported', 'EventSource is not supported in this environment.'));
+                    return;
+                }
+                const probeStatus = await this.probePatchStreamEndpoint(probeEndpoint);
+                if (disposed) {
+                    return;
+                }
+                if (typeof probeStatus === 'number' && probeStatus >= 400) {
+                    subscriber.error(new AiPatchStreamConnectionError('http_status', `Agentic authoring stream probe failed with status ${probeStatus}.`, probeStatus));
+                    return;
+                }
+                source = new EventSource(endpoint, { withCredentials: true });
+                source.onmessage = (messageEvent) => {
+                    try {
+                        const parsed = this.parsePatchStreamEnvelope(messageEvent.data);
+                        subscriber.next(parsed);
+                    }
+                    catch (error) {
+                        if (error instanceof AiPatchStreamConnectionError) {
+                            subscriber.error(error);
+                            return;
+                        }
+                        subscriber.error(new AiPatchStreamConnectionError('parse', 'Failed to parse agentic authoring stream event payload.'));
+                    }
+                };
+                source.onerror = () => {
+                    if (!source) {
+                        subscriber.error(new AiPatchStreamConnectionError('transport', 'Agentic authoring stream connection error.'));
+                        return;
+                    }
+                    if (source.readyState === EventSource.CLOSED) {
+                        subscriber.error(new AiPatchStreamConnectionError('transport', 'Agentic authoring stream connection closed unexpectedly.'));
+                    }
+                };
+            };
+            void openStream();
+            return () => {
+                disposed = true;
+                if (source) {
+                    source.close();
+                    source = null;
+                }
+            };
+        });
+        return {
+            events$,
+            close: () => {
+                if (source) {
+                    source.close();
+                    source = null;
+                }
+            },
+        };
+    }
+    cancelAgenticAuthoringTurnStream(streamId, accessToken) {
+        const endpoint = `${this.baseUrl}/authoring/turn/stream/${encodeURIComponent(streamId)}/cancel${accessToken?.trim()
+            ? `?accessToken=${encodeURIComponent(accessToken.trim())}`
+            : ''}`;
+        return this.http.post(endpoint, {}, {
+            headers: this.buildHeaders(),
+            withCredentials: true,
+        });
+    }
     listModels(request) {
         return this.http.post(`${this.baseUrl}/providers/models`, request, { headers: this.buildHeaders() });
     }
@@ -802,6 +891,24 @@ class AiBackendApiService {
         const params = new HttpParams({ fromObject: { componentType } });
         return this.http.get(`${this.contextUrl}/${componentId}`, { headers: this.buildHeaders(), params });
     }
+    getAgenticAuthoringManifest(componentId) {
+        return this.http.get(`${this.authoringManifestUrl(componentId)}`, { headers: this.buildHeaders() });
+    }
+    listAgenticAuthoringManifestTargets(componentId) {
+        return this.http.get(`${this.authoringManifestUrl(componentId)}/editable-targets`, { headers: this.buildHeaders() });
+    }
+    listAgenticAuthoringManifestOperations(componentId) {
+        return this.http.get(`${this.authoringManifestUrl(componentId)}/operations`, { headers: this.buildHeaders() });
+    }
+    resolveAgenticAuthoringManifestTarget(componentId, request) {
+        return this.http.post(`${this.authoringManifestUrl(componentId)}/resolve-target`, request, { headers: this.buildHeaders() });
+    }
+    validateAgenticAuthoringManifestPlan(componentId, request) {
+        return this.http.post(`${this.authoringManifestUrl(componentId)}/validate-plan`, request, { headers: this.buildHeaders() });
+    }
+    compileAgenticAuthoringManifestPatch(componentId, request) {
+        return this.http.post(`${this.authoringManifestUrl(componentId)}/compile-patch`, request, { headers: this.buildHeaders() });
+    }
     loadGlobalAiConfig() {
         const snapshot = this.globalConfigStore?.getAiConfigSnapshot?.();
         if (snapshot !== undefined) {
@@ -842,6 +949,9 @@ class AiBackendApiService {
         }
         return AI_INTENT_CONTRACT_SCHEMA_HASH;
     }
+    authoringManifestUrl(componentId) {
+        return `${this.baseUrl}/authoring/manifests/${encodeURIComponent(componentId)}`;
+    }
     resolveHeaderMap(extra) {
         const allowLocalIdentityFallback = !!this.storageOpts?.allowLocalIdentityFallback;
         const defaults = this.storageOpts?.defaultHeaders
@@ -1024,7 +1134,7 @@ class AiResponseValidatorService {
                 code: 'MISSING_RULE_NAME'
             });
         }
-        if (!response.targetType || !['field', 'section', 'action', 'row', 'column'].includes(response.targetType)) {
+        if (!response.targetType || !['field', 'section', 'action', 'row', 'column', 'visualBlock'].includes(response.targetType)) {
             errors.push({
                 field: 'targetType',
                 message: 'targetType inválido',
@@ -1158,6 +1268,10 @@ class AiResponseValidatorService {
                 return;
             }
             const args = Array.isArray(rawArgs) ? rawArgs : [rawArgs];
+            const arityIssue = this.validateJsonLogicOperatorArity(operator, args.length);
+            if (arityIssue) {
+                issues.push({ message: arityIssue });
+            }
             args.forEach((arg) => this.walkJsonLogicNode(arg, false, issues));
             return;
         }
@@ -1194,6 +1308,49 @@ class AiResponseValidatorService {
             'max',
         ].includes(operator);
     }
+    validateJsonLogicOperatorArity(operator, argumentCount) {
+        const exactArity = {
+            '==': 2,
+            '===': 2,
+            '!=': 2,
+            '!==': 2,
+            '>': 2,
+            '>=': 2,
+            '<': 2,
+            '<=': 2,
+            '!': 1,
+            '!!': 1,
+            in: 2,
+            contains: 2,
+            startsWith: 2,
+            endsWith: 2,
+            '-': 2,
+            '/': 2,
+            '%': 2,
+        };
+        const expected = exactArity[operator];
+        if (expected !== undefined && argumentCount !== expected) {
+            return `Operator ${operator} requires exactly ${expected} argument(s).`;
+        }
+        if ((operator === 'and' || operator === 'or') && argumentCount < 2) {
+            return `Operator ${operator} requires at least 2 arguments.`;
+        }
+        if (operator === 'if' && argumentCount < 3) {
+            return 'Operator if requires at least 3 arguments.';
+        }
+        if ((operator === 'cat'
+            || operator === '+'
+            || operator === '*'
+            || operator === 'min'
+            || operator === 'max')
+            && argumentCount < 1) {
+            return `Operator ${operator} requires at least 1 argument.`;
+        }
+        if (operator === 'substr' && (argumentCount < 2 || argumentCount > 3)) {
+            return 'Operator substr requires 2 or 3 arguments.';
+        }
+        return null;
+    }
     collectVarPaths(value, collector) {
         if (Array.isArray(value)) {
             value.forEach((item) => this.collectVarPaths(item, collector));
@@ -5084,15 +5241,15 @@ class PraxisAiAssistantComponent {
             .filter((value) => value.length > 0);
     }
     resolveBadgeContextHints(contextHints) {
-        if (!contextHints || typeof contextHints !== 'object')
+        const candidate = this.toAiJsonObject(contextHints);
+        if (!Object.keys(candidate).length)
             return null;
-        const badge = this.asRecord(contextHints['badge']);
+        const badge = this.asRecord(candidate['badge']);
         if (badge)
             return this.toAiJsonObject(badge);
-        const candidate = contextHints;
         const hasBadgeKeys = ['field', 'values', 'valueColorMap', 'palette', 'inferredType', 'explicitType']
             .some((key) => Object.prototype.hasOwnProperty.call(candidate, key));
-        return hasBadgeKeys ? candidate : null;
+        return hasBadgeKeys ? this.toAiJsonObject(candidate) : null;
     }
     hasBadgeValues(badgeHints) {
         if (!badgeHints)

package/index.d.ts

@@ -18,8 +18,9 @@ declare class PraxisAi {
  * Do not edit manually. Run praxis-config-starter/tools/contracts/generate-ai-contract-bindings.js.
  */
 declare const AI_CONTRACT_VERSION: "v1.1";
-declare const AI_CONTRACT_SCHEMA_HASH: "dacaba8fa7ec21ee9ae31bab7057614837d2d1320d784d0ee61fb840efe55a35";
+declare const AI_CONTRACT_SCHEMA_HASH: "de47da5e091f33ba0e885ab6d679fd498b0bcee30479aaa98eb35b2166736311";
 declare const AI_STREAM_EVENT_SCHEMA_VERSION: "v1";
+declare const AI_DOMAIN_CATALOG_CONTEXT_HINT_SCHEMA_VERSION: "praxis.ai.context-hints.domain-catalog/v0.1";
 declare const AI_STREAM_EVENT_TYPES: readonly ["status", "thought.step", "heartbeat", "result", "error", "cancelled"];
 type AiJsonPrimitive = string | number | boolean | null;
 type AiJsonArray = AiJsonValue[];
@@ -27,6 +28,20 @@ interface AiJsonObject {
     [key: string]: AiJsonValue;
 }
 type AiJsonValue = AiJsonPrimitive | AiJsonObject | AiJsonArray;
+type AiDomainCatalogContextHintItemType = 'context' | 'node' | 'edge' | 'binding' | 'evidence' | 'governance';
+interface AiDomainCatalogContextHintContract {
+    schemaVersion?: typeof AI_DOMAIN_CATALOG_CONTEXT_HINT_SCHEMA_VERSION;
+    serviceKey?: string;
+    type?: AiDomainCatalogContextHintItemType;
+    query?: string | null;
+    contextKey?: string | null;
+    nodeType?: string | null;
+    limit?: number;
+}
+interface AiContextHintsContract {
+    domainCatalog?: AiDomainCatalogContextHintContract;
+    [key: string]: AiJsonValue | AiDomainCatalogContextHintContract | undefined;
+}
 interface AiSchemaContextContract {
     path?: string | null;
     operation?: string | null;
@@ -64,7 +79,7 @@ interface AiOrchestratorRequestContract {
     schemaFields?: AiJsonObject[] | null;
     runtimeState?: AiJsonObject | null;
     suggestedPatch?: AiJsonObject | null;
-    contextHints?: AiJsonObject | null;
+    contextHints?: AiContextHintsContract | null;
     aiMode?: string;
     requireSchema?: boolean;
     resourcePath?: string;
@@ -86,7 +101,7 @@ interface AiOptionContract {
     value?: string | null;
     label?: string | null;
     example?: string | null;
-    contextHints?: AiJsonObject | null;
+    contextHints?: AiContextHintsContract | null;
 }
 interface AiClarificationUiContract {
     responseType?: 'text' | 'choice' | 'confirm' | 'mixed' | 'context';
@@ -161,7 +176,7 @@ interface AgenticAuthoringIntentResolutionRequestContract extends AgenticAuthori
     provider?: string | null;
     model?: string | null;
     apiKey?: string | null;
-    contextHints?: AiJsonObject | null;
+    contextHints?: AiContextHintsContract | null;
 }
 interface AgenticAuthoringCandidateContract {
     resourcePath?: string | null;
@@ -172,7 +187,7 @@ interface AgenticAuthoringCandidateContract {
     score?: number | null;
     reason?: string | null;
     evidence?: string[] | null;
-    [key: string]: AiJsonValue | undefined;
+    [key: string]: AiJsonValue | AiContextHintsContract | undefined;
 }
 interface AgenticAuthoringQuickReplyContract {
     id: string;
@@ -182,8 +197,8 @@ interface AgenticAuthoringQuickReplyContract {
     description?: string | null;
     icon?: string | null;
     tone?: string | null;
-    contextHints?: AiJsonObject | null;
-    [key: string]: AiJsonValue | undefined;
+    contextHints?: AiContextHintsContract | null;
+    [key: string]: AiJsonValue | AiContextHintsContract | undefined;
 }
 interface AgenticAuthoringIntentResolutionResultContract {
     valid?: boolean;
@@ -228,7 +243,7 @@ interface AgenticAuthoringPlanRequestContract extends AgenticAuthoringConversati
     apiKey?: string | null;
     currentPage?: AiJsonObject | null;
     intentResolution?: AgenticAuthoringIntentResolutionResultContract | null;
-    contextHints?: AiJsonObject | null;
+    contextHints?: AiContextHintsContract | null;
 }
 interface AgenticAuthoringTurnStreamRequestContract extends AgenticAuthoringConversationContextContract {
     userPrompt: string;
@@ -240,9 +255,9 @@ interface AgenticAuthoringTurnStreamRequestContract extends AgenticAuthoringConv
     provider?: string | null;
     model?: string | null;
     apiKey?: string | null;
-    contextHints?: AiJsonObject | null;
+    contextHints?: AiContextHintsContract | null;
     componentCapabilities?: AgenticAuthoringComponentCapabilitiesResultContract | null;
-    [key: string]: AiJsonValue | AgenticAuthoringComponentCapabilitiesResultContract | AgenticAuthoringConversationMessageContract[] | AgenticAuthoringPendingClarificationContract | AgenticAuthoringAttachmentSummaryContract[] | undefined;
+    [key: string]: AiJsonValue | AiContextHintsContract | AgenticAuthoringComponentCapabilitiesResultContract | AgenticAuthoringConversationMessageContract[] | AgenticAuthoringPendingClarificationContract | AgenticAuthoringAttachmentSummaryContract[] | undefined;
 }
 interface AgenticAuthoringPreviewResultContract {
     valid?: boolean;
@@ -296,6 +311,39 @@ interface AgenticAuthoringComponentCapabilitiesResultContract {
     catalogs?: AgenticAuthoringComponentCapabilityCatalogContract[];
     [key: string]: AiJsonValue | AgenticAuthoringComponentCapabilityCatalogContract[] | undefined;
 }
+interface AgenticAuthoringManifestEditPlanRequestContract {
+    config?: AiJsonObject | null;
+    plan?: AiJsonObject | null;
+}
+interface AgenticAuthoringResolveTargetRequestContract {
+    config?: AiJsonObject | null;
+    operationId?: string | null;
+    target?: AiJsonValue;
+    input?: AiJsonValue;
+}
+interface AgenticAuthoringResolvedTargetContract {
+    status?: string | null;
+    componentId?: string | null;
+    operationId?: string | null;
+    kind?: string | null;
+    resolver?: string | null;
+    path?: string | null;
+    value?: AiJsonValue;
+    candidates?: string[];
+    failures?: string[];
+}
+interface AgenticAuthoringManifestValidationResultContract {
+    valid?: boolean;
+    failures?: string[];
+    warnings?: string[];
+    normalizedPlan?: AiJsonObject | null;
+}
+interface AgenticAuthoringManifestCompileResultContract {
+    compiled?: boolean;
+    failures?: string[];
+    warnings?: string[];
+    patch?: AiJsonObject | null;
+}
 interface AiPatchStreamStartResponseContract {
     streamId: string;
     threadId: string;
@@ -359,7 +407,7 @@ interface AiRuleResponse {
     /** Descriptive name for the rule */
     ruleName: string;
     /** Type of target (scope) */
-    targetType: 'field' | 'section' | 'action' | 'row' | 'column';
+    targetType: 'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock';
     /** IDs of the target elements */
     targetIds: string[];
     /** Canonical JSON Logic condition payload or null for always applied */
@@ -485,7 +533,7 @@ interface RulePropertyDefinition {
     }>;
     category?: 'content' | 'appearance' | 'behavior' | 'layout' | 'validation';
 }
-type RulePropertySchema = Record<'field' | 'section' | 'action' | 'row' | 'column', RulePropertyDefinition[]>;
+type RulePropertySchema = Record<'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock', RulePropertyDefinition[]>;
 
 type PraxisAssistantShellMessageRole = 'user' | 'assistant' | 'system' | 'status' | 'error';
 type PraxisAssistantShellMode = 'config' | 'agentic-authoring' | 'chat' | 'diagnostic' | 'review' | 'inline-help';
@@ -874,7 +922,7 @@ declare class PraxisAiService {
 }
 
 declare const AI_INTENT_CONTRACT_VERSION: "v1.1";
-declare const AI_INTENT_CONTRACT_SCHEMA_HASH: "dacaba8fa7ec21ee9ae31bab7057614837d2d1320d784d0ee61fb840efe55a35";
+declare const AI_INTENT_CONTRACT_SCHEMA_HASH: "de47da5e091f33ba0e885ab6d679fd498b0bcee30479aaa98eb35b2166736311";
 type AiSchemaContext = AiSchemaContextContract;
 interface AiSuggestionsRequest {
     componentId: string;
@@ -907,10 +955,22 @@ type AiPatchStreamEventType = AiPatchStreamEventType$1;
 type AiPatchStreamStartResponse = AiPatchStreamStartResponseContract;
 type AiPatchStreamCancelResponse = AiPatchStreamCancelResponseContract;
 type AiPatchStreamEnvelope<TPayload extends AiJsonObject = AiJsonObject> = AiPatchStreamEnvelopeContract<TPayload>;
+type AgenticAuthoringManifestEditPlanRequest = AgenticAuthoringManifestEditPlanRequestContract;
+type AgenticAuthoringResolveTargetRequest = AgenticAuthoringResolveTargetRequestContract;
+type AgenticAuthoringResolvedTarget = AgenticAuthoringResolvedTargetContract;
+type AgenticAuthoringManifestValidationResult = AgenticAuthoringManifestValidationResultContract;
+type AgenticAuthoringManifestCompileResult = AgenticAuthoringManifestCompileResultContract;
+type AgenticAuthoringTurnStreamRequest = AgenticAuthoringTurnStreamRequestContract;
+type AgenticAuthoringTurnStreamStartResponse = AgenticAuthoringTurnStreamStartResponseContract;
+type AgenticAuthoringTurnStreamEnvelope<TPayload extends AiJsonObject = AiJsonObject> = AgenticAuthoringTurnStreamEnvelopeContract<TPayload>;
 interface AiPatchStreamConnection {
     events$: Observable<AiPatchStreamEnvelope>;
     close: () => void;
 }
+interface AgenticAuthoringTurnStreamConnection {
+    events$: Observable<AgenticAuthoringTurnStreamEnvelope>;
+    close: () => void;
+}
 type AiPatchStreamConnectionErrorKind = 'unsupported' | 'http_status' | 'transport' | 'parse' | 'schema';
 declare class AiPatchStreamConnectionError extends Error {
     readonly kind: AiPatchStreamConnectionErrorKind;
@@ -1016,17 +1076,27 @@ declare class AiBackendApiService {
     startPatchStream(request: AiOrchestratorRequest): Observable<AiPatchStreamStartResponse>;
     connectPatchStream(streamId: string, lastEventId?: string, accessToken?: string): AiPatchStreamConnection;
     cancelPatchStream(streamId: string, accessToken?: string): Observable<AiPatchStreamCancelResponse>;
+    startAgenticAuthoringTurnStream(request: AgenticAuthoringTurnStreamRequest): Observable<AgenticAuthoringTurnStreamStartResponse>;
+    connectAgenticAuthoringTurnStream(streamId: string, lastEventId?: string, accessToken?: string): AgenticAuthoringTurnStreamConnection;
+    cancelAgenticAuthoringTurnStream(streamId: string, accessToken?: string): Observable<AiPatchStreamCancelResponse>;
     listModels(request: AiProviderModelsRequest): Observable<AiProviderModelsResponse>;
     listProviderCatalog(): Observable<AiProviderCatalogResponse>;
     testProvider(request: AiProviderTestRequest): Observable<AiProviderTestResponse>;
     getAiStatus(): Observable<AiProviderStatusResponse>;
     getAiContext(componentId: string, componentType: string): Observable<AiContextDTO>;
+    getAgenticAuthoringManifest(componentId: string): Observable<AiJsonObject>;
+    listAgenticAuthoringManifestTargets(componentId: string): Observable<AiJsonObject[]>;
+    listAgenticAuthoringManifestOperations(componentId: string): Observable<AiJsonObject[]>;
+    resolveAgenticAuthoringManifestTarget(componentId: string, request: AgenticAuthoringResolveTargetRequest): Observable<AgenticAuthoringResolvedTarget>;
+    validateAgenticAuthoringManifestPlan(componentId: string, request: AgenticAuthoringManifestEditPlanRequest): Observable<AgenticAuthoringManifestValidationResult>;
+    compileAgenticAuthoringManifestPatch(componentId: string, request: AgenticAuthoringManifestEditPlanRequest): Observable<AgenticAuthoringManifestCompileResult>;
     loadGlobalAiConfig(): Observable<AiGlobalConfigSnapshot | null>;
     saveGlobalAiConfig(aiConfig: AiGlobalConfigSnapshot): Observable<void>;
     getHeaderContext(): AiHeaderContext;
     private buildHeaders;
     private normalizeContractVersion;
     private normalizeContractSchemaHash;
+    private authoringManifestUrl;
     private resolveHeaderMap;
     private parsePatchStreamEnvelope;
     private isPatchStreamEnvelope;
@@ -1052,6 +1122,7 @@ declare class AiResponseValidatorService {
     private validateJsonLogicExpression;
     private walkJsonLogicNode;
     private isSupportedJsonLogicOperator;
+    private validateJsonLogicOperatorArity;
     private collectVarPaths;
     private isValidTargetId;
     private findSimilarTargetId;
@@ -1156,7 +1227,7 @@ interface ClarificationOption {
     value: string;
     example?: string;
 }
-type ClarificationContextHints = AiJsonObject;
+type ClarificationContextHints = AiContextHintsContract;
 interface ClarificationRichOption extends ClarificationOption {
     contextHints?: ClarificationContextHints;
 }
@@ -1647,7 +1718,7 @@ declare class AiContextBuilderService {
     /**
      * Builds the complete context for the AI prompt
      */
-    buildPromptContext(fieldSchemas: Record<string, FieldSchemaLike>, targetType: 'field' | 'section' | 'action' | 'row' | 'column', propertySchema: RulePropertySchema): PromptContext;
+    buildPromptContext(fieldSchemas: Record<string, FieldSchemaLike>, targetType: 'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock', propertySchema: RulePropertySchema): PromptContext;
     buildRulePrompt(userPrompt: string, context: PromptContext): string;
     buildSuggestionPrompt(context: PromptContext): string;
     /**
@@ -1676,7 +1747,7 @@ declare class AiRuleWizardDialogComponent implements OnInit {
     private snackBar;
     private contextBuilder;
     private cdr;
-    selectedTargetType: 'field' | 'section' | 'action' | 'row' | 'column';
+    selectedTargetType: 'field' | 'section' | 'action' | 'row' | 'column' | 'visualBlock';
     userPrompt: string;
     isGenerating: boolean;
     validationError: string | null;
@@ -1713,4 +1784,4 @@ declare class AiRuleWizardDialogComponent implements OnInit {
 }
 
 export { AI_BACKEND_CONFIG_STORE, AI_BACKEND_STORAGE_OPTIONS, AI_CONTRACT_SCHEMA_HASH, AI_CONTRACT_VERSION, AI_INTENT_CONTRACT_SCHEMA_HASH, AI_INTENT_CONTRACT_VERSION, AI_STREAM_EVENT_SCHEMA_VERSION, AI_STREAM_EVENT_TYPES, AiBackendApiService, AiPatchStreamConnectionError, AiResponseValidatorService, AiRuleWizardDialogComponent, BaseAiAdapter, PraxisAi, PraxisAiAssistantComponent, PraxisAiAssistantShellComponent, PraxisAiService, PraxisAssistantTurnController, PraxisAssistantTurnOrchestratorService, SchemaMinifierService };
-export type { AgenticAuthoringApplyRequestContract, AgenticAuthoringApplyResultContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringCandidateContract, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringConversationContextContract, AgenticAuthoringConversationMessageContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringIntentResolutionResultContract, AgenticAuthoringPendingClarificationContract, AgenticAuthoringPlanRequestContract, AgenticAuthoringPreviewResultContract, AgenticAuthoringQuickReplyContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamEnvelopeContract, AgenticAuthoringTurnStreamRequestContract, AgenticAuthoringTurnStreamStartResponseContract, AiBackendConfigStore, AiBackendStorageOptions, AiChatMessage, AiChatMessageContract, AiClarificationUiContract, AiConfigAdapter, AiContextDTO, AiContextTemplate, AiContextTemplateMeta, AiCurrentStateDigest, AiCurrentStateDigestContract, AiExamplePair, AiGlobalConfigSnapshot, AiHeaderContext, AiIntegrationConfig, AiJsonArray, AiJsonObject, AiJsonPrimitive, AiJsonValue, AiMemoryInfoContract, AiModel, AiOptionContract, AiOrchestratorRequest, AiOrchestratorRequestContract, AiOrchestratorResponse, AiOrchestratorResponseContract, AiOrchestratorResponseType, AiPatchDiff, AiPatchDiffContract, AiPatchStreamCancelResponse, AiPatchStreamCancelResponseContract, AiPatchStreamConnection, AiPatchStreamConnectionErrorKind, AiPatchStreamEnvelope, AiPatchStreamEnvelopeContract, AiPatchStreamEventType, AiPatchStreamStartResponse, AiPatchStreamStartResponseContract, AiProviderCatalogItem, AiProviderCatalogResponse, AiProviderModelsRequest, AiProviderModelsResponse, AiProviderStatusResponse, AiProviderTestRequest, AiProviderTestResponse, AiResponseCompileResult, AiRuleResponse, AiSchemaContext, AiSchemaContextContract, AiSuggestion, AiSuggestionsRequest, AiSuggestionsResponse, AiTurnStreamEventType, AiUiContextRef, AiUiContextRefContract, AiValidationError, AiValidationResult, AiValidationWarning, AiWizardData, Capability, FieldSchemaLike, MinifiedField, PatchResult, PraxisAssistantClarificationOption, PraxisAssistantClarificationQuestion, PraxisAssistantClarificationQuestionType, PraxisAssistantPendingClarification, PraxisAssistantShellAttachment, PraxisAssistantShellContextItem, PraxisAssistantShellLabels, PraxisAssistantShellLayout, PraxisAssistantShellMessage, PraxisAssistantShellMessageAction, PraxisAssistantShellMessageRole, PraxisAssistantShellMode, PraxisAssistantShellQuickReply, PraxisAssistantShellState, PraxisAssistantTurnAction, PraxisAssistantTurnControllerOptions, PraxisAssistantTurnFlow, PraxisAssistantTurnPhase, PraxisAssistantTurnRequest, PraxisAssistantTurnResult, PraxisAssistantTurnViewState, ProblemResponseContract, PromptContext, RulePropertyDefinition, RulePropertySchema, RulePropertyType, ValidationContext, ValueKind };
+export type { AgenticAuthoringApplyRequestContract, AgenticAuthoringApplyResultContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringCandidateContract, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringConversationContextContract, AgenticAuthoringConversationMessageContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringIntentResolutionResultContract, AgenticAuthoringManifestCompileResult, AgenticAuthoringManifestCompileResultContract, AgenticAuthoringManifestEditPlanRequest, AgenticAuthoringManifestEditPlanRequestContract, AgenticAuthoringManifestValidationResult, AgenticAuthoringManifestValidationResultContract, AgenticAuthoringPendingClarificationContract, AgenticAuthoringPlanRequestContract, AgenticAuthoringPreviewResultContract, AgenticAuthoringQuickReplyContract, AgenticAuthoringResolveTargetRequest, AgenticAuthoringResolveTargetRequestContract, AgenticAuthoringResolvedTarget, AgenticAuthoringResolvedTargetContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamConnection, AgenticAuthoringTurnStreamEnvelope, AgenticAuthoringTurnStreamEnvelopeContract, AgenticAuthoringTurnStreamRequest, AgenticAuthoringTurnStreamRequestContract, AgenticAuthoringTurnStreamStartResponse, AgenticAuthoringTurnStreamStartResponseContract, AiBackendConfigStore, AiBackendStorageOptions, AiChatMessage, AiChatMessageContract, AiClarificationUiContract, AiConfigAdapter, AiContextDTO, AiContextHintsContract, AiContextTemplate, AiContextTemplateMeta, AiCurrentStateDigest, AiCurrentStateDigestContract, AiExamplePair, AiGlobalConfigSnapshot, AiHeaderContext, AiIntegrationConfig, AiJsonArray, AiJsonObject, AiJsonPrimitive, AiJsonValue, AiMemoryInfoContract, AiModel, AiOptionContract, AiOrchestratorRequest, AiOrchestratorRequestContract, AiOrchestratorResponse, AiOrchestratorResponseContract, AiOrchestratorResponseType, AiPatchDiff, AiPatchDiffContract, AiPatchStreamCancelResponse, AiPatchStreamCancelResponseContract, AiPatchStreamConnection, AiPatchStreamConnectionErrorKind, AiPatchStreamEnvelope, AiPatchStreamEnvelopeContract, AiPatchStreamEventType, AiPatchStreamStartResponse, AiPatchStreamStartResponseContract, AiProviderCatalogItem, AiProviderCatalogResponse, AiProviderModelsRequest, AiProviderModelsResponse, AiProviderStatusResponse, AiProviderTestRequest, AiProviderTestResponse, AiResponseCompileResult, AiRuleResponse, AiSchemaContext, AiSchemaContextContract, AiSuggestion, AiSuggestionsRequest, AiSuggestionsResponse, AiTurnStreamEventType, AiUiContextRef, AiUiContextRefContract, AiValidationError, AiValidationResult, AiValidationWarning, AiWizardData, Capability, FieldSchemaLike, MinifiedField, PatchResult, PraxisAssistantClarificationOption, PraxisAssistantClarificationQuestion, PraxisAssistantClarificationQuestionType, PraxisAssistantPendingClarification, PraxisAssistantShellAttachment, PraxisAssistantShellContextItem, PraxisAssistantShellLabels, PraxisAssistantShellLayout, PraxisAssistantShellMessage, PraxisAssistantShellMessageAction, PraxisAssistantShellMessageRole, PraxisAssistantShellMode, PraxisAssistantShellQuickReply, PraxisAssistantShellState, PraxisAssistantTurnAction, PraxisAssistantTurnControllerOptions, PraxisAssistantTurnFlow, PraxisAssistantTurnPhase, PraxisAssistantTurnRequest, PraxisAssistantTurnResult, PraxisAssistantTurnViewState, ProblemResponseContract, PromptContext, RulePropertyDefinition, RulePropertySchema, RulePropertyType, ValidationContext, ValueKind };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@praxisui/ai",
-  "version": "8.0.0-beta.11",
+  "version": "8.0.0-beta.13",
   "description": "AI building blocks and assistant integration for Praxis UI applications.",
   "peerDependencies": {
     "@angular/common": "^20.3.0",
     "@angular/core": "^20.3.0",
-    "@praxisui/core": "^8.0.0-beta.11"
+    "@praxisui/core": "^8.0.0-beta.13"
   },
   "dependencies": {
     "tslib": "^2.3.0"