Generated Tools do not send their decription in json

[johnnymast]

Hello,

I noticed my tools were called for no reason so i created a nodejs server that would debug what OllamaSharp sends it and i see that everything is sent over correctly except the Description of the tool. Let me Show you my sever the output and the generated class.

OllamaSharp version: 5.3.4

2025-08-02T14:34:26.739Z - POST /api/chat
Received POST to /api/chat:
Headers: {
  host: 'localhost:11434',
  'content-type': 'application/json; charset=utf-8',
  'content-length': '960'
}
Body: {
  "model": "sparklebeat:latest",
  "messages": [
    {
      "role": "user",
      "content": "Extra Contextual information:\nThe following is factual information about the current state of the game. Use this as your knowledge base to answers questions. If someone asks you a questionmake sure to double check your contextual information.\n\nDressed: You are dressed.\nTalking to: unknown\nCurrent date: 2025-08-02\nCurrent day: Saturday\nCurrent time: 16:34:26\nOnline since: 2025-08-02T16:34:26Z\nYour location: Sin Club\n"
    },
    {
      "role": "user",
      "content": "Ready?"
    }
  ],
  "stream": true,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "WhatDoYouSee",
        "description": "",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "",
              "enum": null
            }
          },
          "required": []
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "GoogleSearch",
        "description": "",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "",
              "enum": null
            }
          },
          "required": [
            "query"
          ]
        }
      }
    }
  ],
  "CustomHeaders": {}
}

This is how i added the description for the tool

This is the generated code make by OllamaSharp..

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

#nullable enable

namespace Core.Ai.Tools.Collection
{
    /// <summary>
    /// This class was auto-generated by the OllamaSharp ToolSourceGenerator.
    /// </summary>
    public class WhatDoYouSeeTool : OllamaSharp.Models.Chat.Tool, OllamaSharp.Tools.IAsyncInvokableTool
    {
        /// <summary>
        /// Initializes a new instance with metadata about the original method.
        /// </summary>
        public WhatDoYouSeeTool()
        {
            this.Function = new OllamaSharp.Models.Chat.Function
            {
                Name = "WhatDoYouSee",
                Description = "Use this function to find out what is happening around you."
            };

            this.Function.Parameters = new OllamaSharp.Models.Chat.Parameters
            {
                Properties = new Dictionary<string, OllamaSharp.Models.Chat.Property>
                {
                    { "query", new OllamaSharp.Models.Chat.Property { Type = "string", Description = "A user question about what is happening around you." } }
                },
                Required = Array.Empty<string>()
            };
        }

        /// <summary>
        /// Invokes the tool with given arguments asynchronously
        /// </summary>
        /// <param name="args">The arguments to invoke the tool with</param>
        /// <returns>The result of the invoked tool</returns>
        public async Task<object?> InvokeMethodAsync(IDictionary<string, object?>? args)
        {
            if (args == null) args = new Dictionary<string, object?>();
            string query = (string?)args["query"] ?? "What does the sign say?";

            var result = await Core.Ai.Tools.Collection.VisionTools.WhatDoYouSee(query);
            return result;
        }
    }
}

Here is the nodejs script i used to debug what OllamSharp was sending to Ollama.

const express = require('express');
const app = express();
const PORT = 11434; // Ollama's default port

// Middleware to parse JSON bodies
app.use(express.json());

// Middleware to log all requests
app.use((req, res, next) => {
    console.log(`\n${new Date().toISOString()} - ${req.method} ${req.path}`);
    next();
});

// Handler for /api/create endpoint
app.post('/api/create', (req, res) => {
    console.log('Received POST to /api/create:');
    console.log('Headers:', req.headers);
    console.log('Body:', JSON.stringify(req.body, null, 2));
    res.status(200).send('OK');
});

// Handler for /api/chat endpoint
app.post('/api/chat', (req, res) => {
    console.log('Received POST to /api/chat:');
    console.log('Headers:', req.headers);
    console.log('Body:', JSON.stringify(req.body, null, 2));
    res.status(200).send('OK');
});

// Start the server
app.listen(PORT, () => {
    console.log(`Server is running on http://localhost:${PORT}`);
});

[awaescher]

The generated source code looks fine and should work. So I guess you might have checked the source of a debug build and tested a released build with your nodejs logger and maybe you don't have <GenerateDocumentationFile> turned on.

If this is true, the release build will remove the XML summary and the source generator cannot find the meta info anymore. See https://awaescher.github.io/OllamaSharp/docs/tool-support.html#important-details.

[silentboy3dx]

Maybe some extra information i can offer is that i am using it with mcptools as well.

[silentboy3dx]

@awaescher The problem is not the generated code. Because i could see the descriptions ending in there just fine. If you spin up the node test server will see see that the defined function description from the generated code is not being send but the name is.

[awaescher]

That's exactly what happens in the case I wrote. Might not be the issue in your case but I would make sure the flag is set.
If not, the summaries are stripped out by the compiler for a release build. Then the source generator is ran again and it will not find the summary metadata anymore. It will however find the method name and include that.

[Rpgdudester]

I had that problem literally about an hour or so ago actually where the descriptions weren't showing up. the names showed up fine but the descriptions weren't.

and it happened that I didn't have the <GenerateDocumentationFile>true</GenerateDocumentationFile> in my project files like @awaescher suggested. once I put that in,

everything showed up so I would suggest going with his suggestion first and seeing if that helped.

[silentboy3dx]

Oh @Rpgdudester thank you for that i must have over read that. i don"t think i read the message the correct way (drunk).

@awaescher sorry for misreading your reply. I am curious why GenerateDocumentationFile was created.

[awaescher]

Being drunk happens from time to time. No worries.

GenerateDocumentationFile is from the dotnet runtime and simply includes the XML summaries while building. This is usually false because it's not needed for executables. Who would read the source code documentation for a compiled app?
If you build a library like OllamaSharp for example, it's highly recommended to set this flag to true to include the XML summaries. That's how the users of the library get the tooltips and IntelliSense from.

The way OllamaSharp reads the tool meta data is by reading these XML summaries. If they are stripped away by the compiler, there's nothing to read.
Still I think doing it this way is pretty slick as many devs use the XML summaries extensively. And documenting these methods for humans is the same way as documenting them for AI models.

Anyways, as projects mature, I see them moving further away from OllamaSharp into something with a higher abstraction level, like Microsoft.Extensions.AI or Semantic Kernel. This way, tools are defined in a different way, for example with [KernelFunction] and [Description] attributes. This has pros and cons. I find it not that clever but it does not depend from the documentation file. And it allows different documentation for humans (XML summaries) vs. AI models (said attributes).

I started a few projects with OllamaSharp and went on to Semantic Kernel with most, just because it's very flexible and can use different providers dynamically. I am not sad at all seeing projects grow out of scope of OllamaSharp. The reason is, that if they use Microsoft.Extensions.AI or even Semantic Kernel, the way they talk to their Ollama endpoints will still be using OllamaSharp under the hood, which I think is awesome.