Using OpenRouter

[gvarela]

Oli asked me to post how to configure the openai_compatible adapter configuration for OpenRouter.

        openrouter_claude = function()
          return require("codecompanion.adapters").extend("openai_compatible", {
            env = {
              url = "https://openrouter.ai/api",
              api_key = "OPENROUTER_API_KEY",
              chat_url = "/v1/chat/completions",
            },
            schema = {
              model = {
                default = "anthropic/claude-3.7-sonnet",
              },
            },
          })

[tlvenn]

Thanks a lot @gvarela

[tlvenn]

One thing I wonder though when i use claude through open router and therefore leveraging the openai_compatible adapter, am I actually not loosing the fine tuning and extra things that comes with the anthropic adaptor @olimorris ?

For example this a497adb ?

[mamachanko]

@tlvenn as for "fine-tuning and extra things" I am making the assumption that openrouter itself handles that for you. When targeting a model through openrouter, say Claude somethingsomething, I assume openrouter has does work not too disimilar from lua/codecompanion/adapters/anthropic.lua. However, I may be completely wrong of course. When it comes to temperature, top-p, etc. you can still tune that yourself for a given adapter.

[gvarela]

@tlvenn I haven't played with it yet. But, you would do that based on the docs here https://codecompanion.olimorris.dev/configuration/adapters#example-using-openai-compatible-models

[hanipcode]

hi, thanks for the config, I update it to have model switching capablity

here is my config

return {
	"olimorris/codecompanion.nvim",
	config = function()
		local default_model = "google/gemini-2.0-flash-001"
		local available_models = {
			"google/gemini-2.0-flash-001",
			"google/gemini-2.5-pro-preview-03-25",
			"anthropic/claude-3.7-sonnet",
			"anthropic/claude-3.5-sonnet",
			"openai/gpt-4o-mini",
		}
		local current_model = default_model

		local function select_model()
			vim.ui.select(available_models, {
				prompt = "Select  Model:",
			}, function(choice)
				if choice then
					current_model = choice
					vim.notify("Selected model: " .. current_model)
				end
			end)
		end

		require("codecompanion").setup({
			strategies = {
				chat = {
					adapter = "openrouter",
				},
				inline = {
					adapter = "openrouter",
				},
			},
			adapters = {
				openrouter = function()
					return require("codecompanion.adapters").extend("openai_compatible", {
						env = {
							url = "https://openrouter.ai/api",
							api_key = "OPENROUTER_API_KEY",
							chat_url = "/v1/chat/completions",
						},
						schema = {
							model = {
								default = current_model,
							},
						},
					})
				end,
			},
		})

		vim.keymap.set({ "n", "v" }, "<leader>ck", "<cmd>CodeCompanionActions<cr>", { noremap = true, silent = true })
		vim.keymap.set(
			{ "n", "v" },
			"<leader>a",
			"<cmd>CodeCompanionChat Toggle<cr>",
			{ noremap = true, silent = true }
		)
		vim.keymap.set("v", "ga", "<cmd>CodeCompanionChat Add<cr>", { noremap = true, silent = true })

		vim.keymap.set("n", "<leader>cs", select_model, { desc = "Select Gemini Model" })
		-- Expand 'cc' into 'CodeCompanion' in the command line
		vim.cmd([[cab cc CodeCompanion]])
	end,

	dependencies = {
		"nvim-lua/plenary.nvim",
		"nvim-treesitter/nvim-treesitter",
	},
}

[Juno-T]

Thanks for the setup code, but for me, the adapter function in config is being evaluated only once at neovim launch, so the current_model will always be default model. Did you experience the same and if so, have you found any workaround?

EDIT
nvm, I have found a work around thanks to #1153

Here is the additional config needed to be set, basically set a callback on chat submission:

        chat = {
          adapter = 'openrouter',
          keymaps = {
            submit = {
              modes = { n = '<CR>' },
              description = 'Submit',
              callback = function(chat)
                chat:apply_model(current_model)
                chat:submit()
              end,
            },
          },
        },

[hanipcode]

Thanks for the code, I almost never change model for the past 2 weeks I am not realizing it is broken.
your comment is very helpful to make it work again.

Actually I have extend the adapter config a lot, Like I add capability to make the config persistent so whenever I opened neovim it will use the last model I pick. it is nice combination with history extension, so that even when I close nvim I get last chat and also the last model I use

here is my config now
the main config: https://github.com/hanipcode/nvim/blob/main/lua/hanipcode/plugins/codecompanion.lua
the adapter: https://github.com/hanipcode/nvim/blob/main/lua/hanipcode/local/adapter.lua

note: I create this before the plugin support image, so there are still my custom slash command for adding image

[hanipcode]

btw based on the docs https://codecompanion.olimorris.dev/configuration/chat-buffer.html#keymaps
it should be "send" instead of "submit" for the keymaps.

[mamachanko]

btw based on the docs https://codecompanion.olimorris.dev/configuration/chat-buffer.html#keymaps it should be "send" instead of "submit" for the keymaps.

Thank you @hanipcode ! And it wasn't working for me and I had parked the issue. You just solved it. ⭐

[srackham]

