Update example to SK 1.1, fix TS generator and marshaller bugs

examples/semantic-kernel/example.js

@@ -4,11 +4,12 @@
 // @ts-check
 
 import dotnet from 'node-api-dotnet';
+import './bin/System.Text.Encodings.Web.js';
+import './bin/Microsoft.Extensions.DependencyInjection.js';
 import './bin/Microsoft.Extensions.Logging.Abstractions.js';
 import './bin/Microsoft.SemanticKernel.Abstractions.js';
 import './bin/Microsoft.SemanticKernel.Core.js';
-import './bin/Microsoft.SemanticKernel.Connectors.AI.OpenAI.js';
-import './bin/Microsoft.SemanticKernel.TemplateEngine.Basic.js';
+import './bin/Microsoft.SemanticKernel.Connectors.OpenAI.js';
 
 const Logging = dotnet.Microsoft.Extensions.Logging;
 const SK = dotnet.Microsoft.SemanticKernel;
@@ -28,18 +29,22 @@ const loggerFactory = {
   dispose() {}
 };
 
-let kernelBuilder = new SK.KernelBuilder();
-kernelBuilder.WithLoggerFactory(loggerFactory);
+const kernelBuilder = SK.Kernel.CreateBuilder();
+//kernelBuilder.WithLoggerFactory(loggerFactory);
 
 // The JS marshaller does not yet support extension methods.
