New Features (new models and function calling)

[kayhantolga]

Just like me, you must be buzzing about OpenAI's new features! I'll be adding them ASAP. Got thoughts or cool ideas? Let's chat about them under this post!

https://openai.com/blog/function-calling-and-other-api-updates

[gekah]

Vague idea: maybe use reflection and attributes to describe callable methods, e.g.

[GptMethod(Class = "DbQueries", Description = "Retrieve product information by name")]
[GptParam(Name = "productName", Description="The name of the product", Required = true)]
ProductInfo GetProductInfo(string productName ) {
// ...
}

(Attributes on parameters unfortunately only supported starting with C# 5)

In the actual CreateCompletion call, just pass the class of functions relevant for this completion and the SDK infers the "functions=" JSON to pass to OpenAI?

For the next step, a helper method could also provide support to call the corresponding method given the name of the method GPT wants to call and the JSON - get the MethodInfo by name, map the JSON, Invoke() ...

[oferavnery]

It would be great to have some sort of indication in streaming mode if the response is going to be a function call or a standard message. Easy to scan the deltas and figure it out but it would be still nice to have it built in.

[msdbcardoso]

If the goal itself is to pass a list of functions and the system generating the required schemas to pass into OpenAI API we can pass a list of functions:

i.e

void ParseFunction(List<(string, dynamic)> functions, string methodName, object[]? args)
{
    //Given the method infos it can generate the schemas and then pass onto OpenAI API...
    var lookup = functions.ToDictionary(i => i.Item1, i => i.Item2);

    MethodInfo method = lookup[methodName].Method;
    method.Invoke(null, args); // This would also invoke the method but I reckon this is beyond the scope..
}
//for example lets assume that we want to dynamically pass otherfunc plus some others..
void otherfunc()
{
    Console.WriteLine("Empty");
}

//This is the ugly part but we can leverage source generators to have C# compiler generate this for us
List<(string, dynamic)> methods = new()
{
    (nameof(SomeFunction), new Action<int>(SomeFunction)),
    (nameof(otherfunc), new Action(otherfunc)),
    (nameof(returnSum),new Func<int,int,int>(returnSum))
};
ParseFunction(methods, nameof(otherfunc), null);

void Example(params object[] functions)
{
    //source generator would convert wtv its passed to this function to the list above.
}

#pragma warning disable CS8974 // Converting method group to non-delegate type
Example(SomeFunction, otherfunc);
#pragma warning restore CS8974 // Converting method group to non-delegate type

The attribute approach is really interesting but I do think that it is to bothersome for the developer to set it up. On the other hand, I assume most developers wouldnt be creating functions that frequently so it might be worth to see how it would work.

[msdbcardoso]

As an alternative we could explore the concept of 'Registering' a method beforehand, for example:

void PreRegister<T>(T function)
{
    dynamic value = function; //Hacky but simple
    MethodInfo info = value.Method;
    Register(info);
}

void Register(MethodInfo methodInfo)
{
    //Add methodinfos to some registry
    Console.WriteLine("Registering {0} with parameters {1}", methodInfo.Name, string.Join(",", methodInfo.GetParameters().Select(i => $"({i.ParameterType.Name} {i.Name})")));
//CreateCompletion could then query the registry and either return method and arguments or actually invoke it.
}

void AnotherFunction()
{

}
void AnotherFunction2(int someNumber)
{

}

PreRegister(AnotherFunction2);
//Registering <<Main>$>g__AnotherFunction2|0_3 with parameters (Int32 someNumber)

[oferavnery]

I would be happy with just an easy way to get the function name as a string and the parameters either as Json or as an object. Different functions can trigger different actions so tying them to specific methods or classes seems too limiting.

[kayhantolga]

I have released a new beta version that includes "function calling", thanks to @rzubek's pull request. I will read the discussions and feedback in this thread and finalize the release version as soon as possible.
#301

[jgriffith3433]

I implemented the function calling update on my own branch locally.
I used the dynamic keyword to handle the loose type associated with the CreateCompletionRequest.function_call and it has worked well enough. I wanted to share that because it keeps your library nice and tidy.

In my project I used custom attributes, system.reflection, and JsonElement from System.Text.Json to fill out function_call.

Best!

[WeLiveOnTheMoon]

Does anyone know when function calling will be added? Can it be added directly to the ChatCompletionCreateRequest object?

Thank you!!

[PedroStival]

Hello! when will this version be released?

[kayhantolga]

Sorry, I had too many personal things to do last week and couldn't find time to work on the repository. However, I will resolve them by the end of this week. This will allow me to have more free time to work on new features starting from next week.

[PedroStival]

Sure, no problem! By the way, good job!

I had seen an example of calling functions on read.me but it is no longer there, could you make it available for testing and playing in the beta release?