## Problem Situational scopes (Entity Types, Entity Item, Taxonomy Terms, Site Sections, Languages) do not match on consumer requests that arrive through an API-proxy route instead of the page being edited. AI CKEditor is the first consumer that hits this, but the problem is in how ai_context detects the request entity and path, so it applies to any similar consumer. ### Steps to reproduce Requires ai_ckeditor 1.5.0-beta2 or later and ai 1.5.0-alpha1 or later. 1. Create a content type "Pirate post". 2. Create a context item scoped with Entity Types = Content: Pirate post that says to talk like a pirate. 3. Enable the CKEditor AI tools, including Generate with AI, and enable context push for the CKEditor consumer. 4. Create a new Pirate post and use Generate with AI in the body field. Expected: the pirate context item is pushed. Actual: the item is not pushed. The item is a hard filter, so it is excluded. ## Root causes ### 1. Unsaved entities have no detectable type or bundle ai_ckeditor puts `entity_type` and `id` into drupalSettings from `hook_form_alter()`. On an add form the id is an empty string, so `AiRequest::validateEntityContext()` drops the whole entity context and no `entity_context` metadata reaches ai_context. On the ai_context side, `AiContextRequestInfoResolver::getEntityType()` needs a saved entity: it loads the entity by id and reads `bundle()`. There is no way to supply a type and bundle without an id. ai_ckeditor already sends `bundle` in `entity_context`, but `AiContextProviderRequestContextFactory::entityItemFromRequestMetadata()` only reads type and id, so the bundle is ignored. The `entity_context` key and its shape (`entity_type`, `bundle`, `id`) were defined by ai_ckeditor in #3581952+s together with the AI core metadata bag. AI core only ships the bag. ai_context adopted the key in #3586346+s but never read `bundle`. The `path` key proposed below is new and must be agreed with ai_ckeditor. ### 2. The route-match fallback picks config entities `AiContextRequestInfoResolver::getEntityFromRouteMatch()` returns the first route parameter that implements `EntityInterface`. On `/api/ai-ckeditor/request/{editor}/{ai_ckeditor_plugin}` that is the Editor config entity, so the detected values become `editor:editor` (Entity Types) and `editor:basic_html` (Entity Item). These never match and the items are filtered out. This also blocks the request-body fallback, because the route match is checked first. ### 3. The path is the API endpoint, not the edited page `AiContextRequestInfoResolver::getPath()` uses a caller-supplied path or `getPathInfo()`. ai_ckeditor sends no path hint, so Site Sections sees `/api/ai-ckeditor/request/...` and returns FALSE for every item with Site Sections values, saved or not. There is no same-site Referer fallback, although `AiContextLanguageService::detect()` already uses one. ### Scope by scope on the CKEditor request | Scope | New entity | Saved entity | Cause | |---|---|---|---| | Entity Types | Fails | Should work | 1, 2 | | Entity Item | Fails | Should work | 1, 2 | | Taxonomy Terms | Fails | Saved terms only | 1 | | Site Sections | Fails | Fails | 3 | | Languages | Partial | Partial | Referer prefix only; entity language never used | | Roles | Works | Works | Uses current user | Note: in testing the saved-entity case also failed. The code path for saved entities looks correct, so that needs a debug run (AI module version, cached JS, POST body containing `entity_id`). ## Proposed resolution ### ai_context (this issue) 1. Let the resolver accept a type and bundle hint without an id: `setEntityBundle()` / `clearEntityBundle()` store a validated `type:bundle` value in the `ai_context_entity_bundle` request attribute. `getEntityType()` uses it only when no request entity loads, so a loaded entity still wins. Unknown types or bundles are ignored. 2. Read `bundle` and `path` from `entity_context` metadata (or a top-level `path`) in `AiContextPreGenerateResponseSubscriber` and set them on the resolver before selection. `AiContextSelection` is unchanged; type and id still travel through it as before. 3. `getEntityFromRouteMatch()` only accepts `ContentEntityInterface`, so config entities such as the Editor on the CKEditor endpoint are ignored and no longer block body hints. 4. `getPath()` falls back to a same-site Referer path, but only on XMLHttpRequest or JSON requests. A normal page load never uses it because there the Referer names the previous page. The site base path is stripped. Explicit hints (attribute, body, metadata) still win. 5. `applyRequestInfo()` also accepts `entity_type` plus `bundle` without an id for the agent path. 6. Hard-filter semantics are unchanged: when nothing can be detected the scope still returns FALSE. 7. Docs: consumer_api.md (new "Request entity and page path" section), context_delivery.md, services.md, scopes.md, events.md. The old statement that the generic path "does not fall back to the current route" was wrong and is corrected. Not done here: a cache context for the Referer-derived path. Selection results are not render-cached on the provider path, so this matches the existing body-hint behavior. ### ai_ckeditor (follow-up issue) ai_ckeditor#3615848+s 1. Include `bundle` in drupalSettings and keep `entity_context` when the id is empty but type and bundle are present. Validate the bundle server-side against bundle info instead of a loaded entity. 2. Send `path` in `entity_context` with the host page path so Site Sections can match without relying on the Referer fallback. ## Remaining tasks - [x] Resolver changes and metadata reading - [x] Unit tests: bundle hint, entity wins over hint, config entity route ignored, Referer on XHR/JSON only, cross-site and page-load Referer ignored, base path stripped - [x] Kernel tests on `PreGenerateResponseEvent`: bundle hint pushes the Entity Types item and a different bundle excludes it, path hint and Referer match Site Sections, proxy path alone does not - [x] Kernel tests on the agent path: bundle from tokens, config entity route does not shadow token entity - [x] Docs - [x] Open the ai_ckeditor follow-up and link it here: ai_ckeditor#3615848+s - [x] Debug the saved-entity failure seen in manual testing (AI module 1.5.0-alpha1 or later, cached JS, POST body containing `entity_id`) - [x] Manual test with ai_ckeditor 1.5.0-beta2 on a new and a saved node ## Related - #3586420+s Relevant-mode index prefilter uses the same detected values - #3586444+s public API; new resolver methods should be marked `@internal` or added deliberately