feat(context)!: switch from contexts to function calling

[deathbeam]

BEGIN_COMMIT_OVERRIDE
feat(context)!: switch from contexts to function calling

This change modernizes the CopilotChat architecture by implementing a tools-based
approach using function calling. Each tool has a schema definition that enables
structured parameter collection and validation. Resources are now handled more
consistently, with a clearer distinction between content types.

https://platform.openai.com/docs/guides/function-calling?api-mode=responses
https://modelcontextprotocol.info/specification/2024-11-05/server/tools/

BREAKING CHANGE: Multiple breaking changes due to big refactor:

• The context API has changed from callback-based input handling to schema-based definitions.
• config.contexts renamed to config.tools
• config.context removed, use config.sticky
• diagnostics moved to separate tool call, selection and buffer calls no longer include them by default
• gi renamed to gc, now also includes selection
• filenames renamed to glob
• files removed (use glob together with tool calling instead, or buffers/quickfix)
• copilot extension agents removed, tools + mcp servers can replace this feature and maintaining them was pain, they can still be implemented via custom providers anyway
• actions and integrations action removed as they were deprecated for a while
• config.questionHeader, config.answerHeader moved to config.headers.user/config.headers.assistant

Closes #1045
Closes #1053
Closes #1076
Closes #1090
Closes #1096
Closes #526

END_COMMIT_OVERRIDE

TODO:

• Improve response format from contexts
• Maybe rename contexts to tools?
• Add names of tool to embedded context value
• Inline contexts/tools - expand directly to user prompt
• Split diagnostics to separate context
• Mark built in tools as safe, mark everything else unsafe
• How to resolve MCP resources? How to resolve built in resources? Currently hardcoded for file and url, not good
• Rest of commands resources for reuse? git?
• Properly store tool responses using "tool" role and also send tool_calls in history
  • When tool_call response is received, new tool_call prompt, user submitable, editable, sends only tools
  • On submit replace with tool_call responses, send proper "tool" role, wait response
• Parse resource template to schema for input, pass uri to input for resolution
• Rename agent to group, allow sharing single tools as well

https://github.com/ravitemer/mcphub.nvim integration:

local mcp = require('mcphub')
mcp.setup()
mcp.on({ 'servers_updated', 'tool_list_changed', 'resource_list_changed' }, function()
    local hub = mcp.get_hub_instance()
    if not hub then
        return
    end

    local async = require('plenary.async')
    local call_tool = async.wrap(function(server, tool, input, callback)
        hub:call_tool(server, tool, input, {
            callback = function(res, err)
                callback(res, err)
            end,
        })
    end, 4)

    local access_resource = async.wrap(function(server, uri, callback)
        hub:access_resource(server, uri, {
            callback = function(res, err)
                callback(res, err)
            end,
        })
    end, 3)

    local resources = hub:get_resources()
    for _, resource in ipairs(resources) do
        local name = resource.name:lower():gsub(' ', '_'):gsub(':', '')
        chat.config.functions[name] = {
            uri = resource.uri,
            description = type(resource.description) == 'string' and resource.description or '',
            resolve = function()
                local res, err = access_resource(resource.server_name, resource.uri)
                if err then
                    error(err)
                end

                res = res or {}
                local result = res.result or {}
                local content = result.contents or {}
                local out = {}

                for _, message in ipairs(content) do
                    if message.text then
                        table.insert(out, {
                            uri = message.uri,
                            data = message.text,
                            mimetype = message.mimeType,
                        })
                    end
                end

                return out
            end
        }
    end

    local tools = hub:get_tools()
    for _, tool in ipairs(tools) do
        chat.config.functions[tool.name] = {
            group = tool.server_name,
            description = tool.description,
            schema = tool.inputSchema,
            resolve = function(input)
                local res, err = call_tool(tool.server_name, tool.name, input)
                if err then
                    error(err)
                end

                res = res or {}
                local result = res.result or {}
                local content = result.content or {}
                local out = {}

                for _, message in ipairs(content) do
                    if message.type == 'text' then
                        table.insert(out, {
                            data = message.text
                        })
                    elseif message.type == 'resource' and message.resource and message.resource.text then
                        table.insert(out, {
                            uri = message.resource.uri,
                            data = message.resource.text,
                            mimetype = message.resource.mimeType,
                        })
                    end
                end

                return out
            end
        }
    end
end)

[deathbeam]

did not rly had time to work on this at all in past few months but I think I got nice interface now working with separate tool call message and proper highlights so its clearly visible what is happening

[deathbeam]

So only 1 thing remains and that is better resource template handling, but I think I can just skip it for now, so will test this a bit more (any more testing would be helpful too) and then probably merge, but its a lot of breaking changes to configs and everything

[deathbeam]

Well lets see if this works :)