@copilotkitnext/angular 0.0.1 → 0.0.4

package/dist/esm2022/components/chat/copilot-chat-tool-calls-view.component.mjs

@@ -0,0 +1,216 @@
+import { Component, Input, ViewContainerRef, inject, ViewChild, TemplateRef, ChangeDetectionStrategy, signal, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { ToolCallStatus } from "@copilotkitnext/core";
+import { CopilotKitService } from "../../core/copilotkit.service";
+import { partialJSONParse } from "@copilotkitnext/shared";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Component for rendering all tool calls for an assistant message.
+ * This component iterates through the message's tool calls and renders each one
+ * using the registered render functions in CopilotKitService.
+ */
+export class CopilotChatToolCallsViewComponent {
+    message;
+    messages = [];
+    isLoading = false;
+    container;
+    copilotkit = inject(CopilotKitService, {
+        optional: true,
+    });
+    componentRefs = new Map();
+    templateCache = new Map();
+    // Signals for reactive state
+    messageSignal = signal(null);
+    messagesSignal = signal([]);
+    isLoadingSignal = signal(false);
+    ngAfterViewInit() {
+        this.renderAllToolCalls();
+    }
+    ngOnChanges(changes) {
+        if (changes["message"]) {
+            this.messageSignal.set(this.message);
+        }
+        if (changes["messages"]) {
+            this.messagesSignal.set(this.messages);
+        }
+        if (changes["isLoading"]) {
+            this.isLoadingSignal.set(this.isLoading);
+        }
+        this.renderAllToolCalls();
+    }
+    ngOnDestroy() {
+        // Clean up all component refs
+        this.componentRefs.forEach((ref) => ref.destroy());
+        this.componentRefs.clear();
+        this.templateCache.clear();
+    }
+    getTemplateForToolCall(toolCall) {
+        return this.templateCache.get(toolCall.id) || null;
+    }
+    renderAllToolCalls() {
+        const message = this.messageSignal();
+        if (!message || !message.toolCalls || message.toolCalls.length === 0) {
+            return;
+        }
+        // Clear existing renders
+        this.componentRefs.forEach((ref) => ref.destroy());
+        this.componentRefs.clear();
+        this.templateCache.clear();
+        if (!this.copilotkit || !this.container) {
+            return;
+        }
+        const messages = this.messagesSignal();
+        const isLoading = this.isLoadingSignal();
+        // Render each tool call
+        message.toolCalls.forEach((toolCall) => {
+            const toolMessage = messages.find((m) => m.role === "tool" && m.toolCallId === toolCall.id);
+            this.renderSingleToolCall(toolCall, toolMessage, isLoading);
+        });
+    }
+    renderSingleToolCall(toolCall, toolMessage, isLoading) {
+        if (!this.copilotkit) {
+            return;
+        }
+        // Get current render tool calls
+        const currentRenderToolCalls = this.copilotkit.currentRenderToolCalls();
+        // Find the render config for this tool call by name
+        // Also check for wildcard (*) renders if no exact match
+        const renderConfig = currentRenderToolCalls.find((rc) => rc.name === toolCall.function.name) || currentRenderToolCalls.find((rc) => rc.name === "*");
+        if (!renderConfig) {
+            return;
+        }
+        // Parse the arguments if they're a string
+        const args = partialJSONParse(toolCall.function.arguments);
+        // Determine status
+        let status;
+        if (toolMessage) {
+            status = ToolCallStatus.Complete;
+        }
+        else if (isLoading) {
+            status = ToolCallStatus.InProgress;
+        }
+        else {
+            status = ToolCallStatus.Complete;
+        }
+        // Create props based on status - use discriminated union properly
+        let props;
+        if (status === ToolCallStatus.InProgress) {
+            props = {
+                name: toolCall.function.name,
+                description: "",
+                args: args, // Partial args for InProgress
+                status: ToolCallStatus.InProgress,
+                result: undefined,
+            };
+        }
+        else {
+            // Complete status
+            props = {
+                name: toolCall.function.name,
+                description: "",
+                args: args, // Full args for Complete
+                status: ToolCallStatus.Complete,
+                result: toolMessage?.content || "",
+            };
+        }
+        // Check if render is a Component class or TemplateRef
+        if (this.isComponentClass(renderConfig.render)) {
+            // Create component dynamically
+            this.renderComponent(toolCall.id, renderConfig.render, props);
+        }
+        else if (this.isTemplateRef(renderConfig.render)) {
+            // Use template
+            this.renderTemplate(toolCall.id, renderConfig.render, props);
+        }
+    }
+    renderComponent(toolCallId, componentClass, props) {
+        if (!this.container) {
+            return;
+        }
+        // Create the component
+        const componentRef = this.container.createComponent(componentClass);
+        this.componentRefs.set(toolCallId, componentRef);
+        // Set inputs on the component
+        for (const [key, value] of Object.entries(props)) {
+            try {
+                componentRef.setInput(key, value);
+            }
+            catch (e) {
+                // Input might not exist on the component, which is fine
+            }
+        }
+        // Trigger change detection
+        componentRef.changeDetectorRef.detectChanges();
+    }
+    renderTemplate(toolCallId, template, props) {
+        this.templateCache.set(toolCallId, {
+            template,
+            context: {
+                $implicit: props,
+                name: props.name,
+                description: props.description,
+                args: props.args,
+                status: props.status,
+                result: props.result,
+            },
+        });
+    }
+    isComponentClass(value) {
+        return typeof value === "function" && value.prototype;
+    }
+    isTemplateRef(value) {
+        return value instanceof TemplateRef;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatToolCallsViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: CopilotChatToolCallsViewComponent, isStandalone: true, selector: "copilot-chat-tool-calls-view", inputs: { message: "message", messages: "messages", isLoading: "isLoading" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["dynamicContainer"], descendants: true, read: ViewContainerRef }], usesOnChanges: true, ngImport: i0, template: `
+    @for (toolCall of message?.toolCalls ?? []; track toolCall.id) {
+      <ng-container>
+        <ng-container #dynamicContainer></ng-container>
+        <ng-container *ngIf="getTemplateForToolCall(toolCall) as templateData">
+          <ng-container
+            *ngTemplateOutlet="
+              templateData.template;
+              context: templateData.context
+            "
+          ></ng-container>
+        </ng-container>
+      </ng-container>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatToolCallsViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "copilot-chat-tool-calls-view",
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    @for (toolCall of message?.toolCalls ?? []; track toolCall.id) {
+      <ng-container>
+        <ng-container #dynamicContainer></ng-container>
+        <ng-container *ngIf="getTemplateForToolCall(toolCall) as templateData">
+          <ng-container
+            *ngTemplateOutlet="
+              templateData.template;
+              context: templateData.context
+            "
+          ></ng-container>
+        </ng-container>
+      </ng-container>
+    }
+  `,
+                }]
+        }], propDecorators: { message: [{
+                type: Input,
+                args: [{ required: true }]
+            }], messages: [{
+                type: Input
+            }], isLoading: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ["dynamicContainer", { read: ViewContainerRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-chat-tool-calls-view.component.js","sourceRoot":"","sources":["../../../../src/components/chat/copilot-chat-tool-calls-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  ViewContainerRef,\n  ComponentRef,\n  inject,\n  ViewChild,\n  AfterViewInit,\n  OnChanges,\n  SimpleChanges,\n  TemplateRef,\n  Type,\n  ChangeDetectionStrategy,\n  signal,\n  computed,\n  OnDestroy,\n} from \"@angular/core\";\nimport { CommonModule } from \"@angular/common\";\nimport type {\n  AssistantMessage,\n  Message,\n  ToolCall,\n  ToolMessage,\n} from \"@ag-ui/core\";\nimport { ToolCallStatus } from \"@copilotkitnext/core\";\nimport { CopilotKitService } from \"../../core/copilotkit.service\";\nimport { partialJSONParse } from \"@copilotkitnext/shared\";\nimport type {\n  ToolCallProps,\n  ToolCallRender,\n} from \"../../core/copilotkit.types\";\n\n/**\n * Component for rendering all tool calls for an assistant message.\n * This component iterates through the message's tool calls and renders each one\n * using the registered render functions in CopilotKitService.\n */\n@Component({\n  selector: \"copilot-chat-tool-calls-view\",\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    @for (toolCall of message?.toolCalls ?? []; track toolCall.id) {\n      <ng-container>\n        <ng-container #dynamicContainer></ng-container>\n        <ng-container *ngIf=\"getTemplateForToolCall(toolCall) as templateData\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              templateData.template;\n              context: templateData.context\n            \"\n          ></ng-container>\n        </ng-container>\n      </ng-container>\n    }\n  `,\n})\nexport class CopilotChatToolCallsViewComponent\n  implements AfterViewInit, OnChanges, OnDestroy\n{\n  @Input({ required: true }) message!: AssistantMessage;\n  @Input() messages: Message[] = [];\n  @Input() isLoading = false;\n\n  @ViewChild(\"dynamicContainer\", { read: ViewContainerRef })\n  private container?: ViewContainerRef;\n\n  private copilotkit: CopilotKitService | null = inject(CopilotKitService, {\n    optional: true,\n  });\n  private componentRefs: Map<string, ComponentRef<any>> = new Map();\n  private templateCache: Map<\n    string,\n    { template: TemplateRef<any>; context: any }\n  > = new Map();\n\n  // Signals for reactive state\n  private messageSignal = signal<AssistantMessage | null>(null);\n  private messagesSignal = signal<Message[]>([]);\n  private isLoadingSignal = signal(false);\n\n  ngAfterViewInit(): void {\n    this.renderAllToolCalls();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[\"message\"]) {\n      this.messageSignal.set(this.message);\n    }\n    if (changes[\"messages\"]) {\n      this.messagesSignal.set(this.messages);\n    }\n    if (changes[\"isLoading\"]) {\n      this.isLoadingSignal.set(this.isLoading);\n    }\n\n    this.renderAllToolCalls();\n  }\n\n  ngOnDestroy(): void {\n    // Clean up all component refs\n    this.componentRefs.forEach((ref) => ref.destroy());\n    this.componentRefs.clear();\n    this.templateCache.clear();\n  }\n\n  getTemplateForToolCall(\n    toolCall: ToolCall\n  ): { template: TemplateRef<any>; context: any } | null {\n    return this.templateCache.get(toolCall.id) || null;\n  }\n\n  private renderAllToolCalls(): void {\n    const message = this.messageSignal();\n    if (!message || !message.toolCalls || message.toolCalls.length === 0) {\n      return;\n    }\n\n    // Clear existing renders\n    this.componentRefs.forEach((ref) => ref.destroy());\n    this.componentRefs.clear();\n    this.templateCache.clear();\n\n    if (!this.copilotkit || !this.container) {\n      return;\n    }\n\n    const messages = this.messagesSignal();\n    const isLoading = this.isLoadingSignal();\n\n    // Render each tool call\n    message.toolCalls.forEach((toolCall) => {\n      const toolMessage = messages.find(\n        (m) =>\n          m.role === \"tool\" && (m as ToolMessage).toolCallId === toolCall.id\n      ) as ToolMessage | undefined;\n\n      this.renderSingleToolCall(toolCall, toolMessage, isLoading);\n    });\n  }\n\n  private renderSingleToolCall(\n    toolCall: ToolCall,\n    toolMessage: ToolMessage | undefined,\n    isLoading: boolean\n  ): void {\n    if (!this.copilotkit) {\n      return;\n    }\n\n    // Get current render tool calls\n    const currentRenderToolCalls = this.copilotkit.currentRenderToolCalls();\n\n    // Find the render config for this tool call by name\n    // Also check for wildcard (*) renders if no exact match\n    const renderConfig =\n      currentRenderToolCalls.find(\n        (rc: ToolCallRender) => rc.name === toolCall.function.name\n      ) || currentRenderToolCalls.find((rc: ToolCallRender) => rc.name === \"*\");\n\n    if (!renderConfig) {\n      return;\n    }\n\n    // Parse the arguments if they're a string\n    const args = partialJSONParse(toolCall.function.arguments);\n\n    // Determine status\n    let status: ToolCallStatus;\n    if (toolMessage) {\n      status = ToolCallStatus.Complete;\n    } else if (isLoading) {\n      status = ToolCallStatus.InProgress;\n    } else {\n      status = ToolCallStatus.Complete;\n    }\n\n    // Create props based on status - use discriminated union properly\n    let props: ToolCallProps;\n    if (status === ToolCallStatus.InProgress) {\n      props = {\n        name: toolCall.function.name,\n        description: \"\",\n        args: args, // Partial args for InProgress\n        status: ToolCallStatus.InProgress,\n        result: undefined,\n      };\n    } else {\n      // Complete status\n      props = {\n        name: toolCall.function.name,\n        description: \"\",\n        args: args, // Full args for Complete\n        status: ToolCallStatus.Complete,\n        result: toolMessage?.content || \"\",\n      };\n    }\n\n    // Check if render is a Component class or TemplateRef\n    if (this.isComponentClass(renderConfig.render)) {\n      // Create component dynamically\n      this.renderComponent(toolCall.id, renderConfig.render, props);\n    } else if (this.isTemplateRef(renderConfig.render)) {\n      // Use template\n      this.renderTemplate(toolCall.id, renderConfig.render, props);\n    }\n  }\n\n  private renderComponent(\n    toolCallId: string,\n    componentClass: Type<any>,\n    props: ToolCallProps\n  ): void {\n    if (!this.container) {\n      return;\n    }\n\n    // Create the component\n    const componentRef = this.container.createComponent(componentClass);\n    this.componentRefs.set(toolCallId, componentRef);\n\n    // Set inputs on the component\n    for (const [key, value] of Object.entries(props)) {\n      try {\n        componentRef.setInput(key, value);\n      } catch (e) {\n        // Input might not exist on the component, which is fine\n      }\n    }\n\n    // Trigger change detection\n    componentRef.changeDetectorRef.detectChanges();\n  }\n\n  private renderTemplate(\n    toolCallId: string,\n    template: TemplateRef<any>,\n    props: ToolCallProps\n  ): void {\n    this.templateCache.set(toolCallId, {\n      template,\n      context: {\n        $implicit: props,\n        name: props.name,\n        description: props.description,\n        args: props.args,\n        status: props.status,\n        result: props.result,\n      },\n    });\n  }\n\n  private isComponentClass(value: any): value is Type<any> {\n    return typeof value === \"function\" && value.prototype;\n  }\n\n  private isTemplateRef(value: any): value is TemplateRef<any> {\n    return value instanceof TemplateRef;\n  }\n}\n"]}

