@copilotkitnext/angular 0.0.1 → 0.0.4

package/src/utils/frontend-tool.utils.ts

@@ -1,266 +0,0 @@
-import { DestroyRef, inject } from '@angular/core';
-import { CopilotKitService } from '../core/copilotkit.service';
-import { AngularFrontendTool, AngularToolCallRender, ToolCallRender } from '../core/copilotkit.types';
-import { 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 function addFrontendTool<T extends Record<string, any> = Record<string, any>>(
-  service: CopilotKitService,
-  tool: AngularFrontendTool<T>
-): () => void {
-  // Add the tool to CopilotKit
-  service.copilotkit.addTool(tool);
-  
-  // Register the render if provided
-  if (tool.render) {
-    const currentRenders = service.currentRenderToolCalls();
-    const existingIndex = currentRenders.findIndex((r: ToolCallRender<unknown>) => r.name === tool.name);
-    
-    if (existingIndex !== -1) {
-      console.error(`Tool with name '${tool.name}' already has a render. Skipping.`);
-    } else {
-      const renderEntry: AngularToolCallRender<T> = {
-        name: tool.name,
-        args: tool.parameters || (z.object({}) as unknown as z.ZodSchema<T>),
-        render: tool.render
-      };
-      
-      service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
-    }
-  }
-  
-  // Return cleanup function
-  return () => {
-    removeFrontendTool(service, tool.name);
-  };
-}
-
-/**
- * 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 function registerFrontendTool<T extends Record<string, any> = Record<string, any>>(
-  tool: AngularFrontendTool<T>
-): string {
-  const service = inject(CopilotKitService);
-  const destroyRef = inject(DestroyRef);
-  
-  // Add the tool
-  service.copilotkit.addTool(tool);
-  
-  // Register the render if provided
-  if (tool.render) {
-    const currentRenders = service.currentRenderToolCalls();
-    const existingIndex = currentRenders.findIndex((r: ToolCallRender<unknown>) => r.name === tool.name);
-    
-    if (existingIndex !== -1) {
-      console.error(`Tool with name '${tool.name}' already has a render. Skipping.`);
-    } else {
-      const renderEntry: AngularToolCallRender<T> = {
-        name: tool.name,
-        args: tool.parameters || (z.object({}) as unknown as z.ZodSchema<T>),
-        render: tool.render
-      };
-      
-      service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
-    }
-  }
-  
-  // Register cleanup with Angular's DestroyRef
-  destroyRef.onDestroy(() => {
-    removeFrontendTool(service, tool.name);
-  });
-  
-  return tool.name;
-}
-
-/**
- * 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 function removeFrontendTool(
-  service: CopilotKitService,
-  toolName: string
-): void {
-  // Remove the tool
-  service.copilotkit.removeTool(toolName);
-  
-  // Remove the render if it exists
-  const currentRenders = service.currentRenderToolCalls();
-  const filtered = currentRenders.filter((r: ToolCallRender<unknown>) => r.name !== toolName);
-  if (filtered.length !== currentRenders.length) {
-    service.setCurrentRenderToolCalls(filtered);
-  }
-}
-
-/**
- * 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 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 } {
-  const service = inject(CopilotKitService);
-  const destroyRef = inject(DestroyRef);
-  
-  let isRegistered = false;
-  
-  const update = () => {
-    // Remove old tool if registered
-    if (isRegistered) {
-      service.copilotkit.removeTool(name);
-    }
-    
-    // Create new tool configuration
-    const desc = typeof description === 'function' ? description() : description;
-    const currentHandler = handler();
-    const currentRender = render ? render() : undefined;
-    
-    const tool: AngularFrontendTool<T> = {
-      name,
-      description: desc,
-      parameters,
-      handler: currentHandler,
-      render: currentRender
-    };
-    
-    // Add the tool
-    service.copilotkit.addTool(tool);
-    
-    // Update render if provided
-    if (currentRender) {
-      const currentRenders = service.currentRenderToolCalls();
-      const renderEntry: AngularToolCallRender<T> = {
-        name: name,
-        args: parameters,
-        render: currentRender
-      };
-      
-      const existingIndex = currentRenders.findIndex((r: ToolCallRender<unknown>) => r.name === name);
-      if (existingIndex !== -1) {
-        const updated = [...currentRenders];
-        updated[existingIndex] = renderEntry;
-        service.setCurrentRenderToolCalls(updated);
-      } else {
-        service.setCurrentRenderToolCalls([...currentRenders, renderEntry]);
-      }
-    }
-    
-    isRegistered = true;
-  };
-  
-  const destroy = () => {
-    if (isRegistered) {
-      removeFrontendTool(service, name);
-      isRegistered = false;
-    }
-  };
-  
-  // Initial setup
-  update();
-  
-  // Register cleanup
-  destroyRef.onDestroy(destroy);
-  
-  return { update, destroy };
-}

package/src/utils/human-in-the-loop.utils.ts

@@ -1,359 +0,0 @@
-import { 
-  DestroyRef, 
-  inject, 
-  signal, 
-  Signal,
-  Type,
-  TemplateRef
-} from '@angular/core';
-import { CopilotKitService } from '../core/copilotkit.service';
-import { 
-  AngularHumanInTheLoop, 
-  ToolCallStatus,
-  HumanInTheLoopState,
-  HumanInTheLoopProps,
-  AngularFrontendTool
-} 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 function registerHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(
-  tool: AngularHumanInTheLoop<T>
-): string {
-  const service = inject(CopilotKitService);
-  const destroyRef = inject(DestroyRef);
-  
-  // Create state management
-  const statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);
-  let resolvePromise: ((result: unknown) => void) | null = null;
-  
-  // Create respond function
-  const respond = async (result: unknown): Promise<void> => {
-    if (resolvePromise) {
-      resolvePromise(result);
-      statusSignal.set(ToolCallStatus.Complete);
-      resolvePromise = null;
-    }
-  };
-  
-  // Create handler that returns a Promise
-  const handler = async (_args: T): Promise<unknown> => {
-    return new Promise((resolve) => {
-      statusSignal.set(ToolCallStatus.Executing);
-      resolvePromise = resolve;
-    });
-  };
-  
-  // Create enhanced render function
-  const enhancedRender = createEnhancedRender(tool.render, statusSignal, respond);
-  
-  // Create the frontend tool
-  const frontendTool: AngularFrontendTool<T> = {
-    ...tool,
-    handler,
-    render: enhancedRender
-  };
-  
-  // Add the tool (returns void, so we use the tool name as ID)
-  service.copilotkit.addTool(frontendTool);
-  const toolId = frontendTool.name;
-  
-  // Register tool render if provided
-  if (frontendTool.render && tool.parameters) {
-    service.registerToolRender(frontendTool.name, {
-      name: frontendTool.name,
-      args: tool.parameters,
-      render: frontendTool.render
-    });
-  }
-  
-  // Cleanup on destroy
-  destroyRef.onDestroy(() => {
-    service.copilotkit.removeTool(toolId);
-    if (frontendTool.render) {
-      service.unregisterToolRender(frontendTool.name);
-    }
-  });
-  
-  return toolId;
-}
-
-/**
- * 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 function addHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(
-  service: CopilotKitService,
-  tool: AngularHumanInTheLoop<T>
-): () => void {
-  // Create state management
-  const statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);
-  let resolvePromise: ((result: unknown) => void) | null = null;
-  
-  // Create respond function
-  const respond = async (result: unknown): Promise<void> => {
-    if (resolvePromise) {
-      resolvePromise(result);
-      statusSignal.set(ToolCallStatus.Complete);
-      resolvePromise = null;
-    }
-  };
-  
-  // Create handler that returns a Promise
-  const handler = async (_args: T): Promise<unknown> => {
-    return new Promise((resolve) => {
-      statusSignal.set(ToolCallStatus.Executing);
-      resolvePromise = resolve;
-    });
-  };
-  
-  // Create enhanced render function
-  const enhancedRender = createEnhancedRender(tool.render, statusSignal, respond);
-  
-  // Create the frontend tool
-  const frontendTool: AngularFrontendTool<T> = {
-    ...tool,
-    handler,
-    render: enhancedRender
-  };
-  
-  // Add the tool (returns void, so we use the tool name as ID)
-  service.copilotkit.addTool(frontendTool);
-  const toolId = frontendTool.name;
-  
-  // Register tool render if provided
-  if (frontendTool.render && tool.parameters) {
-    service.registerToolRender(frontendTool.name, {
-      name: frontendTool.name,
-      args: tool.parameters,
-      render: frontendTool.render
-    });
-  }
-  
-  // Return cleanup function
-  return () => {
-    service.copilotkit.removeTool(toolId);
-    if (frontendTool.render) {
-      service.unregisterToolRender(frontendTool.name);
-    }
-  };
-}
-
-/**
- * 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 function createHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(
-  service: CopilotKitService,
-  tool: AngularHumanInTheLoop<T>
-): HumanInTheLoopState & { update: (updates: Partial<AngularHumanInTheLoop<T>>) => void } {
-  // Create state management
-  const statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);
-  let currentTool = { ...tool };
-  let toolId: string = '';
-  let resolvePromise: ((result: unknown) => void) | null = null;
-  
-  // Create respond function
-  const respond = async (result: unknown): Promise<void> => {
-    if (resolvePromise) {
-      resolvePromise(result);
-      statusSignal.set(ToolCallStatus.Complete);
-      resolvePromise = null;
-    }
-  };
-  
-  // Create handler that returns a Promise
-  const handler = async (_args: T): Promise<unknown> => {
-    return new Promise((resolve) => {
-      statusSignal.set(ToolCallStatus.Executing);
-      resolvePromise = resolve;
-    });
-  };
-  
-  // Function to add the tool
-  const addTool = () => {
-    // Create enhanced render function
-    const enhancedRender = createEnhancedRender(currentTool.render, statusSignal, respond);
-    
-    // Create the frontend tool
-    const frontendTool: AngularFrontendTool<T> = {
-      ...currentTool,
-      handler,
-      render: enhancedRender
-    };
-    
-    // Add tool (returns void, so we use the tool name as ID)
-    service.copilotkit.addTool(frontendTool);
-    toolId = frontendTool.name;
-    
-    // Register tool render if provided
-    if (frontendTool.render && currentTool.parameters) {
-      service.registerToolRender(frontendTool.name, {
-        name: frontendTool.name,
-        args: currentTool.parameters,
-        render: frontendTool.render
-      });
-    }
-  };
-  
-  // Initialize the tool
-  addTool();
-  
-  return {
-    status: statusSignal.asReadonly(),
-    toolId,
-    update: (updates: Partial<AngularHumanInTheLoop<T>>) => {
-      // Remove old tool
-      service.copilotkit.removeTool(toolId);
-      if (currentTool.render) {
-        service.unregisterToolRender(currentTool.name);
-      }
-      
-      // Update tool configuration
-      currentTool = { ...currentTool, ...updates };
-      
-      // Re-add with new configuration
-      addTool();
-    },
-    destroy: () => {
-      service.copilotkit.removeTool(toolId);
-      if (currentTool.render) {
-        service.unregisterToolRender(currentTool.name);
-      }
-    }
-  };
-}
-
-/**
- * Creates an enhanced render function that injects the respond function
- * when the status is 'executing'.
- */
-function createEnhancedRender<T extends Record<string, any>>(
-  originalRender: Type<any> | TemplateRef<HumanInTheLoopProps<T>>,
-  _statusSignal: Signal<ToolCallStatus>,
-  _respond: (result: unknown) => Promise<void>
-): Type<any> | TemplateRef<any> {
-  // For component classes, we need to create a wrapper
-  if (isComponentClass(originalRender)) {
-    // Return a wrapper component factory
-    // This is complex in Angular and would require dynamic component creation
-    // For now, we'll return the original and rely on prop injection
-    return originalRender;
-  }
-  
-  // For templates, we can't easily wrap them
-  // The template context will be enhanced in the render component
-  return originalRender;
-}
-
-/**
- * Helper function to check if a value is a component class
- */
-function isComponentClass(value: any): value is Type<any> {
-  return typeof value === 'function' && value.prototype;
-}
-
-/**
- * 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 function enhancePropsForHumanInTheLoop<T>(
-  props: HumanInTheLoopProps<T>,
-  status: ToolCallStatus,
-  respond?: (result: unknown) => Promise<void>
-): HumanInTheLoopProps<T> {
-  if (status === ToolCallStatus.Executing && respond) {
-    return {
-      ...props,
-      status: ToolCallStatus.Executing,
-      respond
-    } as HumanInTheLoopProps<T>;
-  }
-  
-  if (status === ToolCallStatus.Complete) {
-    return {
-      ...props,
-      status: ToolCallStatus.Complete,
-      result: typeof props.result === 'string' ? props.result : '',
-      respond: undefined
-    } as HumanInTheLoopProps<T>;
-  }
-  
-  // InProgress
-  return {
-    ...props,
-    status: ToolCallStatus.InProgress,
-    result: undefined,
-    respond: undefined
-  } as HumanInTheLoopProps<T>;
-}

package/tsconfig.spec.json

@@ -1,12 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "types": ["node", "vitest/globals"]
-  },
-  "include": [
-    "src/**/*.spec.ts",
-    "src/**/*.test.ts",
-    "src/**/*.d.ts"
-  ],
-  "exclude": ["node_modules", "dist"]
-}