Adding A New Backend (VeniceAI) - Content-Type Header Issue

by ADMIN 60 views

Issue Description:

When attempting to use the VeniceAI backend in your project, you encounter an issue where the error message 'Content-Type' must be 'application/json' indicates that the request is not being properly formatted as JSON. Despite ensuring that the Content-Type header is correctly added in requests.lua, the issue persists.

Steps to Reproduce:

  1. Attempt to use the VeniceAI backend in your project.
  2. Observe the error message 'Content-Type' must be 'application/json'.

Expected Behavior:

The request should be formatted as JSON with the Content-Type header set to application/json.

Actual Behavior:

The Content-Type header is set to application/json, but the issue persists.

Additional Information:

  • The code snippet provided is for Lua and is intended to be used with the Neovim environment.
  • The error message suggests that the issue might be related to how the headers are being handled or the request is being constructed.

Code Snippet for Reference:

local requests = require('cmp_ai.requests')

VeniceAI = requests:new(nil)
BASE_URL = 'https://api.venice.ai/api/v1/chat/completions'

-- Function to stringify a table
function stringify_table(tbl)
  local str = ""
  for k, v in pairs(tbl) do
    if type(k) == "string" then
      k = '"' .. k .. '"'
    end
    if type(v) == "table" then
      v = stringify_table(v)
    end
    if type(v) == "string" then
      v = '"' .. v .. '"'
    end
    str = str .. k .. " = " .. v .. ",\n"
  end
  return "{\n" .. str .. "}"
end

-- Function to initialize VeniceAI
function VeniceAI:new(o, params)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  self.params = vim.tbl_deep_extend('keep', params or {}, {
    model = 'deepseek-coder-v2-lite',
    temperature = 0.1,
    n = 1,
  })

  self.api_key = os.getenv('OPENAI_API_KEY')
  if not self.api_key then
    vim.schedule(function()
      vim.notify('OPENAI_API_KEY environment variable not set', vim.log.levels.ERROR)
    end)
    self.api_key = 'NO_KEY'
  end
  self.headers = {
    'Authorization: Bearer ' .. self.api_key,
  }
  return o
end

-- Function to complete code
function VeniceAI:complete(lines_before, lines_after, cb)
  if not self.api_key then
    vim.schedule(function()
      vim.notify('OPENAI_API_KEY environment variable not set', vim.log.levels.ERROR)
    end)
    return
  end
  local data = {
    messages = {
      {
        role = 'system',
        content = [=[You are a coding companion.
You need to suggest code for the language ]=] .. vim.o.filetype .. [=[
Given some code prefix and suffix for context, output code which should follow the prefix code.
You only output valid code in the language ]=] .. vim.o.filetype .. [=[
. to clearly define a code block, including white space, we will wrap the code block
with tags.
Make sure to respect the white space and indentation rules of the language.
Do not output anything in plain language, make sure you only use the relevant programming language verbatim.
For example, consider the following request:
<begin_code_prefix>def print_hello():<end_code_prefix><begin_code_suffix>\n    return<end_code_suffix><begin_code_middle>
Your answer should be:

    print("Hello")<end_code_middle>
]=],
      },
      {
        role = 'user',
        content = '<begin_code_prefix>' ..
        lines_before ..
        '<end_code_prefix>' .. '<begin_code_suffix>' .. lines_after .. '<end_code_suffix><begin_code_middle>',
      },
    },
  }
  data = vim.tbl_deep_extend('keep', data, self.params)
  self:Get(BASE_URL, self.headers, data, function(answer)
    vim.notify(stringify_table(answer))   --  <---------------------- this is where the error is thrown.
    local new_data = {}
    if answer.choices then
      for _, response in ipairs(answer.choices) do
        local entry = response.message.content:gsub('<end_code_middle>', '')
        entry = entry:gsub('```', '')
        table.insert(new_data, entry)
      end
    end
    cb(new_data)
  end)
end

