@copilotkitnext/angular 0.0.9-alpha.3 → 0.0.10

package/dist/types/frontend-tool.d.ts

@@ -1,37 +0,0 @@
-import { Type, TemplateRef } from "@angular/core";
-import type { z } from "zod";
-/**
- * Angular-specific frontend tool definition.
- * Provides a handler function that executes on the frontend when the tool is called.
- */
-export interface AngularFrontendTool<T extends Record<string, any> = Record<string, any>> {
-    /**
-     * The name of the tool - must be unique
-     */
-    name: string;
-    /**
-     * Description of what the tool does
-     */
-    description?: string;
-    /**
-     * Zod schema defining the parameters for the tool
-     */
-    parameters?: z.ZodSchema<T>;
-    /**
-     * Handler function that executes when the tool is called
-     */
-    handler?: (args: T) => Promise<any>;
-    /**
-     * Optional Angular component or template to render when the tool is called
-     */
-    render?: Type<any> | TemplateRef<any>;
-    /**
-     * Whether the agent should follow up after this tool completes.
-     * Defaults to true if not specified.
-     */
-    followUp?: boolean;
-    /**
-     * Optional agent ID to constrain this tool to a specific agent
-     */
-    agentId?: string;
-}

package/dist/types/human-in-the-loop.d.ts

@@ -1,44 +0,0 @@
-import { Type, TemplateRef } from "@angular/core";
-import type { z } from "zod";
-import { AngularFrontendTool } from "./frontend-tool";
-import { ToolCallStatus } from "@copilotkitnext/core";
-/**
- * Props passed to human-in-the-loop render components - discriminated union matching React
- */
-export type HumanInTheLoopProps<T = unknown> = {
-    name: string;
-    description: string;
-    args: Partial<T>;
-    status: ToolCallStatus.InProgress;
-    result: undefined;
-    respond: undefined;
-} | {
-    name: string;
-    description: string;
-    args: T;
-    status: ToolCallStatus.Executing;
-    result: undefined;
-    respond: (result: unknown) => Promise<void>;
-} | {
-    name: string;
-    description: string;
-    args: T;
-    status: ToolCallStatus.Complete;
-    result: string;
-    respond: undefined;
-};
-/**
- * Angular human-in-the-loop tool definition.
- * Similar to frontend tools but designed for interactive user input scenarios.
- */
-export interface AngularHumanInTheLoop<T extends Record<string, any> = Record<string, any>> extends Omit<AngularFrontendTool<T>, "handler" | "render"> {
-    /**
-     * Angular component or template to render for user interaction.
-     * Required for human-in-the-loop tools.
-     */
-    render: Type<HumanInTheLoopProps<T>> | TemplateRef<HumanInTheLoopProps<T>>;
-    /**
-     * Parameters schema is required for human-in-the-loop tools
-     */
-    parameters: z.ZodType<T>;
-}

package/dist/utils/agent-context.utils.d.ts

@@ -1,75 +0,0 @@
-import { CopilotKitService } from '../core/copilotkit.service';
-import { Context } from '@ag-ui/client';
-/**
- * Programmatically adds an agent context to CopilotKit and returns a cleanup function.
- *
- * @param context - The context to add
- * @returns A cleanup function that removes the context
- *
- * @example
- * ```typescript
- * export class MyComponent implements OnInit {
- *   private copilotkit = injectCopilotKit();
- *
- *   ngOnInit() {
- *     const cleanup = addAgentContext(this.copilotkit, {
- *       description: 'User preferences',
- *       value: this.userSettings
- *     });
- *
- *     // Store cleanup for later or register with DestroyRef
- *     this.cleanupFns.push(cleanup);
- *   }
- * }
- * ```
- */
-export declare function addAgentContext(copilotkit: CopilotKitService, context: Context): () => void;
-/**
- * Registers an agent context with CopilotKit and automatically removes it when the component/service is destroyed.
- * Must be called within an injection context.
- *
- * @param context - The context to add
- * @returns The context ID
- *
- * @example
- * ```typescript
- * export class MyComponent implements OnInit {
- *   ngOnInit() {
- *     // Automatically cleaned up on component destroy
- *     registerAgentContext({
- *       description: 'Component state',
- *       value: this.state
- *     });
- *   }
- * }
- * ```
- */
-export declare function registerAgentContext(context: Context): string;
-/**
- * Creates a reactive context that updates whenever the value changes.
- * Uses Angular signals for reactivity.
- *
- * @param description - Static or signal-based description
- * @param value - Signal that provides the context value
- * @returns Object with update and destroy methods
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   private userSettings = signal({ theme: 'dark' });
- *
- *   ngOnInit() {
- *     const context = createReactiveContext(
- *       'User settings',
- *       computed(() => this.userSettings())
- *     );
- *
- *     // Updates automatically when userSettings signal changes
- *   }
- * }
- * ```
- */
-export declare function createReactiveContext(description: string | (() => string), value: () => any): {
-    update: () => void;
-    destroy: () => void;
-};

