@copilotkitnext/angular 0.0.1

package/dist/core/copilotkit.service.d.ts

@@ -0,0 +1,119 @@
+import { ToolCallRender, AngularFrontendTool, AngularHumanInTheLoop } from "./copilotkit.types";
+import { CopilotKitCore } from "@copilotkitnext/core";
+import { AbstractAgent } from "@ag-ui/client";
+import * as i0 from "@angular/core";
+/**
+ * Angular service for managing CopilotKit state and interactions.
+ * Provides reactive state management using Angular signals and observables.
+ */
+export declare class CopilotKitService {
+    private readonly initialFrontendTools;
+    private readonly initialHumanInTheLoop;
+    private readonly initialRenderToolCalls;
+    readonly copilotkit: CopilotKitCore;
+    private readonly _renderToolCalls;
+    private readonly _currentRenderToolCalls;
+    private readonly _runtimeUrl;
+    private readonly _headers;
+    private readonly _properties;
+    private readonly _agents;
+    private readonly _frontendTools;
+    private readonly _humanInTheLoop;
+    private readonly _runtimeStateVersion;
+    private readonly _allTools;
+    private readonly _allRenderToolCalls;
+    readonly renderToolCalls: any;
+    readonly currentRenderToolCalls: any;
+    readonly runtimeUrl: any;
+    readonly headers: any;
+    readonly properties: any;
+    readonly agents: any;
+    readonly frontendTools: any;
+    readonly humanInTheLoop: any;
+    readonly runtimeStateVersion: any;
+    readonly renderToolCalls$: any;
+    readonly currentRenderToolCalls$: any;
+    readonly runtimeUrl$: any;
+    readonly headers$: any;
+    readonly properties$: any;
+    readonly agents$: any;
+    readonly frontendTools$: any;
+    readonly humanInTheLoop$: any;
+    readonly context: any;
+    readonly context$: any;
+    constructor(runtimeUrl: string | undefined, headers: Record<string, string>, properties: Record<string, unknown>, agents: Record<string, AbstractAgent>, renderToolCalls: ToolCallRender<unknown>[], frontendTools: AngularFrontendTool<any>[], humanInTheLoop: AngularHumanInTheLoop<any>[]);
+    /**
+     * Process frontend tools and human-in-the-loop tools
+     */
+    private processTools;
+    /**
+     * Setup stability warning effects
+     */
+    private setupStabilityWarnings;
+    /**
+     * Setup effects to sync runtime configuration with CopilotKitCore
+     */
+    private setupRuntimeSyncEffects;
+    /**
+     * Subscribe to CopilotKit runtime events
+     */
+    private setupEventSubscription;
+    /**
+     * Notify consumers that the runtime state has changed.
+     * This is similar to React's forceUpdate - it triggers change detection
+     * for any computed signals or effects that depend on runtime state.
+     */
+    private notifyRuntimeStateChange;
+    /**
+     * Update the runtime URL
+     */
+    setRuntimeUrl(url?: string): void;
+    /**
+     * Update request headers
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Update runtime properties
+     */
+    setProperties(properties: Record<string, unknown>): void;
+    /**
+     * Update agents configuration
+     */
+    setAgents(agents: Record<string, AbstractAgent>): void;
+    /**
+     * Get an agent by ID
+     * @param agentId - The agent ID to retrieve
+     * @returns The agent or undefined if not found
+     */
+    getAgent(agentId: string): AbstractAgent | undefined;
+    /**
+     * Update render tool calls (warns if object reference changes)
+     */
+    setRenderToolCalls(renderToolCalls: ToolCallRender<unknown>[]): void;
+    /**
+     * Update frontend tools array
+     */
+    setFrontendTools(frontendTools: AngularFrontendTool<any>[]): void;
+    /**
+     * Update human-in-the-loop array
+     */
+    setHumanInTheLoop(humanInTheLoop: AngularHumanInTheLoop<any>[]): void;
+    /**
+     * Update current render tool calls
+     */
+    setCurrentRenderToolCalls(renderToolCalls: ToolCallRender<unknown>[]): void;
+    /**
+     * Register a tool render
+     */
+    registerToolRender(name: string, render: ToolCallRender<unknown>): void;
+    /**
+     * Unregister a tool render
+     */
+    unregisterToolRender(name: string): void;
+    /**
+     * Get a specific tool render
+     */
+    getToolRender(name: string): ToolCallRender<unknown> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CopilotKitService>;
+}

