@c8y/ngx-components 1024.15.13 → 1024.16.10

package/types/c8y-ngx-components-ai-ai-chat.d.ts

@@ -1,9 +1,36 @@
 import * as _angular_core from '@angular/core';
-import { EventEmitter, Type, TemplateRef } from '@angular/core';
-import { AIAssistantMessage, AssistantMessageDisplayConfig, AIMessagePart, ToolCallPart, AIMessage, ChatConfig } from '@c8y/ngx-components/ai';
+import { TemplateRef, EventEmitter, Type } from '@angular/core';
+import { AIAssistantMessage, AssistantMessageDisplayConfig, ToolCallPart, ToolApprovalDecision, AIMessagePart, AIMessage, ChatConfig } from '@c8y/ngx-components/ai';
 import { SupportedIconsSuggestions } from '@c8y/ngx-components/icon-selector/icons';
+import { Observable } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
 
+/**
+ * Projects arbitrary content into the action bar beneath the `c8y-ai-chat` input box.
+ *
+ * Place one or more `<c8y-ai-chat-action>` elements inside a `<c8y-ai-chat>` (or `<c8y-agent-chat>`)
+ * and use the `placement` input to position them. The projected content is rendered as-is, so it can
+ * hold any component or control (buttons, dropdowns, tags, and so on).
+ *
+ * @example
+ * ```html
+ * <c8y-ai-chat-action placement="left">
+ *   <button class="btn btn-link btn-sm"><i c8yIcon="attach"></i></button>
+ * </c8y-ai-chat-action>
+ * ```
+ */
+declare class AiChatActionComponent {
+    /**
+     * Where the action is placed in the action bar. `more` collects the action into an overflow
+     * dropdown on the right side.
+     */
+    readonly placement: _angular_core.InputSignal<"left" | "right" | "more">;
+    /** The projected content, exposed as a template so the host chat can render it in the right group. */
+    readonly template: _angular_core.Signal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiChatActionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatActionComponent, "c8y-ai-chat-action", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 /**
  * Context object which includes the inputs needed for assistant message rendering.
  * If creating a custom component for assistant message rendering, you will receive this as an input.
@@ -15,6 +42,18 @@ interface AssistantMessageContext {
     isMessageLoading: boolean;
     /** A number identifying this message in the chat history numbered from the latest - 0 is the latest, -1 is the previous, etc. */
     messageDisplayIndex: number;
+    /**
+     * Callback invoked when the user approves or denies a tool call that requires approval.
+     * When set, approve/deny actions are offered on tool calls in the `tool-approval-requested` state.
+     */
+    onToolApprovalResponse?: (part: ToolCallPart, decision: ToolApprovalDecision) => void;
+    /**
+     * Whether the "always approve" options may be offered for a tool call awaiting approval.
+     * Returns false for tools that must be approved explicitly on every call (configured via
+     * `needsApproval`), which show plain approve/deny buttons instead. Defaults to true when
+     * not provided.
+     */
+    canRememberToolApproval?: (part: ToolCallPart) => boolean;
 }
 /**
  * This is the default component used to render the contents of a message from the AI assistant, including
@@ -150,8 +189,12 @@ declare class AiChatMessageComponent {
     private readonly translateService;
     private readonly roleResolved;
     /**
-     * Generates an accessible label for the message container.
-     * Includes the role (user or assistant) and timestamp if available.
+     * Generates an accessible label for the message container: role (user or assistant) and
+     * timestamp if available.
+     *
+     * Deliberately short - the actual message content is already exposed to assistive technology via
+     * the normal (structured) DOM content, so duplicating it here as a flat string would just repeat
+     * a long, unstructured block of text, especially for multi-paragraph assistant responses.
      * @returns The aria-label string for screen readers
      */
     readonly ariaLabel: _angular_core.Signal<any>;
@@ -165,6 +208,88 @@ declare class AiChatMessageComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatMessageComponent, "c8y-ai-chat-message", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, [":not(c8y-ai-chat-message-action)", "c8y-ai-chat-message-action"], true, never>;
 }
 