package/dist/utils/agent.utils.d.ts

@@ -1,108 +0,0 @@
-import { Injector } from "@angular/core";
-import { CopilotKitService } from "../core/copilotkit.service";
-import { AgentSubscriptionCallbacks, AgentWatchResult } from "../core/copilotkit.types";
-import { AbstractAgent } from "@ag-ui/client";
-/**
- * Watches an agent and provides reactive signals for its state.
- * Must be called within an injection context.
- * Automatically cleans up when the component/service is destroyed.
- *
- * @param config - Optional configuration with agentId
- * @returns Object with agent, messages, and isRunning signals plus observables
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   // Automatically tracks agent state
- *   agentState = watchAgent({ agentId: 'my-agent' });
- *
- *   constructor() {
- *     effect(() => {
- *       const messages = this.agentState.messages();
- *       const isRunning = this.agentState.isRunning();
- *       console.log('Messages:', messages.length, 'Running:', isRunning);
- *     });
- *   }
- * }
- * ```
- */
-export declare function watchAgent(config?: {
-    agentId?: string;
-}): AgentWatchResult;
-/**
- * Gets an agent by ID without subscribing to changes.
- *
- * @param service - The CopilotKitService instance
- * @param agentId - Optional agent ID (defaults to DEFAULT_AGENT_ID)
- * @returns The agent or undefined if not found
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   constructor(private copilotkit: CopilotKitService) {}
- *
- *   getCurrentAgent() {
- *     return getAgent(this.copilotkit, 'my-agent');
- *   }
- * }
- * ```
- */
-export declare function getAgent(service: CopilotKitService, agentId?: string): AbstractAgent | undefined;
-export type { AgentWatchResult } from "../core/copilotkit.types";
-/**
- * Convenience wrapper for watchAgent that handles injection context.
- * Useful when you need to call watchAgent outside of a constructor or field initializer.
- *
- * @param injector - The Angular Injector to use for injection context
- * @param config - Optional configuration with agentId
- * @returns Object with agent, messages, and isRunning signals plus observables
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   constructor(private injector: Injector) {}
- *
- *   switchAgent(newAgentId: string) {
- *     // Can call outside of constructor using watchAgentWith
- *     const watcher = watchAgentWith(this.injector, { agentId: newAgentId });
- *     this.agent = watcher.agent;
- *     this.messages = watcher.messages;
- *     this.isRunning = watcher.isRunning;
- *   }
- * }
- * ```
- */
-export declare function watchAgentWith(injector: Injector, config?: {
-    agentId?: string;
-}): AgentWatchResult;
-/**
- * Subscribes to an agent's events with custom callbacks.
- * Returns a cleanup function that should be called to unsubscribe.
- *
- * @param service - The CopilotKitService instance
- * @param agentId - Optional agent ID (defaults to DEFAULT_AGENT_ID)
- * @param callbacks - Event callbacks
- * @returns Cleanup function to unsubscribe
- *
- * @example
- * ```typescript
- * export class MyComponent implements OnInit, OnDestroy {
- *   private unsubscribe?: () => void;
- *
- *   constructor(private copilotkit: CopilotKitService) {}
- *
- *   ngOnInit() {
- *     this.unsubscribe = subscribeToAgent(this.copilotkit, 'my-agent', {
- *       onRunInitialized: () => console.log('Run started'),
- *       onRunFinalized: () => console.log('Run completed'),
- *       onRunFailed: (error) => console.error('Run failed', error),
- *     });
- *   }
- *
- *   ngOnDestroy() {
- *     this.unsubscribe?.();
- *   }
- * }
- * ```
- */
-export declare function subscribeToAgent(service: CopilotKitService, agentId?: string, callbacks?: AgentSubscriptionCallbacks): () => void;