package/dist/core/copilotkit.types.d.ts

@@ -0,0 +1,83 @@
+import { InjectionToken, TemplateRef, Type, Signal } from "@angular/core";
+import { Observable } from "rxjs";
+import { CopilotKitCore, ToolCallStatus } from "@copilotkitnext/core";
+import { AbstractAgent } from "@ag-ui/client";
+import type { z } from "zod";
+import type { AngularFrontendTool } from "../types/frontend-tool";
+import type { AngularHumanInTheLoop } from "../types/human-in-the-loop";
+export type { Context } from "@ag-ui/client";
+export type { AngularFrontendTool } from "../types/frontend-tool";
+export type { AngularHumanInTheLoop, HumanInTheLoopProps, } from "../types/human-in-the-loop";
+export { ToolCallStatus } from "@copilotkitnext/core";
+export type ToolCallProps<T = unknown> = {
+    name: string;
+    description: string;
+    args: Partial<T>;
+    status: ToolCallStatus.InProgress;
+    result: undefined;
+} | {
+    name: string;
+    description: string;
+    args: T;
+    status: ToolCallStatus.Executing;
+    result: undefined;
+} | {
+    name: string;
+    description: string;
+    args: T;
+    status: ToolCallStatus.Complete;
+    result: string;
+};
+export interface AngularToolCallRender<T = unknown> {
+    name: string;
+    args: z.ZodSchema<T>;
+    /**
+     * Optional agent ID to constrain this tool render to a specific agent.
+     * If specified, this render will only be used for the specified agent.
+     */
+    agentId?: string;
+    render: Type<any> | TemplateRef<ToolCallProps<T>>;
+}
+export type ToolCallRender<T = unknown> = AngularToolCallRender<T>;
+export interface CopilotKitContextValue {
+    copilotkit: CopilotKitCore;
+    renderToolCalls: ToolCallRender<unknown>[];
+    currentRenderToolCalls: ToolCallRender<unknown>[];
+    setCurrentRenderToolCalls: (v: ToolCallRender<unknown>[]) => void;
+}
+export interface CopilotKitRuntimeInputs {
+    runtimeUrl?: string;
+    headers?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    agents?: Record<string, AbstractAgent>;
+    renderToolCalls?: ToolCallRender<unknown>[];
+}
+export declare const COPILOTKIT_RUNTIME_URL: InjectionToken<string>;
+export declare const COPILOTKIT_HEADERS: InjectionToken<Record<string, string>>;
+export declare const COPILOTKIT_PROPERTIES: InjectionToken<Record<string, unknown>>;
+export declare const COPILOTKIT_AGENTS: InjectionToken<Record<string, AbstractAgent>>;
+export declare const COPILOTKIT_RENDER_TOOL_CALLS: InjectionToken<ToolCallRender<unknown>[]>;
+export declare const COPILOTKIT_FRONTEND_TOOLS: InjectionToken<AngularFrontendTool<any>[]>;
+export declare const COPILOTKIT_HUMAN_IN_THE_LOOP: InjectionToken<AngularHumanInTheLoop<any>[]>;
+import type { Message } from "@ag-ui/client";
+export interface AgentWatchResult {
+    agent: Signal<AbstractAgent | undefined>;
+    messages: Signal<Message[]>;
+    isRunning: Signal<boolean>;
+    agent$: Observable<AbstractAgent | undefined>;
+    messages$: Observable<Message[]>;
+    isRunning$: Observable<boolean>;
+    unsubscribe: () => void;
+}
+export interface AgentSubscriptionCallbacks {
+    onMessagesChanged?: (params: any) => void;
+    onStateChanged?: (params: any) => void;
+    onRunInitialized?: (params: any) => void;
+    onRunFinalized?: (params: any) => void;
+    onRunFailed?: (params: any) => void;
+}
+export interface HumanInTheLoopState {
+    status: Signal<ToolCallStatus>;
+    toolId: string;
+    destroy: () => void;
+}

