@copilotkitnext/angular 0.0.2 → 0.0.5

package/dist/esm2022/utils/chat-config.utils.mjs

@@ -0,0 +1,186 @@
+import { inject } from '@angular/core';
+import { CopilotChatConfigurationService } from '../core/chat-configuration/chat-configuration.service';
+/**
+ * Watches chat configuration and provides reactive access to all configuration values.
+ * Must be called within an injection context.
+ *
+ * @returns Object with reactive signals and handler functions
+ *
+ * @example
+ * ```typescript
+ * export class ChatInputComponent {
+ *   config = watchChatConfig();
+ *
+ *   constructor() {
+ *     effect(() => {
+ *       const placeholder = this.config.labels().chatInputPlaceholder;
+ *       console.log('Placeholder:', placeholder);
+ *     });
+ *   }
+ *
+ *   handleSubmit(value: string) {
+ *     this.config.submitInput(value);
+ *   }
+ * }
+ * ```
+ */
+export function watchChatConfig() {
+    const service = inject(CopilotChatConfigurationService);
+    return {
+        labels: service.labels,
+        inputValue: service.inputValue,
+        submitInput: (value) => service.submitInput(value),
+        changeInput: (value) => service.changeInput(value)
+    };
+}
+/**
+ * Registers chat configuration within an injection context.
+ * Automatically updates the configuration when called.
+ *
+ * @param config - The configuration to register
+ *
+ * @example
+ * ```typescript
+ * export class ChatComponent {
+ *   constructor() {
+ *     registerChatConfig({
+ *       labels: {
+ *         chatInputPlaceholder: "How can I help?"
+ *       },
+ *       onSubmitInput: (value) => this.handleSubmit(value)
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function registerChatConfig(config) {
+    const service = inject(CopilotChatConfigurationService);
+    service.updateConfiguration(config);
+}
+/**
+ * Gets the current chat labels signal.
+ *
+ * @param service - The CopilotChatConfigurationService instance
+ * @returns Signal containing the current labels
+ *
+ * @example
+ * ```typescript
+ * export class ChatComponent {
+ *   constructor(private chatConfig: CopilotChatConfigurationService) {
+ *     const labels = getChatLabels(this.chatConfig);
+ *     effect(() => {
+ *       console.log('Current labels:', labels());
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function getChatLabels(service) {
+    return service.labels;
+}
+/**
+ * Updates chat labels.
+ *
+ * @param service - The CopilotChatConfigurationService instance
+ * @param labels - Partial labels to merge with defaults
+ *
+ * @example
+ * ```typescript
+ * export class ChatComponent {
+ *   updatePlaceholder(text: string) {
+ *     setChatLabels(this.chatConfig, {
+ *       chatInputPlaceholder: text
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function setChatLabels(service, labels) {
+    service.setLabels(labels);
+}
+/**
+ * Gets the current input value signal.
+ *
+ * @param service - The CopilotChatConfigurationService instance
+ * @returns Signal containing the current input value
+ *
+ * @example
+ * ```typescript
+ * export class ChatInputComponent {
+ *   inputValue = getChatInputValue(this.chatConfig);
+ *
+ *   constructor(private chatConfig: CopilotChatConfigurationService) {
+ *     effect(() => {
+ *       const value = this.inputValue();
+ *       if (value) {
+ *         this.updateTextarea(value);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function getChatInputValue(service) {
+    return service.inputValue;
+}
+/**
+ * Sets the current input value.
+ *
+ * @param service - The CopilotChatConfigurationService instance
+ * @param value - The new input value
+ *
+ * @example
+ * ```typescript
+ * export class ChatInputComponent {
+ *   onInputChange(event: Event) {
+ *     const value = (event.target as HTMLInputElement).value;
+ *     setChatInputValue(this.chatConfig, value);
+ *   }
+ * }
+ * ```
+ */
+export function setChatInputValue(service, value) {
+    service.setInputValue(value);
+}
+/**
+ * Creates a chat configuration controller with dynamic update capabilities.
+ * This is useful when you need to programmatically manage configuration.
+ *
+ * @param service - The CopilotChatConfigurationService instance
+ * @param initialConfig - Optional initial configuration
+ * @returns Controller object with update and reset methods
+ *
+ * @example
+ * ```typescript
+ * export class ChatManagerComponent {
+ *   chatController = createChatConfigController(this.chatConfig, {
+ *     labels: { chatInputPlaceholder: "Ask me..." }
+ *   });
+ *
+ *   constructor(private chatConfig: CopilotChatConfigurationService) {}
+ *
+ *   updateForSupportMode() {
+ *     this.chatController.update({
+ *       labels: { chatInputPlaceholder: "Describe your issue..." }
+ *     });
+ *   }
+ *
+ *   resetToDefaults() {
+ *     this.chatController.reset();
+ *   }
+ * }
+ * ```
+ */
+export function createChatConfigController(service, initialConfig) {
+    // Apply initial configuration if provided
+    if (initialConfig) {
+        service.updateConfiguration(initialConfig);
+    }
+    return {
+        update: (config) => service.updateConfiguration(config),
+        reset: () => service.reset(),
+        getLabels: () => service.labels(),
+        getInputValue: () => service.inputValue()
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat-config.utils.js","sourceRoot":"","sources":["../../../src/utils/chat-config.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,+BAA+B,EAAE,MAAM,uDAAuD,CAAC;AAMxG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,eAAe;IAM7B,MAAM,OAAO,GAAG,MAAM,CAAC,+BAA+B,CAAC,CAAC;IAExD,OAAO;QACL,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,UAAU,EAAE,OAAO,CAAC,UAAU;QAC9B,WAAW,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC;QAC1D,WAAW,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC;KAC3D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAgC;IACjE,MAAM,OAAO,GAAG,MAAM,CAAC,+BAA+B,CAAC,CAAC;IACxD,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAwC;IAExC,OAAO,OAAO,CAAC,MAAM,CAAC;AACxB,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAwC,EACxC,MAAkC;IAElC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAwC;IAExC,OAAO,OAAO,CAAC,UAAU,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAwC,EACxC,KAAyB;IAEzB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,0BAA0B,CACxC,OAAwC,EACxC,aAAwC;IAOxC,0CAA0C;IAC1C,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAC7C,CAAC;IAED,OAAO;QACL,MAAM,EAAE,CAAC,MAAgC,EAAE,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC;QACjF,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE;QAC5B,SAAS,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE;QACjC,aAAa,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,UAAU,EAAE;KAC1C,CAAC;AACJ,CAAC","sourcesContent":["import { inject, Signal } from '@angular/core';\nimport { CopilotChatConfigurationService } from '../core/chat-configuration/chat-configuration.service';\nimport { \n  CopilotChatConfiguration,\n  CopilotChatLabels\n} from '../core/chat-configuration/chat-configuration.types';\n\n/**\n * Watches chat configuration and provides reactive access to all configuration values.\n * Must be called within an injection context.\n * \n * @returns Object with reactive signals and handler functions\n * \n * @example\n * ```typescript\n * export class ChatInputComponent {\n *   config = watchChatConfig();\n *   \n *   constructor() {\n *     effect(() => {\n *       const placeholder = this.config.labels().chatInputPlaceholder;\n *       console.log('Placeholder:', placeholder);\n *     });\n *   }\n *   \n *   handleSubmit(value: string) {\n *     this.config.submitInput(value);\n *   }\n * }\n * ```\n */\nexport function watchChatConfig(): {\n  labels: Signal<CopilotChatLabels>;\n  inputValue: Signal<string | undefined>;\n  submitInput: (value: string) => void;\n  changeInput: (value: string) => void;\n} {\n  const service = inject(CopilotChatConfigurationService);\n  \n  return {\n    labels: service.labels,\n    inputValue: service.inputValue,\n    submitInput: (value: string) => service.submitInput(value),\n    changeInput: (value: string) => service.changeInput(value)\n  };\n}\n\n/**\n * Registers chat configuration within an injection context.\n * Automatically updates the configuration when called.\n * \n * @param config - The configuration to register\n * \n * @example\n * ```typescript\n * export class ChatComponent {\n *   constructor() {\n *     registerChatConfig({\n *       labels: {\n *         chatInputPlaceholder: \"How can I help?\"\n *       },\n *       onSubmitInput: (value) => this.handleSubmit(value)\n *     });\n *   }\n * }\n * ```\n */\nexport function registerChatConfig(config: CopilotChatConfiguration): void {\n  const service = inject(CopilotChatConfigurationService);\n  service.updateConfiguration(config);\n}\n\n/**\n * Gets the current chat labels signal.\n * \n * @param service - The CopilotChatConfigurationService instance\n * @returns Signal containing the current labels\n * \n * @example\n * ```typescript\n * export class ChatComponent {\n *   constructor(private chatConfig: CopilotChatConfigurationService) {\n *     const labels = getChatLabels(this.chatConfig);\n *     effect(() => {\n *       console.log('Current labels:', labels());\n *     });\n *   }\n * }\n * ```\n */\nexport function getChatLabels(\n  service: CopilotChatConfigurationService\n): Signal<CopilotChatLabels> {\n  return service.labels;\n}\n\n/**\n * Updates chat labels.\n * \n * @param service - The CopilotChatConfigurationService instance\n * @param labels - Partial labels to merge with defaults\n * \n * @example\n * ```typescript\n * export class ChatComponent {\n *   updatePlaceholder(text: string) {\n *     setChatLabels(this.chatConfig, {\n *       chatInputPlaceholder: text\n *     });\n *   }\n * }\n * ```\n */\nexport function setChatLabels(\n  service: CopilotChatConfigurationService,\n  labels: Partial<CopilotChatLabels>\n): void {\n  service.setLabels(labels);\n}\n\n/**\n * Gets the current input value signal.\n * \n * @param service - The CopilotChatConfigurationService instance\n * @returns Signal containing the current input value\n * \n * @example\n * ```typescript\n * export class ChatInputComponent {\n *   inputValue = getChatInputValue(this.chatConfig);\n *   \n *   constructor(private chatConfig: CopilotChatConfigurationService) {\n *     effect(() => {\n *       const value = this.inputValue();\n *       if (value) {\n *         this.updateTextarea(value);\n *       }\n *     });\n *   }\n * }\n * ```\n */\nexport function getChatInputValue(\n  service: CopilotChatConfigurationService\n): Signal<string | undefined> {\n  return service.inputValue;\n}\n\n/**\n * Sets the current input value.\n * \n * @param service - The CopilotChatConfigurationService instance\n * @param value - The new input value\n * \n * @example\n * ```typescript\n * export class ChatInputComponent {\n *   onInputChange(event: Event) {\n *     const value = (event.target as HTMLInputElement).value;\n *     setChatInputValue(this.chatConfig, value);\n *   }\n * }\n * ```\n */\nexport function setChatInputValue(\n  service: CopilotChatConfigurationService,\n  value: string | undefined\n): void {\n  service.setInputValue(value);\n}\n\n/**\n * Creates a chat configuration controller with dynamic update capabilities.\n * This is useful when you need to programmatically manage configuration.\n * \n * @param service - The CopilotChatConfigurationService instance\n * @param initialConfig - Optional initial configuration\n * @returns Controller object with update and reset methods\n * \n * @example\n * ```typescript\n * export class ChatManagerComponent {\n *   chatController = createChatConfigController(this.chatConfig, {\n *     labels: { chatInputPlaceholder: \"Ask me...\" }\n *   });\n *   \n *   constructor(private chatConfig: CopilotChatConfigurationService) {}\n *   \n *   updateForSupportMode() {\n *     this.chatController.update({\n *       labels: { chatInputPlaceholder: \"Describe your issue...\" }\n *     });\n *   }\n *   \n *   resetToDefaults() {\n *     this.chatController.reset();\n *   }\n * }\n * ```\n */\nexport function createChatConfigController(\n  service: CopilotChatConfigurationService,\n  initialConfig?: CopilotChatConfiguration\n): {\n  update: (config: CopilotChatConfiguration) => void;\n  reset: () => void;\n  getLabels: () => CopilotChatLabels;\n  getInputValue: () => string | undefined;\n} {\n  // Apply initial configuration if provided\n  if (initialConfig) {\n    service.updateConfiguration(initialConfig);\n  }\n  \n  return {\n    update: (config: CopilotChatConfiguration) => service.updateConfiguration(config),\n    reset: () => service.reset(),\n    getLabels: () => service.labels(),\n    getInputValue: () => service.inputValue()\n  };\n}"]}

package/dist/esm2022/utils/copilotkit.utils.mjs

@@ -0,0 +1,20 @@
+import { inject } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+/**
+ * Utility function to inject the CopilotKit service in a component or directive.
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   private copilotkit = injectCopilotKit();
+ *
+ *   sendMessage() {
+ *     this.copilotkit.copilotkit.sendMessage(...);
+ *   }
+ * }
+ * ```
+ */
+export function injectCopilotKit() {
+    return inject(CopilotKitService);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29waWxvdGtpdC51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9jb3BpbG90a2l0LnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFL0Q7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILE1BQU0sVUFBVSxnQkFBZ0I7SUFDOUIsT0FBTyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQztBQUNuQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0IH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IENvcGlsb3RLaXRTZXJ2aWNlIH0gZnJvbSBcIi4uL2NvcmUvY29waWxvdGtpdC5zZXJ2aWNlXCI7XG5cbi8qKlxuICogVXRpbGl0eSBmdW5jdGlvbiB0byBpbmplY3QgdGhlIENvcGlsb3RLaXQgc2VydmljZSBpbiBhIGNvbXBvbmVudCBvciBkaXJlY3RpdmUuXG4gKiBcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBleHBvcnQgY2xhc3MgTXlDb21wb25lbnQge1xuICogICBwcml2YXRlIGNvcGlsb3RraXQgPSBpbmplY3RDb3BpbG90S2l0KCk7XG4gKiAgIFxuICogICBzZW5kTWVzc2FnZSgpIHtcbiAqICAgICB0aGlzLmNvcGlsb3RraXQuY29waWxvdGtpdC5zZW5kTWVzc2FnZSguLi4pO1xuICogICB9XG4gKiB9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGluamVjdENvcGlsb3RLaXQoKSB7XG4gIHJldHVybiBpbmplY3QoQ29waWxvdEtpdFNlcnZpY2UpO1xufSJdfQ==

package/dist/esm2022/utils/frontend-tool.utils.mjs

@@ -0,0 +1,224 @@
+import { DestroyRef, inject } from '@angular/core';
+import { CopilotKitService } from '../core/copilotkit.service';
+/**
+ * Explicitly adds a frontend tool to CopilotKit.
+ * Requires CopilotKitService to be passed as a parameter.
+ *
+ * @param service - The CopilotKitService instance
+ * @param tool - The tool to add
+ * @returns A cleanup function that removes the tool
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent implements OnInit, OnDestroy {
+ *   private cleanupFns: Array<() => void> = [];
+ *
+ *   constructor(private copilotkit: CopilotKitService) {}
+ *
+ *   ngOnInit() {
+ *     const cleanup = addFrontendTool(this.copilotkit, {
+ *       name: 'calculator',
+ *       description: 'Performs calculations',
+ *       parameters: z.object({
+ *         expression: z.string()
+ *       }),
+ *       handler: async (args) => {
+ *         return eval(args.expression);
+ *       }
+ *     });
+ *
+ *     this.cleanupFns.push(cleanup);
+ *   }
+ *
+ *   ngOnDestroy() {
+ *     this.cleanupFns.forEach(fn => fn());
+ *   }
+ * }
+ * ```
+ */
+export function addFrontendTool(service, tool) {
+    // Add the tool to CopilotKit
+    service.copilotkit.addTool(tool);
+    // Register the render if provided
+    if (tool.render) {
+        const currentRenders = service.currentRenderToolCalls();
+        const existingIndex = currentRenders.findIndex((r) => r.name === tool.name);
+        if (existingIndex !== -1) {
+            console.error(`Tool with name '${tool.name}' already has a render. Skipping.`);
+        }
+        else {
+            const renderEntry = {
+                name: tool.name,
+                render: tool.render
+            };
+            service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
+        }
+    }
+    // Return cleanup function
+    return () => {
+        removeFrontendTool(service, tool.name);
+    };
+}
+/**
+ * Registers a frontend tool with CopilotKit and automatically removes it when the component/service is destroyed.
+ * Must be called within an injection context.
+ *
+ * @param tool - The tool to register
+ * @returns The tool name
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent implements OnInit {
+ *   ngOnInit() {
+ *     // Automatically cleaned up on component destroy
+ *     registerFrontendTool({
+ *       name: 'search',
+ *       description: 'Search for items',
+ *       parameters: z.object({
+ *         query: z.string()
+ *       }),
+ *       handler: async (args) => {
+ *         return this.searchService.search(args.query);
+ *       },
+ *       render: SearchResultsComponent
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function registerFrontendTool(tool) {
+    const service = inject(CopilotKitService);
+    const destroyRef = inject(DestroyRef);
+    // Add the tool
+    service.copilotkit.addTool(tool);
+    // Register the render if provided
+    if (tool.render) {
+        const currentRenders = service.currentRenderToolCalls();
+        const existingIndex = currentRenders.findIndex((r) => r.name === tool.name);
+        if (existingIndex !== -1) {
+            console.error(`Tool with name '${tool.name}' already has a render. Skipping.`);
+        }
+        else {
+            const renderEntry = {
+                name: tool.name,
+                render: tool.render
+            };
+            service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
+        }
+    }
+    // Register cleanup with Angular's DestroyRef
+    destroyRef.onDestroy(() => {
+        removeFrontendTool(service, tool.name);
+    });
+    return tool.name;
+}
+/**
+ * Explicitly removes a frontend tool from CopilotKit.
+ *
+ * @param service - The CopilotKitService instance
+ * @param toolName - The name of the tool to remove
+ *
+ * @example
+ * ```typescript
+ * removeFrontendTool(this.copilotkit, 'calculator');
+ * ```
+ */
+export function removeFrontendTool(service, toolName) {
+    // Remove the tool
+    service.copilotkit.removeTool(toolName);
+    // Remove the render if it exists
+    const currentRenders = service.currentRenderToolCalls();
+    const filtered = currentRenders.filter((r) => r.name !== toolName);
+    if (filtered.length !== currentRenders.length) {
+        service.setCurrentRenderToolCalls(filtered);
+    }
+}
+/**
+ * Creates a frontend tool with dynamic parameters that can change over time.
+ * Uses Angular signals for reactivity.
+ *
+ * @param name - Tool name
+ * @param description - Tool description
+ * @param parameters - Zod schema for parameters
+ * @param handler - Signal or function that provides the handler
+ * @param render - Optional render component or template
+ * @returns Object with update and destroy methods
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   private toolConfig = signal({
+ *     handler: async (args: any) => this.processDefault(args)
+ *   });
+ *
+ *   ngOnInit() {
+ *     const tool = createDynamicFrontendTool(
+ *       'processor',
+ *       'Processes data',
+ *       z.object({ data: z.string() }),
+ *       () => this.toolConfig().handler
+ *     );
+ *
+ *     // Later, update the handler
+ *     this.toolConfig.set({
+ *       handler: async (args: any) => this.processAdvanced(args)
+ *     });
+ *     tool.update();
+ *   }
+ * }
+ * ```
+ */
+export function createDynamicFrontendTool(name, description, parameters, handler, render) {
+    const service = inject(CopilotKitService);
+    const destroyRef = inject(DestroyRef);
+    let isRegistered = false;
+    const update = () => {
+        // Remove old tool if registered
+        if (isRegistered) {
+            service.copilotkit.removeTool(name);
+        }
+        // Create new tool configuration
+        const desc = typeof description === 'function' ? description() : description;
+        const currentHandler = handler();
+        const currentRender = render ? render() : undefined;
+        const tool = {
+            name,
+            description: desc,
+            parameters,
+            handler: currentHandler,
+            render: currentRender
+        };
+        // Add the tool
+        service.copilotkit.addTool(tool);
+        // Update render if provided
+        if (currentRender) {
+            const currentRenders = service.currentRenderToolCalls();
+            const renderEntry = {
+                name: name,
+                render: currentRender
+            };
+            const existingIndex = currentRenders.findIndex((r) => r.name === name);
+            if (existingIndex !== -1) {
+                const updated = [...currentRenders];
+                updated[existingIndex] = renderEntry;
+                service.setCurrentRenderToolCalls(updated);
+            }
+            else {
+                service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
+            }
+        }
+        isRegistered = true;
+    };
+    const destroy = () => {
+        if (isRegistered) {
+            removeFrontendTool(service, name);
+            isRegistered = false;
+        }
+    };
+    // Initial setup
+    update();
+    // Register cleanup
+    destroyRef.onDestroy(destroy);
+    return { update, destroy };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-tool.utils.js","sourceRoot":"","sources":["../../../src/utils/frontend-tool.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, inject } from '@angular/core';\nimport { CopilotKitService } from '../core/copilotkit.service';\nimport { AngularFrontendTool, AngularToolCallRender, ToolCallRender } from '../core/copilotkit.types';\nimport type { z } from 'zod';\n\n/**\n * Explicitly adds a frontend tool to CopilotKit.\n * Requires CopilotKitService to be passed as a parameter.\n * \n * @param service - The CopilotKitService instance\n * @param tool - The tool to add\n * @returns A cleanup function that removes the tool\n * \n * @example\n * ```typescript\n * export class MyComponent implements OnInit, OnDestroy {\n *   private cleanupFns: Array<() => void> = [];\n *   \n *   constructor(private copilotkit: CopilotKitService) {}\n *   \n *   ngOnInit() {\n *     const cleanup = addFrontendTool(this.copilotkit, {\n *       name: 'calculator',\n *       description: 'Performs calculations',\n *       parameters: z.object({\n *         expression: z.string()\n *       }),\n *       handler: async (args) => {\n *         return eval(args.expression);\n *       }\n *     });\n *     \n *     this.cleanupFns.push(cleanup);\n *   }\n *   \n *   ngOnDestroy() {\n *     this.cleanupFns.forEach(fn => fn());\n *   }\n * }\n * ```\n */\nexport function addFrontendTool<T extends Record<string, any> = Record<string, any>>(\n  service: CopilotKitService,\n  tool: AngularFrontendTool<T>\n): () => void {\n  // Add the tool to CopilotKit\n  service.copilotkit.addTool(tool);\n  \n  // Register the render if provided\n  if (tool.render) {\n    const currentRenders = service.currentRenderToolCalls();\n    const existingIndex = currentRenders.findIndex((r: ToolCallRender) => r.name === tool.name);\n    \n    if (existingIndex !== -1) {\n      console.error(`Tool with name '${tool.name}' already has a render. Skipping.`);\n    } else {\n      const renderEntry: AngularToolCallRender = {\n        name: tool.name,\n        render: tool.render\n      };\n      \n      service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);\n    }\n  }\n  \n  // Return cleanup function\n  return () => {\n    removeFrontendTool(service, tool.name);\n  };\n}\n\n/**\n * Registers a frontend tool with CopilotKit and automatically removes it when the component/service is destroyed.\n * Must be called within an injection context.\n * \n * @param tool - The tool to register\n * @returns The tool name\n * \n * @example\n * ```typescript\n * export class MyComponent implements OnInit {\n *   ngOnInit() {\n *     // Automatically cleaned up on component destroy\n *     registerFrontendTool({\n *       name: 'search',\n *       description: 'Search for items',\n *       parameters: z.object({\n *         query: z.string()\n *       }),\n *       handler: async (args) => {\n *         return this.searchService.search(args.query);\n *       },\n *       render: SearchResultsComponent\n *     });\n *   }\n * }\n * ```\n */\nexport function registerFrontendTool<T extends Record<string, any> = Record<string, any>>(\n  tool: AngularFrontendTool<T>\n): string {\n  const service = inject(CopilotKitService);\n  const destroyRef = inject(DestroyRef);\n  \n  // Add the tool\n  service.copilotkit.addTool(tool);\n  \n  // Register the render if provided\n  if (tool.render) {\n    const currentRenders = service.currentRenderToolCalls();\n    const existingIndex = currentRenders.findIndex((r: ToolCallRender) => r.name === tool.name);\n    \n    if (existingIndex !== -1) {\n      console.error(`Tool with name '${tool.name}' already has a render. Skipping.`);\n    } else {\n      const renderEntry: AngularToolCallRender = {\n        name: tool.name,\n        render: tool.render\n      };\n      \n      service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);\n    }\n  }\n  \n  // Register cleanup with Angular's DestroyRef\n  destroyRef.onDestroy(() => {\n    removeFrontendTool(service, tool.name);\n  });\n  \n  return tool.name;\n}\n\n/**\n * Explicitly removes a frontend tool from CopilotKit.\n * \n * @param service - The CopilotKitService instance\n * @param toolName - The name of the tool to remove\n * \n * @example\n * ```typescript\n * removeFrontendTool(this.copilotkit, 'calculator');\n * ```\n */\nexport function removeFrontendTool(\n  service: CopilotKitService,\n  toolName: string\n): void {\n  // Remove the tool\n  service.copilotkit.removeTool(toolName);\n  \n  // Remove the render if it exists\n  const currentRenders = service.currentRenderToolCalls();\n  const filtered = currentRenders.filter((r: ToolCallRender) => r.name !== toolName);\n  if (filtered.length !== currentRenders.length) {\n    service.setCurrentRenderToolCalls(filtered);\n  }\n}\n\n/**\n * Creates a frontend tool with dynamic parameters that can change over time.\n * Uses Angular signals for reactivity.\n * \n * @param name - Tool name\n * @param description - Tool description\n * @param parameters - Zod schema for parameters\n * @param handler - Signal or function that provides the handler\n * @param render - Optional render component or template\n * @returns Object with update and destroy methods\n * \n * @example\n * ```typescript\n * export class MyComponent {\n *   private toolConfig = signal({\n *     handler: async (args: any) => this.processDefault(args)\n *   });\n *   \n *   ngOnInit() {\n *     const tool = createDynamicFrontendTool(\n *       'processor',\n *       'Processes data',\n *       z.object({ data: z.string() }),\n *       () => this.toolConfig().handler\n *     );\n *     \n *     // Later, update the handler\n *     this.toolConfig.set({\n *       handler: async (args: any) => this.processAdvanced(args)\n *     });\n *     tool.update();\n *   }\n * }\n * ```\n */\nexport function createDynamicFrontendTool<T extends Record<string, any> = Record<string, any>>(\n  name: string,\n  description: string | (() => string),\n  parameters: z.ZodSchema<T>,\n  handler: () => ((args: T) => Promise<any>),\n  render?: () => any\n): { update: () => void; destroy: () => void } {\n  const service = inject(CopilotKitService);\n  const destroyRef = inject(DestroyRef);\n  \n  let isRegistered = false;\n  \n  const update = () => {\n    // Remove old tool if registered\n    if (isRegistered) {\n      service.copilotkit.removeTool(name);\n    }\n    \n    // Create new tool configuration\n    const desc = typeof description === 'function' ? description() : description;\n    const currentHandler = handler();\n    const currentRender = render ? render() : undefined;\n    \n    const tool: AngularFrontendTool<T> = {\n      name,\n      description: desc,\n      parameters,\n      handler: currentHandler,\n      render: currentRender\n    };\n    \n    // Add the tool\n    service.copilotkit.addTool(tool);\n    \n    // Update render if provided\n    if (currentRender) {\n      const currentRenders = service.currentRenderToolCalls();\n      const renderEntry: AngularToolCallRender = {\n        name: name,\n        render: currentRender\n      };\n      \n      const existingIndex = currentRenders.findIndex((r: ToolCallRender) => r.name === name);\n      if (existingIndex !== -1) {\n        const updated = [...currentRenders];\n        updated[existingIndex] = renderEntry;\n        service.setCurrentRenderToolCalls(updated);\n      } else {\n        service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);\n      }\n    }\n    \n    isRegistered = true;\n  };\n  \n  const destroy = () => {\n    if (isRegistered) {\n      removeFrontendTool(service, name);\n      isRegistered = false;\n    }\n  };\n  \n  // Initial setup\n  update();\n  \n  // Register cleanup\n  destroyRef.onDestroy(destroy);\n  \n  return { update, destroy };\n}"]}