Merge branch 'feature/element-context-for-blocks' into dev

Author: mattbrailsford

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Core/Prompts/AIPromptExecutionRequest.cs

@@ -32,6 +32,21 @@ public class AIPromptExecutionRequest
     /// </summary>
     public required string ContentTypeAlias { get; init; }
 
+    /// <summary>
+    /// The element ID when editing a block element within an entity.
+    /// Null when editing the entity directly (e.g., a document property).
+    /// When set, <see cref="EntityId"/> refers to the parent entity (document)
+    /// and this refers to the block content key.
+    /// </summary>
+    public Guid? ElementId { get; init; }
+
+    /// <summary>
+    /// The element type when editing a block element within an entity.
+    /// Null when editing the entity directly.
+    /// Example: "block" when editing a block element.
+    /// </summary>
+    public string? ElementType { get; init; }
+
     /// <summary>
     /// The culture/language variant.
     /// </summary>

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Core/Prompts/AIPromptScopeValidator.cs

@@ -86,10 +86,12 @@ private async Task<ResolvedScopeContext> ResolveContextAsync(
             PropertyAlias = request.PropertyAlias,
         };
 
-        // Resolve the property editor UI alias from the content type
+        // Resolve the property editor UI alias from the content type.
+        // Use ElementType when present (e.g., "block") for correct service routing,
+        // since ContentTypeAlias refers to the element type in that case.
         context.PropertyEditorUiAlias = await ResolvePropertyEditorUiAliasAsync(
             request.ContentTypeAlias,
-            request.EntityType,
+            request.ElementType ?? request.EntityType,
             request.PropertyAlias,
             cancellationToken);
 

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Core/Prompts/AIPromptService.cs

@@ -235,6 +235,17 @@ public async Task<AIPromptExecutionResult> ExecutePromptAsync(
             runtimeContext.SetValue(CoreConstants.ContextKeys.EntityId, request.EntityId);
         }
 
+        // If no ElementId was set by contributors, use request.ElementId as fallback
+        if (!runtimeContext.Data.ContainsKey(CoreConstants.ContextKeys.ElementId) && request.ElementId.HasValue && request.ElementId.Value != Guid.Empty)
+        {
+            runtimeContext.SetValue(CoreConstants.ContextKeys.ElementId, request.ElementId.Value);
+        }
+
+        if (!runtimeContext.Data.ContainsKey(CoreConstants.ContextKeys.ElementType) && !string.IsNullOrEmpty(request.ElementType))
+        {
+            runtimeContext.SetValue(CoreConstants.ContextKeys.ElementType, request.ElementType);
+        }
+
         // Set prompt metadata in runtime context for auditing and telemetry
         runtimeContext.SetValue(Constants.MetadataKeys.PromptId, prompt.Id);
         runtimeContext.SetValue(Constants.MetadataKeys.PromptAlias, prompt.Alias);
@@ -448,6 +459,16 @@ void ConfigureChat(AIChatBuilder chat)
             ["propertyAlias"] = request.PropertyAlias,
         };
 
