# AIChatContext classexperimental Manages the context of the current conversation. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. ## Properties ### `isEmpty: boolean` _(readonly)_ Whether the context holds no references. ### `refs: Array` _(readonly)_ The context references, in resolution order. Returns a copy - mutating it does not affect the context. ## Methods ### `constructor( __namedParameters = { __namedParameters.config?, __namedParameters.connector, __namedParameters.ownerId } )` #### Parameters * `__namedParameters: object` Properties * `__namedParameters.config?: AIChatContextConfig` * `__namedParameters.connector: AIConnector` * `__namedParameters.ownerId: string` ### `addCurrentDocumentToContext( label ) → void` _(experimental)_ Adds the current document to the pending context. If the document is already in context, this method returns early without changes. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `label: string` Display label for the current document #### Returns * `void` ### `addFilesToContext( files, attributes? = { attributes.label, attributes.resourceId }, type? ) → Promise` _(experimental)_ Adds files to the context by uploading them and creating context items. This method handles multiple files concurrently and tracks upload progress. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `files: Array` Array of File objects to upload and add to context * `attributes?: object` Optional attributes object containing resourceId and label for tracking purposes and context chips Properties * `attributes.label: string` * `attributes.resourceId: string` * `type?: 'text' | 'file'` Context item type, defaults to 'file' to indicate that the file is being added as a file or text Defaults to `'file'` #### Returns * `Promise` Promise that resolves when all files are processed ### `addLibraryContextToContext( libraryContextId, label? ) → void` _(experimental)_ Adds a reference to an admin-managed context from the Context Library to the pending context items. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `libraryContextId: string` The identifier of the context to attach. * `label?: string` The label displayed on the context chip. Defaults to `libraryContextId`. #### Returns * `void` ### `addResourceToContext( source, resource ) → Promise` _(experimental)_ **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `source: AIContextProvider` * `resource: AIContextResource` #### Returns * `Promise` ### `addSelectionToContext( selection ) → void` _(experimental)_ **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `selection: string` #### Returns * `void` ### `addToConversationContext( contextItems ) → void` _(experimental)_ Adds context items to the conversation context and clears the pending context items. A context reference never becomes a conversation item. It stays pending for as long as it is attached, which is what keeps it sent with every message and reported as being in context, so a second record of it could only go stale once it stops being attached. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `contextItems: Map` #### Returns * `void` ### `addToolItemToContext( contextItem ) → void` _(experimental)_ Adds an AI tool context item to the pending context items. Note, that these context items are ignored by the CKEditor AI agent and should be handled by your backend AI tool. The object which is passed as a parameter can contain the following properties: ```typescript { // Must be set to `'mcp-tool-context'`. type: 'mcp-tool-context', // The name of the MCP server. mcpServerName: string; // The data for the tool. Can be anything. data: Record; // The label of the item used to display it in the chat UI. label: string; // Optional, 1-21 characters. Auto-generated if omitted. id?: string; // The name of the tool. Omit to send context to all tools on the server. toolName?: string; } ``` **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `contextItem: AIToolContextItem` #### Returns * `void` ### `addUrlToContext( url, attributes? = { attributes.label, attributes.resourceId } ) → Promise` _(experimental)_ Adds a URL to the context by uploading it and creating a context item. This method handles URL upload with proper error handling and progress tracking. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `url: string` The URL to upload and add to context * `attributes?: object` Optional attributes object containing resourceId and label for tracking purposes and context chips Properties * `attributes.label: string` * `attributes.resourceId: string` #### Returns * `Promise` Promise that resolves when the URL is processed ### `bind( bindProperty1, bindProperty2 ) → ObservableDualBindChain` _(inherited)_ Binds [observable properties](#function-set:KEY_VALUE) to other objects implementing the [`Observable`](module_utils_observablemixin-Observable.md) interface. Read more in the [dedicated](../framework/deep-dive/observables.md#property-bindings) guide covering the topic of property bindings with some additional examples. Consider two objects: a `button` and an associated `command` (both `Observable`). A simple property binding could be as follows: ```typescript button.bind( 'isEnabled' ).to( command, 'isEnabled' ); ``` or even shorter: ```typescript button.bind( 'isEnabled' ).to( command ); ``` which works in the following way: * `button.isEnabled` **instantly equals** `command.isEnabled`, * whenever `command.isEnabled` changes, `button.isEnabled` will immediately reflect its value. **Note**: To release the binding, use [`unbind`](module_utils_observablemixin-Observable.md#function-unbind). You can also "rename" the property in the binding by specifying the new name in the `to()` chain: ```typescript button.bind( 'isEnabled' ).to( command, 'isWorking' ); ``` It is possible to bind more than one property at a time to shorten the code: ```typescript button.bind( 'isEnabled', 'value' ).to( command ); ``` which corresponds to: ```typescript button.bind( 'isEnabled' ).to( command ); button.bind( 'value' ).to( command ); ``` The binding can include more than one observable, combining multiple data sources in a custom callback: ```typescript button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible', ( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible ); ``` Using a custom callback allows processing the value before passing it to the target property: ```typescript button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' ); ``` It is also possible to bind to the same property in an array of observables. To bind a `button` to multiple commands (also `Observables`) so that each and every one of them must be enabled for the button to become enabled, use the following code: ```typescript button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled', ( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled ); ``` #### Type parameters * * `K1` * `K2` #### Parameters * `bindProperty1: K1` Observable property that will be bound to other observable(s). * `bindProperty2: K2` Observable property that will be bound to other observable(s). #### Returns * `ObservableDualBindChain` The bind chain with the `to()` and `toMany()` methods. ### `bind( bindProperties ) → ObservableMultiBindChain` _(inherited)_ Binds [observable properties](#function-set:KEY_VALUE) to other objects implementing the [`Observable`](module_utils_observablemixin-Observable.md) interface. Read more in the [dedicated](../framework/deep-dive/observables.md#property-bindings) guide covering the topic of property bindings with some additional examples. Consider two objects: a `button` and an associated `command` (both `Observable`). A simple property binding could be as follows: ```typescript button.bind( 'isEnabled' ).to( command, 'isEnabled' ); ``` or even shorter: ```typescript button.bind( 'isEnabled' ).to( command ); ``` which works in the following way: * `button.isEnabled` **instantly equals** `command.isEnabled`, * whenever `command.isEnabled` changes, `button.isEnabled` will immediately reflect its value. **Note**: To release the binding, use [`unbind`](module_utils_observablemixin-Observable.md#function-unbind). You can also "rename" the property in the binding by specifying the new name in the `to()` chain: ```typescript button.bind( 'isEnabled' ).to( command, 'isWorking' ); ``` It is possible to bind more than one property at a time to shorten the code: ```typescript button.bind( 'isEnabled', 'value' ).to( command ); ``` which corresponds to: ```typescript button.bind( 'isEnabled' ).to( command ); button.bind( 'value' ).to( command ); ``` The binding can include more than one observable, combining multiple data sources in a custom callback: ```typescript button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible', ( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible ); ``` Using a custom callback allows processing the value before passing it to the target property: ```typescript button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' ); ``` It is also possible to bind to the same property in an array of observables. To bind a `button` to multiple commands (also `Observables`) so that each and every one of them must be enabled for the button to become enabled, use the following code: ```typescript button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled', ( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled ); ``` #### Parameters * `bindProperties: Array<'off' | 'set' | 'bind' | 'unbind' | 'decorate' | 'stopListening' | 'on' | 'once' | 'listenTo' | 'fire' | 'delegate' | 'stopDelegating' | 'isEmpty' | '_config' | 'init' | 'refs' | 'cloneWith' | 'addDefaultContext' | 'toRequestParts' | 'toRequestContexts' | 'toMessageAttributes' | 'addUrlToContext' | 'addResourceToContext' | 'loadSourceResources' | 'addFilesToContext' | 'addSelectionToContext' | 'removeFromContext' | 'getPendingContextItems' | 'populateFromMessage' | 'getSentContextItems' | 'clearPendingContextItems' | 'addToConversationContext' | 'isCurrentDocumentInContext' | 'isSelectionInContext' | 'isCurrentDocumentInConversation' | 'addCurrentDocumentToContext' | 'getCurrentDocumentContext' | 'updateCurrentDocuments' | 'removeSelectionFromContext' | 'addLibraryContextToContext' | 'addToolItemToContext' | 'addContextSource' | 'toggleAddCurrentDocumentOptionVisibility'>` Observable properties that will be bound to other observable(s). #### Returns * `ObservableMultiBindChain` The bind chain with the `to()` and `toMany()` methods. ### `bind( bindProperty ) → ObservableSingleBindChain` _(inherited)_ Binds [observable properties](#function-set:KEY_VALUE) to other objects implementing the [`Observable`](module_utils_observablemixin-Observable.md) interface. Read more in the [dedicated](../framework/deep-dive/observables.md#property-bindings) guide covering the topic of property bindings with some additional examples. Consider two objects: a `button` and an associated `command` (both `Observable`). A simple property binding could be as follows: ```typescript button.bind( 'isEnabled' ).to( command, 'isEnabled' ); ``` or even shorter: ```typescript button.bind( 'isEnabled' ).to( command ); ``` which works in the following way: * `button.isEnabled` **instantly equals** `command.isEnabled`, * whenever `command.isEnabled` changes, `button.isEnabled` will immediately reflect its value. **Note**: To release the binding, use [`unbind`](module_utils_observablemixin-Observable.md#function-unbind). You can also "rename" the property in the binding by specifying the new name in the `to()` chain: ```typescript button.bind( 'isEnabled' ).to( command, 'isWorking' ); ``` It is possible to bind more than one property at a time to shorten the code: ```typescript button.bind( 'isEnabled', 'value' ).to( command ); ``` which corresponds to: ```typescript button.bind( 'isEnabled' ).to( command ); button.bind( 'value' ).to( command ); ``` The binding can include more than one observable, combining multiple data sources in a custom callback: ```typescript button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible', ( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible ); ``` Using a custom callback allows processing the value before passing it to the target property: ```typescript button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' ); ``` It is also possible to bind to the same property in an array of observables. To bind a `button` to multiple commands (also `Observables`) so that each and every one of them must be enabled for the button to become enabled, use the following code: ```typescript button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled', ( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled ); ``` #### Type parameters * `K` #### Parameters * `bindProperty: K` Observable property that will be bound to other observable(s). #### Returns * `ObservableSingleBindChain` The bind chain with the `to()` and `toMany()` methods. ### `clearPendingContextItems() → void` _(experimental)_ Clears all pending context items, then re-adds the current document and the context references (`type: 'context'`) as read-only and hidden pending items, so that they are sent with the following messages. A context reference that is already read-only and hidden is left untouched. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `void` ### `cloneWith( refs ) → AIContext` _(inherited)_ Returns a new context with the given references appended. The original context is left unchanged. Used to fold in a feature's own reference (for example a review check's `context`). #### Parameters * `refs: Array` #### Returns * `AIContext` ### `decorate( methodName ) → void` _(inherited)_ Turns the given methods of this object into event-based ones. This means that the new method will fire an event (named after the method) and the original action will be plugged as a listener to that event. Read more in the [dedicated](../framework/deep-dive/observables.md#decorating-object-methods) guide covering the topic of decorating methods with some additional examples. Decorating the method does not change its behavior (it only adds an event), but it allows to modify it later on by listening to the method's event. For example, to cancel the method execution the event can be [stopped](module_utils_eventinfo-EventInfo.md#member-stop): ```typescript class Foo extends ObservableMixin() { constructor() { super(); this.decorate( 'method' ); } method() { console.log( 'called!' ); } } const foo = new Foo(); foo.on( 'method', ( evt ) => { evt.stop(); }, { priority: 'high' } ); foo.method(); // Nothing is logged. ``` **Note**: The high [priority](module_utils_priorities-PriorityString.md) listener has been used to execute this particular callback before the one which calls the original method (which uses the "normal" priority). It is also possible to change the returned value: ```typescript foo.on( 'method', ( evt ) => { evt.return = 'Foo!'; } ); foo.method(); // -> 'Foo' ``` Finally, it is possible to access and modify the arguments the method is called with: ```typescript method( a, b ) { console.log( `${ a }, ${ b }` ); } // ... foo.on( 'method', ( evt, args ) => { args[ 0 ] = 3; console.log( args[ 1 ] ); // -> 2 }, { priority: 'high' } ); foo.method( 1, 2 ); // -> '3, 2' ``` #### Parameters * `methodName: 'off' | 'set' | 'bind' | 'unbind' | 'decorate' | 'stopListening' | 'on' | 'once' | 'listenTo' | 'fire' | 'delegate' | 'stopDelegating' | 'isEmpty' | '_config' | 'init' | 'refs' | 'cloneWith' | 'addDefaultContext' | 'toRequestParts' | 'toRequestContexts' | 'toMessageAttributes' | 'addUrlToContext' | 'addResourceToContext' | 'loadSourceResources' | 'addFilesToContext' | 'addSelectionToContext' | 'removeFromContext' | 'getPendingContextItems' | 'populateFromMessage' | 'getSentContextItems' | 'clearPendingContextItems' | 'addToConversationContext' | 'isCurrentDocumentInContext' | 'isSelectionInContext' | 'isCurrentDocumentInConversation' | 'addCurrentDocumentToContext' | 'getCurrentDocumentContext' | 'updateCurrentDocuments' | 'removeSelectionFromContext' | 'addLibraryContextToContext' | 'addToolItemToContext' | 'addContextSource' | 'toggleAddCurrentDocumentOptionVisibility'` Name of the method to decorate. #### Returns * `void` ### `delegate( events ) → EmitterMixinDelegateChain` _(inherited)_ Delegates selected events to another [`Emitter`](module_utils_emittermixin-Emitter.md). For instance: ```typescript emitterA.delegate( 'eventX' ).to( emitterB ); emitterA.delegate( 'eventX', 'eventY' ).to( emitterC ); ``` then `eventX` is delegated (fired by) `emitterB` and `emitterC` along with `data`: ```typescript emitterA.fire( 'eventX', data ); ``` and `eventY` is delegated (fired by) `emitterC` along with `data`: ```typescript emitterA.fire( 'eventY', data ); ``` #### Parameters * `events: Array` Event names that will be delegated to another emitter. #### Returns * `EmitterMixinDelegateChain` ### `fire( eventOrInfo, args ) → GetEventInfo[ 'return' ]` _(inherited)_ Fires an event, executing all callbacks registered for it. The first parameter passed to callbacks is an [`EventInfo`](module_utils_eventinfo-EventInfo.md) object, followed by the optional `args` provided in the `fire()` method call. #### Type parameters * `TEvent: extends BaseEvent` The type describing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `eventOrInfo: GetNameOrEventInfo` The name of the event or `EventInfo` object if event is delegated. * `args: TEvent[ 'args' ]` Additional arguments to be passed to the callbacks. #### Returns * `GetEventInfo[ 'return' ]` By default the method returns `undefined`. However, the return value can be changed by listeners through modification of the [`evt.return`](module_utils_eventinfo-EventInfo.md#member-return)'s property (the event info is the first param of every callback). ### `getCurrentDocumentContext() → AIContextItem | undefined` Returns context item for current document context, or undefined if the document context is not added. #### Returns * `AIContextItem | undefined` ### `getPendingContextItems() → ReadonlyMap` _(experimental)_ Returns the pending context items that will be sent to the AI endpoint in the next interaction. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `ReadonlyMap` Map of pending context items keyed by their uiId ### `getSentContextItems() → ReadonlyMap` _(experimental)_ Returns all context items that have been sent to the AI endpoint in the current conversation. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `ReadonlyMap` Map of sent context items keyed by their uiId ### `init() → void` _(experimental)_ Initializes the context. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `void` ### `isCurrentDocumentInContext() → boolean` _(experimental)_ Checks if the current document is in the pending context. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `boolean` True if the current document is in pending context, false otherwise ### `isCurrentDocumentInConversation() → boolean` _(experimental)_ Checks if the current document is in the conversation context. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `boolean` True if the current document is in conversation context, false otherwise ### `isSelectionInContext() → boolean` _(experimental)_ **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `boolean` ### `listenTo( emitter, event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed when an event is fired in a specific (emitter) object. Events can be grouped in namespaces using `:`. When namespaced event is fired, it additionally fires all callbacks for that namespace. ```typescript // myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ). myEmitter.on( 'myGroup', genericCallback ); myEmitter.on( 'myGroup:myEvent', specificCallback ); // genericCallback is fired. myEmitter.fire( 'myGroup' ); // both genericCallback and specificCallback are fired. myEmitter.fire( 'myGroup:myEvent' ); // genericCallback is fired even though there are no callbacks for "foo". myEmitter.fire( 'myGroup:foo' ); ``` An event callback can [stop the event](module_utils_eventinfo-EventInfo.md#member-stop) and set the [return value](module_utils_eventinfo-EventInfo.md#member-return) of the [`fire`](#function-fire) method. #### Type parameters * `TEvent: extends BaseEvent` The type describing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `emitter: Emitter` The object that fires the event. * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `loadSourceResources( sourceId, query, uid ) → Promise>` _(experimental)_ Loads resources for a given source provider with the specified query. This method calls the source's [`getResources`](module_ai_aichat_model_aichatcontext-AIContextProvider.md#member-getResources) callback and updates resource states. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `sourceId: string` The unique identifier of the source provider * `query: string` Search query to filter resources * `uid: string` Unique identifier for the request to prevent race conditions #### Returns * `Promise>` Promise resolving to array of resources with context state ### `off( event, callback ) → void` _(inherited)_ Stops executing the callback on the given event. Shorthand for [`this.stopListening( this, event, callback )`](#function-stopListening:BASE_STOP). #### Parameters * `event: string` The name of the event. * `callback: Function` The function to stop being called. #### Returns * `void` ### `on( event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed when an event is fired. Shorthand for [`this.listenTo( this, event, callback, options )`](#function-listenTo:BASE_EMITTER) (it makes the emitter listen on itself). #### Type parameters * `TEvent: extends BaseEvent` The type descibing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `once( event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed on the next time the event is fired only. This is similar to calling [`on`](#function-on) followed by [`off`](#function-off) in the callback. #### Type parameters * `TEvent: extends BaseEvent` The type descibing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `populateFromMessage( messageContents, editors, defaultContextIds ) → Promise` _(experimental)_ Populates context items from a historical user message. Documents are batch-loaded and assembled into a single `current-document` context item whose `documents` array carries per-root metadata used downstream (notably by `AIReply`) to route modifications back to the source editor and root; non-document content items are turned into one context item each. The context references carried by the message are restored as pending items, so they keep being attached to every following message the way they were before the conversation was read back from history. Returns the assembled context items together with `unmatchedDocumentIds` — the IDs of documents that could not be matched to a live editor root via `attributes.channelId` (compared against the editor's `collaboration.channelId` config) and `attributes.rootName`. Callers resolve a per-document outdated reason from these IDs so suggestions from unmatched roots render as outdated while their matched siblings stay actionable. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `messageContents: Array` * `editors: readonly Array` * `defaultContextIds: Set` Defaults to `...` #### Returns * `Promise` ### `removeFromContext( uiId ) → void` _(experimental)_ Removes a context item from the pending context. Read-only items cannot be removed and the method returns early. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `uiId: string` The unique identifier of the context item to remove #### Returns * `void` ### `removeSelectionFromContext() → void` _(experimental)_ **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Returns * `void` ### `set( values ) → void` _(inherited)_ Creates and sets the value of an observable properties of this object. Such a property becomes a part of the state and is observable. It accepts a single object literal containing key/value pairs with properties to be set. This method throws the `observable-set-cannot-override` error if the observable instance already has a property with the given property name. This prevents from mistakenly overriding existing properties and methods, but means that `foo.set( 'bar', 1 )` may be slightly slower than `foo.bar = 1`. In TypeScript, those properties should be declared in class using `declare` keyword. In example: ```typescript public declare myProp1: number; public declare myProp2: string; constructor() { this.set( { 'myProp1: 2, 'myProp2: 'foo' } ); } ``` #### Parameters * `values: object & object` An object with `name=>value` pairs. #### Returns * `void` ### `set( name, value ) → void` _(inherited)_ Creates and sets the value of an observable property of this object. Such a property becomes a part of the state and is observable. This method throws the `observable-set-cannot-override` error if the observable instance already has a property with the given property name. This prevents from mistakenly overriding existing properties and methods, but means that `foo.set( 'bar', 1 )` may be slightly slower than `foo.bar = 1`. In TypeScript, those properties should be declared in class using `declare` keyword. In example: ```typescript public declare myProp: number; constructor() { this.set( 'myProp', 2 ); } ``` #### Type parameters * `K` #### Parameters * `name: K` The property's name. * `value: AIChatContext[ K ]` The property's value. #### Returns * `void` ### `stopDelegating( event?, emitter? ) → void` _(inherited)_ Stops delegating events. It can be used at different levels: * To stop delegating all events. * To stop delegating a specific event to all emitters. * To stop delegating a specific event to a specific emitter. #### Parameters * `event?: string` The name of the event to stop delegating. If omitted, stops it all delegations. * `emitter?: Emitter` (requires `event`) The object to stop delegating a particular event to. If omitted, stops delegation of `event` to all emitters. #### Returns * `void` ### `stopListening( emitter?, event?, callback? ) → void` _(inherited)_ Stops listening for events. It can be used at different levels: * To stop listening to a specific callback. * To stop listening to a specific event. * To stop listening to all events fired by a specific object. * To stop listening to all events fired by all objects. #### Parameters * `emitter?: Emitter` The object to stop listening to. If omitted, stops it for all objects. * `event?: string` (Requires the `emitter`) The name of the event to stop listening to. If omitted, stops it for all events from `emitter`. * `callback?: Function` (Requires the `event`) The function to be removed from the call list for the given `event`. #### Returns * `void` ### `toMessageAttributes( attributes? ) → Record | undefined` _(inherited)_ Merges the identifiers of this context's references into the given `message.attributes`, so they can be read back from history to keep the references' pills hidden. Returns the given attributes unchanged when the context holds no references. #### Parameters * `attributes?: Record` #### Returns * `Record | undefined` ### `toRequestParts( parts ) → Array` _(inherited)_ Returns the request parts to send: the context's references followed by the given message parts. This is where the leading references applied to every message are merged with a message's own context items. #### Parameters * `parts: Array` Defaults to `[]` #### Returns * `Array` ### `toggleAddCurrentDocumentOptionVisibility( isVisible? ) → void` _(experimental)_ Toggles the visibility of the add current document option in the add context options. By default, the option is visible if the current document is not in the context or conversation. There's an option to force the visibility of the option by passing `true` or `false` to the method. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `isVisible?: boolean` Whether to force-show or force-hide the option. #### Returns * `void` ### `unbind( unbindProperties ) → void` _(inherited)_ Removes the binding created with [`bind`](#function-bind:SINGLE_BIND). ```typescript // Removes the binding for the 'a' property. A.unbind( 'a' ); // Removes bindings for all properties. A.unbind(); ``` #### Parameters * `unbindProperties: Array<'off' | 'set' | 'bind' | 'unbind' | 'decorate' | 'stopListening' | 'on' | 'once' | 'listenTo' | 'fire' | 'delegate' | 'stopDelegating' | 'isEmpty' | '_config' | 'init' | 'refs' | 'cloneWith' | 'addDefaultContext' | 'toRequestParts' | 'toRequestContexts' | 'toMessageAttributes' | 'addUrlToContext' | 'addResourceToContext' | 'loadSourceResources' | 'addFilesToContext' | 'addSelectionToContext' | 'removeFromContext' | 'getPendingContextItems' | 'populateFromMessage' | 'getSentContextItems' | 'clearPendingContextItems' | 'addToConversationContext' | 'isCurrentDocumentInContext' | 'isSelectionInContext' | 'isCurrentDocumentInConversation' | 'addCurrentDocumentToContext' | 'getCurrentDocumentContext' | 'updateCurrentDocuments' | 'removeSelectionFromContext' | 'addLibraryContextToContext' | 'addToolItemToContext' | 'addContextSource' | 'toggleAddCurrentDocumentOptionVisibility'>` Observable properties to be unbound. All the bindings will be released if no properties are provided. #### Returns * `void` #### Static methods ### `getDefaultContextIds( attributes? ) → Set` _(inherited)_ Reads back the default context reference identifiers stored by [`toMessageAttributes`](#function-toMessageAttributes) from a historical message's `attributes`. #### Parameters * `attributes?: Record` #### Returns * `Set` ### `mapContextItemsToRequestData( contextItems ) → Array` _(experimental)_ Converts context items to request data format for API endpoint. This static method transforms the internal context item format to the format expected by the AI connector. **Experimental:** This is a production-ready API but may change in minor releases without the standard deprecation policy. Check the changelog for migration guidance. #### Parameters * `contextItems: Map` Map of context items to convert #### Returns * `Array` Array of context items in API request format ## Events ### `change:{property}( eventInfo, name, value, oldValue )` _(inherited)_ Fired when a property changed value. ```typescript observable.set( 'prop', 1 ); observable.on>( 'change:prop', ( evt, propertyName, newValue, oldValue ) => { console.log( `${ propertyName } has changed from ${ oldValue } to ${ newValue }` ); } ); observable.prop = 2; // -> 'prop has changed from 1 to 2' ``` #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `name: string` The property name. * `value: TValue` The new property value. * `oldValue: TValue` The previous property value. ### `set:{property}( eventInfo, name, value, oldValue )` _(inherited)_ Fired when a property value is going to be set but is not set yet (before the `change` event is fired). You can control the final value of the property by using the [event's `return` property](module_utils_eventinfo-EventInfo.md#member-return). ```typescript observable.set( 'prop', 1 ); observable.on>( 'set:prop', ( evt, propertyName, newValue, oldValue ) => { console.log( `Value is going to be changed from ${ oldValue } to ${ newValue }` ); console.log( `Current property value is ${ observable[ propertyName ] }` ); // Let's override the value. evt.return = 3; } ); observable.on>( 'change:prop', ( evt, propertyName, newValue, oldValue ) => { console.log( `Value has changed from ${ oldValue } to ${ newValue }` ); } ); observable.prop = 2; // -> 'Value is going to be changed from 1 to 2' // -> 'Current property value is 1' // -> 'Value has changed from 1 to 3' ``` **Note:** The event is fired even when the new value is the same as the old value. #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `name: string` The property name. * `value: TValue` The new property value. * `oldValue: TValue` The previous property value. --- Full index of the CKEditor 5 API reference: [llms.txt](llms.txt)