function VeniceAI:test()
  self:complete('def factorial(n)\n    if', '    return ans\n', function(data)
    dump(data)
  end)
end

return VeniceAI

Troubleshooting the Issue:

After carefully examining the provided code snippet, it appears that the issue lies in how the stringify_table function is being used to notify the error message. The stringify_table function is designed to convert a table into a JSON string, but it is not being used correctly in this context.

The stringify_table function is being called with the answer table as an argument, but it is not being used to format the table as JSON. Instead, it is being used to create a string representation of the table, which is not what is needed.

To fix this issue, you can modify the stringify_table function to correctly format the table as JSON. You can also use a library like json to handle the JSON formatting for you.

Here is an updated version of the stringify_table function that correctly formats the table as JSON:

function stringify_table(tbl)
  local json = require('json')
  return json.encode(tbl)
end

You can also use the json.encode function to format the table as JSON.

Conclusion:

In conclusion, the issue with the Content-Type header not being set correctly is due to the incorrect usage of the stringify_table function. By modifying the stringify_table function to correctly format the table as JSON, you can fix this issue and ensure that the request is properly formatted as JSON.

Additional Tips:

  • Make sure to check the documentation for the requests.lua library to ensure that you are using it correctly.
  • Use a library like json to handle the JSON formatting you.
  • Use a debugger or print statements to help you identify the issue.

Example Use Case:

Here is an example use case for the updated stringify_table function:

local data = {
  messages = {
    {
      role = 'system',
      content = 'Hello, World!',
    },
  },
}

local json_data = stringify_table(data)
print(json_data)

This will output the following JSON string:

{
  "messages": [
    {
      "role": "system",
      "content": "Hello, World!"
    }
  ]
}

Q: What is the issue with the Content-Type header not being set correctly?

A: The issue with the Content-Type header not being set correctly is due to the incorrect usage of the stringify_table function. The stringify_table function is designed to convert a table into a JSON string, but it is not being used correctly in this context.

Q: How can I fix the issue with the Content-Type header not being set correctly?

A: To fix the issue with the Content-Type header not being set correctly, you can modify the stringify_table function to correctly format the table as JSON. You can also use a library like json to handle the JSON formatting for you.

Q: What is the correct way to use the stringify_table function?

A: The correct way to use the stringify_table function is to call it with the table you want to convert to JSON as an argument. For example:

local data = {
  messages = {
    {
      role = 'system',
      content = 'Hello, World!',
    },
  },
}

local json_data = stringify_table(data)
print(json_data)

This will output the following JSON string:

{
  "messages": [
    {
      "role": "system",
      "content": "Hello, World!"
    }
  ]
}

Q: How can I use a library like json to handle the JSON formatting for me?

A: You can use a library like json to handle the JSON formatting for you by requiring the library and using its encode function to convert the table to JSON. For example:

local json = require('json')
local data = {
  messages = {
    {
      role = 'system',
      content = 'Hello, World!',
    },
  },
}

local json_data = json.encode(data)
print(json_data)

This will output the following JSON string:

{
  "messages": [
    {
      "role": "system",
      "content": "Hello, World!"
    }
  ]
}

Q: What are some additional tips for troubleshooting the issue with the Content-Type header not being set correctly?

A: Some additional tips for troubleshooting the issue with the Content-Type header not being set correctly include:

  • Make sure to check the documentation for the requests.lua library to ensure that you are using it correctly.
  • Use a debugger or print statements to help you identify the issue.
  • Make sure to check the response from the server to ensure that it is in the correct format.

Q: What is the example use case for the updated stringify_table function?

A: The example use case for the updated stringify_table function is as follows:

local data = {
  messages = {
    {
      role = 'system',
      content = 'Hello, World!',
    },
  },
}

local json_data = stringify_table(data)
print(json_data)

This will output the following JSON string:

{
 messages": [
    {
      "role": "system",
      "content": "Hello, World!"
    }
  ]
}

This demonstrates how the stringify_table function can be used to correctly format a table as JSON.