@copilotkitnext/angular 0.0.1 → 0.0.4

package/dist/esm2022/utils/human-in-the-loop.utils.mjs

@@ -0,0 +1,296 @@
+import { DestroyRef, inject, signal } from '@angular/core';
+import { CopilotKitService } from '../core/copilotkit.service';
+import { ToolCallStatus } 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(tool) {
+    const service = inject(CopilotKitService);
+    const destroyRef = inject(DestroyRef);
+    // Create state management
+    const statusSignal = signal(ToolCallStatus.InProgress);
+    let resolvePromise = null;
+    // Create respond function
+    const respond = async (result) => {
+        if (resolvePromise) {
+            resolvePromise(result);
+            statusSignal.set(ToolCallStatus.Complete);
+            resolvePromise = null;
+        }
+    };
+    // Create handler that returns a Promise
+    const handler = async (_args) => {
+        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 = {
+        ...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(service, tool) {
+    // Create state management
+    const statusSignal = signal(ToolCallStatus.InProgress);
+    let resolvePromise = null;
+    // Create respond function
+    const respond = async (result) => {
+        if (resolvePromise) {
+            resolvePromise(result);
+            statusSignal.set(ToolCallStatus.Complete);
+            resolvePromise = null;
+        }
+    };
+    // Create handler that returns a Promise
+    const handler = async (_args) => {
+        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 = {
+        ...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(service, tool) {
+    // Create state management
+    const statusSignal = signal(ToolCallStatus.InProgress);
+    let currentTool = { ...tool };
+    let toolId = '';
+    let resolvePromise = null;
+    // Create respond function
+    const respond = async (result) => {
+        if (resolvePromise) {
+            resolvePromise(result);
+            statusSignal.set(ToolCallStatus.Complete);
+            resolvePromise = null;
+        }
+    };
+    // Create handler that returns a Promise
+    const handler = async (_args) => {
+        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 = {
+            ...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) => {
+            // 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(originalRender, _statusSignal, _respond) {
+    // 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) {
+    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(props, status, respond) {
+    if (status === ToolCallStatus.Executing && respond) {
+        return {
+            ...props,
+            status: ToolCallStatus.Executing,
+            respond
+        };
+    }
+    if (status === ToolCallStatus.Complete) {
+        return {
+            ...props,
+            status: ToolCallStatus.Complete,
+            result: typeof props.result === 'string' ? props.result : '',
+            respond: undefined
+        };
+    }
+    // InProgress
+    return {
+        ...props,
+        status: ToolCallStatus.InProgress,
+        result: undefined,
+        respond: undefined
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"human-in-the-loop.utils.js","sourceRoot":"","sources":["../../../src/utils/human-in-the-loop.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { \n  DestroyRef, \n  inject, \n  signal, \n  Signal,\n  Type,\n  TemplateRef\n} from '@angular/core';\nimport { CopilotKitService } from '../core/copilotkit.service';\nimport { \n  AngularHumanInTheLoop, \n  ToolCallStatus,\n  HumanInTheLoopState,\n  HumanInTheLoopProps,\n  AngularFrontendTool\n} from '../core/copilotkit.types';\n\n/**\n * Registers a human-in-the-loop tool that requires user interaction.\n * Must be called within an injection context.\n * Automatically cleans up when the component/service is destroyed.\n * \n * @param tool - The human-in-the-loop tool configuration\n * @returns The tool ID\n * \n * @example\n * ```typescript\n * export class ApprovalComponent {\n *   toolId = registerHumanInTheLoop({\n *     name: 'requireApproval',\n *     description: 'Requires user approval',\n *     args: z.object({ action: z.string() }),\n *     render: ApprovalDialogComponent\n *   });\n * }\n * ```\n */\nexport function registerHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(\n  tool: AngularHumanInTheLoop<T>\n): string {\n  const service = inject(CopilotKitService);\n  const destroyRef = inject(DestroyRef);\n  \n  // Create state management\n  const statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);\n  let resolvePromise: ((result: unknown) => void) | null = null;\n  \n  // Create respond function\n  const respond = async (result: unknown): Promise<void> => {\n    if (resolvePromise) {\n      resolvePromise(result);\n      statusSignal.set(ToolCallStatus.Complete);\n      resolvePromise = null;\n    }\n  };\n  \n  // Create handler that returns a Promise\n  const handler = async (_args: T): Promise<unknown> => {\n    return new Promise((resolve) => {\n      statusSignal.set(ToolCallStatus.Executing);\n      resolvePromise = resolve;\n    });\n  };\n  \n  // Create enhanced render function\n  const enhancedRender = createEnhancedRender(tool.render, statusSignal, respond);\n  \n  // Create the frontend tool\n  const frontendTool: AngularFrontendTool<T> = {\n    ...tool,\n    handler,\n    render: enhancedRender\n  };\n  \n  // Add the tool (returns void, so we use the tool name as ID)\n  service.copilotkit.addTool(frontendTool);\n  const toolId = frontendTool.name;\n  \n  // Register tool render if provided\n  if (frontendTool.render && tool.parameters) {\n    service.registerToolRender(frontendTool.name, {\n      name: frontendTool.name,\n      args: tool.parameters,\n      render: frontendTool.render\n    });\n  }\n  \n  // Cleanup on destroy\n  destroyRef.onDestroy(() => {\n    service.copilotkit.removeTool(toolId);\n    if (frontendTool.render) {\n      service.unregisterToolRender(frontendTool.name);\n    }\n  });\n  \n  return toolId;\n}\n\n/**\n * Adds a human-in-the-loop tool with explicit service parameter.\n * Returns a cleanup function.\n * \n * @param service - The CopilotKitService instance\n * @param tool - The human-in-the-loop tool configuration\n * @returns Cleanup function to remove the tool\n * \n * @example\n * ```typescript\n * export class MyComponent implements OnInit, OnDestroy {\n *   private cleanup?: () => void;\n *   \n *   constructor(private copilotkit: CopilotKitService) {}\n *   \n *   ngOnInit() {\n *     this.cleanup = addHumanInTheLoop(this.copilotkit, {\n *       name: 'requireApproval',\n *       description: 'Requires user approval',\n *       args: z.object({ action: z.string() }),\n *       render: ApprovalDialogComponent\n *     });\n *   }\n *   \n *   ngOnDestroy() {\n *     this.cleanup?.();\n *   }\n * }\n * ```\n */\nexport function addHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(\n  service: CopilotKitService,\n  tool: AngularHumanInTheLoop<T>\n): () => void {\n  // Create state management\n  const statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);\n  let resolvePromise: ((result: unknown) => void) | null = null;\n  \n  // Create respond function\n  const respond = async (result: unknown): Promise<void> => {\n    if (resolvePromise) {\n      resolvePromise(result);\n      statusSignal.set(ToolCallStatus.Complete);\n      resolvePromise = null;\n    }\n  };\n  \n  // Create handler that returns a Promise\n  const handler = async (_args: T): Promise<unknown> => {\n    return new Promise((resolve) => {\n      statusSignal.set(ToolCallStatus.Executing);\n      resolvePromise = resolve;\n    });\n  };\n  \n  // Create enhanced render function\n  const enhancedRender = createEnhancedRender(tool.render, statusSignal, respond);\n  \n  // Create the frontend tool\n  const frontendTool: AngularFrontendTool<T> = {\n    ...tool,\n    handler,\n    render: enhancedRender\n  };\n  \n  // Add the tool (returns void, so we use the tool name as ID)\n  service.copilotkit.addTool(frontendTool);\n  const toolId = frontendTool.name;\n  \n  // Register tool render if provided\n  if (frontendTool.render && tool.parameters) {\n    service.registerToolRender(frontendTool.name, {\n      name: frontendTool.name,\n      args: tool.parameters,\n      render: frontendTool.render\n    });\n  }\n  \n  // Return cleanup function\n  return () => {\n    service.copilotkit.removeTool(toolId);\n    if (frontendTool.render) {\n      service.unregisterToolRender(frontendTool.name);\n    }\n  };\n}\n\n/**\n * Creates a human-in-the-loop tool with dynamic update capabilities.\n * \n * @param service - The CopilotKitService instance\n * @param tool - The human-in-the-loop tool configuration\n * @returns Object with status signal, update and destroy methods\n * \n * @example\n * ```typescript\n * export class MyComponent {\n *   humanInTheLoop = createHumanInTheLoop(this.copilotkit, {\n *     name: 'requireApproval',\n *     description: 'Requires user approval',\n *     args: z.object({ action: z.string() }),\n *     render: ApprovalDialogComponent\n *   });\n *   \n *   updateDescription(newDesc: string) {\n *     this.humanInTheLoop.update({ description: newDesc });\n *   }\n *   \n *   ngOnDestroy() {\n *     this.humanInTheLoop.destroy();\n *   }\n * }\n * ```\n */\nexport function createHumanInTheLoop<T extends Record<string, any> = Record<string, any>>(\n  service: CopilotKitService,\n  tool: AngularHumanInTheLoop<T>\n): HumanInTheLoopState & { update: (updates: Partial<AngularHumanInTheLoop<T>>) => void } {\n  // Create state management\n  const statusSignal = signal<ToolCallStatus>(ToolCallStatus.InProgress);\n  let currentTool = { ...tool };\n  let toolId: string = '';\n  let resolvePromise: ((result: unknown) => void) | null = null;\n  \n  // Create respond function\n  const respond = async (result: unknown): Promise<void> => {\n    if (resolvePromise) {\n      resolvePromise(result);\n      statusSignal.set(ToolCallStatus.Complete);\n      resolvePromise = null;\n    }\n  };\n  \n  // Create handler that returns a Promise\n  const handler = async (_args: T): Promise<unknown> => {\n    return new Promise((resolve) => {\n      statusSignal.set(ToolCallStatus.Executing);\n      resolvePromise = resolve;\n    });\n  };\n  \n  // Function to add the tool\n  const addTool = () => {\n    // Create enhanced render function\n    const enhancedRender = createEnhancedRender(currentTool.render, statusSignal, respond);\n    \n    // Create the frontend tool\n    const frontendTool: AngularFrontendTool<T> = {\n      ...currentTool,\n      handler,\n      render: enhancedRender\n    };\n    \n    // Add tool (returns void, so we use the tool name as ID)\n    service.copilotkit.addTool(frontendTool);\n    toolId = frontendTool.name;\n    \n    // Register tool render if provided\n    if (frontendTool.render && currentTool.parameters) {\n      service.registerToolRender(frontendTool.name, {\n        name: frontendTool.name,\n        args: currentTool.parameters,\n        render: frontendTool.render\n      });\n    }\n  };\n  \n  // Initialize the tool\n  addTool();\n  \n  return {\n    status: statusSignal.asReadonly(),\n    toolId,\n    update: (updates: Partial<AngularHumanInTheLoop<T>>) => {\n      // Remove old tool\n      service.copilotkit.removeTool(toolId);\n      if (currentTool.render) {\n        service.unregisterToolRender(currentTool.name);\n      }\n      \n      // Update tool configuration\n      currentTool = { ...currentTool, ...updates };\n      \n      // Re-add with new configuration\n      addTool();\n    },\n    destroy: () => {\n      service.copilotkit.removeTool(toolId);\n      if (currentTool.render) {\n        service.unregisterToolRender(currentTool.name);\n      }\n    }\n  };\n}\n\n/**\n * Creates an enhanced render function that injects the respond function\n * when the status is 'executing'.\n */\nfunction createEnhancedRender<T extends Record<string, any>>(\n  originalRender: Type<any> | TemplateRef<HumanInTheLoopProps<T>>,\n  _statusSignal: Signal<ToolCallStatus>,\n  _respond: (result: unknown) => Promise<void>\n): Type<any> | TemplateRef<any> {\n  // For component classes, we need to create a wrapper\n  if (isComponentClass(originalRender)) {\n    // Return a wrapper component factory\n    // This is complex in Angular and would require dynamic component creation\n    // For now, we'll return the original and rely on prop injection\n    return originalRender;\n  }\n  \n  // For templates, we can't easily wrap them\n  // The template context will be enhanced in the render component\n  return originalRender;\n}\n\n/**\n * Helper function to check if a value is a component class\n */\nfunction isComponentClass(value: any): value is Type<any> {\n  return typeof value === 'function' && value.prototype;\n}\n\n/**\n * Enhanced component wrapper for human-in-the-loop.\n * This would be used internally by the tool render component to inject\n * the respond function based on status.\n * \n * @internal\n */\nexport function enhancePropsForHumanInTheLoop<T>(\n  props: HumanInTheLoopProps<T>,\n  status: ToolCallStatus,\n  respond?: (result: unknown) => Promise<void>\n): HumanInTheLoopProps<T> {\n  if (status === ToolCallStatus.Executing && respond) {\n    return {\n      ...props,\n      status: ToolCallStatus.Executing,\n      respond\n    } as HumanInTheLoopProps<T>;\n  }\n  \n  if (status === ToolCallStatus.Complete) {\n    return {\n      ...props,\n      status: ToolCallStatus.Complete,\n      result: typeof props.result === 'string' ? props.result : '',\n      respond: undefined\n    } as HumanInTheLoopProps<T>;\n  }\n  \n  // InProgress\n  return {\n    ...props,\n    status: ToolCallStatus.InProgress,\n    result: undefined,\n    respond: undefined\n  } as HumanInTheLoopProps<T>;\n}"]}