You can also put the OpenRouter models list into the CodeCompanion.nvim schema.model.choices array and it will get picked up by the change adapter (ga) chat window command e.g.

  adapters = {
    http = {
      openrouter = function()
        return require("codecompanion.adapters").extend("openai_compatible", {
          env = {
            url = "https://openrouter.ai/api",
            api_key = "OPENROUTER_API_KEY",
            chat_url = "/v1/chat/completions",
          },
          schema = {
            model = {
              -- Update this to your preferred default OpenRouter model ID
              default = "openai/gpt-4o-mini",
              choices = {
                ["x-ai/grok-code-fast-1"] = {},
                ["qwen/qwen3-coder-30b-a3b-instruct"] = {},
                ["anthropic/claude-3.7-sonnet"] = {},
                ["anthropic/claude-3.5-sonnet"] = {},
                ["openai/gpt-4o-mini"] = {},
                -- Add more models as needed (check OpenRouter docs for IDs)
              },
            },
          },
        })
      end,
    },
  },

[e2r2fx]

I'm trying to configure openrouter to display reasoning. Anyone has come across this use case?

[e2r2fx]

To anyone interested here's an openrouter adapter with reasoning support.

[metrix78]

Could this be changed so that it's a plugin, separating the code from the config? We could reference it in the documentation.

[e2r2fx]

To me this makes more sense if it lives in your config (I have it under /utils/openrouter.lua for instance), and then you just extend it like you already do with the official codecompanion adapters. Like so:

        openrouter = function()
          local openrouter = require("utils.openrouter")
          return require("codecompanion.adapters").extend(openrouter, {
            name = "openrouter",
            formatted_name = "Open Router",
            env = {
              url = "https://openrouter.ai/api",
              api_key = "some command to get your API key",
            },
            schema = {
              model = {
                default = "z-ai/glm-4.5",
              },
            },
          })
        end,

that way you own it and can do whatever you want with it

[ernie]

I took the liberty of trying my hand at another OpenRouter adapter with reasoning support. It's here, if it helps anyone. I honestly didn't notice needing the form_reasoning function as I'm not sure anything it's doing is needed happen with OpenRouter, but it worked well both ways, so I figured why not?

The difference between the earlier one and mine is that it observes the params supported by a call to OpenRouter's model list API and populates the choices automatically from that.

One thing I'm noticing is that x-ai/grok-code-fast-1 seems to insist on using ## for its reasoning steps, which seems to break code folding sometimes. I couldn't quite figure out why, but I don't claim to be a Lua or CodeCompanion expert. It doesn't happen with GPT-5's output, though.

[ernie]

OK, so I read through the OpenRouter docs on reasoning and figured out some issues and also a good use for form_reasoning after all. Was able to make improvements and the gist is updated now. Tested with both x-ai and anthropic and seems to work fine.

[stasjok]

I think tools parameters are broken after #2241. I have a random errors about invalid parameters (at least tool_call_id, which is changed in the PR). I think some of the methods (e.g. form_messages) need to be adapted to the changes.

[ernie]

One other wondering I've had about OpenRouter using these adapters: Is CodeCompanion supposed to just sort of fall over when a tool fails? It seems like the LLM should notice the failure on its own and do something about it. I also notice I am not seeing tool output in the chat.

[bassamsdata]

I like how organized your OpenRouter setup is.

Regarding the insert_edit_into_file tool, if it fails, it simply stops and doesn’t do anything further, which is a limitation of the tool itself. For now, you might want to try the @files tool instead, which includes multiple tools bundled together.

I also notice I am not seeing tool output in the chat.

Is this happening with other adapters as well, or just with your OpenRouter setup?

This is what I see in the chat buffer, does yours look different?

Screen.Recording.2025-08-29.at.2.14.28.PM.mp4

[ernie]

I’ve noticed the tool output usually has to be expanded by moving the cursor over it, which I assume is intentional. I’ve also noticed that sometimes tools leave my chat buffer unresponsive, where my edits aren’t sent to the LLM.

[lumpsoid]

Here is a schema extension for Ernie's adapter to add the ability to turn off the reasoning capabilities of the selected model.

    ["reasoning.enabled"] = {
      optional = true,
      default = false,
      order = 2,
      mapping = 'parameters',
      type = 'boolean',
      enabled = function(self)
        local model = self.schema.model.default
        if type(model) == 'function' then
          model = model()
        end
        local choices = self.schema.model.choices
        if type(choices) == 'function' then
          choices = choices(self)
        end
        if choices and choices[model] and choices[model].opts and choices[model].opts.can_reason then
          return true
        end
        return false
      end,
    },
    ["reasoning.effort"] = {
      optional = true,
      default = 'none',
      choices = {
        "xhigh", "high", "medium", "low", "minimal", "none"
      },
      order = 3,
      mapping = 'parameters',
      type = 'string',
      enabled = function(self)
        local model = self.schema.model.default
        if type(model) == 'function' then
          model = model()
        end
        local choices = self.schema.model.choices
        if type(choices) == 'function' then
          choices = choices(self)
        end
        if choices and choices[model] and choices[model].opts and choices[model].opts.can_reason then
          return true
        end
        return false
      end,
    },

to use these parameters you need to remove or disable reasoning_effort parameter.

to modify this schema from the setup, you can use something like this

    require("codecompanion").setup({
      adapters = {
        http = {
          openrouter = require("codecompanion.adapters").extend(function()
            -- your path to the openrouter adapter
            return require("utils.openrouter")
          end, {
            schema = {
              ["reasoning.effort"] = {
                default = "medium",
              },
              reasoning_effort = {
                default = "none",
                enabled = function(_) return false end,
              },
            },
          }),
        },
      },
    })