@copilotkitnext/angular 0.0.0-max-changeset-20260109174803

package/dist/esm2022/lib/components/chat/copilot-chat.mjs

@@ -0,0 +1,167 @@
+import { Component, input, ChangeDetectionStrategy, ViewEncapsulation, signal, effect, ChangeDetectorRef, Injector, computed, inject, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { CopilotChatView } from "./copilot-chat-view";
+import { DEFAULT_AGENT_ID, randomUUID } from "@copilotkitnext/shared";
+import { injectAgentStore } from "../../agent";
+import { ChatState } from "../../chat-state";
+import * as i0 from "@angular/core";
+/**
+ * CopilotChat component - Angular equivalent of React's <CopilotChat>
+ * Provides a complete chat interface that wires an agent to the chat view
+ *
+ * @example
+ * ```html
+ * <copilot-chat [agentId]="'default'" [threadId]="'abc123'"></copilot-chat>
+ * ```
+ */
+export class CopilotChat {
+    inputValue = signal("");
+    agentId = input();
+    threadId = input();
+    inputComponent = input();
+    resolvedAgentId = computed(() => this.agentId() ?? DEFAULT_AGENT_ID);
+    agentStore = injectAgentStore(this.resolvedAgentId);
+    // readonly chatConfig = injectChatConfig();
+    cdr = inject(ChangeDetectorRef);
+    injector = inject(Injector);
+    messages = computed(() => this.agentStore()?.messages());
+    isRunning = computed(() => this.agentStore()?.isRunning());
+    showCursor = signal(false);
+    generatedThreadId = randomUUID();
+    hasConnectedOnce = false;
+    constructor() {
+        // Connect once when agent becomes available
+        // Connect once when agent becomes available
+        effect(() => {
+            const a = this.agentStore()?.agent;
+            if (!a)
+                return;
+            // Apply thread id when agent is available
+            a.threadId = this.threadId() || this.generatedThreadId;
+            if (!this.hasConnectedOnce) {
+                this.hasConnectedOnce = true;
+                if ("isCopilotKitAgent" in a) {
+                    this.connectToAgent(a);
+                }
+                else {
+                    // Non-CopilotKit agent: nothing to connect; keep default cursor state
+                }
+            }
+        }, { allowSignalWrites: true });
+        // Keep agent threadId in sync with input
+        effect(() => {
+            const a = this.agentStore()?.agent;
+            if (a) {
+                a.threadId = this.threadId() || this.generatedThreadId;
+            }
+        });
+    }
+    async connectToAgent(agent) {
+        if (!agent)
+            return;
+        this.showCursor.set(true);
+        this.cdr.markForCheck();
+        try {
+            await agent.runAgent({ forwardedProps: { __copilotkitConnect: true } }, {
+                onTextMessageStartEvent: () => {
+                    this.showCursor.set(false);
+                    this.cdr.detectChanges();
+                },
+                onToolCallStartEvent: () => {
+                    this.showCursor.set(false);
+                    this.cdr.detectChanges();
+                },
+            });
+            this.showCursor.set(false);
+            this.cdr.markForCheck();
+        }
+        catch (error) {
+            console.error("Failed to connect to agent:", error);
+            this.showCursor.set(false);
+            this.cdr.markForCheck();
+        }
+    }
+    async submitInput(value) {
+        const agent = this.agentStore()?.agent;
+        if (!agent || !value.trim())
+            return;
+        // Add user message
+        const userMessage = {
+            id: randomUUID(),
+            role: "user",
+            content: value,
+        };
+        agent.addMessage(userMessage);
+        // Clear the input
+        this.inputValue.set("");
+        // Show cursor while processing
+        this.showCursor.set(true);
+        this.cdr.markForCheck();
+        // Run the agent with named subscriber callbacks
+        try {
+            await agent.runAgent({}, {
+                onTextMessageStartEvent: () => {
+                    this.showCursor.set(false);
+                    this.cdr.detectChanges();
+                },
+                onToolCallStartEvent: () => {
+                    this.showCursor.set(false);
+                    this.cdr.detectChanges();
+                },
+            });
+        }
+        catch (error) {
+            console.error("Agent run error:", error);
+        }
+        finally {
+            this.showCursor.set(false);
+            this.cdr.markForCheck();
+        }
+    }
+    changeInput(value) {
+        this.inputValue.set(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CopilotChat, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: CopilotChat, isStandalone: true, selector: "copilot-chat", inputs: { agentId: { classPropertyName: "agentId", publicName: "agentId", isSignal: true, isRequired: false, transformFunction: null }, threadId: { classPropertyName: "threadId", publicName: "threadId", isSignal: true, isRequired: false, transformFunction: null }, inputComponent: { classPropertyName: "inputComponent", publicName: "inputComponent", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: ChatState,
+                useExisting: CopilotChat,
+            },
+        ], ngImport: i0, template: `
+    <copilot-chat-view
+      [messages]="messages() ?? []"
+      [autoScroll]="true"
+      [messageViewClass]="'w-full'"
+      [showCursor]="showCursor()"
+      [inputComponent]="inputComponent()"
+    >
+    </copilot-chat-view>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: CopilotChatView, selector: "copilot-chat-view", inputs: ["messages", "autoScroll", "showCursor", "messageViewComponent", "messageViewTemplate", "messageViewClass", "scrollViewComponent", "scrollViewTemplate", "scrollViewClass", "scrollToBottomButtonComponent", "scrollToBottomButtonTemplate", "scrollToBottomButtonClass", "inputComponent", "inputTemplate", "inputContainerComponent", "inputContainerTemplate", "inputContainerClass", "featherComponent", "featherTemplate", "featherClass", "disclaimerComponent", "disclaimerTemplate", "disclaimerClass", "disclaimerText"], outputs: ["assistantMessageThumbsUp", "assistantMessageThumbsDown", "assistantMessageReadAloud", "assistantMessageRegenerate", "userMessageCopy", "userMessageEdit"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CopilotChat, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "copilot-chat",
+                    standalone: true,
+                    imports: [CommonModule, CopilotChatView],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <copilot-chat-view
+      [messages]="messages() ?? []"
+      [autoScroll]="true"
+      [messageViewClass]="'w-full'"
+      [showCursor]="showCursor()"
+      [inputComponent]="inputComponent()"
+    >
+    </copilot-chat-view>
+  `,
+                    providers: [
+                        {
+                            provide: ChatState,
+                            useExisting: CopilotChat,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-chat.js","sourceRoot":"","sources":["../../../../../src/lib/components/chat/copilot-chat.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  input,\n  ChangeDetectionStrategy,\n  ViewEncapsulation,\n  signal,\n  effect,\n  ChangeDetectorRef,\n  Injector,\n  Type,\n  computed,\n  inject,\n} from \"@angular/core\";\nimport { CommonModule } from \"@angular/common\";\nimport { CopilotChatView } from \"./copilot-chat-view\";\n\nimport { DEFAULT_AGENT_ID, randomUUID } from \"@copilotkitnext/shared\";\nimport { Message, AbstractAgent } from \"@ag-ui/client\";\nimport { injectAgentStore } from \"../../agent\";\nimport { ChatState } from \"../../chat-state\";\n\n/**\n * CopilotChat component - Angular equivalent of React's <CopilotChat>\n * Provides a complete chat interface that wires an agent to the chat view\n *\n * @example\n * ```html\n * <copilot-chat [agentId]=\"'default'\" [threadId]=\"'abc123'\"></copilot-chat>\n * ```\n */\n@Component({\n  selector: \"copilot-chat\",\n  standalone: true,\n  imports: [CommonModule, CopilotChatView],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  template: `\n    <copilot-chat-view\n      [messages]=\"messages() ?? []\"\n      [autoScroll]=\"true\"\n      [messageViewClass]=\"'w-full'\"\n      [showCursor]=\"showCursor()\"\n      [inputComponent]=\"inputComponent()\"\n    >\n    </copilot-chat-view>\n  `,\n  providers: [\n    {\n      provide: ChatState,\n      useExisting: CopilotChat,\n    },\n  ],\n})\nexport class CopilotChat implements ChatState {\n  readonly inputValue = signal<string>(\"\");\n  readonly agentId = input<string | undefined>();\n  readonly threadId = input<string | undefined>();\n  readonly inputComponent = input<Type<any> | undefined>();\n  private readonly resolvedAgentId = computed(\n    () => this.agentId() ?? DEFAULT_AGENT_ID\n  );\n  readonly agentStore = injectAgentStore(this.resolvedAgentId);\n  // readonly chatConfig = injectChatConfig();\n  readonly cdr = inject(ChangeDetectorRef);\n  readonly injector = inject(Injector);\n\n  protected messages = computed(() => this.agentStore()?.messages());\n  protected isRunning = computed(() => this.agentStore()?.isRunning());\n  protected showCursor = signal<boolean>(false);\n\n  private generatedThreadId: string = randomUUID();\n  private hasConnectedOnce = false;\n\n  constructor() {\n    // Connect once when agent becomes available\n    // Connect once when agent becomes available\n    effect(\n      () => {\n        const a = this.agentStore()?.agent;\n        if (!a) return;\n        // Apply thread id when agent is available\n        a.threadId = this.threadId() || this.generatedThreadId;\n        if (!this.hasConnectedOnce) {\n          this.hasConnectedOnce = true;\n          if (\"isCopilotKitAgent\" in (a as any)) {\n            this.connectToAgent(a);\n          } else {\n            // Non-CopilotKit agent: nothing to connect; keep default cursor state\n          }\n        }\n      },\n      { allowSignalWrites: true }\n    );\n\n    // Keep agent threadId in sync with input\n    effect(() => {\n      const a = this.agentStore()?.agent;\n      if (a) {\n        a.threadId = this.threadId() || this.generatedThreadId;\n      }\n    });\n  }\n\n  private async connectToAgent(agent: AbstractAgent): Promise<void> {\n    if (!agent) return;\n\n    this.showCursor.set(true);\n    this.cdr.markForCheck();\n\n    try {\n      await agent.runAgent(\n        { forwardedProps: { __copilotkitConnect: true } },\n        {\n          onTextMessageStartEvent: () => {\n            this.showCursor.set(false);\n            this.cdr.detectChanges();\n          },\n          onToolCallStartEvent: () => {\n            this.showCursor.set(false);\n            this.cdr.detectChanges();\n          },\n        }\n      );\n      this.showCursor.set(false);\n      this.cdr.markForCheck();\n    } catch (error) {\n      console.error(\"Failed to connect to agent:\", error);\n      this.showCursor.set(false);\n      this.cdr.markForCheck();\n    }\n  }\n\n  async submitInput(value: string): Promise<void> {\n    const agent = this.agentStore()?.agent;\n    if (!agent || !value.trim()) return;\n\n    // Add user message\n    const userMessage: Message = {\n      id: randomUUID(),\n      role: \"user\",\n      content: value,\n    };\n    agent.addMessage(userMessage);\n\n    // Clear the input\n    this.inputValue.set(\"\");\n\n    // Show cursor while processing\n    this.showCursor.set(true);\n    this.cdr.markForCheck();\n\n    // Run the agent with named subscriber callbacks\n    try {\n      await agent.runAgent(\n        {},\n        {\n          onTextMessageStartEvent: () => {\n            this.showCursor.set(false);\n            this.cdr.detectChanges();\n          },\n          onToolCallStartEvent: () => {\n            this.showCursor.set(false);\n            this.cdr.detectChanges();\n          },\n        }\n      );\n    } catch (error) {\n      console.error(\"Agent run error:\", error);\n    } finally {\n      this.showCursor.set(false);\n      this.cdr.markForCheck();\n    }\n  }\n\n  changeInput(value: string): void {\n    this.inputValue.set(value);\n  }\n}\n"]}

package/dist/esm2022/lib/config.mjs

@@ -0,0 +1,9 @@
+import { inject, InjectionToken } from "@angular/core";
+export const COPILOT_KIT_CONFIG = new InjectionToken("COPILOT_KIT_CONFIG");
+export function injectCopilotKitConfig() {
+    return inject(COPILOT_KIT_CONFIG);
+}
+export function provideCopilotKit(config) {
+    return { provide: COPILOT_KIT_CONFIG, useValue: config };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQVksTUFBTSxlQUFlLENBQUM7QUFvQmpFLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLElBQUksY0FBYyxDQUNsRCxvQkFBb0IsQ0FDckIsQ0FBQztBQUVGLE1BQU0sVUFBVSxzQkFBc0I7SUFDcEMsT0FBTyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQztBQUNwQyxDQUFDO0FBRUQsTUFBTSxVQUFVLGlCQUFpQixDQUFDLE1BQXdCO0lBQ3hELE9BQU8sRUFBRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpbmplY3QsIEluamVjdGlvblRva2VuLCBQcm92aWRlciB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBBYnN0cmFjdEFnZW50IH0gZnJvbSBcIkBhZy11aS9jbGllbnRcIjtcbmltcG9ydCB7XG4gIENsaWVudFRvb2wsXG4gIEZyb250ZW5kVG9vbENvbmZpZyxcbiAgSHVtYW5JblRoZUxvb3BDb25maWcsXG4gIFJlbmRlclRvb2xDYWxsQ29uZmlnLFxufSBmcm9tIFwiLi90b29sc1wiO1xuXG5leHBvcnQgaW50ZXJmYWNlIENvcGlsb3RLaXRDb25maWcge1xuICBydW50aW1lVXJsPzogc3RyaW5nO1xuICBoZWFkZXJzPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcbiAgcHJvcGVydGllcz86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xuICBhZ2VudHM/OiBSZWNvcmQ8c3RyaW5nLCBBYnN0cmFjdEFnZW50PjtcbiAgdG9vbHM/OiBDbGllbnRUb29sW107XG4gIHJlbmRlclRvb2xDYWxscz86IFJlbmRlclRvb2xDYWxsQ29uZmlnW107XG4gIGZyb250ZW5kVG9vbHM/OiBGcm9udGVuZFRvb2xDb25maWdbXTtcbiAgaHVtYW5JblRoZUxvb3A/OiBIdW1hbkluVGhlTG9vcENvbmZpZ1tdO1xufVxuXG5leHBvcnQgY29uc3QgQ09QSUxPVF9LSVRfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPENvcGlsb3RLaXRDb25maWc+KFxuICBcIkNPUElMT1RfS0lUX0NPTkZJR1wiXG4pO1xuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0Q29waWxvdEtpdENvbmZpZygpOiBDb3BpbG90S2l0Q29uZmlnIHtcbiAgcmV0dXJuIGluamVjdChDT1BJTE9UX0tJVF9DT05GSUcpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZUNvcGlsb3RLaXQoY29uZmlnOiBDb3BpbG90S2l0Q29uZmlnKTogUHJvdmlkZXIge1xuICByZXR1cm4geyBwcm92aWRlOiBDT1BJTE9UX0tJVF9DT05GSUcsIHVzZVZhbHVlOiBjb25maWcgfTtcbn1cbiJdfQ==

package/dist/esm2022/lib/copilotkit.mjs

@@ -0,0 +1,115 @@
+import { CopilotKitCore } from "@copilotkitnext/core";
+import { Injectable, Injector, runInInjectionContext, signal, inject } from "@angular/core";
+import { injectCopilotKitConfig } from "./config";
+import { HumanInTheLoop } from "./human-in-the-loop";
+import * as i0 from "@angular/core";
+export class CopilotKit {
+    #config = injectCopilotKitConfig();
+    #hitl = inject(HumanInTheLoop);
+    #rootInjector = inject(Injector);
+    #agents = signal(this.#config.agents ?? {});
+    agents = this.#agents.asReadonly();
+    core = new CopilotKitCore({
+        runtimeUrl: this.#config.runtimeUrl,
+        headers: this.#config.headers,
+        properties: this.#config.properties,
+        agents__unsafe_dev_only: this.#config.agents,
+        tools: this.#config.tools,
+    });
+    #toolCallRenderConfigs = signal([]);
+    #clientToolCallRenderConfigs = signal([]);
+    #humanInTheLoopToolRenderConfigs = signal([]);
+    toolCallRenderConfigs = this.#toolCallRenderConfigs.asReadonly();
+    clientToolCallRenderConfigs = this.#clientToolCallRenderConfigs.asReadonly();
+    humanInTheLoopToolRenderConfigs = this.#humanInTheLoopToolRenderConfigs.asReadonly();
+    constructor() {
+        this.#config.renderToolCalls?.forEach((renderConfig) => {
+            this.addRenderToolCall(renderConfig);
+        });
+        this.#config.tools?.forEach((tool) => {
+            if (tool.renderer && tool.parameters) {
+                this.addRenderToolCall({
+                    name: tool.name,
+                    args: tool.parameters,
+                    component: tool.renderer,
+                    agentId: tool.agentId,
+                });
+            }
+        });
+        this.#config.frontendTools?.forEach((clientTool) => {
+            this.addFrontendTool({ ...clientTool, injector: this.#rootInjector });
+        });
+        this.#config.humanInTheLoop?.forEach((humanInTheLoopTool) => {
+            this.addHumanInTheLoop(humanInTheLoopTool);
+        });
+        this.core.subscribe({
+            onAgentsChanged: () => {
+                this.#agents.set(this.core.agents);
+            },
+        });
+    }
+    #bindClientTool(clientToolWithInjector) {
+        const { injector, handler, ...frontendCandidate } = clientToolWithInjector;
+        return {
+            ...frontendCandidate,
+            handler: (args) => runInInjectionContext(injector, () => handler(args)),
+        };
+    }
+    addFrontendTool(clientToolWithInjector) {
+        const tool = this.#bindClientTool(clientToolWithInjector);
+        this.core.addTool(tool);
+        this.#clientToolCallRenderConfigs.update((current) => [...current, clientToolWithInjector]);
+    }
+    addRenderToolCall(renderConfig) {
+        this.#toolCallRenderConfigs.update((current) => [...current, renderConfig]);
+    }
+    #bindHumanInTheLoopTool(humanInTheLoopTool) {
+        return {
+            ...humanInTheLoopTool,
+            handler: (args, toolCall) => {
+                return this.#hitl.onResult(toolCall.id, humanInTheLoopTool.name);
+            },
+        };
+    }
+    addHumanInTheLoop(humanInTheLoopTool) {
+        this.#humanInTheLoopToolRenderConfigs.update((current) => [...current, humanInTheLoopTool]);
+        const tool = this.#bindHumanInTheLoopTool(humanInTheLoopTool);
+        this.core.addTool(tool);
+    }
+    #isSameAgentId(target, agentId) {
+        if (agentId) {
+            return target.agentId === agentId;
+        }
+        return true;
+    }
+    removeTool(toolName, agentId) {
+        this.core.removeTool(toolName);
+        this.#clientToolCallRenderConfigs.update((current) => current.filter((renderConfig) => renderConfig.name !== toolName && this.#isSameAgentId(renderConfig, agentId)));
+        this.#humanInTheLoopToolRenderConfigs.update((current) => current.filter((renderConfig) => renderConfig.name !== toolName && this.#isSameAgentId(renderConfig, agentId)));
+        this.#toolCallRenderConfigs.update((current) => current.filter((renderConfig) => renderConfig.name !== toolName && this.#isSameAgentId(renderConfig, agentId)));
+    }
+    getAgent(agentId) {
+        return this.core.getAgent(agentId);
+    }
+    updateRuntime(options) {
+        if (options.runtimeUrl !== undefined) {
+            this.core.setRuntimeUrl(options.runtimeUrl);
+        }
+        if (options.headers !== undefined) {
+            this.core.setHeaders(options.headers);
+        }
+        if (options.properties !== undefined) {
+            this.core.setProperties(options.properties);
+        }
+        if (options.agents !== undefined) {
+            this.core.setAgents__unsafe_dev_only(options.agents);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CopilotKit, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CopilotKit, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CopilotKit, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilotkit.js","sourceRoot":"","sources":["../../../src/lib/copilotkit.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractAgent } from \"@ag-ui/client\";\nimport { FrontendTool, CopilotKitCore } from \"@copilotkitnext/core\";\nimport { Injectable, Injector, Signal, WritableSignal, runInInjectionContext, signal, inject } from \"@angular/core\";\nimport { FrontendToolConfig, HumanInTheLoopConfig, RenderToolCallConfig } from \"./tools\";\nimport { injectCopilotKitConfig } from \"./config\";\nimport { HumanInTheLoop } from \"./human-in-the-loop\";\n\n@Injectable({ providedIn: \"root\" })\nexport class CopilotKit {\n  readonly #config = injectCopilotKitConfig();\n  readonly #hitl = inject(HumanInTheLoop);\n  readonly #rootInjector = inject(Injector);\n  readonly #agents = signal<Record<string, AbstractAgent>>(this.#config.agents ?? {});\n  readonly agents = this.#agents.asReadonly();\n\n  readonly core = new CopilotKitCore({\n    runtimeUrl: this.#config.runtimeUrl,\n    headers: this.#config.headers,\n    properties: this.#config.properties,\n    agents__unsafe_dev_only: this.#config.agents,\n    tools: this.#config.tools,\n  });\n\n  readonly #toolCallRenderConfigs: WritableSignal<RenderToolCallConfig[]> = signal([]);\n  readonly #clientToolCallRenderConfigs: WritableSignal<FrontendToolConfig[]> = signal([]);\n  readonly #humanInTheLoopToolRenderConfigs: WritableSignal<HumanInTheLoopConfig[]> = signal([]);\n\n  readonly toolCallRenderConfigs: Signal<RenderToolCallConfig[]> = this.#toolCallRenderConfigs.asReadonly();\n  readonly clientToolCallRenderConfigs: Signal<FrontendToolConfig[]> = this.#clientToolCallRenderConfigs.asReadonly();\n  readonly humanInTheLoopToolRenderConfigs: Signal<HumanInTheLoopConfig[]> =\n    this.#humanInTheLoopToolRenderConfigs.asReadonly();\n\n  constructor() {\n    this.#config.renderToolCalls?.forEach((renderConfig) => {\n      this.addRenderToolCall(renderConfig);\n    });\n\n    this.#config.tools?.forEach((tool) => {\n      if (tool.renderer && tool.parameters) {\n        this.addRenderToolCall({\n          name: tool.name,\n          args: tool.parameters,\n          component: tool.renderer,\n          agentId: tool.agentId,\n        });\n      }\n    });\n\n    this.#config.frontendTools?.forEach((clientTool) => {\n      this.addFrontendTool({ ...clientTool, injector: this.#rootInjector });\n    });\n\n    this.#config.humanInTheLoop?.forEach((humanInTheLoopTool) => {\n      this.addHumanInTheLoop(humanInTheLoopTool);\n    });\n\n    this.core.subscribe({\n      onAgentsChanged: () => {\n        this.#agents.set(this.core.agents);\n      },\n    });\n  }\n\n  #bindClientTool(\n    clientToolWithInjector: FrontendToolConfig & {\n      injector: Injector;\n    },\n  ): FrontendTool {\n    const { injector, handler, ...frontendCandidate } = clientToolWithInjector;\n\n    return {\n      ...frontendCandidate,\n      handler: (args) => runInInjectionContext(injector, () => handler(args)),\n    };\n  }\n\n  addFrontendTool(\n    clientToolWithInjector: FrontendToolConfig & {\n      injector: Injector;\n    },\n  ): void {\n    const tool = this.#bindClientTool(clientToolWithInjector);\n\n    this.core.addTool(tool);\n\n    this.#clientToolCallRenderConfigs.update((current) => [...current, clientToolWithInjector]);\n  }\n\n  addRenderToolCall(renderConfig: RenderToolCallConfig): void {\n    this.#toolCallRenderConfigs.update((current) => [...current, renderConfig]);\n  }\n\n  #bindHumanInTheLoopTool(humanInTheLoopTool: HumanInTheLoopConfig): FrontendTool {\n    return {\n      ...humanInTheLoopTool,\n      handler: (args, toolCall) => {\n        return this.#hitl.onResult(toolCall.id, humanInTheLoopTool.name);\n      },\n    };\n  }\n\n  addHumanInTheLoop(humanInTheLoopTool: HumanInTheLoopConfig): void {\n    this.#humanInTheLoopToolRenderConfigs.update((current) => [...current, humanInTheLoopTool]);\n\n    const tool = this.#bindHumanInTheLoopTool(humanInTheLoopTool);\n\n    this.core.addTool(tool);\n  }\n\n  #isSameAgentId<T extends { agentId?: string }>(target: T, agentId?: string): boolean {\n    if (agentId) {\n      return target.agentId === agentId;\n    }\n\n    return true;\n  }\n\n  removeTool(toolName: string, agentId?: string): void {\n    this.core.removeTool(toolName);\n    this.#clientToolCallRenderConfigs.update((current) =>\n      current.filter((renderConfig) => renderConfig.name !== toolName && this.#isSameAgentId(renderConfig, agentId)),\n    );\n    this.#humanInTheLoopToolRenderConfigs.update((current) =>\n      current.filter((renderConfig) => renderConfig.name !== toolName && this.#isSameAgentId(renderConfig, agentId)),\n    );\n    this.#toolCallRenderConfigs.update((current) =>\n      current.filter((renderConfig) => renderConfig.name !== toolName && this.#isSameAgentId(renderConfig, agentId)),\n    );\n  }\n\n  getAgent(agentId: string): AbstractAgent | undefined {\n    return this.core.getAgent(agentId);\n  }\n\n  updateRuntime(options: {\n    runtimeUrl?: string;\n    headers?: Record<string, string>;\n    properties?: Record<string, unknown>;\n    agents?: Record<string, AbstractAgent>;\n  }): void {\n    if (options.runtimeUrl !== undefined) {\n      this.core.setRuntimeUrl(options.runtimeUrl);\n    }\n    if (options.headers !== undefined) {\n      this.core.setHeaders(options.headers);\n    }\n    if (options.properties !== undefined) {\n      this.core.setProperties(options.properties);\n    }\n    if (options.agents !== undefined) {\n      this.core.setAgents__unsafe_dev_only(options.agents);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,130 @@
+import { Directive, Input, Inject, } from "@angular/core";
+import { CopilotKit } from "../copilotkit";
+import * as i0 from "@angular/core";
+import * as i1 from "../copilotkit";
+/**
+ * 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 CopilotKitAgentContext {
+    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.core.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.core.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.14", ngImport: i0, type: CopilotKitAgentContext, deps: [{ token: CopilotKit }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: CopilotKitAgentContext, 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.14", ngImport: i0, type: CopilotKitAgentContext, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitAgentContext]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotKit, decorators: [{
+                    type: Inject,
+                    args: [CopilotKit]
+                }] }], propDecorators: { context: [{
+                type: Input,
+                args: ["copilotkitAgentContext"]
+            }], description: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29waWxvdGtpdC1hZ2VudC1jb250ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9kaXJlY3RpdmVzL2NvcGlsb3RraXQtYWdlbnQtY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsU0FBUyxFQUNULEtBQUssRUFLTCxNQUFNLEdBQ1AsTUFBTSxlQUFlLENBQUM7QUFDdkIsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBRzNDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBS0gsTUFBTSxPQUFPLHNCQUFzQjtJQUdnQjtJQUZ6QyxTQUFTLENBQVU7SUFFM0IsWUFBaUQsVUFBc0I7UUFBdEIsZUFBVSxHQUFWLFVBQVUsQ0FBWTtJQUFHLENBQUM7SUFFM0U7OztPQUdHO0lBQzhCLE9BQU8sQ0FBVztJQUVuRDs7O09BR0c7SUFDTSxXQUFXLENBQVU7SUFFOUI7OztPQUdHO0lBQ00sS0FBSyxDQUFPO0lBRXJCLFFBQVE7UUFDTixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDcEIsQ0FBQztJQUVELFdBQVcsQ0FBQyxPQUFzQjtRQUNoQywwQ0FBMEM7UUFDMUMsTUFBTSxnQkFBZ0IsR0FBRyxTQUFTLElBQUksT0FBTyxDQUFDO1FBQzlDLE1BQU0sb0JBQW9CLEdBQUcsYUFBYSxJQUFJLE9BQU8sQ0FBQztRQUN0RCxNQUFNLGNBQWMsR0FBRyxPQUFPLElBQUksT0FBTyxDQUFDO1FBRTFDLElBQUksZ0JBQWdCLElBQUksb0JBQW9CLElBQUksY0FBYyxFQUFFLENBQUM7WUFDL0QsMERBQTBEO1lBQzFELElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO2dCQUNuQixJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7WUFDdkIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRUQ7O09BRUc7SUFDSyxVQUFVO1FBQ2hCLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUV2QyxJQUFJLFlBQVksRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQ2pFLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSyxhQUFhO1FBQ25CLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUNyQixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDcEIsQ0FBQztJQUVEOztPQUVHO0lBQ0ssYUFBYTtRQUNuQixJQUFJLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUNuQixJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ25ELElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzdCLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSyxVQUFVO1FBQ2hCLHdDQUF3QztRQUN4QyxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNqQixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDdEIsQ0FBQztRQUVELDBDQUEwQztRQUMxQywyREFBMkQ7UUFDM0QsSUFBSSxJQUFJLENBQUMsV0FBVyxLQUFLLFNBQVMsSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQy9ELE9BQU87Z0JBQ0wsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXO2dCQUM3QixLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUs7YUFDbEIsQ0FBQztRQUNKLENBQUM7UUFFRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7d0dBN0ZVLHNCQUFzQixrQkFHYixVQUFVOzRGQUhuQixzQkFBc0I7OzRGQUF0QixzQkFBc0I7a0JBSmxDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLDBCQUEwQjtvQkFDcEMsVUFBVSxFQUFFLElBQUk7aUJBQ2pCOzswQkFJYyxNQUFNOzJCQUFDLFVBQVU7eUNBTUcsT0FBTztzQkFBdkMsS0FBSzt1QkFBQyx3QkFBd0I7Z0JBTXRCLFdBQVc7c0JBQW5CLEtBQUs7Z0JBTUcsS0FBSztzQkFBYixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRGlyZWN0aXZlLFxuICBJbnB1dCxcbiAgT25Jbml0LFxuICBPbkNoYW5nZXMsXG4gIE9uRGVzdHJveSxcbiAgU2ltcGxlQ2hhbmdlcyxcbiAgSW5qZWN0LFxufSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgQ29waWxvdEtpdCB9IGZyb20gXCIuLi9jb3BpbG90a2l0XCI7XG5pbXBvcnQgdHlwZSB7IENvbnRleHQgfSBmcm9tIFwiQGFnLXVpL2NsaWVudFwiO1xuXG4vKipcbiAqIERpcmVjdGl2ZSB0byBtYW5hZ2UgYWdlbnQgY29udGV4dCBpbiBDb3BpbG90S2l0LlxuICogQXV0b21hdGljYWxseSBhZGRzIGNvbnRleHQgb24gaW5pdCwgdXBkYXRlcyBvbiBjaGFuZ2VzLCBhbmQgcmVtb3ZlcyBvbiBkZXN0cm95LlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGBodG1sXG4gKiA8IS0tIFdpdGggc2VwYXJhdGUgaW5wdXRzIC0tPlxuICogPGRpdiBjb3BpbG90a2l0QWdlbnRDb250ZXh0XG4gKiAgICAgIFtkZXNjcmlwdGlvbl09XCInVXNlciBwcmVmZXJlbmNlcydcIlxuICogICAgICBbdmFsdWVdPVwidXNlclNldHRpbmdzXCI+XG4gKiA8L2Rpdj5cbiAqXG4gKiA8IS0tIFdpdGggY29udGV4dCBvYmplY3QgLS0+XG4gKiA8ZGl2IFtjb3BpbG90a2l0QWdlbnRDb250ZXh0XT1cImNvbnRleHRPYmplY3RcIj5cbiAqIDwvZGl2PlxuICpcbiAqIDwhLS0gV2l0aCBkeW5hbWljIHZhbHVlcyAtLT5cbiAqIDxkaXYgY29waWxvdGtpdEFnZW50Q29udGV4dFxuICogICAgICBkZXNjcmlwdGlvbj1cIkZvcm0gc3RhdGVcIlxuICogICAgICBbdmFsdWVdPVwiZm9ybURhdGEkIHwgYXN5bmNcIj5cbiAqIDwvZGl2PlxuICogYGBgXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogXCJbY29waWxvdGtpdEFnZW50Q29udGV4dF1cIixcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgQ29waWxvdEtpdEFnZW50Q29udGV4dCBpbXBsZW1lbnRzIE9uSW5pdCwgT25DaGFuZ2VzLCBPbkRlc3Ryb3kge1xuICBwcml2YXRlIGNvbnRleHRJZD86IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihASW5qZWN0KENvcGlsb3RLaXQpIHByaXZhdGUgcmVhZG9ubHkgY29waWxvdGtpdDogQ29waWxvdEtpdCkge31cblxuICAvKipcbiAgICogQ29udGV4dCBvYmplY3QgY29udGFpbmluZyBib3RoIGRlc2NyaXB0aW9uIGFuZCB2YWx1ZS5cbiAgICogSWYgcHJvdmlkZWQsIHRoaXMgdGFrZXMgcHJlY2VkZW5jZSBvdmVyIGluZGl2aWR1YWwgaW5wdXRzLlxuICAgKi9cbiAgQElucHV0KFwiY29waWxvdGtpdEFnZW50Q29udGV4dFwiKSBjb250ZXh0PzogQ29udGV4dDtcblxuICAvKipcbiAgICogRGVzY3JpcHRpb24gb2YgdGhlIGNvbnRleHQuXG4gICAqIFVzZWQgd2hlbiBjb250ZXh0IG9iamVjdCBpcyBub3QgcHJvdmlkZWQuXG4gICAqL1xuICBASW5wdXQoKSBkZXNjcmlwdGlvbj86IHN0cmluZztcblxuICAvKipcbiAgICogVmFsdWUgb2YgdGhlIGNvbnRleHQuXG4gICAqIFVzZWQgd2hlbiBjb250ZXh0IG9iamVjdCBpcyBub3QgcHJvdmlkZWQuXG4gICAqL1xuICBASW5wdXQoKSB2YWx1ZT86IGFueTtcblxuICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICB0aGlzLmFkZENvbnRleHQoKTtcbiAgfVxuXG4gIG5nT25DaGFuZ2VzKGNoYW5nZXM6IFNpbXBsZUNoYW5nZXMpOiB2b2lkIHtcbiAgICAvLyBDaGVjayBpZiBhbnkgcmVsZXZhbnQgaW5wdXQgaGFzIGNoYW5nZWRcbiAgICBjb25zdCBoYXNDb250ZXh0Q2hhbmdlID0gXCJjb250ZXh0XCIgaW4gY2hhbmdlcztcbiAgICBjb25zdCBoYXNEZXNjcmlwdGlvbkNoYW5nZSA9IFwiZGVzY3JpcHRpb25cIiBpbiBjaGFuZ2VzO1xuICAgIGNvbnN0IGhhc1ZhbHVlQ2hhbmdlID0gXCJ2YWx1ZVwiIGluIGNoYW5nZXM7XG5cbiAgICBpZiAoaGFzQ29udGV4dENoYW5nZSB8fCBoYXNEZXNjcmlwdGlvbkNoYW5nZSB8fCBoYXNWYWx1ZUNoYW5nZSkge1xuICAgICAgLy8gU2tpcCB0aGUgZmlyc3QgY2hhbmdlIGFzIG5nT25Jbml0IGhhbmRsZXMgaW5pdGlhbCBzZXR1cFxuICAgICAgaWYgKHRoaXMuY29udGV4dElkKSB7XG4gICAgICAgIHRoaXMudXBkYXRlQ29udGV4dCgpO1xuICAgICAgfVxuICAgIH1cbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIHRoaXMucmVtb3ZlQ29udGV4dCgpO1xuICB9XG5cbiAgLyoqXG4gICAqIEFkZHMgdGhlIGNvbnRleHQgdG8gQ29waWxvdEtpdFxuICAgKi9cbiAgcHJpdmF0ZSBhZGRDb250ZXh0KCk6IHZvaWQge1xuICAgIGNvbnN0IGNvbnRleHRUb0FkZCA9IHRoaXMuZ2V0Q29udGV4dCgpO1xuXG4gICAgaWYgKGNvbnRleHRUb0FkZCkge1xuICAgICAgdGhpcy5jb250ZXh0SWQgPSB0aGlzLmNvcGlsb3RraXQuY29yZS5hZGRDb250ZXh0KGNvbnRleHRUb0FkZCk7XG4gICAgfVxuICB9XG5cbiAgLyoqXG4gICAqIFVwZGF0ZXMgdGhlIGNvbnRleHQgYnkgcmVtb3ZpbmcgdGhlIG9sZCBvbmUgYW5kIGFkZGluZyBhIG5ldyBvbmVcbiAgICovXG4gIHByaXZhdGUgdXBkYXRlQ29udGV4dCgpOiB2b2lkIHtcbiAgICB0aGlzLnJlbW92ZUNvbnRleHQoKTtcbiAgICB0aGlzLmFkZENvbnRleHQoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZW1vdmVzIHRoZSBjdXJyZW50IGNvbnRleHQgZnJvbSBDb3BpbG90S2l0XG4gICAqL1xuICBwcml2YXRlIHJlbW92ZUNvbnRleHQoKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuY29udGV4dElkKSB7XG4gICAgICB0aGlzLmNvcGlsb3RraXQuY29yZS5yZW1vdmVDb250ZXh0KHRoaXMuY29udGV4dElkKTtcbiAgICAgIHRoaXMuY29udGV4dElkID0gdW5kZWZpbmVkO1xuICAgIH1cbiAgfVxuXG4gIC8qKlxuICAgKiBHZXRzIHRoZSBjb250ZXh0IG9iamVjdCBmcm9tIGlucHV0c1xuICAgKi9cbiAgcHJpdmF0ZSBnZXRDb250ZXh0KCk6IENvbnRleHQgfCBudWxsIHtcbiAgICAvLyBJZiBjb250ZXh0IG9iamVjdCBpcyBwcm92aWRlZCwgdXNlIGl0XG4gICAgaWYgKHRoaXMuY29udGV4dCkge1xuICAgICAgcmV0dXJuIHRoaXMuY29udGV4dDtcbiAgICB9XG5cbiAgICAvLyBPdGhlcndpc2UsIGJ1aWxkIGZyb20gaW5kaXZpZHVhbCBpbnB1dHNcbiAgICAvLyBOb3RlOiBudWxsIGlzIGEgdmFsaWQgdmFsdWUsIGJ1dCB1bmRlZmluZWQgbWVhbnMgbm90IHNldFxuICAgIGlmICh0aGlzLmRlc2NyaXB0aW9uICE9PSB1bmRlZmluZWQgJiYgdGhpcy52YWx1ZSAhPT0gdW5kZWZpbmVkKSB7XG4gICAgICByZXR1cm4ge1xuICAgICAgICBkZXNjcmlwdGlvbjogdGhpcy5kZXNjcmlwdGlvbixcbiAgICAgICAgdmFsdWU6IHRoaXMudmFsdWUsXG4gICAgICB9O1xuICAgIH1cblxuICAgIHJldHVybiBudWxsO1xuICB9XG59XG4iXX0=