@optimizely-opal/opal-tool-ocp-sdk 0.0.0-OCP-1487.7 → 0.0.0-OCP-1487.9

package/src/service/Service.ts

@@ -89,6 +89,21 @@ export class ToolsService {
   private functions: Map<string, Tool<any>> = new Map();
   private interactions: Map<string, Interaction<any>> = new Map();
 
+  /**
+   * Set the import context for tools that will be imported
+   * @param context The context type ('global' | 'regular')
+   */
+  public setImportContext(context: 'global' | 'regular'): void {
+    globalThis.__IMPORT_CONTEXT = context;
+  }
+
+  /**
+   * Clear the import context after import is complete
+   */
+  public clearImportContext(): void {
+    globalThis.__IMPORT_CONTEXT = undefined;
+  }
+
   /**
    * Enforce OptiID authentication for tools by ensuring OptiID auth requirement is present
    * @param authRequirements Original authentication requirements
@@ -113,6 +128,7 @@ export class ToolsService {
    * @param parameters List of parameters for the tool
    * @param endpoint API endpoint for the tool
    * @param authRequirements Authentication requirements (optional)
+   * @param isGlobal Whether the tool is global
    */
   public registerTool<TAuthData>(
     name: string,
@@ -217,17 +233,18 @@ export class ToolsService {
   /**
    * Handle discovery endpoint requests with context-aware filtering
    * @param functionContext The function context making the request
-   * @returns Response with filtered functions based on context type
+   * @returns Response with filtered functions based on where tools are defined/imported
    */
   private handleDiscovery(functionContext: ToolFunction | GlobalToolFunction): App.Response {
-    // Filter tools based on the function context type
-    const isGlobalFunction = functionContext instanceof GlobalToolFunction;
-    const availableFunctions = Array.from(this.functions.values()).filter((f) => {
-      if (isGlobalFunction) {
-        // Global functions can only see global tools
-        return f.isGlobal;
+    const isGlobalContext = functionContext instanceof GlobalToolFunction;
+
+    const availableFunctions = Array.from(this.functions.values()).filter((tool) => {
+      if (isGlobalContext) {
+        // Global context can only see global tools (defined in or imported into GlobalToolFunction)
+        return tool.isGlobal;
       } else {
-        return !f.isGlobal;
+        // Regular context can only see regular tools (defined in or imported into ToolFunction)
+        return !tool.isGlobal;
       }
     });
 

package/src/utils/ImportUtils.ts

@@ -0,0 +1,45 @@
+import { toolsService } from '../service/Service';
+
+/**
+ * Import a module as global tools
+ * @param modulePath The path to the module to import
+ * @param baseUrl The base URL for resolving relative imports (optional)
+ * @returns The imported module
+ */
+export async function importAsGlobal<T = any>(
+  modulePath: string,
+  baseUrl?: string
+): Promise<T> {
+  try {
+    toolsService.setImportContext('global');
+    // If baseUrl is provided, resolve the module path relative to it
+    // Otherwise, use the modulePath as-is
+    const resolvedPath = baseUrl ? new URL(modulePath, baseUrl).href : modulePath;
+    const module = await import(resolvedPath);
+    return module;
+  } finally {
+    toolsService.clearImportContext();
+  }
+}
+
+/**
+ * Import a module as regular tools
+ * @param modulePath The path to the module to import
+ * @param baseUrl The base URL for resolving relative imports (optional)
+ * @returns The imported module
+ */
+export async function importAsRegular<T = any>(
+  modulePath: string,
+  baseUrl?: string
+): Promise<T> {
+  try {
+    toolsService.setImportContext('regular');
+    // If baseUrl is provided, resolve the module path relative to it
+    // Otherwise, use the modulePath as-is
+    const resolvedPath = baseUrl ? new URL(modulePath, baseUrl).href : modulePath;
+    const module = await import(resolvedPath);
+    return module;
+  } finally {
+    toolsService.clearImportContext();
+  }
+}