@copilotkitnext/angular 0.0.1 → 0.0.4

package/src/core/__tests__/copilotkit.service.wildcard.spec.ts

@@ -1,316 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { CopilotKitService } from '../copilotkit.service';
-import { Component } from '@angular/core';
-import { provideCopilotKit } from '../copilotkit.providers';
-import { AngularFrontendTool } from '../../types/frontend-tool';
-import { AngularHumanInTheLoop } from '../../types/human-in-the-loop';
-import { z } from 'zod';
-
-describe('CopilotKitService - Wildcard Tool', () => {
-  beforeEach(() => {
-    TestBed.resetTestingModule();
-  });
-
-  describe('Wildcard Frontend Tool', () => {
-    it('should register wildcard frontend tool', () => {
-      const wildcardHandler = vi.fn(async ({ toolName, args }) => 
-        `Handled ${toolName}`
-      );
-      
-      const wildcardTool: AngularFrontendTool = {
-        name: '*',
-        description: 'Fallback for undefined tools',
-        handler: wildcardHandler,
-      };
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            frontendTools: [wildcardTool],
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      expect(service.copilotkit.tools['*']).toBeDefined();
-      expect(service.copilotkit.tools['*'].name).toBe('*');
-      expect(service.copilotkit.tools['*'].handler).toBe(wildcardHandler);
-    });
-
-    it('should register wildcard alongside specific tools', () => {
-      const specificHandler = vi.fn();
-      const wildcardHandler = vi.fn();
-      
-      const specificTool: AngularFrontendTool = {
-        name: 'specific',
-        handler: specificHandler,
-      };
-      
-      const wildcardTool: AngularFrontendTool = {
-        name: '*',
-        handler: wildcardHandler,
-      };
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            frontendTools: [specificTool, wildcardTool],
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      expect(service.copilotkit.tools['specific']).toBeDefined();
-      expect(service.copilotkit.tools['*']).toBeDefined();
-    });
-
-    it('should register wildcard with render component', () => {
-      @Component({
-        selector: 'app-wildcard-render',
-        template: '<div>Unknown tool: {{ args.toolName }}</div>',
-        standalone: true,
-      })
-      class WildcardRenderComponent {
-        args: any;
-      }
-      
-      const wildcardTool: AngularFrontendTool = {
-        name: '*',
-        description: 'Fallback with render',
-        parameters: z.object({
-          toolName: z.string(),
-          args: z.unknown(),
-        }),
-        render: WildcardRenderComponent,
-      };
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            frontendTools: [wildcardTool],
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      const renderToolCalls = service.renderToolCalls();
-      const wildcardRender = renderToolCalls.find(r => r.name === '*');
-      expect(wildcardRender).toBeDefined();
-      expect(wildcardRender?.render).toBe(WildcardRenderComponent);
-    });
-
-    it('should support wildcard with agentId', () => {
-      const wildcardHandler = vi.fn();
-      const wildcardTool: AngularFrontendTool = {
-        name: '*',
-        handler: wildcardHandler,
-        agentId: 'specificAgent',
-      };
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            frontendTools: [wildcardTool],
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      expect(service.copilotkit.tools['*'].agentId).toBe('specificAgent');
-    });
-  });
-
-  describe('Wildcard Human-in-the-Loop', () => {
-    it('should register wildcard human-in-the-loop tool', () => {
-      @Component({
-        selector: 'app-wildcard-interaction',
-        template: '<div>Unknown interaction: {{ args.toolName }}</div>',
-        standalone: true,
-      })
-      class WildcardInteractionComponent {
-        args: any;
-      }
-      
-      const wildcardHitl: AngularHumanInTheLoop = {
-        name: '*',
-        description: 'Fallback interaction',
-        parameters: z.object({
-          toolName: z.string(),
-          args: z.unknown(),
-        }),
-        render: WildcardInteractionComponent,
-      };
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            humanInTheLoop: [wildcardHitl],
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      expect(service.copilotkit.tools['*']).toBeDefined();
-      const renderToolCalls = service.renderToolCalls();
-      const wildcardRender = renderToolCalls.find(r => r.name === '*');
-      expect(wildcardRender).toBeDefined();
-      expect(wildcardRender?.render).toBe(WildcardInteractionComponent);
-    });
-
-    it('should support wildcard human-in-the-loop with agentId', () => {
-      @Component({
-        selector: 'app-wildcard',
-        template: '<div>Wildcard</div>',
-        standalone: true,
-      })
-      class WildcardComponent {}
-      
-      const wildcardHitl: AngularHumanInTheLoop = {
-        name: '*',
-        parameters: z.object({
-          toolName: z.string(),
-          args: z.unknown(),
-        }),
-        render: WildcardComponent,
-        agentId: 'agent1',
-      };
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            humanInTheLoop: [wildcardHitl],
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      expect(service.copilotkit.tools['*'].agentId).toBe('agent1');
-      const renderToolCalls = service.renderToolCalls();
-      const wildcardRender = renderToolCalls.find(r => r.name === '*');
-      expect(wildcardRender?.agentId).toBe('agent1');
-    });
-  });
-
-  describe('Wildcard Render Tool Calls', () => {
-    it('should register wildcard in renderToolCalls', () => {
-      @Component({
-        selector: 'app-wildcard-render',
-        template: '<div>Fallback render</div>',
-        standalone: true,
-      })
-      class WildcardRenderComponent {}
-      
-      const renderToolCalls = [{
-        name: '*',
-        args: z.object({
-          toolName: z.string(),
-          args: z.unknown(),
-        }),
-        render: WildcardRenderComponent,
-      }];
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            renderToolCalls,
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      const currentRenderToolCalls = service.renderToolCalls();
-      const wildcardRender = currentRenderToolCalls.find(r => r.name === '*');
-      expect(wildcardRender).toBeDefined();
-      expect(wildcardRender?.render).toBe(WildcardRenderComponent);
-    });
-
-    it('should support wildcard render with agentId', () => {
-      @Component({
-        selector: 'app-agent-wildcard',
-        template: '<div>Agent wildcard</div>',
-        standalone: true,
-      })
-      class AgentWildcardComponent {}
-      
-      const renderToolCalls = [{
-        name: '*',
-        args: z.object({
-          toolName: z.string(),
-          args: z.unknown(),
-        }),
-        render: AgentWildcardComponent,
-        agentId: 'agent1',
-      }];
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            renderToolCalls,
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      const currentRenderToolCalls = service.renderToolCalls();
-      const wildcardRender = currentRenderToolCalls.find(r => r.name === '*');
-      expect(wildcardRender?.agentId).toBe('agent1');
-    });
-  });
-
-  describe('Combined wildcard and specific tools', () => {
-    it('should handle both wildcard and specific tools together', () => {
-      @Component({
-        selector: 'app-specific',
-        template: '<div>Specific</div>',
-        standalone: true,
-      })
-      class SpecificRenderComponent {}
-      
-      @Component({
-        selector: 'app-wildcard',
-        template: '<div>Wildcard</div>',
-        standalone: true,
-      })
-      class WildcardRenderComponent {}
-      
-      const frontendTools: AngularFrontendTool[] = [
-        {
-          name: 'specificTool',
-          handler: vi.fn(),
-          parameters: z.object({ value: z.string() }),
-          render: SpecificRenderComponent,
-        },
-        {
-          name: '*',
-          handler: vi.fn(),
-          parameters: z.object({
-            toolName: z.string(),
-            args: z.unknown(),
-          }),
-          render: WildcardRenderComponent,
-        },
-      ];
-
-      TestBed.configureTestingModule({
-        providers: [
-          provideCopilotKit({
-            frontendTools,
-          }),
-        ],
-      });
-      const service = TestBed.inject(CopilotKitService);
-      
-      // Both tools should be registered
-      expect(service.copilotkit.tools['specificTool']).toBeDefined();
-      expect(service.copilotkit.tools['*']).toBeDefined();
-      
-      // Both renders should be registered
-      const renderToolCalls = service.renderToolCalls();
-      const specificRender = renderToolCalls.find(r => r.name === 'specificTool');
-      const wildcardRender = renderToolCalls.find(r => r.name === '*');
-      expect(specificRender).toBeDefined();
-      expect(wildcardRender).toBeDefined();
-    });
-  });
-});