package/dist/utils/chat-config.utils.d.ts

@@ -1,166 +0,0 @@
-import { Signal } from '@angular/core';
-import { CopilotChatConfigurationService } from '../core/chat-configuration/chat-configuration.service';
-import { CopilotChatConfiguration, CopilotChatLabels } from '../core/chat-configuration/chat-configuration.types';
-/**
- * Watches chat configuration and provides reactive access to all configuration values.
- * Must be called within an injection context.
- *
- * @returns Object with reactive signals and handler functions
- *
- * @example
- * ```typescript
- * export class ChatInputComponent {
- *   config = watchChatConfig();
- *
- *   constructor() {
- *     effect(() => {
- *       const placeholder = this.config.labels().chatInputPlaceholder;
- *       console.log('Placeholder:', placeholder);
- *     });
- *   }
- *
- *   handleSubmit(value: string) {
- *     this.config.submitInput(value);
- *   }
- * }
- * ```
- */
-export declare function watchChatConfig(): {
-    labels: Signal<CopilotChatLabels>;
-    inputValue: Signal<string | undefined>;
-    submitInput: (value: string) => void;
-    changeInput: (value: string) => void;
-};
-/**
- * Registers chat configuration within an injection context.
- * Automatically updates the configuration when called.
- *
- * @param config - The configuration to register
- *
- * @example
- * ```typescript
- * export class ChatComponent {
- *   constructor() {
- *     registerChatConfig({
- *       labels: {
- *         chatInputPlaceholder: "How can I help?"
- *       },
- *       onSubmitInput: (value) => this.handleSubmit(value)
- *     });
- *   }
- * }
- * ```
- */
-export declare function registerChatConfig(config: CopilotChatConfiguration): void;
-/**
- * Gets the current chat labels signal.
- *
- * @param service - The CopilotChatConfigurationService instance
- * @returns Signal containing the current labels
- *
- * @example
- * ```typescript
- * export class ChatComponent {
- *   constructor(private chatConfig: CopilotChatConfigurationService) {
- *     const labels = getChatLabels(this.chatConfig);
- *     effect(() => {
- *       console.log('Current labels:', labels());
- *     });
- *   }
- * }
- * ```
- */
-export declare function getChatLabels(service: CopilotChatConfigurationService): Signal<CopilotChatLabels>;
-/**
- * Updates chat labels.
- *
- * @param service - The CopilotChatConfigurationService instance
- * @param labels - Partial labels to merge with defaults
- *
- * @example
- * ```typescript
- * export class ChatComponent {
- *   updatePlaceholder(text: string) {
- *     setChatLabels(this.chatConfig, {
- *       chatInputPlaceholder: text
- *     });
- *   }
- * }
- * ```
- */
-export declare function setChatLabels(service: CopilotChatConfigurationService, labels: Partial<CopilotChatLabels>): void;
-/**
- * Gets the current input value signal.
- *
- * @param service - The CopilotChatConfigurationService instance
- * @returns Signal containing the current input value
- *
- * @example
- * ```typescript
- * export class ChatInputComponent {
- *   inputValue = getChatInputValue(this.chatConfig);
- *
- *   constructor(private chatConfig: CopilotChatConfigurationService) {
- *     effect(() => {
- *       const value = this.inputValue();
- *       if (value) {
- *         this.updateTextarea(value);
- *       }
- *     });
- *   }
- * }
- * ```
- */
-export declare function getChatInputValue(service: CopilotChatConfigurationService): Signal<string | undefined>;
-/**
- * Sets the current input value.
- *
- * @param service - The CopilotChatConfigurationService instance
- * @param value - The new input value
- *
- * @example
- * ```typescript
- * export class ChatInputComponent {
- *   onInputChange(event: Event) {
- *     const value = (event.target as HTMLInputElement).value;
- *     setChatInputValue(this.chatConfig, value);
- *   }
- * }
- * ```
- */
-export declare function setChatInputValue(service: CopilotChatConfigurationService, value: string | undefined): void;
-/**
- * Creates a chat configuration controller with dynamic update capabilities.
- * This is useful when you need to programmatically manage configuration.
- *
- * @param service - The CopilotChatConfigurationService instance
- * @param initialConfig - Optional initial configuration
- * @returns Controller object with update and reset methods
- *
- * @example
- * ```typescript
- * export class ChatManagerComponent {
- *   chatController = createChatConfigController(this.chatConfig, {
- *     labels: { chatInputPlaceholder: "Ask me..." }
- *   });
- *
- *   constructor(private chatConfig: CopilotChatConfigurationService) {}
- *
- *   updateForSupportMode() {
- *     this.chatController.update({
- *       labels: { chatInputPlaceholder: "Describe your issue..." }
- *     });
- *   }
- *
- *   resetToDefaults() {
- *     this.chatController.reset();
- *   }
- * }
- * ```
- */
-export declare function createChatConfigController(service: CopilotChatConfigurationService, initialConfig?: CopilotChatConfiguration): {
-    update: (config: CopilotChatConfiguration) => void;
-    reset: () => void;
-    getLabels: () => CopilotChatLabels;
-    getInputValue: () => string | undefined;
-};

