Refactoring, and add helpers for calling functions

CHANGELOG.md

@@ -5,6 +5,7 @@
 - Lowercase model name before invoking for hypermode hosted models [#221](https://github.com/gohypermode/runtime/pull/221)
 - Improve HTTP error messages [#222](https://github.com/gohypermode/runtime/pull/222)
 - Add host function for direct logging [#224](https://github.com/gohypermode/runtime/pull/224)
+- Refactoring, and add helpers for calling functions [#226](https://github.com/gohypermode/runtime/pull/226)
 
 ## 2024-06-03 - Version 0.8.2
 

functions/registration.go

@@ -9,7 +9,6 @@ import (
 
 	"hmruntime/logger"
 	"hmruntime/plugins"
-	"hmruntime/wasmhost"
 )
 
 var Functions = make(map[string]FunctionInfo)
@@ -19,38 +18,22 @@ type FunctionInfo struct {
 	Plugin   *plugins.Plugin
 }
 
-func MonitorRegistration(ctx context.Context) {
-	go func() {
-		for {
-			select {
-			case <-wasmhost.RegistrationRequest:
-				r := newRegistration()
-				r.registerAll(ctx)
-				r.cleanup(ctx)
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-}
-
-type registration struct {
-	functions map[string]bool
-	types     map[string]bool
-}
-
-func newRegistration() *registration {
-	return &registration{
+func RegisterFunctions(ctx context.Context, plugins []plugins.Plugin) {
+	r := &registration{
 		functions: make(map[string]bool),
 		types:     make(map[string]bool),
 	}
-}
 
-func (r *registration) registerAll(ctx context.Context) {
-	var plugins = wasmhost.Plugins.GetAll()
 	for _, plugin := range plugins {
 		r.registerPlugin(ctx, &plugin)
 	}
+
+	r.cleanup(ctx)
+}
+
+type registration struct {
+	functions map[string]bool
+	types     map[string]bool
 }
 
 func (r *registration) registerPlugin(ctx context.Context, plugin *plugins.Plugin) {

hostfunctions/helpers.go

@@ -7,7 +7,10 @@
 import (
 	"context"
 	"errors"
+	"fmt"
+	"strings"
 
+	"hmruntime/functions"
 	"hmruntime/functions/assemblyscript"
 
 	wasm "github.com/tetratelabs/wazero/api"
@@ -112,3 +115,38 @@
 // 	err6 := readParam[T6](ctx, mod, p6, v6)
 // 	return errors.Join(err1, err2, err3, err4, err5, err6)
 // }
+
+func callFunction(ctx context.Context, mod wasm.Module, fnName string, inputValues ...any) (any, error) {
+	info, ok := functions.Functions[fnName]
+	if !ok {
+		return nil, fmt.Errorf("no function registered named %s", fnName)
+	}
+
+	parameters := make(map[string]any, len(inputValues))
+	for i, value := range inputValues {
+		name := info.Function.Parameters[i].Name
+		parameters[name] = value
+	}
+
+	return functions.CallFunction(ctx, mod, info, parameters)
+}
+
+func verifyFunctionSignature(fnName string, expectedTypes ...string) error {
+	info, ok := functions.Functions[fnName]
+	if !ok {
+		return fmt.Errorf("no function registered named %s", fnName)
+	}
+
+	if len(expectedTypes) == 0 {
+		return errors.New("expectedTypes must not be empty")
+	}
+	l := len(expectedTypes)
+	expectedSig := fmt.Sprintf("(%s):%s", strings.Join(expectedTypes[:l-1], ","), expectedTypes[l-1])
+
+	sig := info.Function.Signature()
+	if sig != expectedSig {
+		return fmt.Errorf("function %s has signature %s, expected %s", fnName, sig, expectedSig)
+	}
+
+	return nil
+}

hostfunctions/helpers_test.go

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 Hypermode, Inc.
+ */
+
+package hostfunctions
+
+import (
+	"hmruntime/functions"
+	"hmruntime/plugins"
+	"testing"
+)
+
+func Test_VerifyFunctionSignature(t *testing.T) {
+
+	functions.Functions["myFunction"] = functions.FunctionInfo{
+		Function: plugins.FunctionSignature{
+			Name: "myFunction",
+			Parameters: []plugins.Parameter{
+				{Name: "param1", Type: plugins.TypeInfo{Name: "int"}},
+				{Name: "param2", Type: plugins.TypeInfo{Name: "string"}},
+			},
+			ReturnType: plugins.TypeInfo{Name: "bool"},
+		}}
+
+	err := verifyFunctionSignature("myFunction", "int", "string", "bool")
+	if err != nil {
+		t.Errorf("verifyFunctionSignature failed: %v", err)
+	}
+
+	functions.Functions["anotherFunction"] = functions.FunctionInfo{
+		Function: plugins.FunctionSignature{
+			Name:       "anotherFunction",
+			ReturnType: plugins.TypeInfo{Name: "bool"},
+		},
+	}
+
+	err = verifyFunctionSignature("anotherFunction", "bool")
+	if err != nil {
+		t.Errorf("verifyFunctionSignature failed: %v", err)
+	}
+
+	err = verifyFunctionSignature("nonExistentFunction", "float64")
+	if err == nil {
+		t.Error("verifyFunctionSignature should have returned an error for non-existent function")
+	}
+}

main.go

@@ -16,7 +16,6 @@ import (
 	"hmruntime/aws"
 	"hmruntime/config"
 	"hmruntime/db"
-	"hmruntime/functions"
 	"hmruntime/graphql"
 	"hmruntime/logger"
 	"hmruntime/manifestdata"
@@ -81,9 +80,6 @@ func initRuntimeServices(ctx context.Context) {
 	// Initialize the metadata database
 	db.Initialize(ctx)
 
-	// Watch for function registration requests
-	functions.MonitorRegistration(ctx)
-
 	// Load app data and monitor for changes
 	manifestdata.MonitorManifestFile(ctx)
 

plugins/plugins.go

@@ -7,6 +7,7 @@ package plugins
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	"hmruntime/utils"
@@ -38,6 +39,37 @@ type FunctionSignature struct {
 	ReturnType TypeInfo    `json:"returnType"`
 }
 
+func (f *FunctionSignature) String() string {
+	b := strings.Builder{}
+	b.WriteString(f.Name)
+	b.WriteString("(")
+	for i, p := range f.Parameters {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(p.Name)
+		b.WriteString(": ")
+		b.WriteString(p.Type.Name)
+	}
+	b.WriteString("): ")
+	b.WriteString(f.ReturnType.Name)
+	return b.String()
+}
+
+func (f *FunctionSignature) Signature() string {
+	b := strings.Builder{}
+	b.WriteString("(")
+	for i, p := range f.Parameters {
+		if i > 0 {
+			b.WriteString(",")
+		}
+		b.WriteString(p.Type.Name)
+	}
+	b.WriteString("):")
+	b.WriteString(f.ReturnType.Name)
+	return b.String()
+}
+
 type TypeDefinition struct {
 	Id     uint32  `json:"id"`
 	Size   uint32  `json:"size"`

wasmhost/loader.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"time"
 
+	"hmruntime/functions"
 	"hmruntime/logger"
 	"hmruntime/plugins"
 	"hmruntime/storage"
@@ -49,8 +50,8 @@ func MonitorPlugins(ctx context.Context) {
 	}
 	sm.Changed = func(errors []error) {
 		if len(errors) == 0 {
-			// Signal that we need to register functions
-			RegistrationRequest <- true
+			plugins := Plugins.GetAll()
+			functions.RegisterFunctions(ctx, plugins)
 		}
 	}
 	sm.Start(ctx)

wasmhost/wasmhost.go

@@ -23,9 +23,6 @@ import (
 // Global runtime instance for the WASM modules
 var RuntimeInstance wazero.Runtime
 
-// Channel used to signal that registration is needed
-var RegistrationRequest chan bool = make(chan bool)
-
 // Global, thread-safe registry of all plugins loaded by the host
 var Plugins = plugins.NewPluginRegistry()