package/src/core/chat-configuration/__tests__/chat-configuration.service.spec.ts

@@ -1,287 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { CopilotChatConfigurationService } from '../chat-configuration.service';
-import { provideCopilotChatConfiguration } from '../chat-configuration.providers';
-import { 
-  COPILOT_CHAT_DEFAULT_LABELS,
-  COPILOT_CHAT_INITIAL_CONFIG
-} from '../chat-configuration.types';
-import { effect } from '@angular/core';
-
-describe('CopilotChatConfigurationService', () => {
-  describe('Default Configuration', () => {
-    let service: CopilotChatConfigurationService;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: [CopilotChatConfigurationService]
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-    });
-
-    it('should create service with default labels', () => {
-      expect(service).toBeDefined();
-      expect(service.labels()).toEqual(COPILOT_CHAT_DEFAULT_LABELS);
-    });
-
-    it('should have undefined input value by default', () => {
-      expect(service.inputValue()).toBeUndefined();
-    });
-
-    it('should have no handlers by default', () => {
-      expect(service.getSubmitHandler()).toBeUndefined();
-      expect(service.getChangeHandler()).toBeUndefined();
-    });
-  });
-
-  describe('With Initial Configuration', () => {
-    let service: CopilotChatConfigurationService;
-    const customLabels = {
-      chatInputPlaceholder: 'Custom placeholder'
-    };
-    const submitHandler = vi.fn();
-    const changeHandler = vi.fn();
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: provideCopilotChatConfiguration({
-          labels: customLabels,
-          inputValue: 'initial value',
-          onSubmitInput: submitHandler,
-          onChangeInput: changeHandler
-        })
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-    });
-
-    it('should merge custom labels with defaults', () => {
-      const labels = service.labels();
-      expect(labels.chatInputPlaceholder).toBe('Custom placeholder');
-      expect(labels.chatInputToolbarAddButtonLabel).toBe(COPILOT_CHAT_DEFAULT_LABELS.chatInputToolbarAddButtonLabel);
-    });
-
-    it('should set initial input value', () => {
-      expect(service.inputValue()).toBe('initial value');
-    });
-
-    it('should set initial handlers', () => {
-      expect(service.getSubmitHandler()).toBe(submitHandler);
-      expect(service.getChangeHandler()).toBe(changeHandler);
-    });
-  });
-
-  describe('Label Management', () => {
-    let service: CopilotChatConfigurationService;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: [CopilotChatConfigurationService]
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-    });
-
-    it('should update labels partially', () => {
-      service.setLabels({
-        chatInputPlaceholder: 'New placeholder',
-        userMessageToolbarEditMessageLabel: 'Modify'
-      });
-
-      const labels = service.labels();
-      expect(labels.chatInputPlaceholder).toBe('New placeholder');
-      expect(labels.userMessageToolbarEditMessageLabel).toBe('Modify');
-      expect(labels.chatInputToolbarAddButtonLabel).toBe(COPILOT_CHAT_DEFAULT_LABELS.chatInputToolbarAddButtonLabel);
-    });
-
-    it('should notify subscribers when labels change', () => {
-      // Signals update synchronously, no need for effect
-      service.setLabels({ chatInputPlaceholder: 'Updated' });
-      
-      const labelsValue = service.labels();
-      expect(labelsValue.chatInputPlaceholder).toBe('Updated');
-    });
-  });
-
-  describe('Input Value Management', () => {
-    let service: CopilotChatConfigurationService;
-    const changeHandler = vi.fn();
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: provideCopilotChatConfiguration({
-          onChangeInput: changeHandler
-        })
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-      vi.clearAllMocks();
-    });
-
-    it('should update input value', () => {
-      service.setInputValue('test value');
-      expect(service.inputValue()).toBe('test value');
-    });
-
-    it('should trigger change handler when setting value', () => {
-      service.setInputValue('new value');
-      expect(changeHandler).toHaveBeenCalledWith('new value');
-    });
-
-    it('should not trigger change handler for undefined', () => {
-      service.setInputValue(undefined);
-      expect(changeHandler).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Submit and Change Handlers', () => {
-    let service: CopilotChatConfigurationService;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: [CopilotChatConfigurationService]
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-    });
-
-    it('should set and call submit handler', () => {
-      const submitHandler = vi.fn();
-      service.setSubmitHandler(submitHandler);
-      
-      service.submitInput('test message');
-      
-      expect(submitHandler).toHaveBeenCalledWith('test message');
-    });
-
-    it('should set and call change handler', () => {
-      const changeHandler = vi.fn();
-      service.setChangeHandler(changeHandler);
-      
-      service.changeInput('typing...');
-      
-      expect(changeHandler).toHaveBeenCalledWith('typing...');
-    });
-
-    it('should handle missing handlers gracefully', () => {
-      expect(() => service.submitInput('test')).not.toThrow();
-      expect(() => service.changeInput('test')).not.toThrow();
-    });
-
-    it('should replace handlers', () => {
-      const handler1 = vi.fn();
-      const handler2 = vi.fn();
-      
-      service.setSubmitHandler(handler1);
-      service.submitInput('first');
-      expect(handler1).toHaveBeenCalledWith('first');
-      
-      service.setSubmitHandler(handler2);
-      service.submitInput('second');
-      expect(handler2).toHaveBeenCalledWith('second');
-      expect(handler1).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('Update Configuration', () => {
-    let service: CopilotChatConfigurationService;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: [CopilotChatConfigurationService]
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-    });
-
-    it('should update entire configuration at once', () => {
-      const submitHandler = vi.fn();
-      const changeHandler = vi.fn();
-      
-      service.updateConfiguration({
-        labels: { chatInputPlaceholder: 'Updated' },
-        inputValue: 'new value',
-        onSubmitInput: submitHandler,
-        onChangeInput: changeHandler
-      });
-      
-      expect(service.labels().chatInputPlaceholder).toBe('Updated');
-      expect(service.inputValue()).toBe('new value');
-      expect(service.getSubmitHandler()).toBe(submitHandler);
-      expect(service.getChangeHandler()).toBe(changeHandler);
-    });
-
-    it('should handle partial updates', () => {
-      service.setInputValue('initial');
-      
-      service.updateConfiguration({
-        labels: { chatInputPlaceholder: 'New' }
-      });
-      
-      expect(service.labels().chatInputPlaceholder).toBe('New');
-      expect(service.inputValue()).toBe('initial');
-    });
-  });
-
-  describe('Reset', () => {
-    let service: CopilotChatConfigurationService;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        providers: provideCopilotChatConfiguration({
-          labels: { chatInputPlaceholder: 'Custom' },
-          inputValue: 'test',
-          onSubmitInput: vi.fn(),
-          onChangeInput: vi.fn()
-        })
-      });
-      
-      service = TestBed.inject(CopilotChatConfigurationService);
-    });
-
-    it('should reset to default configuration', () => {
-      service.reset();
-      
-      expect(service.labels()).toEqual(COPILOT_CHAT_DEFAULT_LABELS);
-      expect(service.inputValue()).toBeUndefined();
-      expect(service.getSubmitHandler()).toBeUndefined();
-      expect(service.getChangeHandler()).toBeUndefined();
-    });
-  });
-
-  describe('Multiple Service Instances', () => {
-    it('should support independent service instances', () => {
-      // First service with one configuration
-      const providers1 = provideCopilotChatConfiguration({
-        labels: { chatInputPlaceholder: 'Service 1' }
-      });
-      
-      // Second service with different configuration
-      const providers2 = provideCopilotChatConfiguration({
-        labels: { chatInputPlaceholder: 'Service 2' }
-      });
-      
-      // Create two independent injectors
-      const injector1 = TestBed.configureTestingModule({
-        providers: providers1
-      });
-      
-      const service1 = TestBed.inject(CopilotChatConfigurationService);
-      
-      // Reset TestBed for second configuration
-      TestBed.resetTestingModule();
-      
-      const injector2 = TestBed.configureTestingModule({
-        providers: providers2
-      });
-      
-      const service2 = TestBed.inject(CopilotChatConfigurationService);
-      
-      // Services should have different configurations
-      expect(service1).not.toBe(service2);
-      // Note: Due to TestBed reset, we can't compare values directly
-      // but in real usage, they would be independent
-    });
-  });
-});