+/**
+ * A microphone button for the `c8y-ai-chat` action bar that transcribes speech into the chat input
+ * using the browser's Web Speech API. Recognized text is appended to the current `prompt`.
+ *
+ * The button is only rendered when the current browser supports the Web Speech API, so it stays
+ * hidden where speech input is unavailable. While a recognition session is running the microphone
+ * icon pulses.
+ *
+ * `c8y-ai-chat` renders this button automatically unless `config.enableSpeechToText` is `false`, so
+ * you normally do not place it yourself.
+ */
+declare class AiChatSpeechToTextComponent {
+    private readonly speechRecognition;
+    private readonly alertService;
+    private readonly destroyRef;
+    private readonly appState;
+    /**
+     * Disables the button, for example while the chat is loading or otherwise unavailable. The
+     * button is still rendered (see {@link isAvailable} for whether it is offered at all), just
+     * not interactive.
+     */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * BCP-47 language tag to recognize, e.g. `en-US`. When not set, the application's active UI
+     * language is used (falling back to the browser language).
+     */
+    readonly lang: _angular_core.InputSignal<string>;
+    /**
+     * The chat input text. Recognized speech is appended to it. Supports two-way binding with
+     * `[(prompt)]`.
+     */
+    readonly prompt: _angular_core.ModelSignal<string>;
+    /**
+     * Whether a recognition session is currently running. Drives the pulsing microphone icon.
+     */
+    readonly isListening: _angular_core.WritableSignal<boolean>;
+    /**
+     * Emits whenever listening starts (`true`) or stops (`false`), so the host can react, for example
+     * by adapting the chat input placeholder while the user is dictating.
+     */
+    readonly listeningChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Whether the button should be shown at all: the browser supports the Web Speech API. Callers
+     * that want to withhold the feature entirely (as `c8y-ai-chat` does via
+     * `config.enableSpeechToText`) should not render this component rather than pass a "disabled"
+     * flag here - `disabled` only controls interactivity of an already-shown button.
+     */
+    readonly isAvailable: _angular_core.Signal<boolean>;
+    protected readonly startLabel: "Start voice input";
+    protected readonly stopLabel: "Stop voice input";
+    /**
+     * The input text present when listening started, so recognized speech is appended to it.
+     */
+    private textBeforeListening;
+    private listenSubscription?;
+    /**
+     * Starts listening when idle, or stops the current session when already listening.
+     */
+    toggleListening(): void;
+    private startListening;
+    private stopListening;
+    /**
+     * Resolves the language to recognize: the explicit {@link lang} input when set, otherwise the
+     * application's active UI language. The stored language uses an underscore region separator
+     * (e.g. `zh_CN`), so it is normalized to the hyphenated BCP-47 form the Web Speech API expects.
+     */
+    private resolveLang;
+    /** Updates the listening state and notifies the host, ignoring no-op transitions. */
+    private setListening;
+    /**
+     * Appends the recognized transcript to the text that was present when listening started.
+     */
+    private appendTranscript;
+    /**
+     * Ends the session and, for errors the user can act on (such as a denied microphone permission),
+     * shows an alert. Benign outcomes like "no speech detected" or a user-initiated stop are ignored.
+     */
+    private handleError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiChatSpeechToTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatSpeechToTextComponent, "c8y-ai-chat-speech-to-text", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lang": { "alias": "lang"; "required": false; "isSignal": true; }; "prompt": { "alias": "prompt"; "required": false; "isSignal": true; }; }, { "prompt": "promptChange"; "listeningChange": "listeningChange"; }, never, never, true, never>;
+}
+
 /**
  * A suggestion chip that can be displayed in the chat interface.
  * When clicked, it automatically populates and sends a predefined prompt.
@@ -202,6 +327,38 @@ declare class AiChatSuggestionComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatSuggestionComponent, "c8y-ai-chat-suggestion", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "prompt": { "alias": "prompt"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "useAiButtons": { "alias": "useAiButtons"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "suggestionClicked": "suggestionClicked"; }, never, never, true, never>;
 }
 
+/** Options accepted when starting a recognition session. */
+interface SpeechRecognitionOptions {
+    /** BCP-47 language tag to recognize, e.g. `en-US`. Defaults to the browser language. */
+    lang?: string;
+    /** Whether to emit interim (not yet final) results as the user speaks. Default: true. */
+    interimResults?: boolean;
+}
+/**
+ * Thin wrapper around the browser's Web Speech API (`SpeechRecognition`) used to transcribe speech
+ * to text. The API is not available in every browser, so consumers must check {@link isSupported}
+ * before offering speech input.
+ */
+declare class SpeechRecognitionService {
+    private readonly ngZone;
+    private readonly recognitionConstructor;
+    /** Whether the current browser exposes the Web Speech API required for speech-to-text. */
+    get isSupported(): boolean;
+    /**
+     * Starts a recognition session and emits the cumulative transcript recognized so far on every
+     * update (including interim results, when enabled). The observable completes when recognition
+     * ends and errors with the API error code (a string such as `not-allowed`) when it fails.
+     * Unsubscribing aborts an in-progress recognition.
+     */
+    listen(options?: SpeechRecognitionOptions): Observable<string>;
+    /** Joins the transcripts of every recognition result into a single string. */
+    private collectTranscript;
+    /** Resolves the recognition constructor from the window, handling the `webkit` prefix. */
+    private resolveConstructor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpeechRecognitionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpeechRecognitionService>;
+}
+
 declare class AiChatToolCallComponent {
     /**
      * The tool call part to render. This includes all information about the tool call, including the name of the tool,
@@ -229,16 +386,41 @@ declare class AiChatToolCallComponent {
      */
     readonly completedLabel: _angular_core.InputSignal<string>;
     /**
-     * A function that can generate a label for this tool call based on the tool call data.
+     * A function that can generate a label for this tool call based on the tool call data,
+     * including for the `tool-approval-requested` state - e.g. "Delete device weather-station-12"
+     * instead of the generic "Tool delete_device requires approval". When this returns nothing for
+     * a pending approval, the details section is auto-expanded so the raw input is visible instead.
      */
     readonly labelProvider: _angular_core.InputSignal<(toolCallPart: ToolCallPart, translateService: TranslateService) => string | undefined>;
+    /**
+     * Whether the approve/deny actions are offered when the tool is in the `tool-approval-requested` state.
+     * Only enabled for the latest message while no response is streaming.
+     */
+    readonly approvalEnabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the "always approve" options are offered next to the approve action. Disabled for
+     * tools that must be approved explicitly on every call (configured via `needsApproval`),
+     * which show plain approve/deny buttons without the dropdown.
+     */
+    readonly rememberApprovalEnabled: _angular_core.InputSignal<boolean>;
+    /** Emits the user's decision for a tool call awaiting approval. */
+    readonly approvalResponse: _angular_core.OutputEmitterRef<ToolApprovalDecision>;
     protected readonly expanded: _angular_core.WritableSignal<boolean>;
     protected readonly everExpanded: _angular_core.WritableSignal<boolean>;
     private readonly translateService;
+    /** Guards the auto-expand-on-approval effect so it only ever applies its initial decision once. */
+    private hasSetInitialApprovalExpansion;
+    constructor();
     getToolLabel(tool: ToolCallPart): string;
+    /**
+     * The fieldset's accessible name (and, for a pending approval, also its visible legend - see the
+     * template). Both must stay in sync so sighted and screen-reader users see/hear the same thing.
+     */
+    getFieldsetLabel(tool: ToolCallPart): string;
     protected toggleExpanded(): void;
+    private getDynamicLabel;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiChatToolCallComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatToolCallComponent, "c8y-ai-chat-tool-call", never, { "tool": { "alias": "tool"; "required": true; "isSignal": true; }; "isExecuting": { "alias": "isExecuting"; "required": true; "isSignal": true; }; "toolDetailsComponent": { "alias": "toolDetailsComponent"; "required": false; "isSignal": true; }; "showDefaultToolDetails": { "alias": "showDefaultToolDetails"; "required": false; "isSignal": true; }; "executingLabel": { "alias": "executingLabel"; "required": false; "isSignal": true; }; "completedLabel": { "alias": "completedLabel"; "required": false; "isSignal": true; }; "labelProvider": { "alias": "labelProvider"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatToolCallComponent, "c8y-ai-chat-tool-call", never, { "tool": { "alias": "tool"; "required": true; "isSignal": true; }; "isExecuting": { "alias": "isExecuting"; "required": true; "isSignal": true; }; "toolDetailsComponent": { "alias": "toolDetailsComponent"; "required": false; "isSignal": true; }; "showDefaultToolDetails": { "alias": "showDefaultToolDetails"; "required": false; "isSignal": true; }; "executingLabel": { "alias": "executingLabel"; "required": false; "isSignal": true; }; "completedLabel": { "alias": "completedLabel"; "required": false; "isSignal": true; }; "labelProvider": { "alias": "labelProvider"; "required": false; "isSignal": true; }; "approvalEnabled": { "alias": "approvalEnabled"; "required": false; "isSignal": true; }; "rememberApprovalEnabled": { "alias": "rememberApprovalEnabled"; "required": false; "isSignal": true; }; }, { "approvalResponse": "approvalResponse"; }, never, never, true, never>;
 }
 
 /**
@@ -251,7 +433,11 @@ declare class AiChatComponent {
      * Indicates whether the chat is currently processing a request.
      * When true, displays a cancel button instead of send button and disables the input.
      */
-    isLoading: boolean;
+    set isLoading(value: boolean);
+    get isLoading(): boolean;
+    private _isLoading;
+    /** Announced politely when the response starts and when it finishes. */
+    readonly statusAnnouncement: _angular_core.WritableSignal<string>;
     /**
      * Disables the chat input and send button when true.
      */
@@ -286,11 +472,34 @@ declare class AiChatComponent {
      * Child message components displayed in the chat.
      */
     readonly messages: _angular_core.Signal<readonly AiChatMessageComponent[]>;
+    /**
+     * Action components projected into the action bar beneath the input box.
+     */
+    private readonly projectedActions;
+    /**
+     * Action components provided programmatically. Used by wrapper components (such as
+     * `c8y-agent-chat`) to forward actions projected by their own consumers, since content queries do
+     * not reach components re-projected through a nested `ng-content`.
+     */
+    readonly actions: _angular_core.InputSignal<readonly AiChatActionComponent[]>;
+    /** All actions from content projection and the `actions` input, in declaration order. */
+    private readonly allActions;
+    /** Whether any action is present, i.e. whether the action bar should be rendered. */
+    readonly hasActionBar: _angular_core.Signal<boolean>;
+    /** Actions placed on the left side of the action bar. */
+    readonly leftActions: _angular_core.Signal<AiChatActionComponent[]>;
+    /** Actions placed on the right side of the action bar. */
+    readonly rightActions: _angular_core.Signal<AiChatActionComponent[]>;
+    /** Actions collected into the overflow (`more`) dropdown on the right side. */
+    readonly moreActions: _angular_core.Signal<AiChatActionComponent[]>;
     /**
      * Reference to the scroll container for the chat messages.
      */
     private readonly scrollContainer;
+    private readonly chatInput;
     readonly componentId: string;
+    /** Whether the speech-to-text button is currently listening; swaps the input placeholder. */
+    readonly isListeningForSpeech: _angular_core.WritableSignal<boolean>;
     private _config;
     constructor();
     /**
@@ -312,10 +521,15 @@ declare class AiChatComponent {
      * Emits the onCancel event.
      */
     cancel(): void;
+    /**
+     * Moves keyboard focus to the prompt input. Call this after removing or replacing messages, so
+     * that focus is not lost with the element the user was on.
+     */
+    focusInput(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiChatComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatComponent, "c8y-ai-chat", never, { "isLoading": { "alias": "isLoading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; "suggestionsTemplate": { "alias": "suggestionsTemplate"; "required": false; }; "welcomeTemplate": { "alias": "welcomeTemplate"; "required": false; }; "cumulativeUsage": { "alias": "cumulativeUsage"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "onMessage": "onMessage"; "onCancel": "onCancel"; }, ["messages"], ["[slot='before-messages']", "c8y-ai-chat-message", "[slot='after-messages']", "c8y-ai-chat-suggestion"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatComponent, "c8y-ai-chat", never, { "isLoading": { "alias": "isLoading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; "suggestionsTemplate": { "alias": "suggestionsTemplate"; "required": false; }; "welcomeTemplate": { "alias": "welcomeTemplate"; "required": false; }; "cumulativeUsage": { "alias": "cumulativeUsage"; "required": false; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; }; }, { "onMessage": "onMessage"; "onCancel": "onCancel"; }, ["messages", "projectedActions"], ["[slot='before-messages']", "c8y-ai-chat-message", "[slot='after-messages']", "c8y-ai-chat-suggestion", "[slot='input-actions']"], true, never>;
 }
 
-export { AiChatAssistantMessageComponent, AiChatAssistantPartComponent, AiChatComponent, AiChatMessageActionComponent, AiChatMessageComponent, AiChatSuggestionComponent, AiChatToolCallComponent };
-export type { AssistantMessageContext };
+export { AiChatActionComponent, AiChatAssistantMessageComponent, AiChatAssistantPartComponent, AiChatComponent, AiChatMessageActionComponent, AiChatMessageComponent, AiChatSpeechToTextComponent, AiChatSuggestionComponent, AiChatToolCallComponent, SpeechRecognitionService };
+export type { AssistantMessageContext, SpeechRecognitionOptions };
 //# sourceMappingURL=c8y-ngx-components-ai-ai-chat.d.ts.map

package/types/c8y-ngx-components-ai-ai-chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"c8y-ngx-components-ai-ai-chat.d.ts","sources":["../../ai/ai-chat/ai-chat-assistant-message.component.ts","../../ai/ai-chat/ai-chat-assistant-part.component.ts","../../ai/ai-chat/ai-chat-message-action.component.ts","../../ai/ai-chat/ai-chat-message.component.ts","../../ai/ai-chat/ai-chat-suggestion.component.ts","../../ai/ai-chat/ai-chat-tool-call.component.ts","../../ai/ai-chat/ai-chat.component.ts"],"mappings":";;;;;;AAqBA;;;AAGG;UACc,uBAAuB;aAC7B,kBAAkB;YACnB,6BAA6B;;;;;AAOtC;AAED;;;AAGG;AACH,cAaa,+BAA+B;AAC1C;;;AAGG;sCAC6B,aAAA,CAAA,WAAA,CAAA,uBAAA;AAEhC;;AAEG;mCAC0B,aAAA,CAAA,WAAA;AAE7B;;;AAGG;AACH,yCAAmC,aAAA,CAAA,cAAA;AAEnC;;AAEG;AACH,qDAA+C,aAAA,CAAA,cAAA,CAAA,GAAA;AAE/C;mDAE6C,aAAA,CAAA,MAAA;AAyG5B,uBAAA,aAAa;AACX,yBAAA,aAAa;AAxG9B;;AAYF;;;AAGG;AACH;AAIA;;;;AAIG;AACH,uBAAmB,YAAY;AA8B/B;AAQA;;;;;AAKG;AACH,oCAAgC,uBAAuB;gCAQ3B,aAAa;wDASlC,uBAAuB,GAC3B,6BAA6B;AAKhC;;;;;;;;;AASG;AACH,yDAAqD,uBAAuB;uBAC3D,aAAa;yBACX,aAAa;AAC/B;AA8DD;;;;;;AAMG;AACH;oDAzMW,+BAA+B;sDAA/B,+BAA+B;AAmO3C;;AC1QD;AACA,cAiBa,4BAA4B;mBAC1B,aAAA,CAAA,WAAA,CAAA,aAAA;;wCAGqB,aAAA,CAAA,WAAA;AAElC;;;AAGG;sCAC6B,aAAA,CAAA,WAAA,CAAA,uBAAA;;AAGhC,iCAA2B,aAAA,CAAA,cAAA;;oDAbhB,4BAA4B;sDAA5B,4BAA4B;AAkBxC;;AC7CD;;;AAGG;AACH,cAMa,4BAA4B;AACvC;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;UAEG,yBAAyB;AAE/B;;AAEG;AAEH,mBAAa,YAAA;oDA7BF,4BAA4B;sDAA5B,4BAA4B;AA8BxC;;ACpCD;;;;;AAKG;AACH,cAQa,sBAAsB;mBACpB,aAAA,CAAA,WAAA;sBACG,aAAA,CAAA,WAAA,CAAA,SAAA;AAEhB;AAEA;AAIA;;;;AAIG;wBACe,aAAA,CAAA,MAAA;AASlB;;;;AAIG;sCAC6B,aAAA,CAAA,MAAA;oDA7BrB,sBAAsB;sDAAtB,sBAAsB;AA4ClC;;AC9DD;;;AAGG;AACH,cAOa,yBAAyB;AACpC;;AAEG;oBACW,aAAA,CAAA,WAAA;AAEd;;AAEG;qBACY,aAAA,CAAA,WAAA;AAEf;;AAEG;mBACU,aAAA,CAAA,WAAA,CAAA,yBAAA;AAEb;;AAEG;2BACkB,aAAA,CAAA,WAAA;AAErB;;AAEG;uBACc,aAAA,CAAA,WAAA;AAEjB;;AAEG;gCACuB,aAAA,CAAA,gBAAA,CAAA,SAAA;AAE1B;;AAEG;;oDAjCQ,yBAAyB;sDAAzB,yBAAyB;AAyCrC;;ACjDD,cAaa,uBAAuB;AAClC;;;AAGG;mBACU,aAAA,CAAA,WAAA,CAAA,YAAA,CAAA,MAAA;AAEb;;AAEG;0BACiB,aAAA,CAAA,WAAA;AAEpB;;AAEG;mCAC0B,aAAA,CAAA,WAAA,CAAA,IAAA;AAE7B;;AAEG;qCAC4B,aAAA,CAAA,WAAA;AAE/B;;AAEG;6BACoB,aAAA,CAAA,WAAA;AACvB;;AAEG;6BACoB,aAAA,CAAA,WAAA;AAEvB;;AAEG;4BACmB,aAAA,CAAA,WAAA,gBAAA,YAAA,oBAAA,gBAAA;AAEtB,iCAA2B,aAAA,CAAA,cAAA;AAC3B,qCAA+B,aAAA,CAAA,cAAA;AAE/B;AAEA,uBAAmB,YAAY;;oDAzCpB,uBAAuB;sDAAvB,uBAAuB;AAyEnC;;ACpED;;;;AAIG;AACH,cAmBa,eAAe;AAC1B;;;AAGG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;;;AAIG;AAEH,0BAAsB,WAAW;;AAGxB,sBAAkB,WAAW;AAE7B;;;;AAIR;AAED;;;AAGG;AAEH,eAAS,YAAA,CAAA,SAAA;AAET;;AAEG;AAEH,cAAQ,YAAA;AAER;;AAEG;uBACc,aAAA,CAAA,MAAA,UAAA,sBAAA;AAEjB;;AAEG;AACH;;;;AAoCA;;;;;AAKG;sBAEe,OAAO,CAAC,UAAU;kBAGtB,UAAU;AAIxB;;;;AAIG;AACH,wBAAoB,KAAK;AAWzB;;;AAGG;AACH;oDAhIW,eAAe;sDAAf,eAAe;AAmI3B;;;;","names":[]}
+{"version":3,"file":"c8y-ngx-components-ai-ai-chat.d.ts","sources":["../../ai/ai-chat/ai-chat-action.component.ts","../../ai/ai-chat/ai-chat-assistant-message.component.ts","../../ai/ai-chat/ai-chat-assistant-part.component.ts","../../ai/ai-chat/ai-chat-message-action.component.ts","../../ai/ai-chat/ai-chat-message.component.ts","../../ai/ai-chat/ai-chat-speech-to-text.component.ts","../../ai/ai-chat/ai-chat-suggestion.component.ts","../../ai/ai-chat/speech-recognition.service.ts","../../ai/ai-chat/ai-chat-tool-call.component.ts","../../ai/ai-chat/ai-chat.component.ts"],"mappings":";;;;;;;AAEA;;;;;;;;;;;;;AAaG;AACH,cAMa,qBAAqB;AAChC;;;AAGG;wBACe,aAAA,CAAA,WAAA;;uBAGD,aAAA,CAAA,MAAA,CAAA,WAAA;oDARN,qBAAqB;sDAArB,qBAAqB;AASjC;;ACTD;;;AAGG;UACc,uBAAuB;aAC7B,kBAAkB;YACnB,6BAA6B;;;;;AAQrC;;;AAGG;AACH,oCAAgC,YAAY,YAAY,oBAAoB;AAE5E;;;;;AAKG;qCAC8B,YAAY;AAC9C;AAED;;;AAGG;AACH,cAaa,+BAA+B;AAC1C;;;AAGG;sCAC6B,aAAA,CAAA,WAAA,CAAA,uBAAA;AAEhC;;AAEG;mCAC0B,aAAA,CAAA,WAAA;AAE7B;;;AAGG;AACH,yCAAmC,aAAA,CAAA,cAAA;AAEnC;;AAEG;AACH,qDAA+C,aAAA,CAAA,cAAA,CAAA,GAAA;AAE/C;mDAE6C,aAAA,CAAA,MAAA;AAyG5B,uBAAA,aAAa;AACX,yBAAA,aAAa;AAxG9B;;AAYF;;;AAGG;AACH;AAIA;;;;AAIG;AACH,uBAAmB,YAAY;AA8B/B;AAYA;;;;;AAKG;AACH,oCAAgC,uBAAuB;gCAQ3B,aAAa;wDAKlC,uBAAuB,GAC3B,6BAA6B;AAKhC;;;;;;;;;AASG;AACH,yDAAqD,uBAAuB;uBAC3D,aAAa;yBACX,aAAa;AAC/B;AAyDD;;;;;;AAMG;AACH;oDApMW,+BAA+B;sDAA/B,+BAA+B;AA8N3C;;ACpRD;AACA,cAiBa,4BAA4B;mBAC1B,aAAA,CAAA,WAAA,CAAA,aAAA;;wCAGqB,aAAA,CAAA,WAAA;AAElC;;;AAGG;sCAC6B,aAAA,CAAA,WAAA,CAAA,uBAAA;;AAGhC,iCAA2B,aAAA,CAAA,cAAA;;oDAbhB,4BAA4B;sDAA5B,4BAA4B;AAkBxC;;AC7CD;;;AAGG;AACH,cAMa,4BAA4B;AACvC;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;UAEG,yBAAyB;AAE/B;;AAEG;AAEH,mBAAa,YAAA;oDA7BF,4BAA4B;sDAA5B,4BAA4B;AA8BxC;;ACpCD;;;;;AAKG;AACH,cAQa,sBAAsB;mBACpB,aAAA,CAAA,WAAA;sBACG,aAAA,CAAA,WAAA,CAAA,SAAA;AAEhB;AAEA;AAIA;;;;;;;;AAQG;wBACe,aAAA,CAAA,MAAA;AAElB;;;;AAIG;sCAC6B,aAAA,CAAA,MAAA;oDA1BrB,sBAAsB;sDAAtB,sBAAsB;AAyClC;;AC1CD;;;;;;;;;;AAUG;AACH,cAOa,2BAA2B;AACtC;AACA;AACA;AACA;AAEA;;;;AAIG;uBACc,aAAA,CAAA,WAAA;AAEjB;;;AAGG;mBACU,aAAA,CAAA,WAAA;AAEb;;;AAGG;qBACY,aAAA,CAAA,WAAA;AAEf;;AAEG;0BACiB,aAAA,CAAA,cAAA;AAEpB;;;AAGG;8BACqB,aAAA,CAAA,gBAAA;AAExB;;;;;AAKG;0BACiB,aAAA,CAAA,MAAA;AAEpB;AACA;AAEA;;AAEG;;;AAIH;;AAEG;AACH;AAQA;AAcA;AAKA;;;;AAIG;AACH;;AAKA;AAQA;;AAEG;AACH;AAQA;;;AAGG;AACH;oDApHW,2BAA2B;sDAA3B,2BAA2B;AAkIvC;;ACrKD;;;AAGG;AACH,cAOa,yBAAyB;AACpC;;AAEG;oBACW,aAAA,CAAA,WAAA;AAEd;;AAEG;qBACY,aAAA,CAAA,WAAA;AAEf;;AAEG;mBACU,aAAA,CAAA,WAAA,CAAA,yBAAA;AAEb;;AAEG;2BACkB,aAAA,CAAA,WAAA;AAErB;;AAEG;uBACc,aAAA,CAAA,WAAA;AAEjB;;AAEG;gCACuB,aAAA,CAAA,gBAAA,CAAA,SAAA;AAE1B;;AAEG;;oDAjCQ,yBAAyB;sDAAzB,yBAAyB;AAyCrC;;ACpBD;UACiB,wBAAwB;;;;;AAKxC;AAED;;;;AAIG;AACH,cACa,wBAAwB;AACnC;AACA;;;AAOA;;;;;AAKG;qBACa,wBAA6B,GAAG,UAAU;;AAgC1D;;AASA;oDAxDW,wBAAwB;wDAAxB,wBAAwB;AAkEpC;;AC9FD,cAea,uBAAuB;AAClC;;;AAGG;mBACU,aAAA,CAAA,WAAA,CAAA,YAAA,CAAA,MAAA;AAEb;;AAEG;0BACiB,aAAA,CAAA,WAAA;AAEpB;;AAEG;mCAC0B,aAAA,CAAA,WAAA,CAAA,IAAA;AAE7B;;AAEG;qCAC4B,aAAA,CAAA,WAAA;AAE/B;;AAEG;6BACoB,aAAA,CAAA,WAAA;AACvB;;AAEG;6BACoB,aAAA,CAAA,WAAA;AAEvB;;;;;AAKG;4BACmB,aAAA,CAAA,WAAA,gBAAA,YAAA,oBAAA,gBAAA;AAEtB;;;AAGG;8BACqB,aAAA,CAAA,WAAA;AAExB;;;;AAIG;sCAC6B,aAAA,CAAA,WAAA;;+BAGP,aAAA,CAAA,gBAAA,CAAA,oBAAA;AAEzB,iCAA2B,aAAA,CAAA,cAAA;AAC3B,qCAA+B,aAAA,CAAA,cAAA;AAE/B;;;;AAqBA,uBAAmB,YAAY;AAgC/B;;;AAGG;AACH,2BAAuB,YAAY;;AAiBnC;oDApIW,uBAAuB;sDAAvB,uBAAuB;AA+InC;;ACpJD;;;;AAIG;AACH,cAsBa,eAAe;AAC1B;;;AAGG;AACH;;;;iCAe2B,aAAA,CAAA,cAAA;AAE3B;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;;;AAIG;AAEH,0BAAsB,WAAW;;AAGxB,sBAAkB,WAAW;AAE7B;;;;AAIR;AAED;;;AAGG;AAEH,eAAS,YAAA,CAAA,SAAA;AAET;;AAEG;AAEH,cAAQ,YAAA;AAER;;AAEG;uBACc,aAAA,CAAA,MAAA,UAAA,sBAAA;AAEjB;;AAEG;AACH;AAEA;;;;AAIG;sBACa,aAAA,CAAA,WAAA,UAAA,qBAAA;;AAGhB;;2BAGqB,aAAA,CAAA,MAAA;;0BAGD,aAAA,CAAA,MAAA,CAAA,qBAAA;;2BAKC,aAAA,CAAA,MAAA,CAAA,qBAAA;;0BAKD,aAAA,CAAA,MAAA,CAAA,qBAAA;AAIpB;;AAEG;AACH;AAEA;;;mCAK6B,aAAA,CAAA,cAAA;;;AAmC7B;;;;;AAKG;sBAEe,OAAO,CAAC,UAAU;kBAGtB,UAAU;AAIxB;;;;AAIG;AACH,wBAAoB,KAAK;AAWzB;;;AAGG;AACH;AAIA;;;AAGG;AACH;oDA7LW,eAAe;sDAAf,eAAe;AAgM3B;;;;","names":[]}

package/types/c8y-ngx-components-ai.d.ts

@@ -37,8 +37,9 @@ interface AIAssistantMessage {
 }
 /** The part of an AI message representing a call to a tool (which may or may not have completed and a result is available). */
 interface ToolCallPart<TInput extends Record<string, any> = Record<string, unknown>, TOutput = unknown> {
-    /** The status of the tool call - whether it is currently streaming its input, in progress, or has completed and a result (output or error) is available */
-    type: 'tool-input-streaming' | 'tool-executing' | 'tool-result';
+    /** The status of the tool call - whether it is currently streaming its input, in progress,
+     * has completed and a result (output or error) is available, or requires human approval before execution. */
+    type: 'tool-input-streaming' | 'tool-executing' | 'tool-result' | 'tool-approval-requested' | 'tool-approval-responded';
     /** Unique identifier for the tool, as specified in the MCP server and agent definition. */
     toolName: string;
     /** Unique identifier for this invocation of the tool, used to match calls with results. */
@@ -62,7 +63,64 @@ interface ToolCallPart<TInput extends Record<string, any> = Record<string, unkno
     outputType?: 'content' | string;
     /** Set to true for a tool-result where an error occurred. The error message or JSON is in the output field. */
     error?: boolean;
+    /**
+     * Present when the tool requires human approval before execution (type `tool-approval-requested`
+     * or `tool-approval-responded`). `approved` is set once the user has made a decision.
+     */
+    approval?: {
+        /** Identifier for this approval request, used to match the response when resuming the conversation. */
+        approvalId: string;
+        /** The user's decision. Undefined while the approval is still pending. */
+        approved?: boolean;
+        /** Optional reason given for the decision. */
+        reason?: string;
+    };
+}
+/**
+ * The user's decision on a tool call awaiting approval.
+ */
+interface ToolApprovalDecision {
+    /** Whether the tool call may execute. */
+    approved: boolean;
+    /**
+     * When approving, optionally remember the decision for the rest of the current chat session
+     * so future calls are approved automatically without prompting: `'tool'` remembers this tool
+     * only, `'all'` remembers every tool of the conversation. A new conversation prompts again.
+     * Tools configured with `needsApproval` always prompt, regardless of remembered decisions.
+     * Ignored when `approved` is false.
+     */
+    remember?: 'tool' | 'all';
 }
+/**
+ * Policy for requiring human approval of tool calls based on the annotations (behaviour hints)
+ * the MCP server declares for each tool. Each enabled criterion is checked against the tool's
+ * annotations; if any matches, the call pauses for approval. Tools without annotations are
+ * treated as matching every criterion (the MCP specification assumes the worst case for
+ * missing hints).
+ */
+interface McpToolApprovalPolicy {
+    /** Require approval for tools that may perform destructive updates. */
+    destructive?: boolean;
+    /** Require approval for tools that may modify their environment in any way. */
+    nonReadOnly?: boolean;
+    /** Require approval for tools that may interact with external entities. */
+    openWorld?: boolean;
+}
+/**
+ * A tool entry in an MCP configuration's `tools` array: either just the tool name, or an
+ * object naming the tool together with its own approval policy. A tool with its own policy
+ * is judged by that policy alone - it replaces the server-wide `approvalPolicy` for this
+ * tool, so an entry without any enabled criterion (`{ name: 'x' }`) exempts the tool from
+ * the server-wide policy.
+ *
+ * `needsApproval` set on the entry decides for this tool and overrides the MCP-entry-level
+ * `needsApproval`: `true` requires explicit approval on every call - such tools are never
+ * approved automatically, not even by the "approve all tools" options.
+ */
+type McpToolConfig = string | ({
+    name: string;
+    needsApproval?: boolean;
+} & McpToolApprovalPolicy);
 /** Parts that make up the content of a message (typically an assistant message). */
 type AIMessagePart = {
     type: 'text' | 'reasoning';
@@ -137,7 +195,25 @@ interface AgentDefinition {
     /** The tools this agent can use from the configured MCP servers. */
     mcp?: Array<{
         serverName: string;
-        tools: string[];
+        /**
+         * The tools of this server the agent can use. Each entry is either a tool name, or an
+         * object naming the tool together with its own approval policy (see {@link McpToolConfig}).
+         */
+        tools: McpToolConfig[];
+        /**
+         * Tools that require human approval before execution. `true` applies to all tools of this
+         * server, an array applies to the listed tool names only. When triggered, the response stops
+         * with a `tool-approval-requested` part and the user is asked to approve or deny the call.
+         */
+        needsApproval?: boolean | string[];
+        /**
+         * Annotation-based approval policy for the tools of this server, applied to tools that
+         * `needsApproval` does not already cover. See {@link McpToolApprovalPolicy}.
+         *
+         * A tool entry carrying its own policy is judged by that policy instead of this one;
+         * plain tool names fall back to this server-wide policy.
+         */
+        approvalPolicy?: McpToolApprovalPolicy;
     }>;
 }
 /** Configuration for the `ai-chat` component. */
@@ -152,12 +228,19 @@ interface ChatConfig {
     welcomePosition: 'top' | 'bottom' | 'center';
     /** The message displayed in the input box before the user types their message */
     placeholder: string;
+    /** The placeholder shown in the input box while the speech-to-text button is actively listening. */
+    listeningPlaceholder?: string;
     /** Default is horizontal */
     suggestionsLayout?: 'vertical' | 'horizontal';
     /** Hide scrollbar except when hovering over the chat conversation (default: false) */
     scrollbarOnlyOnHover?: boolean;
     /** By default a framed appearance is used; use this to choose a flat appearance with no shading instead. */
     appearance?: 'framed' | 'flat';
+    /**
+     * When `false`, hides the speech-to-text (voice input) button. The button is only shown when it
+     * is enabled and the browser supports the Web Speech API. Default: `true`.
+     */
+    enableSpeechToText?: boolean;
     sendButtonText: string;
     cancelButtonText: string;
     disclaimerText: string;
@@ -174,6 +257,11 @@ interface AgentChatConfig extends ChatConfig {
     showUsagePerMessage?: boolean;
     /** When true, shows a delete button on the last completed assistant message to remove the last exchange. Default: false. */
     showDeleteAction?: boolean;
+    /**
+     * When false, hides the global tool-approval mode selector (Manual/Auto) and its banner.
+     * Per-message tool approval prompts are unaffected. Default: true.
+     */
+    showGlobalToolApprovalToggle?: boolean;
 }
 /** Configuration for how the `<ai-chat-assistant-message>` displays a calls for a specific tool name to the user. */
 type ToolCallConfig = {
@@ -350,13 +438,13 @@ declare enum DataStreamType {
     TOOL_CALL_STREAMING = "tool-call-streaming",
     TOOL_CALL_DELTA = "tool-call-delta",
     TOOL_RESULT = "tool-result",
+    TOOL_APPROVAL_REQUEST = "tool-approval-request",
     REASONING = "reasoning",
     REASONING_DELTA = "reasoning-delta",
     REDACTED_REASONING = "redacted-reasoning",
     REASONING_SIGNATURE = "reasoning-signature",
     FINISH_REASONING = "finish-reasoning",
     FINISH = "finish",
-    FINISH_STEP = "finish-step",
     ERROR = "error",
     DATA = "data",
     MESSAGE_ANNOTATIONS = "message-annotations",
@@ -449,6 +537,22 @@ declare class AIService {
         [key: string]: any;
     }, abortController: AbortController, fromApp?: string): Promise<Observable<AIStreamResponse>>;
     protected convertToAgentMessageFormat(messages: AIMessage[]): object[];
+    /**
+     * Converts an assistant message containing tool approval parts into the wire format expected by
+     * the agent: an assistant message carrying `tool-call` and `tool-approval-request` parts, followed
+     * (once the user has decided) by a `tool` role message carrying the matching `tool-approval-response`
+     * parts.
+     *
+     * The agent strips approval parts from the prompt it sends to the model provider, so a *resolved*
+     * exchange must also carry the call's outcome in its tool message: the executed result (found via
+     * `resultsByToolCallId`, since it streams in with the following assistant message) or an
+     * `execution-denied` marker. Each such result is serialized exactly once - `serializedToolCallIds`
+     * tracks consumed calls so the copy stored in the following message is not emitted again as a
+     * duplicate tool call.
+     */
+    private convertAssistantMessageWithApprovals;
+    /** Converts a tool output stored in our format back to the LanguageModelV*ToolResultOutput wire format. */
+    private convertToolResultOutputForAgent;
     /**
      * Convert a tool output from the MCP/wire format (which is different/more compact than LanguageModelV3ToolResultOutput)
      * into our own standard representation, which can be roundtripped to the format we need to provide when making future requests.
@@ -499,6 +603,72 @@ declare class AIService {
  */
 declare function defaultPruneMessagesForAgent(messages: AIMessage[]): AIMessage[];
 
-export { AIService, DataStreamType, defaultPruneMessagesForAgent };
-export type { AIAssistantMessage, AIMessage, AIMessagePart, AIStreamResponse, AISystemMessage, AIUserMessage, AgentChatConfig, AgentDefinition, AgentHealthCheckResponse, AssistantMessageDisplayConfig, ChatConfig, ChatHistory, ChatHistoryConfig, ClientAgentDefinition, ObjectAgentResponse, ResponseMetadataPart, Suggestion, ToolCallConfig, ToolCallPart, WidgetAiChatSectionComponentConfig, pruneMessagesFunction };
+/**
+ * Remembers the user's "always approve" decisions for tool calls that require human approval.
+ *
+ * Decisions are held in memory only and are scoped to a chat session: each chat component
+ * instance identifies its conversation with a unique session ID, so approvals never outlive
+ * the conversation they were given in. Navigating away and back, reopening a dialog, or
+ * starting a new conversation creates a new session that prompts again. This applies both to
+ * single tools ("always approve this tool") and to the session-wide YOLO mode
+ * ({@link rememberAllTools}, "always approve all tools").
+ *
+ * Tools configured with `needsApproval` always prompt regardless of these preferences; that
+ * is enforced by the chat component, since it requires the agent definition. The chat
+ * component also offers a global "approve all tools" option persisted as a user preference,
+ * which is not managed by this service.
+ *
+ * Only approvals are remembered, never denials.
+ */
+declare class AiToolApprovalMemoryService {
+    /** Remembered approvals, keyed by chat session ID. */
+    private readonly sessions;
+    private nextSessionId;
+    /**
+     * Returns a new chat session ID, unique for the lifetime of the page. Chat components request
+     * one per conversation and pass it to the other methods to scope their approvals.
+     */
+    newSessionId(): string;
+    /** Remembers that calls of the given tool are always approved within the given chat session. */
+    rememberTool(sessionId: string, toolName: string): void;
+    /**
+     * Enables YOLO mode for the given chat session: every tool of the conversation is approved
+     * automatically, without prompting, until the conversation ends.
+     */
+    rememberAllTools(sessionId: string): void;
+    /** Whether the user chose to always approve the given tool within the given chat session. */
+    isToolRemembered(sessionId: string, toolName: string): boolean;
+    /** Whether YOLO mode is enabled for the given chat session (see {@link rememberAllTools}). */
+    isApproveAllToolsEnabled(sessionId: string): boolean;
+    /** Forgets the remembered approvals of a chat session, e.g. when the conversation ends. */
+    endSession(sessionId: string): void;
+    /** Forgets all remembered approvals of all sessions. */
+    clear(): void;
+    private session;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiToolApprovalMemoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiToolApprovalMemoryService>;
+}
+
+/**
+ * A `labelProvider` (see `ToolCallConfig`) for the `cumulocity-api-request` tool: the generic
+ * Cumulocity REST query tool offered to AI agents to look up API data. For a tool call awaiting
+ * approval, produces a human-readable summary of the query - e.g. "Look up: alarms with status:
+ * active" -
+ * instead of the raw `{ "query": "/alarm/alarms?status=ACTIVE" }`, so the user can judge the
+ * request without reading the API path themselves.
+ *
+ * Only applies to the `tool-approval-requested`/`tool-approval-responded` states; for every other
+ * state this returns `undefined` so the caller's own `executingLabel`/`completedLabel` is used
+ * instead. It also returns `undefined` for any query it doesn't recognize, which keeps the generic
+ * "Tool cumulocity-api-request requires approval" text and the auto-expanded raw input as a
+ * fallback - recognizes the common read endpoints (inventory, alarms, measurements, events,
+ * operations, users, applications, identity).
+ *
+ * Assumes the tool's `query` input is a REST path with no separate `method`/body fields, matching
+ * its documented purpose of verifying/looking up API data.
+ */
+declare function cumulocityApiRequestLabelProvider(tool: ToolCallPart, translateService: TranslateService): string | undefined;
+
+export { AIService, AiToolApprovalMemoryService, DataStreamType, cumulocityApiRequestLabelProvider, defaultPruneMessagesForAgent };
+export type { AIAssistantMessage, AIMessage, AIMessagePart, AIStreamResponse, AISystemMessage, AIUserMessage, AgentChatConfig, AgentDefinition, AgentHealthCheckResponse, AssistantMessageDisplayConfig, ChatConfig, ChatHistory, ChatHistoryConfig, ClientAgentDefinition, McpToolApprovalPolicy, McpToolConfig, ObjectAgentResponse, ResponseMetadataPart, Suggestion, ToolApprovalDecision, ToolCallConfig, ToolCallPart, WidgetAiChatSectionComponentConfig, pruneMessagesFunction };
 //# sourceMappingURL=c8y-ngx-components-ai.d.ts.map

package/types/c8y-ngx-components-ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"c8y-ngx-components-ai.d.ts","sources":["../../ai/ai.model.ts","../../ai/ai.service.ts"],"mappings":"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","names":[]}
+{"version":3,"file":"c8y-ngx-components-ai.d.ts","sources":["../../ai/ai.model.ts","../../ai/ai.service.ts","../../ai/ai-tool-approval-memory.service.ts","../../ai/cumulocity-api-request-label.ts"],"mappings":"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","names":[]}