initial commit of untested function stuff

schema/basic.go

@@ -0,0 +1,105 @@
+package schema
+
+import (
+	"errors"
+	"reflect"
+	"strconv"
+
+	"github.com/sashabaranov/go-openai/jsonschema"
+)
+
+// just enforcing that basic implements Type
+var _ Type = basic{}
+
+type basic struct {
+	jsonschema.DataType
+
+	// index is the position of the parameter in the StructField of the function's parameter struct
+	index int
+
+	// required is a flag that indicates whether the parameter is required in the function's parameter struct.
+	// this is inferred by if the parameter is a pointer type or not.
+	required bool
+
+	// description is a llm-readable description of the parameter passed to openai
+	description string
+}
+
+func (b basic) SchemaType() jsonschema.DataType {
+	return b.DataType
+}
+
+func (b basic) Definition() jsonschema.Definition {
+	return jsonschema.Definition{
+		Type:        b.DataType,
+		Description: b.description,
+	}
+}
+
+func (b basic) Required() bool {
+	return b.required
+}
+
+func (b basic) Description() string {
+	return b.description
+}
+
+func (b basic) FromAny(val any) (reflect.Value, error) {
+	v := reflect.ValueOf(val)
+
+	switch b.DataType {
+	case jsonschema.String:
+		var val = v.String()
+
+		return reflect.ValueOf(val), nil
+
+	case jsonschema.Integer:
+		if v.Kind() == reflect.Float64 {
+			return v.Convert(reflect.TypeOf(int(0))), nil
+		} else if v.Kind() != reflect.Int {
+			return reflect.Value{}, errors.New("expected int, got " + v.Kind().String())
+		} else {
+			return v, nil
+		}
+
+	case jsonschema.Number:
+		if v.Kind() == reflect.Float64 {
+			return v.Convert(reflect.TypeOf(float64(0))), nil
+		} else if v.Kind() != reflect.Float64 {
+			return reflect.Value{}, errors.New("expected float64, got " + v.Kind().String())
+		} else {
+			return v, nil
+		}
+
+	case jsonschema.Boolean:
+		if v.Kind() == reflect.Bool {
+			return v, nil
+		} else if v.Kind() == reflect.String {
+			b, err := strconv.ParseBool(v.String())
+			if err != nil {
+				return reflect.Value{}, errors.New("expected bool, got " + v.Kind().String())
+			}
+			return reflect.ValueOf(b), nil
+		} else {
+			return reflect.Value{}, errors.New("expected bool, got " + v.Kind().String())
+		}
+
+	default:
+		return reflect.Value{}, errors.New("unknown type")
+	}
+}
+
+func (b basic) SetValueOnField(obj reflect.Value, val reflect.Value) {
+	// if this basic type is not required that means it's a pointer type
+	// so we need to create a new value of the type of the pointer
+	if !b.required {
+		vv := reflect.New(obj.Field(b.index).Type().Elem())
+
+		// and then set the value of the pointer to the new value
+		vv.Elem().Set(val)
+
+		obj.Field(b.index).Set(vv)
+		return
+	}
+	obj.Field(b.index).Set(val)
+}