package/src/core/chat-configuration/chat-configuration.providers.ts

@@ -1,71 +0,0 @@
-import { Provider } from '@angular/core';
-import { CopilotChatConfigurationService } from './chat-configuration.service';
-import { 
-  CopilotChatConfiguration,
-  COPILOT_CHAT_INITIAL_CONFIG 
-} from './chat-configuration.types';
-
-/**
- * Provides CopilotKit chat configuration at a specific component level.
- * This allows for scoped configuration where different parts of the app
- * can have different chat configurations.
- * 
- * @param config - Optional initial configuration
- * @returns Array of providers
- * 
- * @example
- * ```typescript
- * // Global configuration in app.config.ts
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideCopilotChatConfiguration({
- *       labels: {
- *         chatInputPlaceholder: "How can I help you today?"
- *       }
- *     })
- *   ]
- * };
- * 
- * // Component-scoped configuration
- * @Component({
- *   selector: 'customer-support-chat',
- *   providers: [
- *     provideCopilotChatConfiguration({
- *       labels: {
- *         chatInputPlaceholder: "Describe your issue..."
- *       },
- *       onSubmitInput: (value) => console.log('Support message:', value)
- *     })
- *   ],
- *   template: `...`
- * })
- * export class CustomerSupportChatComponent {}
- * 
- * // Multiple independent chats
- * @Component({
- *   selector: 'sales-chat',
- *   providers: [
- *     provideCopilotChatConfiguration({
- *       labels: {
- *         chatInputPlaceholder: "Ask about our products..."
- *       }
- *     })
- *   ],
- *   template: `...`
- * })
- * export class SalesChatComponent {}
- * ```
- */
-export function provideCopilotChatConfiguration(
-  config?: CopilotChatConfiguration
-): Provider[] {
-  return [
-    // Provide the service
-    CopilotChatConfigurationService,
-    // Provide the initial configuration
-    {
-      provide: COPILOT_CHAT_INITIAL_CONFIG,
-      useValue: config || {}
-    }
-  ];
-}