@copilotkitnext/angular 0.0.1 → 0.0.4

package/dist/esm2022/directives/copilotkit-agent-context.directive.mjs

@@ -0,0 +1,130 @@
+import { Directive, Input, Inject, } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/copilotkit.service";
+/**
+ * Directive to manage agent context in CopilotKit.
+ * Automatically adds context on init, updates on changes, and removes on destroy.
+ *
+ * @example
+ * ```html
+ * <!-- With separate inputs -->
+ * <div copilotkitAgentContext
+ *      [description]="'User preferences'"
+ *      [value]="userSettings">
+ * </div>
+ *
+ * <!-- With context object -->
+ * <div [copilotkitAgentContext]="contextObject">
+ * </div>
+ *
+ * <!-- With dynamic values -->
+ * <div copilotkitAgentContext
+ *      description="Form state"
+ *      [value]="formData$ | async">
+ * </div>
+ * ```
+ */
+export class CopilotKitAgentContextDirective {
+    copilotkit;
+    contextId;
+    constructor(copilotkit) {
+        this.copilotkit = copilotkit;
+    }
+    /**
+     * Context object containing both description and value.
+     * If provided, this takes precedence over individual inputs.
+     */
+    context;
+    /**
+     * Description of the context.
+     * Used when context object is not provided.
+     */
+    description;
+    /**
+     * Value of the context.
+     * Used when context object is not provided.
+     */
+    value;
+    ngOnInit() {
+        this.addContext();
+    }
+    ngOnChanges(changes) {
+        // Check if any relevant input has changed
+        const hasContextChange = "context" in changes;
+        const hasDescriptionChange = "description" in changes;
+        const hasValueChange = "value" in changes;
+        if (hasContextChange || hasDescriptionChange || hasValueChange) {
+            // Skip the first change as ngOnInit handles initial setup
+            if (this.contextId) {
+                this.updateContext();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.removeContext();
+    }
+    /**
+     * Adds the context to CopilotKit
+     */
+    addContext() {
+        const contextToAdd = this.getContext();
+        if (contextToAdd) {
+            this.contextId = this.copilotkit.copilotkit.addContext(contextToAdd);
+        }
+    }
+    /**
+     * Updates the context by removing the old one and adding a new one
+     */
+    updateContext() {
+        this.removeContext();
+        this.addContext();
+    }
+    /**
+     * Removes the current context from CopilotKit
+     */
+    removeContext() {
+        if (this.contextId) {
+            this.copilotkit.copilotkit.removeContext(this.contextId);
+            this.contextId = undefined;
+        }
+    }
+    /**
+     * Gets the context object from inputs
+     */
+    getContext() {
+        // If context object is provided, use it
+        if (this.context) {
+            return this.context;
+        }
+        // Otherwise, build from individual inputs
+        // Note: null is a valid value, but undefined means not set
+        if (this.description !== undefined && this.value !== undefined) {
+            return {
+                description: this.description,
+                value: this.value,
+            };
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitAgentContextDirective, deps: [{ token: CopilotKitService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitAgentContextDirective, isStandalone: true, selector: "[copilotkitAgentContext]", inputs: { context: ["copilotkitAgentContext", "context"], description: "description", value: "value" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitAgentContextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitAgentContext]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotKitService, decorators: [{
+                    type: Inject,
+                    args: [CopilotKitService]
+                }] }], propDecorators: { context: [{
+                type: Input,
+                args: ["copilotkitAgentContext"]
+            }], description: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/directives/copilotkit-agent.directive.mjs

@@ -0,0 +1,217 @@
+import { Directive, Input, Output, EventEmitter, signal, Inject, } from "@angular/core";
+import { toObservable } from "@angular/core/rxjs-interop";
+import { CopilotKitService } from "../core/copilotkit.service";
+import { DEFAULT_AGENT_ID } from "@copilotkitnext/shared";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/copilotkit.service";
+/**
+ * Directive to watch and interact with CopilotKit agents.
+ * Provides reactive outputs for agent state changes.
+ *
+ * @example
+ * ```html
+ * <!-- Basic usage with default agent -->
+ * <div copilotkitAgent
+ *      (agentChange)="onAgentChange($event)"
+ *      (runningChange)="isProcessing = $event">
+ *   Content here
+ * </div>
+ *
+ * <!-- With specific agent ID -->
+ * <div copilotkitAgent
+ *      [agentId]="'my-agent-id'"
+ *      (agentChange)="currentAgent = $event"
+ *      (runningChange)="onRunningStateChange($event)"
+ *      (messagesChange)="onMessagesUpdate($event)"
+ *      (stateChange)="onStateUpdate($event)">
+ *   Content here
+ * </div>
+ *
+ * <!-- Two-way binding for running state -->
+ * <div copilotkitAgent
+ *      [(running)]="isAgentRunning">
+ *   <span *ngIf="isAgentRunning">Processing...</span>
+ * </div>
+ * ```
+ */
+export class CopilotKitAgentDirective {
+    copilotkit;
+    agent;
+    agentSubscription;
+    coreUnsubscribe; // subscribe returns function directly
+    _isRunning = false;
+    runningSignal = signal(false);
+    agentSignal = signal(undefined);
+    constructor(copilotkit) {
+        this.copilotkit = copilotkit;
+    }
+    /**
+     * The ID of the agent to watch.
+     * If not provided, uses the default agent ID.
+     */
+    agentId;
+    /**
+     * Alternative input using the directive selector.
+     * Allows: [copilotkitAgent]="'agent-id'"
+     */
+    set directiveAgentId(value) {
+        this.agentId = value || undefined;
+    }
+    /**
+     * Emits when the agent instance changes.
+     */
+    agentChange = new EventEmitter();
+    /**
+     * Emits when the running state changes.
+     */
+    runningChange = new EventEmitter();
+    /**
+     * Observable of the running state.
+     */
+    get running$() {
+        return toObservable(this.runningSignal);
+    }
+    /**
+     * Observable of the agent instance.
+     */
+    get agent$() {
+        return toObservable(this.agentSignal);
+    }
+    /**
+     * Two-way binding for running state.
+     */
+    get running() {
+        return this._isRunning;
+    }
+    set running(value) {
+        // Input setter for two-way binding (though typically read-only from agent)
+        this._isRunning = value;
+    }
+    /**
+     * Emits when agent messages change.
+     */
+    messagesChange = new EventEmitter();
+    /**
+     * Emits when agent state changes.
+     */
+    stateChange = new EventEmitter();
+    /**
+     * Emits when a run is initialized.
+     */
+    runInitialized = new EventEmitter();
+    /**
+     * Emits when a run is finalized.
+     */
+    runFinalized = new EventEmitter();
+    /**
+     * Emits when a run fails.
+     */
+    runFailed = new EventEmitter();
+    ngOnInit() {
+        this.setupAgent();
+        this.subscribeToCore();
+    }
+    ngOnChanges(changes) {
+        if (changes["agentId"] && !changes["agentId"].firstChange) {
+            // Agent ID changed, re-setup
+            this.cleanupAgentSubscription();
+            this.setupAgent();
+        }
+    }
+    ngOnDestroy() {
+        this.cleanupAgentSubscription();
+        this.cleanupCoreSubscription();
+    }
+    setupAgent() {
+        const effectiveAgentId = this.agentId ?? DEFAULT_AGENT_ID;
+        this.agent = this.copilotkit.getAgent(effectiveAgentId);
+        // Update signals
+        this.agentSignal.set(this.agent);
+        // Emit initial agent
+        this.agentChange.emit(this.agent);
+        // Subscribe to agent events
+        this.subscribeToAgent();
+    }
+    subscribeToAgent() {
+        this.cleanupAgentSubscription();
+        if (this.agent) {
+            this.agentSubscription = this.agent.subscribe({
+                onMessagesChanged: (params) => {
+                    this.messagesChange.emit(params);
+                },
+                onStateChanged: (params) => {
+                    this.stateChange.emit(params);
+                },
+                onRunInitialized: (params) => {
+                    this._isRunning = true;
+                    this.runningSignal.set(true);
+                    this.runningChange.emit(true);
+                    this.runInitialized.emit(params);
+                },
+                onRunFinalized: (params) => {
+                    this._isRunning = false;
+                    this.runningSignal.set(false);
+                    this.runningChange.emit(false);
+                    this.runFinalized.emit(params);
+                },
+                onRunFailed: (params) => {
+                    this._isRunning = false;
+                    this.runningSignal.set(false);
+                    this.runningChange.emit(false);
+                    this.runFailed.emit(params);
+                },
+            });
+        }
+    }
+    subscribeToCore() {
+        // Subscribe to CopilotKit changes to detect agent updates
+        this.coreUnsubscribe = this.copilotkit.copilotkit.subscribe({
+            onRuntimeLoaded: () => {
+                // Re-check agent when runtime loads
+                this.setupAgent();
+            },
+        });
+    }
+    cleanupAgentSubscription() {
+        this.agentSubscription?.unsubscribe();
+        this.agentSubscription = undefined;
+    }
+    cleanupCoreSubscription() {
+        this.coreUnsubscribe?.();
+        this.coreUnsubscribe = undefined;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitAgentDirective, deps: [{ token: CopilotKitService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitAgentDirective, isStandalone: true, selector: "[copilotkitAgent]", inputs: { agentId: "agentId", directiveAgentId: ["copilotkitAgent", "directiveAgentId"], running: "running" }, outputs: { agentChange: "agentChange", runningChange: "runningChange", messagesChange: "messagesChange", stateChange: "stateChange", runInitialized: "runInitialized", runFinalized: "runFinalized", runFailed: "runFailed" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitAgentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitAgent]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotKitService, decorators: [{
+                    type: Inject,
+                    args: [CopilotKitService]
+                }] }], propDecorators: { agentId: [{
+                type: Input
+            }], directiveAgentId: [{
+                type: Input,
+                args: ["copilotkitAgent"]
+            }], agentChange: [{
+                type: Output
+            }], runningChange: [{
+                type: Output
+            }], running: [{
+                type: Input
+            }], messagesChange: [{
+                type: Output
+            }], stateChange: [{
+                type: Output
+            }], runInitialized: [{
+                type: Output
+            }], runFinalized: [{
+                type: Output
+            }], runFailed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilotkit-agent.directive.js","sourceRoot":"","sources":["../../../src/directives/copilotkit-agent.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,MAAM,EACN,YAAY,EAKZ,MAAM,EACN,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;;;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAKH,MAAM,OAAO,wBAAwB;IASW;IARtC,KAAK,CAAiB;IACtB,iBAAiB,CAA+B;IAChD,eAAe,CAAc,CAAC,sCAAsC;IACpE,UAAU,GAAG,KAAK,CAAC;IACnB,aAAa,GAAG,MAAM,CAAU,KAAK,CAAC,CAAC;IACvC,WAAW,GAAG,MAAM,CAA4B,SAAS,CAAC,CAAC;IAEnE,YAC8C,UAA6B;QAA7B,eAAU,GAAV,UAAU,CAAmB;IACxE,CAAC;IAEJ;;;OAGG;IACM,OAAO,CAAU;IAE1B;;;OAGG;IACH,IACI,gBAAgB,CAAC,KAAyB;QAC5C,IAAI,CAAC,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC;IACpC,CAAC;IAED;;OAEG;IACO,WAAW,GAAG,IAAI,YAAY,EAA6B,CAAC;IAEtE;;OAEG;IACO,aAAa,GAAG,IAAI,YAAY,EAAW,CAAC;IAEtD;;OAEG;IACH,IAAI,QAAQ;QACV,OAAO,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,IACI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,OAAO,CAAC,KAAc;QACxB,2EAA2E;QAC3E,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;OAEG;IACO,cAAc,GAAG,IAAI,YAAY,EAAO,CAAC;IAEnD;;OAEG;IACO,WAAW,GAAG,IAAI,YAAY,EAAO,CAAC;IAEhD;;OAEG;IACO,cAAc,GAAG,IAAI,YAAY,EAAO,CAAC;IAEnD;;OAEG;IACO,YAAY,GAAG,IAAI,YAAY,EAAO,CAAC;IAEjD;;OAEG;IACO,SAAS,GAAG,IAAI,YAAY,EAAO,CAAC;IAE9C,QAAQ;QACN,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;YAC1D,6BAA6B;YAC7B,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAEO,UAAU;QAChB,MAAM,gBAAgB,GAAG,IAAI,CAAC,OAAO,IAAI,gBAAgB,CAAC;QAC1D,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;QAExD,iBAAiB;QACjB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEjC,qBAAqB;QACrB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAElC,4BAA4B;QAC5B,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEhC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;gBAC5C,iBAAiB,EAAE,CAAC,MAAM,EAAE,EAAE;oBAC5B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,cAAc,EAAE,CAAC,MAAM,EAAE,EAAE;oBACzB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAChC,CAAC;gBACD,gBAAgB,EAAE,CAAC,MAAM,EAAE,EAAE;oBAC3B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;oBACvB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBAC7B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC9B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,cAAc,EAAE,CAAC,MAAM,EAAE,EAAE;oBACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAC9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC/B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACjC,CAAC;gBACD,WAAW,EAAE,CAAC,MAAM,EAAE,EAAE;oBACtB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAC9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC/B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAC9B,CAAC;aACF,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,eAAe;QACrB,0DAA0D;QAC1D,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC;YAC1D,eAAe,EAAE,GAAG,EAAE;gBACpB,oCAAoC;gBACpC,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,wBAAwB;QAC9B,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE,CAAC;QACtC,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;IACrC,CAAC;IAEO,uBAAuB;QAC7B,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC;QACzB,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;IACnC,CAAC;wGA3KU,wBAAwB,kBASzB,iBAAiB;4FAThB,wBAAwB;;4FAAxB,wBAAwB;kBAJpC,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,UAAU,EAAE,IAAI;iBACjB;;0BAUI,MAAM;2BAAC,iBAAiB;yCAOlB,OAAO;sBAAf,KAAK;gBAOF,gBAAgB;sBADnB,KAAK;uBAAC,iBAAiB;gBAQd,WAAW;sBAApB,MAAM;gBAKG,aAAa;sBAAtB,MAAM;gBAoBH,OAAO;sBADV,KAAK;gBAYI,cAAc;sBAAvB,MAAM;gBAKG,WAAW;sBAApB,MAAM;gBAKG,cAAc;sBAAvB,MAAM;gBAKG,YAAY;sBAArB,MAAM;gBAKG,SAAS;sBAAlB,MAAM","sourcesContent":["import {\n  Directive,\n  Input,\n  Output,\n  EventEmitter,\n  OnInit,\n  OnChanges,\n  OnDestroy,\n  SimpleChanges,\n  signal,\n  Inject,\n} from \"@angular/core\";\nimport { toObservable } from \"@angular/core/rxjs-interop\";\nimport { Observable } from \"rxjs\";\nimport { CopilotKitService } from \"../core/copilotkit.service\";\nimport { AbstractAgent } from \"@ag-ui/client\";\nimport { DEFAULT_AGENT_ID } from \"@copilotkitnext/shared\";\n\n/**\n * Directive to watch and interact with CopilotKit agents.\n * Provides reactive outputs for agent state changes.\n *\n * @example\n * ```html\n * <!-- Basic usage with default agent -->\n * <div copilotkitAgent\n *      (agentChange)=\"onAgentChange($event)\"\n *      (runningChange)=\"isProcessing = $event\">\n *   Content here\n * </div>\n *\n * <!-- With specific agent ID -->\n * <div copilotkitAgent\n *      [agentId]=\"'my-agent-id'\"\n *      (agentChange)=\"currentAgent = $event\"\n *      (runningChange)=\"onRunningStateChange($event)\"\n *      (messagesChange)=\"onMessagesUpdate($event)\"\n *      (stateChange)=\"onStateUpdate($event)\">\n *   Content here\n * </div>\n *\n * <!-- Two-way binding for running state -->\n * <div copilotkitAgent\n *      [(running)]=\"isAgentRunning\">\n *   <span *ngIf=\"isAgentRunning\">Processing...</span>\n * </div>\n * ```\n */\n@Directive({\n  selector: \"[copilotkitAgent]\",\n  standalone: true,\n})\nexport class CopilotKitAgentDirective implements OnInit, OnChanges, OnDestroy {\n  private agent?: AbstractAgent;\n  private agentSubscription?: { unsubscribe: () => void };\n  private coreUnsubscribe?: () => void; // subscribe returns function directly\n  private _isRunning = false;\n  private runningSignal = signal<boolean>(false);\n  private agentSignal = signal<AbstractAgent | undefined>(undefined);\n\n  constructor(\n    @Inject(CopilotKitService) private readonly copilotkit: CopilotKitService\n  ) {}\n\n  /**\n   * The ID of the agent to watch.\n   * If not provided, uses the default agent ID.\n   */\n  @Input() agentId?: string;\n\n  /**\n   * Alternative input using the directive selector.\n   * Allows: [copilotkitAgent]=\"'agent-id'\"\n   */\n  @Input(\"copilotkitAgent\")\n  set directiveAgentId(value: string | undefined) {\n    this.agentId = value || undefined;\n  }\n\n  /**\n   * Emits when the agent instance changes.\n   */\n  @Output() agentChange = new EventEmitter<AbstractAgent | undefined>();\n\n  /**\n   * Emits when the running state changes.\n   */\n  @Output() runningChange = new EventEmitter<boolean>();\n\n  /**\n   * Observable of the running state.\n   */\n  get running$(): Observable<boolean> {\n    return toObservable(this.runningSignal);\n  }\n\n  /**\n   * Observable of the agent instance.\n   */\n  get agent$(): Observable<AbstractAgent | undefined> {\n    return toObservable(this.agentSignal);\n  }\n\n  /**\n   * Two-way binding for running state.\n   */\n  @Input()\n  get running(): boolean {\n    return this._isRunning;\n  }\n  set running(value: boolean) {\n    // Input setter for two-way binding (though typically read-only from agent)\n    this._isRunning = value;\n  }\n\n  /**\n   * Emits when agent messages change.\n   */\n  @Output() messagesChange = new EventEmitter<any>();\n\n  /**\n   * Emits when agent state changes.\n   */\n  @Output() stateChange = new EventEmitter<any>();\n\n  /**\n   * Emits when a run is initialized.\n   */\n  @Output() runInitialized = new EventEmitter<any>();\n\n  /**\n   * Emits when a run is finalized.\n   */\n  @Output() runFinalized = new EventEmitter<any>();\n\n  /**\n   * Emits when a run fails.\n   */\n  @Output() runFailed = new EventEmitter<any>();\n\n  ngOnInit(): void {\n    this.setupAgent();\n    this.subscribeToCore();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[\"agentId\"] && !changes[\"agentId\"].firstChange) {\n      // Agent ID changed, re-setup\n      this.cleanupAgentSubscription();\n      this.setupAgent();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.cleanupAgentSubscription();\n    this.cleanupCoreSubscription();\n  }\n\n  private setupAgent(): void {\n    const effectiveAgentId = this.agentId ?? DEFAULT_AGENT_ID;\n    this.agent = this.copilotkit.getAgent(effectiveAgentId);\n\n    // Update signals\n    this.agentSignal.set(this.agent);\n\n    // Emit initial agent\n    this.agentChange.emit(this.agent);\n\n    // Subscribe to agent events\n    this.subscribeToAgent();\n  }\n\n  private subscribeToAgent(): void {\n    this.cleanupAgentSubscription();\n\n    if (this.agent) {\n      this.agentSubscription = this.agent.subscribe({\n        onMessagesChanged: (params) => {\n          this.messagesChange.emit(params);\n        },\n        onStateChanged: (params) => {\n          this.stateChange.emit(params);\n        },\n        onRunInitialized: (params) => {\n          this._isRunning = true;\n          this.runningSignal.set(true);\n          this.runningChange.emit(true);\n          this.runInitialized.emit(params);\n        },\n        onRunFinalized: (params) => {\n          this._isRunning = false;\n          this.runningSignal.set(false);\n          this.runningChange.emit(false);\n          this.runFinalized.emit(params);\n        },\n        onRunFailed: (params) => {\n          this._isRunning = false;\n          this.runningSignal.set(false);\n          this.runningChange.emit(false);\n          this.runFailed.emit(params);\n        },\n      });\n    }\n  }\n\n  private subscribeToCore(): void {\n    // Subscribe to CopilotKit changes to detect agent updates\n    this.coreUnsubscribe = this.copilotkit.copilotkit.subscribe({\n      onRuntimeLoaded: () => {\n        // Re-check agent when runtime loads\n        this.setupAgent();\n      },\n    });\n  }\n\n  private cleanupAgentSubscription(): void {\n    this.agentSubscription?.unsubscribe();\n    this.agentSubscription = undefined;\n  }\n\n  private cleanupCoreSubscription(): void {\n    this.coreUnsubscribe?.();\n    this.coreUnsubscribe = undefined;\n  }\n}\n"]}

package/dist/esm2022/directives/copilotkit-chat-config.directive.mjs

@@ -0,0 +1,218 @@
+import { Directive, Input, Output, EventEmitter, Optional, isDevMode, Inject, } from "@angular/core";
+import { CopilotChatConfigurationService } from "../core/chat-configuration/chat-configuration.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/chat-configuration/chat-configuration.service";
+/**
+ * Directive for configuring CopilotKit chat settings declaratively in templates.
+ * Works with the CopilotChatConfigurationService to provide reactive chat configuration.
+ *
+ * @example
+ * ```html
+ * <!-- Basic usage with individual inputs -->
+ * <div copilotkitChatConfig
+ *      [labels]="customLabels"
+ *      [inputValue]="currentInput"
+ *      (submitInput)="onSubmit($event)"
+ *      (changeInput)="onChange($event)">
+ *   <!-- Chat UI components -->
+ * </div>
+ *
+ * <!-- Using configuration object -->
+ * <div [copilotkitChatConfig]="chatConfig">
+ *   <!-- Chat UI components -->
+ * </div>
+ *
+ * <!-- Two-way binding for input value -->
+ * <div copilotkitChatConfig
+ *      [(value)]="chatInput"
+ *      (submitInput)="handleSubmit($event)">
+ *   <!-- Chat UI components -->
+ * </div>
+ * ```
+ */
+export class CopilotKitChatConfigDirective {
+    chatConfig;
+    _value;
+    submitHandler;
+    changeHandler;
+    constructor(chatConfig) {
+        this.chatConfig = chatConfig;
+    }
+    /**
+     * Partial labels to override defaults
+     */
+    labels;
+    /**
+     * The current input value
+     */
+    inputValue;
+    /**
+     * Event emitted when input is submitted
+     */
+    submitInput = new EventEmitter();
+    /**
+     * Event emitted when input value changes
+     */
+    changeInput = new EventEmitter();
+    /**
+     * Alternative: accept full configuration object
+     */
+    set config(value) {
+        if (value) {
+            if (value.labels)
+                this.labels = value.labels;
+            if (value.inputValue !== undefined)
+                this.inputValue = value.inputValue;
+            // Store handlers for later setup
+            if (value.onSubmitInput)
+                this.submitHandler = value.onSubmitInput;
+            if (value.onChangeInput)
+                this.changeHandler = value.onChangeInput;
+        }
+    }
+    /**
+     * Two-way binding for input value
+     */
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.valueChange.emit(v);
+        if (v !== undefined) {
+            this.updateInputValue(v);
+        }
+    }
+    /**
+     * Two-way binding output for value
+     */
+    valueChange = new EventEmitter();
+    ngOnInit() {
+        if (!this.chatConfig) {
+            if (isDevMode()) {
+                console.warn("CopilotKitChatConfigDirective: No CopilotChatConfigurationService found. " +
+                    "Make sure to provide it using provideCopilotChatConfiguration().");
+            }
+            return;
+        }
+        this.updateConfiguration();
+        this.setupHandlers();
+    }
+    ngOnChanges(changes) {
+        if (!this.chatConfig) {
+            return;
+        }
+        const relevantChanges = changes["labels"] || changes["inputValue"] || changes["value"];
+        if (relevantChanges && !relevantChanges.firstChange) {
+            this.updateConfiguration();
+        }
+    }
+    ngOnDestroy() {
+        // Cleanup if needed
+    }
+    /**
+     * Submit the current input value
+     */
+    submit(value) {
+        // Emit to template binding
+        this.submitInput.emit(value);
+        // Call service handler
+        if (this.chatConfig) {
+            this.chatConfig.submitInput(value);
+        }
+        // Call provided handler
+        if (this.submitHandler) {
+            this.submitHandler(value);
+        }
+    }
+    /**
+     * Handle input value change
+     */
+    change(value) {
+        // Update internal value
+        this._value = value;
+        // Emit to template bindings
+        this.changeInput.emit(value);
+        this.valueChange.emit(value);
+        // Call service handler
+        if (this.chatConfig) {
+            this.chatConfig.changeInput(value);
+        }
+        // Call provided handler
+        if (this.changeHandler) {
+            this.changeHandler(value);
+        }
+    }
+    updateConfiguration() {
+        if (!this.chatConfig) {
+            return;
+        }
+        // Update labels if provided
+        if (this.labels) {
+            this.chatConfig.setLabels(this.labels);
+        }
+        // Update input value if provided
+        const valueToSet = this._value !== undefined ? this._value : this.inputValue;
+        if (valueToSet !== undefined) {
+            this.chatConfig.setInputValue(valueToSet);
+        }
+    }
+    updateInputValue(value) {
+        if (this.chatConfig) {
+            this.chatConfig.setInputValue(value);
+            this.chatConfig.changeInput(value);
+        }
+    }
+    setupHandlers() {
+        if (!this.chatConfig) {
+            return;
+        }
+        // Create composite handlers that call both service and directive handlers
+        const submitComposite = (value) => {
+            this.submitInput.emit(value);
+            if (this.submitHandler) {
+                this.submitHandler(value);
+            }
+        };
+        const changeComposite = (value) => {
+            this.changeInput.emit(value);
+            this.valueChange.emit(value);
+            if (this.changeHandler) {
+                this.changeHandler(value);
+            }
+        };
+        // Set handlers on the service
+        this.chatConfig.setSubmitHandler(submitComposite);
+        this.chatConfig.setChangeHandler(changeComposite);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitChatConfigDirective, deps: [{ token: CopilotChatConfigurationService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitChatConfigDirective, isStandalone: true, selector: "[copilotkitChatConfig]", inputs: { labels: "labels", inputValue: "inputValue", config: ["copilotkitChatConfig", "config"], value: "value" }, outputs: { submitInput: "submitInput", changeInput: "changeInput", valueChange: "valueChange" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitChatConfigDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitChatConfig]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotChatConfigurationService, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CopilotChatConfigurationService]
+                }] }], propDecorators: { labels: [{
+                type: Input
+            }], inputValue: [{
+                type: Input
+            }], submitInput: [{
+                type: Output
+            }], changeInput: [{
+                type: Output
+            }], config: [{
+                type: Input,
+                args: ["copilotkitChatConfig"]
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilotkit-chat-config.directive.js","sourceRoot":"","sources":["../../../src/directives/copilotkit-chat-config.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  Input,\n  Output,\n  EventEmitter,\n  OnInit,\n  OnChanges,\n  OnDestroy,\n  SimpleChanges,\n  Optional,\n  isDevMode,\n  Inject,\n} 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 * Directive for configuring CopilotKit chat settings declaratively in templates.\n * Works with the CopilotChatConfigurationService to provide reactive chat configuration.\n *\n * @example\n * ```html\n * <!-- Basic usage with individual inputs -->\n * <div copilotkitChatConfig\n *      [labels]=\"customLabels\"\n *      [inputValue]=\"currentInput\"\n *      (submitInput)=\"onSubmit($event)\"\n *      (changeInput)=\"onChange($event)\">\n *   <!-- Chat UI components -->\n * </div>\n *\n * <!-- Using configuration object -->\n * <div [copilotkitChatConfig]=\"chatConfig\">\n *   <!-- Chat UI components -->\n * </div>\n *\n * <!-- Two-way binding for input value -->\n * <div copilotkitChatConfig\n *      [(value)]=\"chatInput\"\n *      (submitInput)=\"handleSubmit($event)\">\n *   <!-- Chat UI components -->\n * </div>\n * ```\n */\n@Directive({\n  selector: \"[copilotkitChatConfig]\",\n  standalone: true,\n})\nexport class CopilotKitChatConfigDirective\n  implements OnInit, OnChanges, OnDestroy\n{\n  private _value?: string;\n  private submitHandler?: (value: string) => void;\n  private changeHandler?: (value: string) => void;\n\n  constructor(\n    @Optional()\n    @Inject(CopilotChatConfigurationService)\n    private readonly chatConfig: CopilotChatConfigurationService | null\n  ) {}\n\n  /**\n   * Partial labels to override defaults\n   */\n  @Input() labels?: Partial<CopilotChatLabels>;\n\n  /**\n   * The current input value\n   */\n  @Input() inputValue?: string;\n\n  /**\n   * Event emitted when input is submitted\n   */\n  @Output() submitInput = new EventEmitter<string>();\n\n  /**\n   * Event emitted when input value changes\n   */\n  @Output() changeInput = new EventEmitter<string>();\n\n  /**\n   * Alternative: accept full configuration object\n   */\n  @Input(\"copilotkitChatConfig\")\n  set config(value: CopilotChatConfiguration | undefined) {\n    if (value) {\n      if (value.labels) this.labels = value.labels;\n      if (value.inputValue !== undefined) this.inputValue = value.inputValue;\n      // Store handlers for later setup\n      if (value.onSubmitInput) this.submitHandler = value.onSubmitInput;\n      if (value.onChangeInput) this.changeHandler = value.onChangeInput;\n    }\n  }\n\n  /**\n   * Two-way binding for input value\n   */\n  @Input()\n  get value(): string | undefined {\n    return this._value;\n  }\n  set value(v: string | undefined) {\n    this._value = v;\n    this.valueChange.emit(v);\n    if (v !== undefined) {\n      this.updateInputValue(v);\n    }\n  }\n\n  /**\n   * Two-way binding output for value\n   */\n  @Output() valueChange = new EventEmitter<string | undefined>();\n\n  ngOnInit(): void {\n    if (!this.chatConfig) {\n      if (isDevMode()) {\n        console.warn(\n          \"CopilotKitChatConfigDirective: No CopilotChatConfigurationService found. \" +\n            \"Make sure to provide it using provideCopilotChatConfiguration().\"\n        );\n      }\n      return;\n    }\n\n    this.updateConfiguration();\n    this.setupHandlers();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this.chatConfig) {\n      return;\n    }\n\n    const relevantChanges =\n      changes[\"labels\"] || changes[\"inputValue\"] || changes[\"value\"];\n\n    if (relevantChanges && !relevantChanges.firstChange) {\n      this.updateConfiguration();\n    }\n  }\n\n  ngOnDestroy(): void {\n    // Cleanup if needed\n  }\n\n  /**\n   * Submit the current input value\n   */\n  submit(value: string): void {\n    // Emit to template binding\n    this.submitInput.emit(value);\n\n    // Call service handler\n    if (this.chatConfig) {\n      this.chatConfig.submitInput(value);\n    }\n\n    // Call provided handler\n    if (this.submitHandler) {\n      this.submitHandler(value);\n    }\n  }\n\n  /**\n   * Handle input value change\n   */\n  change(value: string): void {\n    // Update internal value\n    this._value = value;\n\n    // Emit to template bindings\n    this.changeInput.emit(value);\n    this.valueChange.emit(value);\n\n    // Call service handler\n    if (this.chatConfig) {\n      this.chatConfig.changeInput(value);\n    }\n\n    // Call provided handler\n    if (this.changeHandler) {\n      this.changeHandler(value);\n    }\n  }\n\n  private updateConfiguration(): void {\n    if (!this.chatConfig) {\n      return;\n    }\n\n    // Update labels if provided\n    if (this.labels) {\n      this.chatConfig.setLabels(this.labels);\n    }\n\n    // Update input value if provided\n    const valueToSet =\n      this._value !== undefined ? this._value : this.inputValue;\n    if (valueToSet !== undefined) {\n      this.chatConfig.setInputValue(valueToSet);\n    }\n  }\n\n  private updateInputValue(value: string): void {\n    if (this.chatConfig) {\n      this.chatConfig.setInputValue(value);\n      this.chatConfig.changeInput(value);\n    }\n  }\n\n  private setupHandlers(): void {\n    if (!this.chatConfig) {\n      return;\n    }\n\n    // Create composite handlers that call both service and directive handlers\n    const submitComposite = (value: string) => {\n      this.submitInput.emit(value);\n      if (this.submitHandler) {\n        this.submitHandler(value);\n      }\n    };\n\n    const changeComposite = (value: string) => {\n      this.changeInput.emit(value);\n      this.valueChange.emit(value);\n      if (this.changeHandler) {\n        this.changeHandler(value);\n      }\n    };\n\n    // Set handlers on the service\n    this.chatConfig.setSubmitHandler(submitComposite);\n    this.chatConfig.setChangeHandler(changeComposite);\n  }\n}\n"]}