package/dist/utils/copilotkit.utils.d.ts

@@ -1,16 +0,0 @@
-import { CopilotKitService } from "../core/copilotkit.service";
-/**
- * Utility function to inject the CopilotKit service in a component or directive.
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   private copilotkit = injectCopilotKit();
- *
- *   sendMessage() {
- *     this.copilotkit.copilotkit.sendMessage(...);
- *   }
- * }
- * ```
- */
-export declare function injectCopilotKit(): CopilotKitService;

package/dist/utils/frontend-tool.utils.d.ts

@@ -1,119 +0,0 @@
-import { CopilotKitService } from '../core/copilotkit.service';
-import { AngularFrontendTool } from '../core/copilotkit.types';
-import type { z } from 'zod';
-/**
- * Explicitly adds a frontend tool to CopilotKit.
- * Requires CopilotKitService to be passed as a parameter.
- *
- * @param service - The CopilotKitService instance
- * @param tool - The tool to add
- * @returns A cleanup function that removes the tool
- *
- * @example
- * ```typescript
- * export class MyComponent implements OnInit, OnDestroy {
- *   private cleanupFns: Array<() => void> = [];
- *
- *   constructor(private copilotkit: CopilotKitService) {}
- *
- *   ngOnInit() {
- *     const cleanup = addFrontendTool(this.copilotkit, {
- *       name: 'calculator',
- *       description: 'Performs calculations',
- *       parameters: z.object({
- *         expression: z.string()
- *       }),
- *       handler: async (args) => {
- *         return eval(args.expression);
- *       }
- *     });
- *
- *     this.cleanupFns.push(cleanup);
- *   }
- *
- *   ngOnDestroy() {
- *     this.cleanupFns.forEach(fn => fn());
- *   }
- * }
- * ```
- */
-export declare function addFrontendTool<T extends Record<string, any> = Record<string, any>>(service: CopilotKitService, tool: AngularFrontendTool<T>): () => void;
-/**
- * Registers a frontend tool with CopilotKit and automatically removes it when the component/service is destroyed.
- * Must be called within an injection context.
- *
- * @param tool - The tool to register
- * @returns The tool name
- *
- * @example
- * ```typescript
- * export class MyComponent implements OnInit {
- *   ngOnInit() {
- *     // Automatically cleaned up on component destroy
- *     registerFrontendTool({
- *       name: 'search',
- *       description: 'Search for items',
- *       parameters: z.object({
- *         query: z.string()
- *       }),
- *       handler: async (args) => {
- *         return this.searchService.search(args.query);
- *       },
- *       render: SearchResultsComponent
- *     });
- *   }
- * }
- * ```
- */
-export declare function registerFrontendTool<T extends Record<string, any> = Record<string, any>>(tool: AngularFrontendTool<T>): string;
-/**
- * Explicitly removes a frontend tool from CopilotKit.
- *
- * @param service - The CopilotKitService instance
- * @param toolName - The name of the tool to remove
- *
- * @example
- * ```typescript
- * removeFrontendTool(this.copilotkit, 'calculator');
- * ```
- */
-export declare function removeFrontendTool(service: CopilotKitService, toolName: string): void;
-/**
- * Creates a frontend tool with dynamic parameters that can change over time.
- * Uses Angular signals for reactivity.
- *
- * @param name - Tool name
- * @param description - Tool description
- * @param parameters - Zod schema for parameters
- * @param handler - Signal or function that provides the handler
- * @param render - Optional render component or template
- * @returns Object with update and destroy methods
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   private toolConfig = signal({
- *     handler: async (args: any) => this.processDefault(args)
- *   });
- *
- *   ngOnInit() {
- *     const tool = createDynamicFrontendTool(
- *       'processor',
- *       'Processes data',
- *       z.object({ data: z.string() }),
- *       () => this.toolConfig().handler
- *     );
- *
- *     // Later, update the handler
- *     this.toolConfig.set({
- *       handler: async (args: any) => this.processAdvanced(args)
- *     });
- *     tool.update();
- *   }
- * }
- * ```
- */
-export declare function createDynamicFrontendTool<T extends Record<string, any> = Record<string, any>>(name: string, description: string | (() => string), parameters: z.ZodSchema<T>, handler: () => ((args: T) => Promise<any>), render?: () => any): {
-    update: () => void;
-    destroy: () => void;
-};

