@copilotkitnext/angular 0.0.2 → 0.0.5

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

@@ -0,0 +1,94 @@
+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 configure CopilotKit runtime settings declaratively in templates.
+ *
+ * @example
+ * ```html
+ * <div [copilotkitConfig]="{
+ *   runtimeUrl: 'https://api.example.com',
+ *   headers: { 'Authorization': 'Bearer token' }
+ * }">
+ *   <!-- Your app content -->
+ * </div>
+ * ```
+ *
+ * Or with individual inputs:
+ * ```html
+ * <div copilotkitConfig
+ *      [runtimeUrl]="apiUrl"
+ *      [headers]="authHeaders"
+ *      [agents]="myAgents">
+ *   <!-- Your app content -->
+ * </div>
+ * ```
+ */
+export class CopilotKitConfigDirective {
+    copilotkit;
+    constructor(copilotkit) {
+        this.copilotkit = copilotkit;
+    }
+    copilotkitConfig;
+    runtimeUrl;
+    headers;
+    properties;
+    agents;
+    ngOnChanges(changes) {
+        // Handle combined config object
+        if (changes['copilotkitConfig']) {
+            const config = this.copilotkitConfig;
+            if (config) {
+                if (config.runtimeUrl !== undefined) {
+                    this.copilotkit.setRuntimeUrl(config.runtimeUrl);
+                }
+                if (config.headers) {
+                    this.copilotkit.setHeaders(config.headers);
+                }
+                if (config.properties) {
+                    this.copilotkit.setProperties(config.properties);
+                }
+                if (config.agents) {
+                    this.copilotkit.setAgents(config.agents);
+                }
+            }
+        }
+        // Handle individual inputs
+        if (changes['runtimeUrl'] && !this.copilotkitConfig) {
+            this.copilotkit.setRuntimeUrl(this.runtimeUrl);
+        }
+        if (changes['headers'] && !this.copilotkitConfig) {
+            this.copilotkit.setHeaders(this.headers || {});
+        }
+        if (changes['properties'] && !this.copilotkitConfig) {
+            this.copilotkit.setProperties(this.properties || {});
+        }
+        if (changes['agents'] && !this.copilotkitConfig) {
+            this.copilotkit.setAgents(this.agents || {});
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitConfigDirective, deps: [{ token: CopilotKitService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitConfigDirective, isStandalone: true, selector: "[copilotkitConfig]", inputs: { copilotkitConfig: "copilotkitConfig", runtimeUrl: "runtimeUrl", headers: "headers", properties: "properties", agents: "agents" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitConfigDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitConfig]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotKitService, decorators: [{
+                    type: Inject,
+                    args: [CopilotKitService]
+                }] }], propDecorators: { copilotkitConfig: [{
+                type: Input
+            }], runtimeUrl: [{
+                type: Input
+            }], headers: [{
+                type: Input
+            }], properties: [{
+                type: Input
+            }], agents: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/directives/copilotkit-frontend-tool.directive.mjs

@@ -0,0 +1,128 @@
+import { Directive, Input, isDevMode, Inject, } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/copilotkit.service";
+export class CopilotKitFrontendToolDirective {
+    copilotkit;
+    isRegistered = false;
+    constructor(copilotkit) {
+        this.copilotkit = copilotkit;
+    }
+    name;
+    description;
+    parameters;
+    handler;
+    render;
+    followUp;
+    // Alternative: Accept a full tool object
+    tool;
+    ngOnInit() {
+        this.registerTool();
+    }
+    ngOnChanges(_changes) {
+        if (this.isRegistered) {
+            // Re-register the tool if any properties change
+            this.unregisterTool();
+            this.registerTool();
+        }
+    }
+    ngOnDestroy() {
+        this.unregisterTool();
+    }
+    registerTool() {
+        const tool = this.getTool();
+        if (!tool.name) {
+            if (isDevMode()) {
+                console.warn('CopilotKitFrontendToolDirective: "name" is required. ' +
+                    'Please provide a name via [name]="toolName" or ' +
+                    "[copilotkitFrontendTool]=\"{ name: 'toolName', ... }\"");
+            }
+            return; // Don't register if no name
+        }
+        // Register the tool with CopilotKit
+        this.copilotkit.copilotkit.addTool(tool);
+        // Register the render if provided
+        if (tool.render) {
+            const currentRenders = this.copilotkit.currentRenderToolCalls();
+            const renderEntry = {
+                name: tool.name,
+                render: tool.render,
+            };
+            // Check for duplicate
+            const existingIndex = currentRenders.findIndex((r) => r.name === tool.name);
+            if (existingIndex !== -1) {
+                if (isDevMode()) {
+                    console.warn(`[CopilotKit] Tool "${tool.name}" already has a render. ` +
+                        `The previous render will be replaced. ` +
+                        `This may indicate a duplicate tool registration.`);
+                }
+                const updated = [...currentRenders];
+                updated[existingIndex] = renderEntry;
+                this.copilotkit.setCurrentRenderToolCalls(updated);
+            }
+            else {
+                this.copilotkit.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
+            }
+        }
+        this.isRegistered = true;
+    }
+    unregisterTool() {
+        if (!this.isRegistered)
+            return;
+        const tool = this.getTool();
+        if (tool.name) {
+            // Remove the tool
+            this.copilotkit.copilotkit.removeTool(tool.name);
+            // Remove the render if it exists
+            const currentRenders = this.copilotkit.currentRenderToolCalls();
+            const filtered = currentRenders.filter((r) => r.name !== tool.name);
+            if (filtered.length !== currentRenders.length) {
+                this.copilotkit.setCurrentRenderToolCalls(filtered);
+            }
+        }
+        this.isRegistered = false;
+    }
+    getTool() {
+        // If full tool object is provided, use it
+        if (this.tool) {
+            return this.tool;
+        }
+        // Otherwise, construct from individual inputs
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: this.parameters,
+            handler: this.handler,
+            render: this.render,
+            followUp: this.followUp,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitFrontendToolDirective, deps: [{ token: CopilotKitService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitFrontendToolDirective, isStandalone: true, selector: "[copilotkitFrontendTool]", inputs: { name: "name", description: "description", parameters: "parameters", handler: "handler", render: "render", followUp: "followUp", tool: ["copilotkitFrontendTool", "tool"] }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitFrontendToolDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitFrontendTool]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotKitService, decorators: [{
+                    type: Inject,
+                    args: [CopilotKitService]
+                }] }], propDecorators: { name: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }], handler: [{
+                type: Input
+            }], render: [{
+                type: Input
+            }], followUp: [{
+                type: Input
+            }], tool: [{
+                type: Input,
+                args: ["copilotkitFrontendTool"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilotkit-frontend-tool.directive.js","sourceRoot":"","sources":["../../../src/directives/copilotkit-frontend-tool.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  Input,\n  OnInit,\n  OnChanges,\n  OnDestroy,\n  SimpleChanges,\n  TemplateRef,\n  Type,\n  isDevMode,\n  Inject,\n} from \"@angular/core\";\nimport { CopilotKitService } from \"../core/copilotkit.service\";\nimport type {\n  AngularFrontendTool,\n  AngularToolCallRender,\n  ToolCallRender,\n} from \"../core/copilotkit.types\";\nimport type { z } from \"zod\";\n\n@Directive({\n  selector: \"[copilotkitFrontendTool]\",\n  standalone: true,\n})\nexport class CopilotKitFrontendToolDirective<\n    T extends Record<string, any> = Record<string, any>,\n  >\n  implements OnInit, OnChanges, OnDestroy\n{\n  private isRegistered = false;\n\n  constructor(\n    @Inject(CopilotKitService) private readonly copilotkit: CopilotKitService\n  ) {}\n\n  @Input() name!: string;\n  @Input() description?: string;\n  @Input() parameters?: z.ZodSchema<T>;\n  @Input() handler?: (args: T) => Promise<any>;\n  @Input() render?: Type<any> | TemplateRef<any>;\n  @Input() followUp?: boolean;\n\n  // Alternative: Accept a full tool object\n  @Input(\"copilotkitFrontendTool\") tool?: AngularFrontendTool<T>;\n\n  ngOnInit(): void {\n    this.registerTool();\n  }\n\n  ngOnChanges(_changes: SimpleChanges): void {\n    if (this.isRegistered) {\n      // Re-register the tool if any properties change\n      this.unregisterTool();\n      this.registerTool();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.unregisterTool();\n  }\n\n  private registerTool(): void {\n    const tool = this.getTool();\n\n    if (!tool.name) {\n      if (isDevMode()) {\n        console.warn(\n          'CopilotKitFrontendToolDirective: \"name\" is required. ' +\n            'Please provide a name via [name]=\"toolName\" or ' +\n            \"[copilotkitFrontendTool]=\\\"{ name: 'toolName', ... }\\\"\"\n        );\n      }\n      return; // Don't register if no name\n    }\n\n    // Register the tool with CopilotKit\n    this.copilotkit.copilotkit.addTool(tool);\n\n    // Register the render if provided\n    if (tool.render) {\n      const currentRenders = this.copilotkit.currentRenderToolCalls();\n      const renderEntry: AngularToolCallRender = {\n        name: tool.name,\n        render: tool.render,\n      };\n\n      // Check for duplicate\n      const existingIndex = currentRenders.findIndex((r: ToolCallRender) => r.name === tool.name);\n      if (existingIndex !== -1) {\n        if (isDevMode()) {\n          console.warn(\n            `[CopilotKit] Tool \"${tool.name}\" already has a render. ` +\n              `The previous render will be replaced. ` +\n              `This may indicate a duplicate tool registration.`\n          );\n        }\n        const updated = [...currentRenders];\n        updated[existingIndex] = renderEntry;\n        this.copilotkit.setCurrentRenderToolCalls(updated);\n      } else {\n        this.copilotkit.setCurrentRenderToolCalls([...currentRenders, renderEntry]);\n      }\n    }\n\n    this.isRegistered = true;\n  }\n\n  private unregisterTool(): void {\n    if (!this.isRegistered) return;\n\n    const tool = this.getTool();\n\n    if (tool.name) {\n      // Remove the tool\n      this.copilotkit.copilotkit.removeTool(tool.name);\n\n      // Remove the render if it exists\n      const currentRenders = this.copilotkit.currentRenderToolCalls();\n      const filtered = currentRenders.filter((r: ToolCallRender) => r.name !== tool.name);\n      if (filtered.length !== currentRenders.length) {\n        this.copilotkit.setCurrentRenderToolCalls(filtered);\n      }\n    }\n\n    this.isRegistered = false;\n  }\n\n  private getTool(): AngularFrontendTool<T> {\n    // If full tool object is provided, use it\n    if (this.tool) {\n      return this.tool;\n    }\n\n    // Otherwise, construct from individual inputs\n    return {\n      name: this.name,\n      description: this.description,\n      parameters: this.parameters,\n      handler: this.handler,\n      render: this.render,\n      followUp: this.followUp,\n    };\n  }\n}\n"]}

package/dist/esm2022/directives/copilotkit-human-in-the-loop.directive.mjs

@@ -0,0 +1,265 @@
+import { Directive, Input, Output, EventEmitter, signal, isDevMode, Inject, } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import { ToolCallStatus } from "../core/copilotkit.types";
+import * as i0 from "@angular/core";
+import * as i1 from "../core/copilotkit.service";
+/**
+ * Directive for declaratively creating human-in-the-loop tools.
+ * Provides reactive outputs for status changes and response events.
+ *
+ * @example
+ * ```html
+ * <!-- Basic usage -->
+ * <div copilotkitHumanInTheLoop
+ *      [name]="'requireApproval'"
+ *      [description]="'Requires user approval'"
+ *      [args]="argsSchema"
+ *      [render]="approvalComponent"
+ *      (statusChange)="onStatusChange($event)"
+ *      (responseProvided)="onResponse($event)">
+ * </div>
+ *
+ * <!-- With template -->
+ * <div copilotkitHumanInTheLoop
+ *      [name]="'requireApproval'"
+ *      [description]="'Requires user approval'"
+ *      [args]="argsSchema"
+ *      [render]="approvalTemplate"
+ *      [(status)]="approvalStatus">
+ * </div>
+ *
+ * <ng-template #approvalTemplate let-props>
+ *   <div *ngIf="props.status === 'executing'">
+ *     <p>{{ props.args.action }}</p>
+ *     <button (click)="props.respond('approved')">Approve</button>
+ *     <button (click)="props.respond('rejected')">Reject</button>
+ *   </div>
+ * </ng-template>
+ * ```
+ */
+export class CopilotKitHumanInTheLoopDirective {
+    copilotkit;
+    toolId;
+    statusSignal = signal(ToolCallStatus.InProgress);
+    resolvePromise = null;
+    _status = ToolCallStatus.InProgress;
+    constructor(copilotkit) {
+        this.copilotkit = copilotkit;
+    }
+    /**
+     * The name of the human-in-the-loop tool.
+     */
+    name;
+    /**
+     * Description of what the tool does.
+     */
+    description;
+    /**
+     * Zod schema for the tool parameters.
+     */
+    parameters;
+    /**
+     * Component class or template to render for user interaction.
+     */
+    render;
+    /**
+     * Whether the tool should be registered (default: true).
+     */
+    enabled = true;
+    /**
+     * Alternative input using the directive selector.
+     * Allows: [copilotkitHumanInTheLoop]="config"
+     */
+    set config(value) {
+        if (value) {
+            if (value.name)
+                this.name = value.name;
+            if (value.description)
+                this.description = value.description;
+            if ("parameters" in value && value.parameters)
+                this.parameters = value.parameters;
+            if ("render" in value && value.render)
+                this.render = value.render;
+        }
+    }
+    /**
+     * Emits when the status changes.
+     */
+    statusChange = new EventEmitter();
+    /**
+     * Two-way binding for status.
+     */
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        // Input setter for two-way binding (though typically read-only)
+        this._status = value;
+    }
+    /**
+     * Emits when a response is provided by the user.
+     */
+    responseProvided = new EventEmitter();
+    /**
+     * Emits when the tool execution starts.
+     */
+    executionStarted = new EventEmitter();
+    /**
+     * Emits when the tool execution completes.
+     */
+    executionCompleted = new EventEmitter();
+    ngOnInit() {
+        if (this.enabled) {
+            this.registerTool();
+        }
+    }
+    ngOnChanges(changes) {
+        const relevantChanges = changes["name"] ||
+            changes["description"] ||
+            changes["args"] ||
+            changes["render"] ||
+            changes["enabled"];
+        if (relevantChanges && !relevantChanges.firstChange) {
+            // Re-register the tool with new configuration
+            this.unregisterTool();
+            if (this.enabled) {
+                this.registerTool();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.unregisterTool();
+    }
+    /**
+     * Programmatically trigger a response.
+     * Useful when the directive is used as a controller.
+     */
+    respond(result) {
+        this.handleResponse(result);
+    }
+    registerTool() {
+        if (!this.name || !this.description || !this.parameters || !this.render) {
+            if (isDevMode()) {
+                throw new Error("CopilotKitHumanInTheLoopDirective: Missing required inputs. " +
+                    "Required: name, description, parameters, and render.");
+            }
+            return;
+        }
+        // Create handler that returns a Promise
+        const handler = async (args) => {
+            return new Promise((resolve) => {
+                this.updateStatus(ToolCallStatus.Executing);
+                this.resolvePromise = resolve;
+                this.executionStarted.emit(args);
+            });
+        };
+        // Create the frontend tool with enhanced render
+        const frontendTool = {
+            name: this.name,
+            description: this.description,
+            parameters: this.parameters,
+            handler,
+            render: this.render, // Will be enhanced by the render component
+        };
+        // Add the tool (returns void, so we use the tool name as ID)
+        this.copilotkit.copilotkit.addTool(frontendTool);
+        this.toolId = this.name;
+        // Register the render with respond capability
+        this.copilotkit.registerToolRender(this.name, {
+            name: this.name,
+            render: this.createEnhancedRender(),
+        });
+    }
+    unregisterTool() {
+        if (this.toolId) {
+            this.copilotkit.copilotkit.removeTool(this.toolId);
+            this.copilotkit.unregisterToolRender(this.name);
+            this.toolId = undefined;
+        }
+    }
+    createEnhancedRender() {
+        // If it's a template, we need to wrap it with our respond function
+        // This is handled by returning a special marker that the render component
+        // will recognize and enhance with the respond function
+        // Store reference to this directive instance for the render component
+        this.render.__humanInTheLoopDirective = this;
+        this.render.__humanInTheLoopStatus = this.statusSignal;
+        return this.render;
+    }
+    handleResponse(result) {
+        if (this.resolvePromise) {
+            this.resolvePromise(result);
+            this.updateStatus(ToolCallStatus.Complete);
+            this.resolvePromise = null;
+            this.responseProvided.emit(result);
+            this.executionCompleted.emit(result);
+        }
+    }
+    updateStatus(status) {
+        this._status = status;
+        this.statusSignal.set(status);
+        this.statusChange.emit(status);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitHumanInTheLoopDirective, deps: [{ token: CopilotKitService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitHumanInTheLoopDirective, isStandalone: true, selector: "[copilotkitHumanInTheLoop]", inputs: { name: "name", description: "description", parameters: "parameters", render: "render", enabled: "enabled", config: ["copilotkitHumanInTheLoop", "config"], status: "status" }, outputs: { statusChange: "statusChange", responseProvided: "responseProvided", executionStarted: "executionStarted", executionCompleted: "executionCompleted" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitHumanInTheLoopDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitHumanInTheLoop]",
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.CopilotKitService, decorators: [{
+                    type: Inject,
+                    args: [CopilotKitService]
+                }] }], propDecorators: { name: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }], render: [{
+                type: Input
+            }], enabled: [{
+                type: Input
+            }], config: [{
+                type: Input,
+                args: ["copilotkitHumanInTheLoop"]
+            }], statusChange: [{
+                type: Output
+            }], status: [{
+                type: Input
+            }], responseProvided: [{
+                type: Output
+            }], executionStarted: [{
+                type: Output
+            }], executionCompleted: [{
+                type: Output
+            }] } });
+/**
+ * Helper directive to provide respond function in templates.
+ * This would be used internally by the tool render component.
+ *
+ * @internal
+ */
+export class CopilotKitHumanInTheLoopRespondDirective {
+    copilotkitHumanInTheLoopRespond;
+    /**
+     * Convenience method for templates to call respond.
+     */
+    respond(result) {
+        this.copilotkitHumanInTheLoopRespond?.(result);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitHumanInTheLoopRespondDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotKitHumanInTheLoopRespondDirective, isStandalone: true, selector: "[copilotkitHumanInTheLoopRespond]", inputs: { copilotkitHumanInTheLoopRespond: "copilotkitHumanInTheLoopRespond" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotKitHumanInTheLoopRespondDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotkitHumanInTheLoopRespond]",
+                    standalone: true,
+                }]
+        }], propDecorators: { copilotkitHumanInTheLoopRespond: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilotkit-human-in-the-loop.directive.js","sourceRoot":"","sources":["../../../src/directives/copilotkit-human-in-the-loop.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  TemplateRef,\n  Type,\n  signal,\n  isDevMode,\n  Inject,\n} from \"@angular/core\";\nimport { CopilotKitService } from \"../core/copilotkit.service\";\nimport type {\n  AngularHumanInTheLoop,\n  HumanInTheLoopProps,\n  AngularFrontendTool,\n} from \"../core/copilotkit.types\";\nimport { ToolCallStatus } from \"../core/copilotkit.types\";\nimport * as z from \"zod\";\n\n/**\n * Directive for declaratively creating human-in-the-loop tools.\n * Provides reactive outputs for status changes and response events.\n *\n * @example\n * ```html\n * <!-- Basic usage -->\n * <div copilotkitHumanInTheLoop\n *      [name]=\"'requireApproval'\"\n *      [description]=\"'Requires user approval'\"\n *      [args]=\"argsSchema\"\n *      [render]=\"approvalComponent\"\n *      (statusChange)=\"onStatusChange($event)\"\n *      (responseProvided)=\"onResponse($event)\">\n * </div>\n *\n * <!-- With template -->\n * <div copilotkitHumanInTheLoop\n *      [name]=\"'requireApproval'\"\n *      [description]=\"'Requires user approval'\"\n *      [args]=\"argsSchema\"\n *      [render]=\"approvalTemplate\"\n *      [(status)]=\"approvalStatus\">\n * </div>\n *\n * <ng-template #approvalTemplate let-props>\n *   <div *ngIf=\"props.status === 'executing'\">\n *     <p>{{ props.args.action }}</p>\n *     <button (click)=\"props.respond('approved')\">Approve</button>\n *     <button (click)=\"props.respond('rejected')\">Reject</button>\n *   </div>\n * </ng-template>\n * ```\n */\n@Directive({\n  selector: \"[copilotkitHumanInTheLoop]\",\n  standalone: true,\n})\nexport class CopilotKitHumanInTheLoopDirective<\n    T extends Record<string, any> = Record<string, any>,\n  >\n  implements OnInit, OnChanges, OnDestroy\n{\n  private toolId?: string;\n  private statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);\n  private resolvePromise: ((result: unknown) => void) | null = null;\n  private _status: ToolCallStatus = ToolCallStatus.InProgress;\n\n  constructor(\n    @Inject(CopilotKitService) private readonly copilotkit: CopilotKitService\n  ) {}\n\n  /**\n   * The name of the human-in-the-loop tool.\n   */\n  @Input() name!: string;\n\n  /**\n   * Description of what the tool does.\n   */\n  @Input() description!: string;\n\n  /**\n   * Zod schema for the tool parameters.\n   */\n  @Input() parameters!: z.ZodSchema<T>;\n\n  /**\n   * Component class or template to render for user interaction.\n   */\n  @Input() render!: Type<any> | TemplateRef<HumanInTheLoopProps<T>>;\n\n  /**\n   * Whether the tool should be registered (default: true).\n   */\n  @Input() enabled = true;\n\n  /**\n   * Alternative input using the directive selector.\n   * Allows: [copilotkitHumanInTheLoop]=\"config\"\n   */\n  @Input(\"copilotkitHumanInTheLoop\")\n  set config(value: Partial<AngularHumanInTheLoop<T>> | undefined) {\n    if (value) {\n      if (value.name) this.name = value.name;\n      if (value.description) this.description = value.description;\n      if (\"parameters\" in value && value.parameters)\n        this.parameters = value.parameters as z.ZodSchema<T>;\n      if (\"render\" in value && value.render) this.render = value.render;\n    }\n  }\n\n  /**\n   * Emits when the status changes.\n   */\n  @Output() statusChange = new EventEmitter<ToolCallStatus>();\n\n  /**\n   * Two-way binding for status.\n   */\n  @Input()\n  get status(): ToolCallStatus {\n    return this._status;\n  }\n  set status(value: ToolCallStatus) {\n    // Input setter for two-way binding (though typically read-only)\n    this._status = value;\n  }\n\n  /**\n   * Emits when a response is provided by the user.\n   */\n  @Output() responseProvided = new EventEmitter<unknown>();\n\n  /**\n   * Emits when the tool execution starts.\n   */\n  @Output() executionStarted = new EventEmitter<any>();\n\n  /**\n   * Emits when the tool execution completes.\n   */\n  @Output() executionCompleted = new EventEmitter<unknown>();\n\n  ngOnInit(): void {\n    if (this.enabled) {\n      this.registerTool();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    const relevantChanges =\n      changes[\"name\"] ||\n      changes[\"description\"] ||\n      changes[\"args\"] ||\n      changes[\"render\"] ||\n      changes[\"enabled\"];\n\n    if (relevantChanges && !relevantChanges.firstChange) {\n      // Re-register the tool with new configuration\n      this.unregisterTool();\n      if (this.enabled) {\n        this.registerTool();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.unregisterTool();\n  }\n\n  /**\n   * Programmatically trigger a response.\n   * Useful when the directive is used as a controller.\n   */\n  respond(result: unknown): void {\n    this.handleResponse(result);\n  }\n\n  private registerTool(): void {\n    if (!this.name || !this.description || !this.parameters || !this.render) {\n      if (isDevMode()) {\n        throw new Error(\n          \"CopilotKitHumanInTheLoopDirective: Missing required inputs. \" +\n            \"Required: name, description, parameters, and render.\"\n        );\n      }\n      return;\n    }\n\n    // Create handler that returns a Promise\n    const handler = async (args: T): Promise<unknown> => {\n      return new Promise((resolve) => {\n        this.updateStatus(ToolCallStatus.Executing);\n        this.resolvePromise = resolve;\n        this.executionStarted.emit(args);\n      });\n    };\n\n    // Create the frontend tool with enhanced render\n    const frontendTool: AngularFrontendTool<T> = {\n      name: this.name,\n      description: this.description,\n      parameters: this.parameters,\n      handler,\n      render: this.render, // Will be enhanced by the render component\n    };\n\n    // Add the tool (returns void, so we use the tool name as ID)\n    this.copilotkit.copilotkit.addTool(frontendTool);\n    this.toolId = this.name;\n\n    // Register the render with respond capability\n    this.copilotkit.registerToolRender(this.name, {\n      name: this.name,\n      render: this.createEnhancedRender(),\n    });\n  }\n\n  private unregisterTool(): void {\n    if (this.toolId) {\n      this.copilotkit.copilotkit.removeTool(this.toolId);\n      this.copilotkit.unregisterToolRender(this.name);\n      this.toolId = undefined;\n    }\n  }\n\n  private createEnhancedRender(): Type<any> | TemplateRef<any> {\n    // If it's a template, we need to wrap it with our respond function\n    // This is handled by returning a special marker that the render component\n    // will recognize and enhance with the respond function\n\n    // Store reference to this directive instance for the render component\n    (this.render as any).__humanInTheLoopDirective = this;\n    (this.render as any).__humanInTheLoopStatus = this.statusSignal;\n\n    return this.render;\n  }\n\n  private handleResponse(result: unknown): void {\n    if (this.resolvePromise) {\n      this.resolvePromise(result);\n      this.updateStatus(ToolCallStatus.Complete);\n      this.resolvePromise = null;\n      this.responseProvided.emit(result);\n      this.executionCompleted.emit(result);\n    }\n  }\n\n  private updateStatus(status: ToolCallStatus): void {\n    this._status = status;\n    this.statusSignal.set(status);\n    this.statusChange.emit(status);\n  }\n}\n\n/**\n * Helper directive to provide respond function in templates.\n * This would be used internally by the tool render component.\n *\n * @internal\n */\n@Directive({\n  selector: \"[copilotkitHumanInTheLoopRespond]\",\n  standalone: true,\n})\nexport class CopilotKitHumanInTheLoopRespondDirective {\n  @Input() copilotkitHumanInTheLoopRespond?: (result: unknown) => Promise<void>;\n\n  /**\n   * Convenience method for templates to call respond.\n   */\n  respond(result: unknown): void {\n    this.copilotkitHumanInTheLoopRespond?.(result);\n  }\n}\n"]}