Creating Custom adapter for the HAWKI API

[KobKobson]

I'm a bit stuck implementing a custom adapter for the HAWKI API.

My current draft heavily inspired by the DashScope Community Adapter:

tudagpt = function()
    local log = require "codecompanion.utils.log"
    local openai = require "codecompanion.adapters.http.openai"
    local utils = require "codecompanion.adapters.utils"

    ---@class CodeCompanion.HTTPAdapter.DashScope: CodeCompanion.HTTPAdapter
    return {
        name = "tudagpt",
        formatted_name = "TUDaGPT",
        roles = {
            llm = "assistant",
            user = "user",
        },
        opts = {
            stream = false, 
            tools = false,  
        },
        features = {
            text = true,   
            tokens = true, 
        },
        url = "${url}${chat_url}",
        env = {
            url = "https://tudagpt.hrz.tu-darmstadt.de",
            api_key = "cmd:secret-tool lookup tudagpt codecompanion",
            chat_url = "/api/ai-req",
        },
        headers = {
            ["Authorization"] = "Bearer ${api_key}",
            ["Content-Type"] = "application/json",
        },
        handlers = {
            -- Lifecycle hooks (side effects and initialization)
            lifecycle = {
                setup = function(self) -- Called before request is sent
                    return openai.handlers.setup(self)
                end,
                on_exit = function(self, data) -- Called after request completes
                    return openai.handlers.on_exit(self, data)
                end,
            },

            -- Request builders (pure transformations)
            request = {
                -- identical to openai `form_parameters`
                build_parameters = function(self, params, messages)
                    return params
                end,
                build_messages = function(self, messages) -- Format messages for LLM
                    messages = utils.merge_messages(messages)
                    messages = utils.merge_system_messages(messages)

                    -- Ensure that all messages have a content field
                    messages = vim.iter(messages)
                        :map(function(msg)
                            local content = msg.content
                            if content and type(content) == "table" then
                                msg.content = table.concat(content, "\n")
                            elseif not content then
                                msg.content = ""
                            end
                            return msg
                        end)
                        :totable()
                    return { messages = messages }
                end,
                
                build_tools = function(self, tools) -- Transform tool schemas
                    local model = self.schema.model.default
                    local model_opts = self.schema.model.choices[model]

                    if model_opts.opts and model_opts.opts.can_use_tools == false then
                        if tools and vim.tbl_count(tools) > 0 then
                            log:warn "Tools are not supported for this model"
                        end
                        return
                    end
                    return openai.handlers.form_tools(self, tools)
                end,
            },

            -- Response parsers (pure transformations)
            response = {
                parse_chat = function(self, data, tools) -- Parse chat response
                    local output = {}
                    if data and data ~= "" then
                        local data_mod = utils.clean_streamed_data(data)
                        local ok, json =
                            pcall(vim.json.decode, data_mod, { luanil = { object = true } })
                        if ok and json.choices and #json.choices > 0 then
                            local choice = json.choices[1]
                            local delta = (self.opts and self.opts.stream) and choice.delta
                                or choice.message
                            if delta then
                                output.role = delta.role
                                output.content = delta.content
                                if delta.reasoning_content then
                                    output.reasoning = output.reasoning or {}
                                    output.reasoning.content = delta.reasoning_content
                                end

                                -- Process tools
                                if self.opts.tools and delta.tool_calls and tools then
                                    for _, tool in ipairs(delta.tool_calls) do
                                        if self.opts.stream then
                                            local index = tool.index
                                            local found = false

                                            for i, existing_tool in ipairs(tools) do
                                                if existing_tool._index == index then
                                                    tools[i]["function"].arguments = (
                                                            tools[i]["function"].arguments or ""
                                                        )
                                                        .. (tool["function"]["arguments"] or "")
                                                    found = true
                                                    break
                                                end
                                            end

                                            if not found then
                                                table.insert(tools, {
                                                    ["function"] = {
                                                        name = tool["function"]["name"],
                                                        arguments = tool["function"]["arguments"]
                                                            or "",
                                                    },
                                                    id = tool.id,
                                                    type = "function",
                                                    _index = index,
                                                })
                                            end
                                        else
                                            table.insert(tools, {
                                                _index = tool.index,
                                                ["function"] = {
                                                    name = tool["function"]["name"],
                                                    arguments = tool["function"]["arguments"],
                                                },
                                                id = tool.id,
                                                type = "function",
                                            })
                                        end
                                    end
                                end

                                return {
                                    status = "success",
                                    output = output,
                                }
                            end
                        end
                    end
                end,
                
                parse_inline = function(self, data, context) -- Parse inline response
                    return openai.handlers.inline_output(self, data, context)
                end,
                
                parse_tokens = function(self, data) -- Extract token count
                    return openai.handlers.tokens(self, data)
                end,
            },

            -- Tool handlers (grouped functionality)
            tools = {
                format_calls = function(self, tools) -- Format tool calls for request
                    return tools
                end,
                format_response = function(self, tool_call, output) -- Format tool response for LLM
                    return openai.handlers.tools.output_response(self, tool_call, output)
                end,
            },
        },
        
        schema = {
            ---@type CodeCompanion.Schema
            model = {
                order = 1,
                mapping = "parameters",
                type = "enum",
                desc = "ID of the model to use.",
                ---@type string|fun(): string
                default = "gwdg-meta-llama-3.1-8b-instruct",
                choices = {
                    
                    ["gwdg-meta-llama-3.1-8b-instruct"] = {
                        formatted_name = "Meta LLama",
                        opts = { can_reason = false, can_use_tools = false },
                    },
                },
            },
			...
        },
    }
end

I get the following error:

[chat::_submit_http] Error: {                                                                                                                                                                                                                                                                                                   
  body = '{"success":false,"message":"Validation Error","errors":{"payload.model":["validation.required"],"payload.messages":["validation.required"]}}',                                                                                                                                                                        
  exit = 0,                                                                                                                                                                                                                                                                                                                     
  headers = { "server: nginx", "content-type: application/json", "cache-control: no-cache, private", "date: Tue, 15 Sep 2026 17:06:45 GMT", "access-control-allow-origin: *" },                                                                                                                                                 
  status = 422                                                                                                                                                                                                                                                                                                                  
}

This differs from the error if use the curl example with an invalid token, which returns {"message":"Unauthenticated."}.

Do you have any tips how I can approach this problem or can you spot the faulty lines right away?
Is there for example a way of retrieving the complete messages sent to the API?

Thank you for your help :)

[olimorris]

My advice would be to use the search_help tool, sharing it with an LLM and the documentation from HAWKI. A Sonnet-5 equivalent model should be able to one-shot it.

[KobKobson]

Thank you, that worked - not a one-shot, but then again I used Copilot "auto" mode.
It helped me restructure build_parameters and build_messages.

[olimorris]

Wow. Kudos to you because Copilot Auto mode is generally awful 😆. Glad you got it sorted