package/dist/esm2022/components/chat/copilot-chat-toolbar.component.mjs

@@ -0,0 +1,25 @@
+import { Component, Input, signal, computed, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from '../../lib/utils';
+import * as i0 from "@angular/core";
+export class CopilotChatToolbarComponent {
+    set inputClass(val) {
+        this.customClass.set(val);
+    }
+    customClass = signal(undefined);
+    computedClass = computed(() => {
+        const baseClasses = 'w-full h-[60px] bg-transparent flex items-center justify-between';
+        return cn(baseClasses, this.customClass());
+    });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatToolbarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CopilotChatToolbarComponent, isStandalone: true, selector: "div[copilotChatToolbar]", inputs: { inputClass: "inputClass" }, host: { properties: { "class": "computedClass()" } }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'div[copilotChatToolbar]', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        '[class]': 'computedClass()'
+                    }, template: `<ng-content></ng-content>` }]
+        }], propDecorators: { inputClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29waWxvdC1jaGF0LXRvb2xiYXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvY2hhdC9jb3BpbG90LWNoYXQtdG9vbGJhci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFNBQVMsRUFDVCxLQUFLLEVBQ0wsTUFBTSxFQUNOLFFBQVEsRUFDUix1QkFBdUIsRUFDdkIsaUJBQWlCLEVBQ2xCLE1BQU0sZUFBZSxDQUFDO0FBQ3ZCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0saUJBQWlCLENBQUM7O0FBY3JDLE1BQU0sT0FBTywyQkFBMkI7SUFDdEMsSUFBYSxVQUFVLENBQUMsR0FBdUI7UUFDN0MsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDNUIsQ0FBQztJQUVELFdBQVcsR0FBRyxNQUFNLENBQXFCLFNBQVMsQ0FBQyxDQUFDO0lBRXBELGFBQWEsR0FBRyxRQUFRLENBQUMsR0FBRyxFQUFFO1FBQzVCLE1BQU0sV0FBVyxHQUFHLGtFQUFrRSxDQUFDO1FBQ3ZGLE9BQU8sRUFBRSxDQUFDLFdBQVcsRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztJQUM3QyxDQUFDLENBQUMsQ0FBQzt3R0FWUSwyQkFBMkI7NEZBQTNCLDJCQUEyQiwrS0FINUIsMkJBQTJCLDJEQU4zQixZQUFZOzs0RkFTWCwyQkFBMkI7a0JBWnZDLFNBQVM7K0JBQ0UseUJBQXlCLGNBQ3ZCLElBQUksV0FDUCxDQUFDLFlBQVksQ0FBQyxtQkFDTix1QkFBdUIsQ0FBQyxNQUFNLGlCQUNoQyxpQkFBaUIsQ0FBQyxJQUFJLFFBQy9CO3dCQUNKLFNBQVMsRUFBRSxpQkFBaUI7cUJBQzdCLFlBQ1MsMkJBQTJCOzhCQUl4QixVQUFVO3NCQUF0QixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ29tcG9uZW50LFxuICBJbnB1dCxcbiAgc2lnbmFsLFxuICBjb21wdXRlZCxcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIFZpZXdFbmNhcHN1bGF0aW9uXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IGNuIH0gZnJvbSAnLi4vLi4vbGliL3V0aWxzJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnZGl2W2NvcGlsb3RDaGF0VG9vbGJhcl0nLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXG4gIGhvc3Q6IHtcbiAgICAnW2NsYXNzXSc6ICdjb21wdXRlZENsYXNzKCknXG4gIH0sXG4gIHRlbXBsYXRlOiBgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PmAsXG4gIHN0eWxlczogW11cbn0pXG5leHBvcnQgY2xhc3MgQ29waWxvdENoYXRUb29sYmFyQ29tcG9uZW50IHtcbiAgQElucHV0KCkgc2V0IGlucHV0Q2xhc3ModmFsOiBzdHJpbmcgfCB1bmRlZmluZWQpIHtcbiAgICB0aGlzLmN1c3RvbUNsYXNzLnNldCh2YWwpO1xuICB9XG4gIFxuICBjdXN0b21DbGFzcyA9IHNpZ25hbDxzdHJpbmcgfCB1bmRlZmluZWQ+KHVuZGVmaW5lZCk7XG4gIFxuICBjb21wdXRlZENsYXNzID0gY29tcHV0ZWQoKCkgPT4ge1xuICAgIGNvbnN0IGJhc2VDbGFzc2VzID0gJ3ctZnVsbCBoLVs2MHB4XSBiZy10cmFuc3BhcmVudCBmbGV4IGl0ZW1zLWNlbnRlciBqdXN0aWZ5LWJldHdlZW4nO1xuICAgIHJldHVybiBjbihiYXNlQ2xhc3NlcywgdGhpcy5jdXN0b21DbGFzcygpKTtcbiAgfSk7XG59Il19

package/dist/esm2022/components/chat/copilot-chat-tools-menu.component.mjs

@@ -0,0 +1,199 @@
+import { Component, Input, signal, computed, inject, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CdkMenuModule } from '@angular/cdk/menu';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { LucideAngularModule, Settings2, ChevronRight } from 'lucide-angular';
+import { CopilotChatConfigurationService } from '../../core/chat-configuration/chat-configuration.service';
+import { cn } from '../../lib/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+import * as i2 from "lucide-angular";
+export class CopilotChatToolsMenuComponent {
+    Settings2Icon = Settings2;
+    ChevronRightIcon = ChevronRight;
+    set inputToolsMenu(val) {
+        this.toolsMenu.set(val || []);
+    }
+    set inputDisabled(val) {
+        this.disabled.set(val || false);
+    }
+    set inputClass(val) {
+        this.customClass.set(val);
+    }
+    chatConfig = inject(CopilotChatConfigurationService);
+    toolsMenu = signal([]);
+    disabled = signal(false);
+    customClass = signal(undefined);
+    hasItems = computed(() => this.toolsMenu().length > 0);
+    label = computed(() => this.chatConfig.labels().chatInputToolbarToolsButtonLabel);
+    buttonClass = computed(() => {
+        const baseClasses = cn(
+        // Base button styles
+        'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-full text-sm font-medium', 'transition-all disabled:pointer-events-none disabled:opacity-50', 'shrink-0 outline-none', 'focus-visible:ring-[3px]', 
+        // chatInputToolbarSecondary variant
+        'cursor-pointer', 'bg-transparent text-[#444444]', 'dark:text-white dark:border-[#404040]', 'transition-colors', 'focus:outline-none', 'hover:bg-[#f8f8f8] hover:text-[#333333]', 'dark:hover:bg-[#404040] dark:hover:text-[#FFFFFF]', 'disabled:cursor-not-allowed disabled:opacity-50', 'disabled:hover:bg-transparent disabled:hover:text-[#444444]', 'dark:disabled:hover:bg-transparent dark:disabled:hover:text-[#CCCCCC]', 
+        // Size
+        'h-9 px-3 gap-2 font-normal');
+        return cn(baseClasses, this.customClass());
+    });
+    isMenuItem(item) {
+        return item && typeof item === 'object' && 'label' in item;
+    }
+    handleItemClick(item) {
+        if (item.action) {
+            item.action();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatToolsMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: CopilotChatToolsMenuComponent, isStandalone: true, selector: "copilot-chat-tools-menu", inputs: { inputToolsMenu: "inputToolsMenu", inputDisabled: "inputDisabled", inputClass: "inputClass" }, ngImport: i0, template: `
+    @if (hasItems()) {
+      <button
+        type="button"
+        [disabled]="disabled()"
+        [class]="buttonClass()"
+        [cdkMenuTriggerFor]="menu"
+      >
+        <lucide-angular [img]="Settings2Icon" [size]="18"></lucide-angular>
+        <span class="text-sm font-normal">{{ label() }}</span>
+      </button>
+      
+      <ng-template #menu>
+        <div class="min-w-[200px] bg-white dark:bg-[#1F1F1F] border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-1"
+             cdkMenu>
+          @for (item of toolsMenu(); track $index) {
+            @if (item === '-') {
+              <div class="h-px bg-gray-200 dark:bg-gray-700 my-1"></div>
+            } @else if (isMenuItem(item)) {
+              @if (item.items && item.items.length > 0) {
+                <!-- Submenu trigger -->
+                <button
+                  type="button"
+                  class="w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm flex items-center justify-between"
+                  [cdkMenuTriggerFor]="submenu"
+                  cdkMenuItem
+                >
+                  {{ item.label }}
+                  <lucide-angular [img]="ChevronRightIcon" [size]="12" class="ml-auto"></lucide-angular>
+                </button>
+                
+                <!-- Submenu template -->
+                <ng-template #submenu>
+                  <div class="min-w-[200px] bg-white dark:bg-[#1F1F1F] border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-1"
+                       cdkMenu>
+                    @for (subItem of item.items; track $index) {
+                      @if (subItem === '-') {
+                        <div class="h-px bg-gray-200 dark:bg-gray-700 my-1"></div>
+                      } @else if (isMenuItem(subItem)) {
+                        <button
+                          type="button"
+                          class="w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm"
+                          (click)="handleItemClick(subItem)"
+                          cdkMenuItem
+                        >
+                          {{ subItem.label }}
+                        </button>
+                      }
+                    }
+                  </div>
+                </ng-template>
+              } @else {
+                <!-- Regular menu item -->
+                <button
+                  type="button"
+                  class="w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm"
+                  (click)="handleItemClick(item)"
+                  cdkMenuItem
+                >
+                  {{ item.label }}
+                </button>
+              }
+            }
+          }
+        </div>
+      </ng-template>
+    }
+  `, isInline: true, styles: [".cdk-overlay-pane{position:absolute;pointer-events:auto;z-index:1000}.cdk-overlay-container{position:fixed;z-index:1000}[cdkMenu]{animation:menuFadeIn .15s ease-out}@keyframes menuFadeIn{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: CdkMenuModule }, { kind: "directive", type: i1.CdkMenu, selector: "[cdkMenu]", outputs: ["closed"], exportAs: ["cdkMenu"] }, { kind: "directive", type: i1.CdkMenuItem, selector: "[cdkMenuItem]", inputs: ["cdkMenuItemDisabled", "cdkMenuitemTypeaheadLabel"], outputs: ["cdkMenuItemTriggered"], exportAs: ["cdkMenuItem"] }, { kind: "directive", type: i1.CdkMenuTrigger, selector: "[cdkMenuTriggerFor]", inputs: ["cdkMenuTriggerFor", "cdkMenuPosition", "cdkMenuTriggerData"], outputs: ["cdkMenuOpened", "cdkMenuClosed"], exportAs: ["cdkMenuTriggerFor"] }, { kind: "ngmodule", type: OverlayModule }, { kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i2.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatToolsMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'copilot-chat-tools-menu', standalone: true, imports: [
+                        CommonModule,
+                        CdkMenuModule,
+                        OverlayModule,
+                        LucideAngularModule
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: `
+    @if (hasItems()) {
+      <button
+        type="button"
+        [disabled]="disabled()"
+        [class]="buttonClass()"
+        [cdkMenuTriggerFor]="menu"
+      >
+        <lucide-angular [img]="Settings2Icon" [size]="18"></lucide-angular>
+        <span class="text-sm font-normal">{{ label() }}</span>
+      </button>
+      
+      <ng-template #menu>
+        <div class="min-w-[200px] bg-white dark:bg-[#1F1F1F] border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-1"
+             cdkMenu>
+          @for (item of toolsMenu(); track $index) {
+            @if (item === '-') {
+              <div class="h-px bg-gray-200 dark:bg-gray-700 my-1"></div>
+            } @else if (isMenuItem(item)) {
+              @if (item.items && item.items.length > 0) {
+                <!-- Submenu trigger -->
+                <button
+                  type="button"
+                  class="w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm flex items-center justify-between"
+                  [cdkMenuTriggerFor]="submenu"
+                  cdkMenuItem
+                >
+                  {{ item.label }}
+                  <lucide-angular [img]="ChevronRightIcon" [size]="12" class="ml-auto"></lucide-angular>
+                </button>
+                
+                <!-- Submenu template -->
+                <ng-template #submenu>
+                  <div class="min-w-[200px] bg-white dark:bg-[#1F1F1F] border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-1"
+                       cdkMenu>
+                    @for (subItem of item.items; track $index) {
+                      @if (subItem === '-') {
+                        <div class="h-px bg-gray-200 dark:bg-gray-700 my-1"></div>
+                      } @else if (isMenuItem(subItem)) {
+                        <button
+                          type="button"
+                          class="w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm"
+                          (click)="handleItemClick(subItem)"
+                          cdkMenuItem
+                        >
+                          {{ subItem.label }}
+                        </button>
+                      }
+                    }
+                  </div>
+                </ng-template>
+              } @else {
+                <!-- Regular menu item -->
+                <button
+                  type="button"
+                  class="w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm"
+                  (click)="handleItemClick(item)"
+                  cdkMenuItem
+                >
+                  {{ item.label }}
+                </button>
+              }
+            }
+          }
+        </div>
+      </ng-template>
+    }
+  `, styles: [".cdk-overlay-pane{position:absolute;pointer-events:auto;z-index:1000}.cdk-overlay-container{position:fixed;z-index:1000}[cdkMenu]{animation:menuFadeIn .15s ease-out}@keyframes menuFadeIn{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}\n"] }]
+        }], propDecorators: { inputToolsMenu: [{
+                type: Input
+            }], inputDisabled: [{
+                type: Input
+            }], inputClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-chat-tools-menu.component.js","sourceRoot":"","sources":["../../../../src/components/chat/copilot-chat-tools-menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  signal,\n  computed,\n  inject,\n  ChangeDetectionStrategy,\n  ViewEncapsulation\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { CdkMenuModule } from '@angular/cdk/menu';\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { LucideAngularModule, Settings2, ChevronRight } from 'lucide-angular';\nimport { CopilotChatConfigurationService } from '../../core/chat-configuration/chat-configuration.service';\nimport type { ToolsMenuItem } from './copilot-chat-input.types';\nimport { cn } from '../../lib/utils';\n\n@Component({\n  selector: 'copilot-chat-tools-menu',\n  standalone: true,\n  imports: [\n    CommonModule,\n    CdkMenuModule,\n    OverlayModule,\n    LucideAngularModule\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  template: `\n    @if (hasItems()) {\n      <button\n        type=\"button\"\n        [disabled]=\"disabled()\"\n        [class]=\"buttonClass()\"\n        [cdkMenuTriggerFor]=\"menu\"\n      >\n        <lucide-angular [img]=\"Settings2Icon\" [size]=\"18\"></lucide-angular>\n        <span class=\"text-sm font-normal\">{{ label() }}</span>\n      </button>\n      \n      <ng-template #menu>\n        <div class=\"min-w-[200px] bg-white dark:bg-[#1F1F1F] border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-1\"\n             cdkMenu>\n          @for (item of toolsMenu(); track $index) {\n            @if (item === '-') {\n              <div class=\"h-px bg-gray-200 dark:bg-gray-700 my-1\"></div>\n            } @else if (isMenuItem(item)) {\n              @if (item.items && item.items.length > 0) {\n                <!-- Submenu trigger -->\n                <button\n                  type=\"button\"\n                  class=\"w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm flex items-center justify-between\"\n                  [cdkMenuTriggerFor]=\"submenu\"\n                  cdkMenuItem\n                >\n                  {{ item.label }}\n                  <lucide-angular [img]=\"ChevronRightIcon\" [size]=\"12\" class=\"ml-auto\"></lucide-angular>\n                </button>\n                \n                <!-- Submenu template -->\n                <ng-template #submenu>\n                  <div class=\"min-w-[200px] bg-white dark:bg-[#1F1F1F] border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-1\"\n                       cdkMenu>\n                    @for (subItem of item.items; track $index) {\n                      @if (subItem === '-') {\n                        <div class=\"h-px bg-gray-200 dark:bg-gray-700 my-1\"></div>\n                      } @else if (isMenuItem(subItem)) {\n                        <button\n                          type=\"button\"\n                          class=\"w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm\"\n                          (click)=\"handleItemClick(subItem)\"\n                          cdkMenuItem\n                        >\n                          {{ subItem.label }}\n                        </button>\n                      }\n                    }\n                  </div>\n                </ng-template>\n              } @else {\n                <!-- Regular menu item -->\n                <button\n                  type=\"button\"\n                  class=\"w-full px-3 py-2 text-left bg-transparent border-none rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer text-sm\"\n                  (click)=\"handleItemClick(item)\"\n                  cdkMenuItem\n                >\n                  {{ item.label }}\n                </button>\n              }\n            }\n          }\n        </div>\n      </ng-template>\n    }\n  `,\n  styles: [`\n    /* CDK Overlay styles for positioning */\n    .cdk-overlay-pane {\n      position: absolute;\n      pointer-events: auto;\n      z-index: 1000;\n    }\n    \n    /* Ensure menu appears above other content */\n    .cdk-overlay-container {\n      position: fixed;\n      z-index: 1000;\n    }\n    \n    /* Menu animation */\n    [cdkMenu] {\n      animation: menuFadeIn 0.15s ease-out;\n    }\n    \n    @keyframes menuFadeIn {\n      from {\n        opacity: 0;\n        transform: translateY(4px);\n      }\n      to {\n        opacity: 1;\n        transform: translateY(0);\n      }\n    }\n  `]\n})\nexport class CopilotChatToolsMenuComponent {\n  readonly Settings2Icon = Settings2;\n  readonly ChevronRightIcon = ChevronRight;\n  \n  @Input() set inputToolsMenu(val: (ToolsMenuItem | '-')[] | undefined) {\n    this.toolsMenu.set(val || []);\n  }\n  @Input() set inputDisabled(val: boolean | undefined) {\n    this.disabled.set(val || false);\n  }\n  @Input() set inputClass(val: string | undefined) {\n    this.customClass.set(val);\n  }\n  \n  private chatConfig = inject(CopilotChatConfigurationService);\n  \n  toolsMenu = signal<(ToolsMenuItem | '-')[]>([]);\n  disabled = signal<boolean>(false);\n  customClass = signal<string | undefined>(undefined);\n  \n  hasItems = computed(() => this.toolsMenu().length > 0);\n  \n  label = computed(() => this.chatConfig.labels().chatInputToolbarToolsButtonLabel);\n  \n  buttonClass = computed(() => {\n    const baseClasses = cn(\n      // Base button styles\n      'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-full text-sm font-medium',\n      'transition-all disabled:pointer-events-none disabled:opacity-50',\n      'shrink-0 outline-none',\n      'focus-visible:ring-[3px]',\n      // chatInputToolbarSecondary variant\n      'cursor-pointer',\n      'bg-transparent text-[#444444]',\n      'dark:text-white dark:border-[#404040]',\n      'transition-colors',\n      'focus:outline-none',\n      'hover:bg-[#f8f8f8] hover:text-[#333333]',\n      'dark:hover:bg-[#404040] dark:hover:text-[#FFFFFF]',\n      'disabled:cursor-not-allowed disabled:opacity-50',\n      'disabled:hover:bg-transparent disabled:hover:text-[#444444]',\n      'dark:disabled:hover:bg-transparent dark:disabled:hover:text-[#CCCCCC]',\n      // Size\n      'h-9 px-3 gap-2 font-normal'\n    );\n    return cn(baseClasses, this.customClass());\n  });\n  \n  isMenuItem(item: any): item is ToolsMenuItem {\n    return item && typeof item === 'object' && 'label' in item;\n  }\n  \n  handleItemClick(item: ToolsMenuItem): void {\n    if (item.action) {\n      item.action();\n    }\n  }\n}\n"]}