package/dist/utils/human-in-the-loop.utils.d.ts

@@ -1,92 +0,0 @@
-import { CopilotKitService } from '../core/copilotkit.service';
-import { AngularHumanInTheLoop, ToolCallStatus, HumanInTheLoopState, HumanInTheLoopProps } from '../core/copilotkit.types';
-/**
- * Registers a human-in-the-loop tool that requires user interaction.
- * Must be called within an injection context.
- * Automatically cleans up when the component/service is destroyed.
- *
- * @param tool - The human-in-the-loop tool configuration
- * @returns The tool ID
- *
- * @example
- * ```typescript
- * export class ApprovalComponent {
- *   toolId = registerHumanInTheLoop({
- *     name: 'requireApproval',
- *     description: 'Requires user approval',
- *     args: z.object({ action: z.string() }),
- *     render: ApprovalDialogComponent
- *   });
- * }
- * ```
- */
-export declare function registerHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(tool: AngularHumanInTheLoop<T>): string;
-/**
- * Adds a human-in-the-loop tool with explicit service parameter.
- * Returns a cleanup function.
- *
- * @param service - The CopilotKitService instance
- * @param tool - The human-in-the-loop tool configuration
- * @returns Cleanup function to remove the tool
- *
- * @example
- * ```typescript
- * export class MyComponent implements OnInit, OnDestroy {
- *   private cleanup?: () => void;
- *
- *   constructor(private copilotkit: CopilotKitService) {}
- *
- *   ngOnInit() {
- *     this.cleanup = addHumanInTheLoop(this.copilotkit, {
- *       name: 'requireApproval',
- *       description: 'Requires user approval',
- *       args: z.object({ action: z.string() }),
- *       render: ApprovalDialogComponent
- *     });
- *   }
- *
- *   ngOnDestroy() {
- *     this.cleanup?.();
- *   }
- * }
- * ```
- */
-export declare function addHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(service: CopilotKitService, tool: AngularHumanInTheLoop<T>): () => void;
-/**
- * Creates a human-in-the-loop tool with dynamic update capabilities.
- *
- * @param service - The CopilotKitService instance
- * @param tool - The human-in-the-loop tool configuration
- * @returns Object with status signal, update and destroy methods
- *
- * @example
- * ```typescript
- * export class MyComponent {
- *   humanInTheLoop = createHumanInTheLoop(this.copilotkit, {
- *     name: 'requireApproval',
- *     description: 'Requires user approval',
- *     args: z.object({ action: z.string() }),
- *     render: ApprovalDialogComponent
- *   });
- *
- *   updateDescription(newDesc: string) {
- *     this.humanInTheLoop.update({ description: newDesc });
- *   }
- *
- *   ngOnDestroy() {
- *     this.humanInTheLoop.destroy();
- *   }
- * }
- * ```
- */
-export declare function createHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(service: CopilotKitService, tool: AngularHumanInTheLoop<T>): HumanInTheLoopState & {
-    update: (updates: Partial<AngularHumanInTheLoop<T>>) => void;
-};
-/**
- * Enhanced component wrapper for human-in-the-loop.
- * This would be used internally by the tool render component to inject
- * the respond function based on status.
- *
- * @internal
- */
-export declare function enhancePropsForHumanInTheLoop<T>(props: HumanInTheLoopProps<T>, status: ToolCallStatus, respond?: (result: unknown) => Promise<void>): HumanInTheLoopProps<T>;