+        if (request.ElementId.HasValue)
+        {
+            context["elementId"] = request.ElementId.Value.ToString();
+        }
+
+        if (!string.IsNullOrEmpty(request.ElementType))
+        {
+            context["elementType"] = request.ElementType;
+        }
+
         if (!string.IsNullOrEmpty(request.Culture))
         {
             context["culture"] = request.Culture;

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Web.StaticAssets/Client/src/prompt/controllers/prompt.controller.ts

@@ -20,6 +20,10 @@ export interface UaiPromptExecuteOptions {
     propertyAlias: string;
     /** The content type alias for scope validation. For blocks, this is the element type alias. */
     contentTypeAlias: string;
+    /** The element ID when editing a block element within an entity. */
+    elementId?: string;
+    /** The element type when editing a block element (e.g., "block"). */
+    elementType?: string;
     /** The culture variant. */
     culture?: string;
     /** The segment variant. */
@@ -104,6 +108,8 @@ export class UaiPromptController extends UmbControllerBase {
                     entityType: options.entityType,
                     propertyAlias: options.propertyAlias,
                     contentTypeAlias: options.contentTypeAlias,
+                    elementId: options.elementId,
+                    elementType: options.elementType,
                     culture: options.culture,
                     segment: options.segment,
                     context: options.context,

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Web.StaticAssets/Client/src/prompt/property-actions/prompt-insert.property-action.ts

@@ -3,9 +3,10 @@ import { UmbPropertyActionBase, type UmbPropertyActionArgs } from "@umbraco-cms/
 import { UMB_PROPERTY_CONTEXT } from "@umbraco-cms/backoffice/property";
 import { UMB_CONTENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/content";
 import { UMB_BLOCK_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/block";
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/document";
 import { UMB_PROPERTY_STRUCTURE_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/content-type";
 import { umbOpenModal } from "@umbraco-cms/backoffice/modal";
-import { createEntityContextItem, resolveEntityAdapterByType, type UaiEntityAdapterApi } from "@umbraco-ai/core";
+import { createEntityContextItem, createElementContextItem, resolveEntityAdapterByType, type UaiEntityAdapterApi } from "@umbraco-ai/core";
 import { UAI_PROMPT_PREVIEW_MODAL, UAI_PROMPT_PREVIEW_SIDEBAR } from "./prompt-preview-modal.token.js";
 import type { UaiPromptPropertyActionMeta, UaiPromptContextItem, UaiPromptPreviewModalData } from "./types.js";
 
@@ -30,6 +31,8 @@ interface WorkspaceContextLike {
 export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiPromptPropertyActionMeta> {
     #propertyContext?: typeof UMB_PROPERTY_CONTEXT.TYPE;
     #workspaceContext?: WorkspaceContextLike;
+    #parentDocumentContext?: WorkspaceContextLike;
+    #isBlockWorkspace = false;
     #contentTypeAlias?: string;
     #init: Promise<unknown>;
     #workspaceAdapter?: UaiEntityAdapterApi;
@@ -49,6 +52,7 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
             this.consumeContext(UMB_BLOCK_WORKSPACE_CONTEXT, (ctx) => {
                 if (!this.#workspaceContext) {
                     this.#workspaceContext = ctx;
+                    this.#isBlockWorkspace = true;
                     // For blocks, get content type alias from the content element manager's structure
                     if (ctx) {
                         this.observe(
@@ -63,6 +67,13 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
             });
         });
 
+        // Observe the parent document context for blocks.
+        // Uses passContextAliasMatches() to skip the block workspace alias match
+        // and find the document workspace higher in the DOM tree.
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (ctx) => {
+            this.#parentDocumentContext = ctx as unknown as WorkspaceContextLike;
+        }).passContextAliasMatches();
+
         this.#init = Promise.all([
             this.consumeContext(UMB_PROPERTY_CONTEXT, (context) => {
                 this.#propertyContext = context;
@@ -100,10 +111,39 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
             throw new Error("Property action meta is not available");
         }
 
-        // Resolve required entity context for prompt execution
-        const entityId = this.#workspaceContext.getUnique();
-        const entityType = this.#workspaceContext.getEntityType();
+        // Resolve required context for prompt execution
         const propertyAlias = this.#propertyContext.getAlias();
+        if (!propertyAlias) {
+            throw new Error("Property alias is not available");
+        }
+
+        // For blocks: entity = parent document, element = block
+        // For documents: entity = document, no element
+        let entityId: string | null | undefined;
+        let entityType: string;
+        let elementId: string | undefined;
+        let elementType: string | undefined;
+
+        if (this.#isBlockWorkspace) {
+            try {
+                elementId = this.#workspaceContext.getUnique() ?? undefined;
+            } catch {
+                // getUnique() can throw for blocks if contentKey is not yet available
+            }
+            elementType = this.#workspaceContext.getEntityType();
+
+            if (this.#parentDocumentContext) {
+                entityId = this.#parentDocumentContext.getUnique();
+                entityType = this.#parentDocumentContext.getEntityType();
+            } else {
+                // Fallback: if parent document couldn't be resolved, use block as entity
+                entityId = elementId;
+                entityType = elementType;
+            }
+        } else {
+            entityId = this.#workspaceContext.getUnique();
+            entityType = this.#workspaceContext.getEntityType();
+        }
 
         if (!entityId) {
             throw new Error("Entity ID is not available");
@@ -113,11 +153,7 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
             throw new Error("Entity type is not available");
         }
 
-        if (!propertyAlias) {
-            throw new Error("Property alias is not available");
-        }
-
-        // Serialize document context for AI operations
+        // Serialize entity and element context for AI operations
         const context = await this.#serializeEntityContext();
 
         // Get maxChars from property editor config (if available)
@@ -134,6 +170,8 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
             entityType,
             propertyAlias,
             contentTypeAlias: this.#contentTypeAlias ?? "",
+            elementId,
+            elementType,
             culture: this.#propertyContext.getVariantId?.()?.culture ?? undefined,
             segment: this.#propertyContext.getVariantId?.()?.segment ?? undefined,
             context,
@@ -187,8 +225,9 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
     }
 
     /**
-     * Serialize the current entity for AI context injection.
-     * Resolves the appropriate adapter based on the workspace entity type.
+     * Serialize the current entity (and element, if editing a block) for AI context injection.
+     * For blocks: sends both the parent document (entity context) and the block (element context).
+     * For documents: sends only the document (entity context).
      */
     async #serializeEntityContext(): Promise<UaiPromptContextItem[] | undefined> {
         if (!this.#workspaceContext) {
@@ -200,13 +239,33 @@ export class UaiPromptInsertPropertyAction extends UmbPropertyActionBase<UaiProm
             return undefined;
         }
 
+        const contextItems: UaiPromptContextItem[] = [];
+
         try {
-            const serializedEntity = await adapter.serializeForLlm(this.#workspaceContext);
-            return [createEntityContextItem(serializedEntity)];
+            if (this.#isBlockWorkspace) {
+                // Block: serialize block as element context
+                const serializedElement = await adapter.serializeForLlm(this.#workspaceContext);
+                contextItems.push(createElementContextItem(serializedElement));
+
+                // Serialize parent document as entity context
+                if (this.#parentDocumentContext) {
+                    const docAdapter = await resolveEntityAdapterByType("document");
+                    if (docAdapter?.canHandle(this.#parentDocumentContext)) {
+                        const serializedEntity = await docAdapter.serializeForLlm(this.#parentDocumentContext);
+                        contextItems.push(createEntityContextItem(serializedEntity));
+                    }
+                }
+            } else {
+                // Document/media: serialize as entity context (as before)
+                const serializedEntity = await adapter.serializeForLlm(this.#workspaceContext);
+                contextItems.push(createEntityContextItem(serializedEntity));
+            }
         } catch {
             // Serialization failed - continue without context
             return undefined;
         }
+
+        return contextItems.length > 0 ? contextItems : undefined;
     }
 }
 

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Web.StaticAssets/Client/src/prompt/property-actions/prompt-preview-modal.element.ts

@@ -62,6 +62,8 @@ export class UaiPromptPreviewModalElement extends UmbModalBaseElement<
             entityType: this.data.entityType,
             propertyAlias: this.data.propertyAlias,
             contentTypeAlias: this.data.contentTypeAlias,
+            elementId: this.data.elementId,
+            elementType: this.data.elementType,
             culture: this.data.culture,
             segment: this.data.segment,
             // Pass serialized entity context for AI processing

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Web.StaticAssets/Client/src/prompt/property-actions/types.ts

@@ -100,6 +100,10 @@ export interface UaiPromptPreviewModalData {
     propertyAlias: string;
     /** Content type alias for scope validation. For blocks, this is the element type alias. */
     contentTypeAlias: string;
+    /** The element ID when editing a block element within an entity. */
+    elementId?: string;
+    /** The element type when editing a block element (e.g., "block"). */
+    elementType?: string;
     culture?: string;
     segment?: string;
     /** Serialized entity context for AI operations */

Umbraco.AI.Prompt/src/Umbraco.AI.Prompt.Web.StaticAssets/Client/src/prompt/repository/execution/prompt-execution.server.data-source.ts

@@ -34,12 +34,16 @@ export interface UaiPromptValueChange {
 export interface UaiPromptExecutionRequest {
     /** The entity ID for context. Required for scope validation. */
     entityId: string;
-    /** The entity type (e.g., "document", "media", "block"). Required for scope validation. */
+    /** The entity type (e.g., "document", "media"). Required for scope validation. */
     entityType: string;
     /** The property alias being edited. Required for scope validation. */
     propertyAlias: string;
     /** The content type alias for scope validation. For blocks, this is the element type alias. */
     contentTypeAlias: string;
+    /** The element ID when editing a block element within an entity. */
+    elementId?: string;
+    /** The element type when editing a block element (e.g., "block"). */
+    elementType?: string;
     /** The culture variant. */
     culture?: string;
     /** The segment variant. */
@@ -106,6 +110,8 @@ export class UaiPromptExecutionServerDataSource {
             entityType: request.entityType,
             propertyAlias: request.propertyAlias,
             contentTypeAlias: request.contentTypeAlias,
+            elementId: request.elementId,
+            elementType: request.elementType,
             culture: request.culture,
             segment: request.segment,
             context: request.context,