package/dist/directives/copilotkit-agent-context.directive.d.ts

@@ -0,0 +1,68 @@
+import { OnInit, OnChanges, OnDestroy, SimpleChanges } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import type { Context } from "@ag-ui/client";
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class CopilotKitAgentContextDirective implements OnInit, OnChanges, OnDestroy {
+    private readonly copilotkit;
+    private contextId?;
+    constructor(copilotkit: CopilotKitService);
+    /**
+     * Context object containing both description and value.
+     * If provided, this takes precedence over individual inputs.
+     */
+    context?: Context;
+    /**
+     * Description of the context.
+     * Used when context object is not provided.
+     */
+    description?: string;
+    /**
+     * Value of the context.
+     * Used when context object is not provided.
+     */
+    value?: any;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Adds the context to CopilotKit
+     */
+    private addContext;
+    /**
+     * Updates the context by removing the old one and adding a new one
+     */
+    private updateContext;
+    /**
+     * Removes the current context from CopilotKit
+     */
+    private removeContext;
+    /**
+     * Gets the context object from inputs
+     */
+    private getContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitAgentContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitAgentContextDirective, "[copilotkitAgentContext]", never, { "context": { "alias": "copilotkitAgentContext"; "required": false; }; "description": { "alias": "description"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/directives/copilotkit-agent.directive.d.ts

@@ -0,0 +1,106 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges } from "@angular/core";
+import { Observable } from "rxjs";
+import { CopilotKitService } from "../core/copilotkit.service";
+import { AbstractAgent } from "@ag-ui/client";
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class CopilotKitAgentDirective implements OnInit, OnChanges, OnDestroy {
+    private readonly copilotkit;
+    private agent?;
+    private agentSubscription?;
+    private coreUnsubscribe?;
+    private _isRunning;
+    private runningSignal;
+    private agentSignal;
+    constructor(copilotkit: CopilotKitService);
+    /**
+     * The ID of the agent to watch.
+     * If not provided, uses the default agent ID.
+     */
+    agentId?: string;
+    /**
+     * Alternative input using the directive selector.
+     * Allows: [copilotkitAgent]="'agent-id'"
+     */
+    set directiveAgentId(value: string | undefined);
+    /**
+     * Emits when the agent instance changes.
+     */
+    agentChange: EventEmitter<AbstractAgent>;
+    /**
+     * Emits when the running state changes.
+     */
+    runningChange: EventEmitter<boolean>;
+    /**
+     * Observable of the running state.
+     */
+    get running$(): Observable<boolean>;
+    /**
+     * Observable of the agent instance.
+     */
+    get agent$(): Observable<AbstractAgent | undefined>;
+    /**
+     * Two-way binding for running state.
+     */
+    get running(): boolean;
+    set running(value: boolean);
+    /**
+     * Emits when agent messages change.
+     */
+    messagesChange: EventEmitter<any>;
+    /**
+     * Emits when agent state changes.
+     */
+    stateChange: EventEmitter<any>;
+    /**
+     * Emits when a run is initialized.
+     */
+    runInitialized: EventEmitter<any>;
+    /**
+     * Emits when a run is finalized.
+     */
+    runFinalized: EventEmitter<any>;
+    /**
+     * Emits when a run fails.
+     */
+    runFailed: EventEmitter<any>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private setupAgent;
+    private subscribeToAgent;
+    private subscribeToCore;
+    private cleanupAgentSubscription;
+    private cleanupCoreSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitAgentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitAgentDirective, "[copilotkitAgent]", never, { "agentId": { "alias": "agentId"; "required": false; }; "directiveAgentId": { "alias": "copilotkitAgent"; "required": false; }; "running": { "alias": "running"; "required": false; }; }, { "agentChange": "agentChange"; "runningChange": "runningChange"; "messagesChange": "messagesChange"; "stateChange": "stateChange"; "runInitialized": "runInitialized"; "runFinalized": "runFinalized"; "runFailed": "runFailed"; }, never, never, true, never>;
+}

package/dist/directives/copilotkit-chat-config.directive.d.ts

@@ -0,0 +1,84 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges } from "@angular/core";
+import { CopilotChatConfigurationService } from "../core/chat-configuration/chat-configuration.service";
+import { CopilotChatConfiguration, CopilotChatLabels } from "../core/chat-configuration/chat-configuration.types";
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class CopilotKitChatConfigDirective implements OnInit, OnChanges, OnDestroy {
+    private readonly chatConfig;
+    private _value?;
+    private submitHandler?;
+    private changeHandler?;
+    constructor(chatConfig: CopilotChatConfigurationService | null);
+    /**
+     * Partial labels to override defaults
+     */
+    labels?: Partial<CopilotChatLabels>;
+    /**
+     * The current input value
+     */
+    inputValue?: string;
+    /**
+     * Event emitted when input is submitted
+     */
+    submitInput: EventEmitter<string>;
+    /**
+     * Event emitted when input value changes
+     */
+    changeInput: EventEmitter<string>;
+    /**
+     * Alternative: accept full configuration object
+     */
+    set config(value: CopilotChatConfiguration | undefined);
+    /**
+     * Two-way binding for input value
+     */
+    get value(): string | undefined;
+    set value(v: string | undefined);
+    /**
+     * Two-way binding output for value
+     */
+    valueChange: EventEmitter<string>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Submit the current input value
+     */
+    submit(value: string): void;
+    /**
+     * Handle input value change
+     */
+    change(value: string): void;
+    private updateConfiguration;
+    private updateInputValue;
+    private setupHandlers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitChatConfigDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitChatConfigDirective, "[copilotkitChatConfig]", never, { "labels": { "alias": "labels"; "required": false; }; "inputValue": { "alias": "inputValue"; "required": false; }; "config": { "alias": "copilotkitChatConfig"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "submitInput": "submitInput"; "changeInput": "changeInput"; "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/dist/directives/copilotkit-config.directive.d.ts

@@ -0,0 +1,44 @@
+import { OnChanges, SimpleChanges } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import { AbstractAgent } from "@ag-ui/client";
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class CopilotKitConfigDirective implements OnChanges {
+    private readonly copilotkit;
+    constructor(copilotkit: CopilotKitService);
+    copilotkitConfig?: {
+        runtimeUrl?: string;
+        headers?: Record<string, string>;
+        properties?: Record<string, unknown>;
+        agents?: Record<string, AbstractAgent>;
+    };
+    runtimeUrl?: string;
+    headers?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    agents?: Record<string, AbstractAgent>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitConfigDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitConfigDirective, "[copilotkitConfig]", never, { "copilotkitConfig": { "alias": "copilotkitConfig"; "required": false; }; "runtimeUrl": { "alias": "runtimeUrl"; "required": false; }; "headers": { "alias": "headers"; "required": false; }; "properties": { "alias": "properties"; "required": false; }; "agents": { "alias": "agents"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/directives/copilotkit-frontend-tool.directive.d.ts

@@ -0,0 +1,25 @@
+import { OnInit, OnChanges, OnDestroy, SimpleChanges, TemplateRef, Type } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import type { AngularFrontendTool } from "../core/copilotkit.types";
+import { z } from "zod";
+import * as i0 from "@angular/core";
+export declare class CopilotKitFrontendToolDirective<T extends Record<string, any> = Record<string, any>> implements OnInit, OnChanges, OnDestroy {
+    private readonly copilotkit;
+    private isRegistered;
+    constructor(copilotkit: CopilotKitService);
+    name: string;
+    description?: string;
+    parameters?: z.ZodSchema<T>;
+    handler?: (args: T) => Promise<any>;
+    render?: Type<any> | TemplateRef<any>;
+    followUp?: boolean;
+    tool?: AngularFrontendTool<T>;
+    ngOnInit(): void;
+    ngOnChanges(_changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private registerTool;
+    private unregisterTool;
+    private getTool;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitFrontendToolDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitFrontendToolDirective<any>, "[copilotkitFrontendTool]", never, { "name": { "alias": "name"; "required": false; }; "description": { "alias": "description"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "handler": { "alias": "handler"; "required": false; }; "render": { "alias": "render"; "required": false; }; "followUp": { "alias": "followUp"; "required": false; }; "tool": { "alias": "copilotkitFrontendTool"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/directives/copilotkit-human-in-the-loop.directive.d.ts

@@ -0,0 +1,124 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, TemplateRef, Type } from "@angular/core";
+import { CopilotKitService } from "../core/copilotkit.service";
+import type { AngularHumanInTheLoop, HumanInTheLoopProps } from "../core/copilotkit.types";
+import { ToolCallStatus } from "../core/copilotkit.types";
+import * as z from "zod";
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class CopilotKitHumanInTheLoopDirective<T extends Record<string, any> = Record<string, any>> implements OnInit, OnChanges, OnDestroy {
+    private readonly copilotkit;
+    private toolId?;
+    private statusSignal;
+    private resolvePromise;
+    private _status;
+    constructor(copilotkit: CopilotKitService);
+    /**
+     * The name of the human-in-the-loop tool.
+     */
+    name: string;
+    /**
+     * Description of what the tool does.
+     */
+    description: string;
+    /**
+     * Zod schema for the tool parameters.
+     */
+    parameters: z.ZodSchema<T>;
+    /**
+     * Component class or template to render for user interaction.
+     */
+    render: Type<any> | TemplateRef<HumanInTheLoopProps<T>>;
+    /**
+     * Whether the tool should be registered (default: true).
+     */
+    enabled: boolean;
+    /**
+     * Alternative input using the directive selector.
+     * Allows: [copilotkitHumanInTheLoop]="config"
+     */
+    set config(value: Partial<AngularHumanInTheLoop<T>> | undefined);
+    /**
+     * Emits when the status changes.
+     */
+    statusChange: EventEmitter<ToolCallStatus>;
+    /**
+     * Two-way binding for status.
+     */
+    get status(): ToolCallStatus;
+    set status(value: ToolCallStatus);
+    /**
+     * Emits when a response is provided by the user.
+     */
+    responseProvided: EventEmitter<unknown>;
+    /**
+     * Emits when the tool execution starts.
+     */
+    executionStarted: EventEmitter<any>;
+    /**
+     * Emits when the tool execution completes.
+     */
+    executionCompleted: EventEmitter<unknown>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Programmatically trigger a response.
+     * Useful when the directive is used as a controller.
+     */
+    respond(result: unknown): void;
+    private registerTool;
+    private unregisterTool;
+    private createEnhancedRender;
+    private handleResponse;
+    private updateStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitHumanInTheLoopDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitHumanInTheLoopDirective<any>, "[copilotkitHumanInTheLoop]", never, { "name": { "alias": "name"; "required": false; }; "description": { "alias": "description"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "render": { "alias": "render"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "config": { "alias": "copilotkitHumanInTheLoop"; "required": false; }; "status": { "alias": "status"; "required": false; }; }, { "statusChange": "statusChange"; "responseProvided": "responseProvided"; "executionStarted": "executionStarted"; "executionCompleted": "executionCompleted"; }, never, never, true, never>;
+}
+/**
+ * Helper directive to provide respond function in templates.
+ * This would be used internally by the tool render component.
+ *
+ * @internal
+ */
+export declare class CopilotKitHumanInTheLoopRespondDirective {
+    copilotkitHumanInTheLoopRespond?: (result: unknown) => Promise<void>;
+    /**
+     * Convenience method for templates to call respond.
+     */
+    respond(result: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitHumanInTheLoopRespondDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitHumanInTheLoopRespondDirective, "[copilotkitHumanInTheLoopRespond]", never, { "copilotkitHumanInTheLoopRespond": { "alias": "copilotkitHumanInTheLoopRespond"; "required": false; }; }, {}, never, never, true, never>;
+}