openai_provider.hpp

Go to the documentation of this file.

#pragma once
 
#include <prompt_base/prompt_base_class.hpp>
 
namespace prompt
{
 
class OpenAIProvider : public PromptBaseClass
{
public:
  OpenAIProvider() : PromptBaseClass()
  {
  }
 
  virtual void initialize(rclcpp::Node::SharedPtr node) override
  {
    // initialize base class
    initialize_prompt_base(node, "OpenAIProvider", "OPENAI_API_KEY");
  }
 
protected:
  virtual Poco::JSON::Object toJson(prompt::PromptRequest& prompt) override
  {
   // add options (model, temperature, etc.)
   Poco::JSON::Object result = handle_options(prompt.options);
 
    // /v1/responses uses `input` instead of `prompt`
    // For simple one-shot prompts, send the text directly as a string.
    result.set("input", prompt.prompt);
 
    return result;
  }
 
  virtual Poco::JSON::Object toJsonConversation(prompt::PromptRequest& prompt,
                                                std::vector<PromptDialogue>& conversation) override
  {
    // add options (model, temperature, etc.)
    Poco::JSON::Object result = handle_options(prompt.options);
 
    // /v1/responses represents conversational input as an array of "message" items
    // Each message has: role + content array with input_text/output_text entries.
    Poco::JSON::Array input_array;
 
    // add previous conversation
    for (const prompt::PromptDialogue& dialog : conversation)
    {
      Poco::JSON::Object message_obj;
      message_obj.set("type", "message");
      message_obj.set("role", dialog.role);
 
      Poco::JSON::Array content_array;
      Poco::JSON::Object content_obj;
      content_obj.set("type", "input_text");
      content_obj.set("text", dialog.content);
      content_array.add(content_obj);
 
      message_obj.set("content", content_array);
      input_array.add(message_obj);
    }
 
    // add latest user prompt as the final message
    Poco::JSON::Object latest_message;
    latest_message.set("type", "message");
    latest_message.set("role", "user");
 
    Poco::JSON::Array latest_content_array;
    Poco::JSON::Object latest_content_obj;
    latest_content_obj.set("type", "input_text");
    latest_content_obj.set("text", prompt.prompt);
    latest_content_array.add(latest_content_obj);
 
    latest_message.set("content", latest_content_array);
    input_array.add(latest_message);
 
    // attach to body as `input`
    result.set("input", input_array);
 
    return result;
  }
 
  virtual prompt::PromptResponse fromJson(const Poco::JSON::Object::Ptr object) override
  {
    prompt::PromptResponse res;
 
    // Extract assistant text from /v1/responses `output` structure
    if (object->has("output"))
    {
      try
      {
        Poco::JSON::Array::Ptr output_array = object->getArray("output");
        for (size_t i = 0; i < output_array->size(); ++i)
        {
          Poco::JSON::Object::Ptr out_item = output_array->getObject(i);
          if (!out_item->has("content"))
            continue;
 
          Poco::JSON::Array::Ptr content_array = out_item->getArray("content");
          for (size_t j = 0; j < content_array->size(); ++j)
          {
            Poco::JSON::Object::Ptr content_obj = content_array->getObject(j);
            if (content_obj->has("text"))
            {
              res.response = content_obj->getValue<std::string>("text");
              break;
            }
          }
 
          if (!res.response.empty())
            break;
        }
      }
      catch (const Poco::Exception& ex)
      {
        RCLCPP_WARN(node_->get_logger(), "Failed to parse OpenAI /v1/responses output: %s", ex.what());
      }
    }
 
    res.success = !res.response.empty();
 
    // attach remaining top-level fields as options (excluding large nested structures)
    for (Poco::JSON::Object::ConstIterator it = object->begin(); it != object->end(); ++it)
    {
      if ((it->first == "output") || (it->first == "usage"))
        continue;
 
      try
      {
        if (!it->second.isEmpty() && it->second.isString())
        {
          res.options.push_back(prompt::PromptOption{ it->first, it->second.convert<std::string>(), "" });
        }
        else if (!it->second.isEmpty())
        {
          res.options.push_back(prompt::PromptOption{ it->first, it->second.toString(), "" });
        }
        else
        {
          res.options.push_back(prompt::PromptOption{ it->first, "[null]", "" });
        }
      }
      catch (const Poco::Exception& ex)
      {
        RCLCPP_WARN(node_->get_logger(), "Failed to convert JSON key '%s': %s", it->first.c_str(), ex.what());
      }
    }
 
    return res;
  }
 
  virtual prompt::PromptResponse fromJsonConversation(const Poco::JSON::Object::Ptr object) override
  {
    prompt::PromptResponse res;
    // Parse the same /v1/responses structure for conversational responses
    if (object->has("output"))
    {
      try
      {
        Poco::JSON::Array::Ptr output_array = object->getArray("output");
        for (size_t i = 0; i < output_array->size(); ++i)
        {
          Poco::JSON::Object::Ptr out_item = output_array->getObject(i);
          if (!out_item->has("content"))
            continue;
 
          Poco::JSON::Array::Ptr content_array = out_item->getArray("content");
          for (size_t j = 0; j < content_array->size(); ++j)
          {
            Poco::JSON::Object::Ptr content_obj = content_array->getObject(j);
            if (content_obj->has("text"))
            {
              res.response = content_obj->getValue<std::string>("text");
              break;
            }
          }
 
          if (!res.response.empty())
            break;
        }
      }
      catch (const Poco::Exception& ex)
      {
        RCLCPP_WARN(node_->get_logger(), "Failed to parse OpenAI /v1/responses output (conversation): %s", ex.what());
      }
    }
 
    res.success = !res.response.empty();
 
    // Attach remaining top-level fields as options (excluding large nested structures)
    for (Poco::JSON::Object::ConstIterator it = object->begin(); it != object->end(); ++it)
    {
      if ((it->first == "output") || (it->first == "usage"))
        continue;
 
      try
      {
        if (!it->second.isEmpty() && it->second.isString())
        {
          res.options.push_back(prompt::PromptOption{ it->first, it->second.convert<std::string>(), "" });
        }
        else if (!it->second.isEmpty())
        {
          res.options.push_back(prompt::PromptOption{ it->first, it->second.toString(), "" });
        }
        else
        {
          res.options.push_back(prompt::PromptOption{ it->first, "[null]", "" });
        }
      }
      catch (const Poco::Exception& ex)
      {
        RCLCPP_WARN(node_->get_logger(), "Failed to convert JSON key '%s': %s", it->first.c_str(), ex.what());
      }
    }
 
    // Clean up any fenced XML blocks if present (for backward compatibility)
    size_t startPos = res.response.find("```xml\n");
    if (startPos != std::string::npos)
    {
      res.response.replace(startPos, 6, "");
    }
 
    size_t endPos = res.response.rfind("\n```");
    if (endPos != std::string::npos)
    {
      res.response.replace(endPos, 4, "");
    }
 
    return res;
  }
};
 
}  // namespace prompt