-SK.OpenAIKernelBuilderExtensions.WithAzureOpenAIChatCompletionService(
+SK.OpenAIServiceCollectionExtensions.AddAzureOpenAIChatCompletion(
   kernelBuilder,
   process.env['OPENAI_DEPLOYMENT'] || '',
   process.env['OPENAI_ENDPOINT'] || '',
   process.env['OPENAI_KEY'] || '',
+  // Include optional parameters to disambiguate the overload.
+  undefined,
+  undefined,
+  undefined,
 );
 
-const kernel = kernelBuilder.Build();
+const kernel = SK.KernelExtensions.Build(kernelBuilder);
 
 const prompt = `{{$input}}
 
@@ -57,15 +62,18 @@ such orders would conflict with the First Law.
 does not conflict with the First or Second Law.
 `;
 
-const requestSettings = new SK.Connectors.AI.OpenAI.OpenAIRequestSettings();
-requestSettings.MaxTokens = 100;
+const executionSettings = new SK.Connectors.OpenAI.OpenAIPromptExecutionSettings();
+executionSettings.MaxTokens = 100;
 
 // The JS marshaller does not yet support extension methods.
-const summaryFunction = SK.OpenAIKernelExtensions
-  .CreateSemanticFunction(kernel, prompt, requestSettings);
+const summaryFunction = SK.KernelExtensions.CreateFunctionFromPrompt(
+  kernel, prompt, executionSettings);
 
-const summary = await SK.SKFunctionExtensions.InvokeAsync(
-  summaryFunction, textToSummarize, kernel);
+const summarizeArguments = new Map();
+summarizeArguments.set('input', textToSummarize);
+
+const summary = await kernel.InvokeAsync(
+  summaryFunction, new SK.KernelArguments(summarizeArguments, undefined));
 
 console.log();
 console.log(summary.toString());

examples/semantic-kernel/semantic-kernel.csproj

@@ -8,7 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.SemanticKernel" Version="1.0.0-beta8" />
+    <PackageReference Include="Microsoft.SemanticKernel" Version="1.1.0" />
     <PackageReference Include="Microsoft.JavaScript.NodeApi.Generator" Version="0.4.*-*" />
   </ItemGroup>
 

src/NodeApi.DotNetHost/JSMarshaller.cs

@@ -351,7 +351,7 @@ public Expression<JSCallback> BuildFromJSConstructorExpression(ConstructorInfo c
 
         for (int i = 0; i < parameters.Length; i++)
         {
-            argVariables[i] = Expression.Variable(parameters[i].ParameterType, parameters[i].Name);
+            argVariables[i] = Variable(parameters[i]);
             statements.Add(Expression.Assign(argVariables[i],
                 BuildArgumentExpression(i, parameters[i])));
         }
@@ -1859,10 +1859,10 @@ private LambdaExpression BuildConvertFromJSValueExpression(Type toType)
             // public type is passed to JS and then passed back to .NET as `object` type.
 
             /*
-             * (T)(value.TryUnwrap() ?? value.TryGetValueExternal());
+             * (T)(value.TryUnwrap() ?? value.GetValueExternalOrPrimitive());
              */
-            MethodInfo getExternalMethod =
-                typeof(JSNativeApi).GetStaticMethod(nameof(JSNativeApi.TryGetValueExternal));
+            MethodInfo getExternalMethod = typeof(JSNativeApi).GetStaticMethod(
+                nameof(JSNativeApi.GetValueExternalOrPrimitive));
             statements = new[]
             {
                 Expression.Convert(

src/NodeApi.DotNetHost/ManagedHost.cs

@@ -175,12 +175,14 @@ JSValue removeListener(JSCallbackArgs args)
     }
 
     public static bool IsTracingEnabled { get; } =
+        Debugger.IsAttached ||
         Environment.GetEnvironmentVariable("TRACE_NODE_API_HOST") == "1";
 
     public static void Trace(string msg)
     {
         if (IsTracingEnabled)
         {
+            Debug.WriteLine(msg);
             Console.WriteLine(msg);
             Console.Out.Flush();
         }
@@ -213,7 +215,8 @@ public static napi_value InitializeModule(napi_env env, napi_value exports)
 
         JSRuntime runtime = new NodejsRuntime();
 
-        if (Environment.GetEnvironmentVariable("TRACE_NODE_API_RUNTIME") != null)
+        if (Debugger.IsAttached ||
+            Environment.GetEnvironmentVariable("TRACE_NODE_API_RUNTIME") != null)
         {
             TraceSource trace = new(typeof(JSValue).Namespace!);
             trace.Switch.Level = SourceLevels.All;

src/NodeApi.DotNetHost/TypeExporter.cs

@@ -94,62 +94,78 @@ private JSReference ExportType(Type type)
 
     private JSReference ExportClass(Type type)
     {
+        string typeName = type.Name;
+        Trace($"### ExportClass({typeName}");
+
         if (_exportedTypes.TryGetValue(type, out JSReference? classObjectReference))
         {
             return classObjectReference;
         }
 
         Trace($"> {nameof(TypeExporter)}.ExportClass({type.FormatName()})");
 
-        bool isStatic = type.IsAbstract && type.IsSealed;
-        Type classBuilderType =
-            (type.IsValueType ? typeof(JSStructBuilder<>) : typeof(JSClassBuilder<>))
-            .MakeGenericType(isStatic ? typeof(object) : type);
-
-        object classBuilder;
-        if (type.IsInterface || isStatic || type.IsValueType)
-        {
-            classBuilder = classBuilderType.CreateInstance(
-                new[] { typeof(string) }, new[] { type.Name });
-        }
-        else
+        // Add a temporary null entry to the dictionary while exporting this type, in case the
+        // type is encountered while exporting members. It will be non-null by the time this method returns
+        // (or removed if an exception is thrown).
+        _exportedTypes.Add(type, null!);
+        try
         {
-            ConstructorInfo[] constructors =
-                type.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
-                .Where(IsSupportedConstructor)
-                .ToArray();
-            JSCallbackDescriptor constructorDescriptor;
-            if (constructors.Length == 1 &&
-                !constructors[0].GetParameters().Any((p) => p.IsOptional))
+            bool isStatic = type.IsAbstract && type.IsSealed;
+            Type classBuilderType =
+                (type.IsValueType ? typeof(JSStructBuilder<>) : typeof(JSClassBuilder<>))
+                .MakeGenericType(isStatic ? typeof(object) : type);
+
+            object classBuilder;
+            if (type.IsInterface || isStatic || type.IsValueType)
             {
-                constructorDescriptor =
-                    _marshaller.BuildFromJSConstructorExpression(constructors[0]).Compile();
+                classBuilder = classBuilderType.CreateInstance(
+                    new[] { typeof(string) }, new[] { type.Name });
             }
             else
             {
-                // Multiple constructors or optional parameters require overload resolution.
-                constructorDescriptor =
-                    _marshaller.BuildConstructorOverloadDescriptor(constructors);
-            }
+                ConstructorInfo[] constructors =
+                    type.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
+                    .Where(IsSupportedConstructor)
+                    .ToArray();
+                JSCallbackDescriptor constructorDescriptor;
+                if (constructors.Length == 1 &&
+                    !constructors[0].GetParameters().Any((p) => p.IsOptional))
+                {
+                    constructorDescriptor =
+                        _marshaller.BuildFromJSConstructorExpression(constructors[0]).Compile();
+                }
+                else
+                {
+                    // Multiple constructors or optional parameters require overload resolution.
+                    constructorDescriptor =
+                        _marshaller.BuildConstructorOverloadDescriptor(constructors);
+                }
 
-            classBuilder = classBuilderType.CreateInstance(
-                new[] { typeof(string), typeof(JSCallbackDescriptor) },
-                new object[] { type.Name, constructorDescriptor });
-        }
+                classBuilder = classBuilderType.CreateInstance(
+                    new[] { typeof(string), typeof(JSCallbackDescriptor) },
+                    new object[] { type.Name, constructorDescriptor });
+            }
 
-        ExportProperties(type, classBuilder);
-        ExportMethods(type, classBuilder);
-        ExportNestedTypes(type, classBuilder);
+            ExportProperties(type, classBuilder);
+            ExportMethods(type, classBuilder);
+            ExportNestedTypes(type, classBuilder);
 
-        string defineMethodName = type.IsInterface ? "DefineInterface" :
-            isStatic ? "DefineStaticClass" : type.IsValueType ? "DefineStruct" : "DefineClass";
-        MethodInfo defineClassMethod = classBuilderType.GetInstanceMethod(defineMethodName);
-        JSValue classObject = (JSValue)defineClassMethod.Invoke(
-            classBuilder,
-            defineClassMethod.GetParameters().Select((_) => (object?)null).ToArray())!;
+            string defineMethodName = type.IsInterface ? "DefineInterface" :
+                isStatic ? "DefineStaticClass" : type.IsValueType ? "DefineStruct" : "DefineClass";
+            MethodInfo defineClassMethod = classBuilderType.GetInstanceMethod(defineMethodName);
+            JSValue classObject = (JSValue)defineClassMethod.Invoke(
+                classBuilder,
+                defineClassMethod.GetParameters().Select((_) => (object?)null).ToArray())!;
 
-        classObjectReference = new JSReference(classObject);
-        _exportedTypes.Add(type, classObjectReference);
+            classObjectReference = new JSReference(classObject);
+            _exportedTypes[type] = classObjectReference;
+        }
+        catch
+        {
+            // Clean up the temporary null entry.
+            _exportedTypes.Remove(type);
+            throw;
+        }
 
         // Also export any types returned by properties or methods of this type, because
         // they might otherwise not be referenced by JS before they are used.

src/NodeApi.Generator/SourceGenerator.cs

@@ -24,6 +24,8 @@ public abstract class SourceGenerator
 
     private static readonly Regex s_paragraphBreakRegex = new(@" *\<para */\> *");
 
+    protected const char NonBreakingSpace = (char)0xA0;
+
     public enum DiagnosticId
     {
         NoExports = 1000,
@@ -193,11 +195,11 @@ protected static IEnumerable<string> WrapComment(string comment, int wrapColumn)
                     }
                 }
 
-                yield return comment.Substring(0, i).TrimEnd();
+                yield return comment.Substring(0, i).TrimEnd().Replace(NonBreakingSpace, ' ');
                 comment = comment.Substring(i + 1);
             }
 
-            yield return comment.TrimEnd();
+            yield return comment.TrimEnd().Replace(NonBreakingSpace, ' ');
         }
     }
 }