@copilotkitnext/angular 0.0.2 → 0.0.4

package/dist/esm2022/services/scroll-position.service.mjs

@@ -0,0 +1,124 @@
+import { Injectable, ElementRef } from '@angular/core';
+import { Subject, BehaviorSubject, fromEvent, merge, animationFrameScheduler } from 'rxjs';
+import { takeUntil, debounceTime, throttleTime, distinctUntilChanged, map, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/scrolling";
+export class ScrollPositionService {
+    scrollDispatcher;
+    viewportRuler;
+    ngZone;
+    destroy$ = new Subject();
+    scrollStateSubject = new BehaviorSubject({
+        isAtBottom: true,
+        scrollTop: 0,
+        scrollHeight: 0,
+        clientHeight: 0
+    });
+    scrollState$ = this.scrollStateSubject.asObservable();
+    constructor(scrollDispatcher, viewportRuler, ngZone) {
+        this.scrollDispatcher = scrollDispatcher;
+        this.viewportRuler = viewportRuler;
+        this.ngZone = ngZone;
+    }
+    /**
+     * Monitor scroll position of an element
+     * @param element The element to monitor
+     * @param threshold Pixels from bottom to consider "at bottom" (default 10)
+     */
+    monitorScrollPosition(element, threshold = 10) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        // Create scroll observable
+        const scroll$ = merge(fromEvent(el, 'scroll'), this.viewportRuler.change(150) // Monitor viewport changes
+        ).pipe(startWith(null), // Emit initial state
+        throttleTime(16, animationFrameScheduler, { trailing: true }), // ~60fps
+        map(() => this.getScrollState(el, threshold)), distinctUntilChanged((a, b) => a.isAtBottom === b.isAtBottom &&
+            a.scrollTop === b.scrollTop &&
+            a.scrollHeight === b.scrollHeight), takeUntil(this.destroy$));
+        // Subscribe and update subject
+        scroll$.subscribe(state => {
+            this.scrollStateSubject.next(state);
+        });
+        return scroll$;
+    }
+    /**
+     * Scroll element to bottom with smooth animation
+     * @param element The element to scroll
+     * @param smooth Whether to use smooth scrolling
+     */
+    scrollToBottom(element, smooth = true) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        this.ngZone.runOutsideAngular(() => {
+            if (smooth && 'scrollBehavior' in document.documentElement.style) {
+                el.scrollTo({
+                    top: el.scrollHeight,
+                    behavior: 'smooth'
+                });
+            }
+            else {
+                el.scrollTop = el.scrollHeight;
+            }
+        });
+    }
+    /**
+     * Check if element is at bottom
+     * @param element The element to check
+     * @param threshold Pixels from bottom to consider "at bottom"
+     */
+    isAtBottom(element, threshold = 10) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        return this.getScrollState(el, threshold).isAtBottom;
+    }
+    /**
+     * Get current scroll state of element
+     */
+    getScrollState(element, threshold) {
+        const scrollTop = element.scrollTop;
+        const scrollHeight = element.scrollHeight;
+        const clientHeight = element.clientHeight;
+        const distanceFromBottom = scrollHeight - scrollTop - clientHeight;
+        const isAtBottom = distanceFromBottom <= threshold;
+        return {
+            isAtBottom,
+            scrollTop,
+            scrollHeight,
+            clientHeight
+        };
+    }
+    /**
+     * Create a ResizeObserver for element size changes
+     * @param element The element to observe
+     * @param debounceMs Debounce time in milliseconds
+     */
+    observeResize(element, debounceMs = 250) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        const resize$ = new Subject();
+        const resizeObserver = new ResizeObserver((entries) => {
+            const entry = entries[0];
+            if (entry) {
+                this.ngZone.run(() => {
+                    resize$.next(entry);
+                });
+            }
+        });
+        resizeObserver.observe(el);
+        // Cleanup on destroy
+        this.destroy$.subscribe(() => {
+            resizeObserver.disconnect();
+        });
+        return resize$.pipe(debounceTime(debounceMs), takeUntil(this.destroy$));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.scrollStateSubject.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollPositionService, deps: [{ token: i1.ScrollDispatcher }, { token: i1.ViewportRuler }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollPositionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollPositionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ScrollDispatcher }, { type: i1.ViewportRuler }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-position.service.js","sourceRoot":"","sources":["../../../src/services/scroll-position.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ElementRef, NgZone, OnDestroy } from '@angular/core';\nimport { ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';\nimport { Observable, Subject, BehaviorSubject, fromEvent, merge, animationFrameScheduler } from 'rxjs';\nimport { \n  takeUntil, \n  debounceTime, \n  throttleTime, \n  distinctUntilChanged,\n  map,\n  observeOn,\n  startWith\n} from 'rxjs/operators';\n\nexport interface ScrollState {\n  isAtBottom: boolean;\n  scrollTop: number;\n  scrollHeight: number;\n  clientHeight: number;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ScrollPositionService implements OnDestroy {\n  private destroy$ = new Subject<void>();\n  private scrollStateSubject = new BehaviorSubject<ScrollState>({\n    isAtBottom: true,\n    scrollTop: 0,\n    scrollHeight: 0,\n    clientHeight: 0\n  });\n  \n  public scrollState$ = this.scrollStateSubject.asObservable();\n  \n  constructor(\n    private scrollDispatcher: ScrollDispatcher,\n    private viewportRuler: ViewportRuler,\n    private ngZone: NgZone\n  ) {}\n  \n  /**\n   * Monitor scroll position of an element\n   * @param element The element to monitor\n   * @param threshold Pixels from bottom to consider \"at bottom\" (default 10)\n   */\n  monitorScrollPosition(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    threshold: number = 10\n  ): Observable<ScrollState> {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    \n    // Create scroll observable\n    const scroll$ = merge(\n      fromEvent(el, 'scroll'),\n      this.viewportRuler.change(150) // Monitor viewport changes\n    ).pipe(\n      startWith(null), // Emit initial state\n      throttleTime(16, animationFrameScheduler, { trailing: true }), // ~60fps\n      map(() => this.getScrollState(el, threshold)),\n      distinctUntilChanged((a, b) => \n        a.isAtBottom === b.isAtBottom && \n        a.scrollTop === b.scrollTop &&\n        a.scrollHeight === b.scrollHeight\n      ),\n      takeUntil(this.destroy$)\n    );\n    \n    // Subscribe and update subject\n    scroll$.subscribe(state => {\n      this.scrollStateSubject.next(state);\n    });\n    \n    return scroll$;\n  }\n  \n  /**\n   * Scroll element to bottom with smooth animation\n   * @param element The element to scroll\n   * @param smooth Whether to use smooth scrolling\n   */\n  scrollToBottom(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    smooth: boolean = true\n  ): void {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    \n    this.ngZone.runOutsideAngular(() => {\n      if (smooth && 'scrollBehavior' in document.documentElement.style) {\n        el.scrollTo({\n          top: el.scrollHeight,\n          behavior: 'smooth'\n        });\n      } else {\n        el.scrollTop = el.scrollHeight;\n      }\n    });\n  }\n  \n  /**\n   * Check if element is at bottom\n   * @param element The element to check\n   * @param threshold Pixels from bottom to consider \"at bottom\"\n   */\n  isAtBottom(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    threshold: number = 10\n  ): boolean {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    return this.getScrollState(el, threshold).isAtBottom;\n  }\n  \n  /**\n   * Get current scroll state of element\n   */\n  public getScrollState(element: HTMLElement, threshold: number): ScrollState {\n    const scrollTop = element.scrollTop;\n    const scrollHeight = element.scrollHeight;\n    const clientHeight = element.clientHeight;\n    const distanceFromBottom = scrollHeight - scrollTop - clientHeight;\n    const isAtBottom = distanceFromBottom <= threshold;\n    \n    return {\n      isAtBottom,\n      scrollTop,\n      scrollHeight,\n      clientHeight\n    };\n  }\n  \n  /**\n   * Create a ResizeObserver for element size changes\n   * @param element The element to observe\n   * @param debounceMs Debounce time in milliseconds\n   */\n  observeResize(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    debounceMs: number = 250\n  ): Observable<ResizeObserverEntry> {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    const resize$ = new Subject<ResizeObserverEntry>();\n    \n    const resizeObserver = new ResizeObserver((entries) => {\n      const entry = entries[0];\n      if (entry) {\n        this.ngZone.run(() => {\n          resize$.next(entry);\n        });\n      }\n    });\n    \n    resizeObserver.observe(el);\n    \n    // Cleanup on destroy\n    this.destroy$.subscribe(() => {\n      resizeObserver.disconnect();\n    });\n    \n    return resize$.pipe(\n      debounceTime(debounceMs),\n      takeUntil(this.destroy$)\n    );\n  }\n  \n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.scrollStateSubject.complete();\n  }\n}"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbnRlbmQtdG9vbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90eXBlcy9mcm9udGVuZC10b29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlLCBUZW1wbGF0ZVJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgdHlwZSB7IHogfSBmcm9tIFwiem9kXCI7XG5cbi8qKlxuICogQW5ndWxhci1zcGVjaWZpYyBmcm9udGVuZCB0b29sIGRlZmluaXRpb24uXG4gKiBQcm92aWRlcyBhIGhhbmRsZXIgZnVuY3Rpb24gdGhhdCBleGVjdXRlcyBvbiB0aGUgZnJvbnRlbmQgd2hlbiB0aGUgdG9vbCBpcyBjYWxsZWQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQW5ndWxhckZyb250ZW5kVG9vbDxUIGV4dGVuZHMgUmVjb3JkPHN0cmluZywgYW55PiA9IFJlY29yZDxzdHJpbmcsIGFueT4+IHtcbiAgLyoqXG4gICAqIFRoZSBuYW1lIG9mIHRoZSB0b29sIC0gbXVzdCBiZSB1bmlxdWVcbiAgICovXG4gIG5hbWU6IHN0cmluZztcbiAgXG4gIC8qKlxuICAgKiBEZXNjcmlwdGlvbiBvZiB3aGF0IHRoZSB0b29sIGRvZXNcbiAgICovXG4gIGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuICBcbiAgLyoqXG4gICAqIFpvZCBzY2hlbWEgZGVmaW5pbmcgdGhlIHBhcmFtZXRlcnMgZm9yIHRoZSB0b29sXG4gICAqL1xuICBwYXJhbWV0ZXJzPzogei5ab2RTY2hlbWE8VD47XG4gIFxuICAvKipcbiAgICogSGFuZGxlciBmdW5jdGlvbiB0aGF0IGV4ZWN1dGVzIHdoZW4gdGhlIHRvb2wgaXMgY2FsbGVkXG4gICAqL1xuICBoYW5kbGVyPzogKGFyZ3M6IFQpID0+IFByb21pc2U8YW55PjtcbiAgXG4gIC8qKlxuICAgKiBPcHRpb25hbCBBbmd1bGFyIGNvbXBvbmVudCBvciB0ZW1wbGF0ZSB0byByZW5kZXIgd2hlbiB0aGUgdG9vbCBpcyBjYWxsZWRcbiAgICovXG4gIHJlbmRlcj86IFR5cGU8YW55PiB8IFRlbXBsYXRlUmVmPGFueT47XG4gIFxuICAvKipcbiAgICogV2hldGhlciB0aGUgYWdlbnQgc2hvdWxkIGZvbGxvdyB1cCBhZnRlciB0aGlzIHRvb2wgY29tcGxldGVzLlxuICAgKiBEZWZhdWx0cyB0byB0cnVlIGlmIG5vdCBzcGVjaWZpZWQuXG4gICAqL1xuICBmb2xsb3dVcD86IGJvb2xlYW47XG4gIFxuICAvKipcbiAgICogT3B0aW9uYWwgYWdlbnQgSUQgdG8gY29uc3RyYWluIHRoaXMgdG9vbCB0byBhIHNwZWNpZmljIGFnZW50XG4gICAqL1xuICBhZ2VudElkPzogc3RyaW5nO1xufSJdfQ==

package/dist/esm2022/types/human-in-the-loop.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/utils/agent-context.utils.mjs

@@ -0,0 +1,114 @@
+import { DestroyRef, inject } from '@angular/core';
+import { CopilotKitService } from '../core/copilotkit.service';
+/**
+ * Programmatically adds an agent context to CopilotKit and returns a cleanup function.
+ *
+ * @param context - The context to add
+ * @returns A cleanup function that removes the context
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent implements OnInit {
+ *   private copilotkit = injectCopilotKit();
+ *
+ *   ngOnInit() {
+ *     const cleanup = addAgentContext(this.copilotkit, {
+ *       description: 'User preferences',
+ *       value: this.userSettings
+ *     });
+ *
+ *     // Store cleanup for later or register with DestroyRef
+ *     this.cleanupFns.push(cleanup);
+ *   }
+ * }
+ * ```
+ */
+export function addAgentContext(copilotkit, context) {
+    const contextId = copilotkit.copilotkit.addContext(context);
+    return () => {
+        copilotkit.copilotkit.removeContext(contextId);
+    };
+}
+/**
+ * Registers an agent context with CopilotKit and automatically removes it when the component/service is destroyed.
+ * Must be called within an injection context.
+ *
+ * @param context - The context to add
+ * @returns The context ID
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent implements OnInit {
+ *   ngOnInit() {
+ *     // Automatically cleaned up on component destroy
+ *     registerAgentContext({
+ *       description: 'Component state',
+ *       value: this.state
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function registerAgentContext(context) {
+    const copilotkit = inject(CopilotKitService);
+    const destroyRef = inject(DestroyRef);
+    const contextId = copilotkit.copilotkit.addContext(context);
+    // Register cleanup with Angular's DestroyRef
+    destroyRef.onDestroy(() => {
+        copilotkit.copilotkit.removeContext(contextId);
+    });
+    return contextId;
+}
+/**
+ * Creates a reactive context that updates whenever the value changes.
+ * Uses Angular signals for reactivity.
+ *
+ * @param description - Static or signal-based description
+ * @param value - Signal that provides the context value
+ * @returns Object with update and destroy methods
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   private userSettings = signal({ theme: 'dark' });
+ *
+ *   ngOnInit() {
+ *     const context = createReactiveContext(
+ *       'User settings',
+ *       computed(() => this.userSettings())
+ *     );
+ *
+ *     // Updates automatically when userSettings signal changes
+ *   }
+ * }
+ * ```
+ */
+export function createReactiveContext(description, value) {
+    const copilotkit = inject(CopilotKitService);
+    let currentContextId;
+    const update = () => {
+        // Remove old context if it exists
+        if (currentContextId) {
+            copilotkit.copilotkit.removeContext(currentContextId);
+        }
+        // Add new context
+        const desc = typeof description === 'function' ? description() : description;
+        currentContextId = copilotkit.copilotkit.addContext({
+            description: desc,
+            value: value()
+        });
+    };
+    const destroy = () => {
+        if (currentContextId) {
+            copilotkit.copilotkit.removeContext(currentContextId);
+            currentContextId = undefined;
+        }
+    };
+    // Initial setup
+    update();
+    // Register cleanup
+    const destroyRef = inject(DestroyRef);
+    destroyRef.onDestroy(destroy);
+    return { update, destroy };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/utils/agent.utils.mjs

@@ -0,0 +1,204 @@
+import { DestroyRef, inject, signal, computed } from "@angular/core";
+import { toObservable } from "@angular/core/rxjs-interop";
+import { CopilotKitService } from "../core/copilotkit.service";
+import { DEFAULT_AGENT_ID } from "@copilotkitnext/shared";
+/**
+ * Watches an agent and provides reactive signals for its state.
+ * Must be called within an injection context.
+ * Automatically cleans up when the component/service is destroyed.
+ *
+ * @param config - Optional configuration with agentId
+ * @returns Object with agent, messages, and isRunning signals plus observables
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   // Automatically tracks agent state
+ *   agentState = watchAgent({ agentId: 'my-agent' });
+ *
+ *   constructor() {
+ *     effect(() => {
+ *       const messages = this.agentState.messages();
+ *       const isRunning = this.agentState.isRunning();
+ *       console.log('Messages:', messages.length, 'Running:', isRunning);
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function watchAgent(config) {
+    // Use inject() internally to get required services
+    const service = inject(CopilotKitService);
+    const destroyRef = inject(DestroyRef);
+    const effectiveAgentId = config?.agentId ?? DEFAULT_AGENT_ID;
+    // Create reactive signals with tick mechanism for reliable updates
+    const agentSignal = signal(undefined);
+    const tick = signal(0);
+    const isRunningSignal = signal(false);
+    // Create computed messages signal that reacts to tick changes
+    const messages = computed(() => {
+        // Access tick to ensure recomputation
+        tick();
+        const a = agentSignal();
+        if (!a)
+            return [];
+        // Return a shallow clone to ensure change detection
+        return a.messages.map((m) => ({ ...m }));
+    });
+    // Get initial agent
+    const updateAgent = () => {
+        const agent = service.copilotkit.getAgent(effectiveAgentId);
+        agentSignal.set(agent);
+        return agent;
+    };
+    // Initial update
+    let currentAgent = updateAgent();
+    // Subscribe to agent changes
+    let agentSubscription;
+    const subscribeToAgent = () => {
+        // Unsubscribe from previous agent if any
+        agentSubscription?.unsubscribe();
+        if (currentAgent) {
+            agentSubscription = currentAgent.subscribe({
+                onMessagesChanged() {
+                    // Increment tick to force recomputation of messages computed
+                    tick.update((v) => v + 1);
+                },
+                onStateChanged() {
+                    // Increment tick to force recomputation
+                    tick.update((v) => v + 1);
+                },
+                onRunInitialized() {
+                    isRunningSignal.set(true);
+                },
+                onRunFinalized() {
+                    isRunningSignal.set(false);
+                },
+                onRunFailed() {
+                    isRunningSignal.set(false);
+                },
+            });
+        }
+    };
+    // Initial subscription
+    subscribeToAgent();
+    // Subscribe to CopilotKit changes to detect agent updates
+    const coreUnsubscribe = service.copilotkit.subscribe({
+        onRuntimeLoaded() {
+            // Re-check agent when runtime loads
+            currentAgent = updateAgent();
+            subscribeToAgent();
+        },
+        onRuntimeLoadError() {
+            // Also re-check agent on runtime load error to ensure consistency
+            currentAgent = updateAgent();
+            subscribeToAgent();
+        },
+    });
+    // Register cleanup
+    const unsubscribe = () => {
+        agentSubscription?.unsubscribe();
+        coreUnsubscribe(); // subscribe returns a function directly
+    };
+    destroyRef.onDestroy(unsubscribe);
+    // Create observables from signals using toObservable
+    const agent$ = toObservable(agentSignal);
+    const isRunning$ = toObservable(isRunningSignal);
+    const messages$ = toObservable(messages);
+    return {
+        agent: agentSignal.asReadonly(),
+        messages: messages,
+        isRunning: isRunningSignal.asReadonly(),
+        agent$,
+        messages$,
+        isRunning$,
+        unsubscribe,
+    };
+}
+/**
+ * Gets an agent by ID without subscribing to changes.
+ *
+ * @param service - The CopilotKitService instance
+ * @param agentId - Optional agent ID (defaults to DEFAULT_AGENT_ID)
+ * @returns The agent or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   constructor(private copilotkit: CopilotKitService) {}
+ *
+ *   getCurrentAgent() {
+ *     return getAgent(this.copilotkit, 'my-agent');
+ *   }
+ * }
+ * ```
+ */
+export function getAgent(service, agentId) {
+    const effectiveAgentId = agentId ?? DEFAULT_AGENT_ID;
+    return service.copilotkit.getAgent(effectiveAgentId);
+}
+/**
+ * Subscribes to an agent's events with custom callbacks.
+ * Returns a cleanup function that should be called to unsubscribe.
+ *
+ * @param service - The CopilotKitService instance
+ * @param agentId - Optional agent ID (defaults to DEFAULT_AGENT_ID)
+ * @param callbacks - Event callbacks
+ * @returns Cleanup function to unsubscribe
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent implements OnInit, OnDestroy {
+ *   private unsubscribe?: () => void;
+ *
+ *   constructor(private copilotkit: CopilotKitService) {}
+ *
+ *   ngOnInit() {
+ *     this.unsubscribe = subscribeToAgent(this.copilotkit, 'my-agent', {
+ *       onRunInitialized: () => console.log('Run started'),
+ *       onRunFinalized: () => console.log('Run completed'),
+ *       onRunFailed: (error) => console.error('Run failed', error),
+ *     });
+ *   }
+ *
+ *   ngOnDestroy() {
+ *     this.unsubscribe?.();
+ *   }
+ * }
+ * ```
+ */
+export function subscribeToAgent(service, agentId, callbacks) {
+    const effectiveAgentId = agentId ?? DEFAULT_AGENT_ID;
+    const agent = service.copilotkit.getAgent(effectiveAgentId);
+    if (!agent) {
+        // Return no-op cleanup if agent doesn't exist
+        return () => { };
+    }
+    const subscription = agent.subscribe({
+        onMessagesChanged: callbacks?.onMessagesChanged,
+        onStateChanged: callbacks?.onStateChanged,
+        onRunInitialized: callbacks?.onRunInitialized,
+        onRunFinalized: callbacks?.onRunFinalized,
+        onRunFailed: callbacks?.onRunFailed,
+    });
+    return () => subscription.unsubscribe();
+}
+/**
+ * Registers an agent watcher that automatically cleans up on component destroy.
+ * This is an alias for watchAgent with a more explicit name.
+ * Must be called within an injection context.
+ *
+ * @param config - Optional configuration with agentId
+ * @returns Object with agent, messages, and isRunning signals plus observables
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   agentState = registerAgentWatcher({ agentId: 'my-agent' });
+ * }
+ * ```
+ */
+export function registerAgentWatcher(config) {
+    return watchAgent(config);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent.utils.js","sourceRoot":"","sources":["../../../src/utils/agent.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, inject, signal, computed } from \"@angular/core\";\nimport { toObservable } from \"@angular/core/rxjs-interop\";\nimport { CopilotKitService } from \"../core/copilotkit.service\";\nimport {\n  AgentSubscriptionCallbacks,\n  AgentWatchResult,\n} from \"../core/copilotkit.types\";\nimport { AbstractAgent } from \"@ag-ui/client\";\nimport { DEFAULT_AGENT_ID } from \"@copilotkitnext/shared\";\n\n/**\n * Watches an agent and provides reactive signals for its state.\n * Must be called within an injection context.\n * Automatically cleans up when the component/service is destroyed.\n *\n * @param config - Optional configuration with agentId\n * @returns Object with agent, messages, and isRunning signals plus observables\n *\n * @example\n * ```typescript\n * export class MyComponent {\n *   // Automatically tracks agent state\n *   agentState = watchAgent({ agentId: 'my-agent' });\n *\n *   constructor() {\n *     effect(() => {\n *       const messages = this.agentState.messages();\n *       const isRunning = this.agentState.isRunning();\n *       console.log('Messages:', messages.length, 'Running:', isRunning);\n *     });\n *   }\n * }\n * ```\n */\nexport function watchAgent(config?: { agentId?: string }): AgentWatchResult {\n  // Use inject() internally to get required services\n  const service = inject(CopilotKitService);\n  const destroyRef = inject(DestroyRef);\n  const effectiveAgentId = config?.agentId ?? DEFAULT_AGENT_ID;\n\n  // Create reactive signals with tick mechanism for reliable updates\n  const agentSignal = signal<AbstractAgent | undefined>(undefined);\n  const tick = signal<number>(0);\n  const isRunningSignal = signal<boolean>(false);\n\n  // Create computed messages signal that reacts to tick changes\n  const messages = computed(() => {\n    // Access tick to ensure recomputation\n    tick();\n    const a = agentSignal();\n    if (!a) return [];\n    // Return a shallow clone to ensure change detection\n    return a.messages.map((m) => ({ ...m }));\n  });\n\n  // Get initial agent\n  const updateAgent = () => {\n    const agent = service.copilotkit.getAgent(effectiveAgentId);\n    agentSignal.set(agent);\n    return agent;\n  };\n\n  // Initial update\n  let currentAgent = updateAgent();\n\n  // Subscribe to agent changes\n  let agentSubscription: { unsubscribe: () => void } | undefined;\n\n  const subscribeToAgent = () => {\n    // Unsubscribe from previous agent if any\n    agentSubscription?.unsubscribe();\n\n    if (currentAgent) {\n      agentSubscription = currentAgent.subscribe({\n        onMessagesChanged() {\n          // Increment tick to force recomputation of messages computed\n          tick.update((v) => v + 1);\n        },\n        onStateChanged() {\n          // Increment tick to force recomputation\n          tick.update((v) => v + 1);\n        },\n        onRunInitialized() {\n          isRunningSignal.set(true);\n        },\n        onRunFinalized() {\n          isRunningSignal.set(false);\n        },\n        onRunFailed() {\n          isRunningSignal.set(false);\n        },\n      });\n    }\n  };\n\n  // Initial subscription\n  subscribeToAgent();\n\n  // Subscribe to CopilotKit changes to detect agent updates\n  const coreUnsubscribe = service.copilotkit.subscribe({\n    onRuntimeLoaded() {\n      // Re-check agent when runtime loads\n      currentAgent = updateAgent();\n      subscribeToAgent();\n    },\n    onRuntimeLoadError() {\n      // Also re-check agent on runtime load error to ensure consistency\n      currentAgent = updateAgent();\n      subscribeToAgent();\n    },\n  });\n\n  // Register cleanup\n  const unsubscribe = () => {\n    agentSubscription?.unsubscribe();\n    coreUnsubscribe(); // subscribe returns a function directly\n  };\n\n  destroyRef.onDestroy(unsubscribe);\n\n  // Create observables from signals using toObservable\n  const agent$ = toObservable(agentSignal);\n  const isRunning$ = toObservable(isRunningSignal);\n  const messages$ = toObservable(messages);\n\n  return {\n    agent: agentSignal.asReadonly(),\n    messages: messages,\n    isRunning: isRunningSignal.asReadonly(),\n    agent$,\n    messages$,\n    isRunning$,\n    unsubscribe,\n  };\n}\n\n/**\n * Gets an agent by ID without subscribing to changes.\n *\n * @param service - The CopilotKitService instance\n * @param agentId - Optional agent ID (defaults to DEFAULT_AGENT_ID)\n * @returns The agent or undefined if not found\n *\n * @example\n * ```typescript\n * export class MyComponent {\n *   constructor(private copilotkit: CopilotKitService) {}\n *\n *   getCurrentAgent() {\n *     return getAgent(this.copilotkit, 'my-agent');\n *   }\n * }\n * ```\n */\nexport function getAgent(\n  service: CopilotKitService,\n  agentId?: string\n): AbstractAgent | undefined {\n  const effectiveAgentId = agentId ?? DEFAULT_AGENT_ID;\n  return service.copilotkit.getAgent(effectiveAgentId);\n}\n\n// Re-export the type for convenience (the actual type is in copilotkit.types)\nexport type { AgentWatchResult } from \"../core/copilotkit.types\";\n\n/**\n * Subscribes to an agent's events with custom callbacks.\n * Returns a cleanup function that should be called to unsubscribe.\n *\n * @param service - The CopilotKitService instance\n * @param agentId - Optional agent ID (defaults to DEFAULT_AGENT_ID)\n * @param callbacks - Event callbacks\n * @returns Cleanup function to unsubscribe\n *\n * @example\n * ```typescript\n * export class MyComponent implements OnInit, OnDestroy {\n *   private unsubscribe?: () => void;\n *\n *   constructor(private copilotkit: CopilotKitService) {}\n *\n *   ngOnInit() {\n *     this.unsubscribe = subscribeToAgent(this.copilotkit, 'my-agent', {\n *       onRunInitialized: () => console.log('Run started'),\n *       onRunFinalized: () => console.log('Run completed'),\n *       onRunFailed: (error) => console.error('Run failed', error),\n *     });\n *   }\n *\n *   ngOnDestroy() {\n *     this.unsubscribe?.();\n *   }\n * }\n * ```\n */\nexport function subscribeToAgent(\n  service: CopilotKitService,\n  agentId?: string,\n  callbacks?: AgentSubscriptionCallbacks\n): () => void {\n  const effectiveAgentId = agentId ?? DEFAULT_AGENT_ID;\n  const agent = service.copilotkit.getAgent(effectiveAgentId);\n\n  if (!agent) {\n    // Return no-op cleanup if agent doesn't exist\n    return () => {};\n  }\n\n  const subscription = agent.subscribe({\n    onMessagesChanged: callbacks?.onMessagesChanged,\n    onStateChanged: callbacks?.onStateChanged,\n    onRunInitialized: callbacks?.onRunInitialized,\n    onRunFinalized: callbacks?.onRunFinalized,\n    onRunFailed: callbacks?.onRunFailed,\n  });\n\n  return () => subscription.unsubscribe();\n}\n\n/**\n * Registers an agent watcher that automatically cleans up on component destroy.\n * This is an alias for watchAgent with a more explicit name.\n * Must be called within an injection context.\n *\n * @param config - Optional configuration with agentId\n * @returns Object with agent, messages, and isRunning signals plus observables\n *\n * @example\n * ```typescript\n * export class MyComponent {\n *   agentState = registerAgentWatcher({ agentId: 'my-agent' });\n * }\n * ```\n */\nexport function registerAgentWatcher(config?: {\n  agentId?: string;\n}): AgentWatchResult {\n  return watchAgent(config);\n}\n"]}