Support functions in responses api

mkulakow · mkulakow · commit 36f2b660b987 · 2026-04-30T14:28:53.000+02:00
diff --git a/src/llm/apis/openai_responses.cpp b/src/llm/apis/openai_responses.cpp
@@ -95,6 +95,43 @@ absl::Status OpenAIResponsesHandler::parseInput(std::optional<std::string> allow
             }
 
             auto itemObj = item.GetObject();
+
+            // Determine item type (if present)
+            auto itemTypeIt = itemObj.FindMember("type");
+            const std::string itemType = (itemTypeIt != itemObj.MemberEnd() && itemTypeIt->value.IsString())
+                ? itemTypeIt->value.GetString() : "";
+
+            // Skip reasoning items — they are internal chain-of-thought and not passed to the model
+            if (itemType == "reasoning") {
+                continue;
+            }
+
+            // Handle function_call items (assistant tool use)
+            // For chatHistory (non-Python path), represent as an assistant message with empty content.
+            // The proper tool_calls structure is reconstructed in processedJson for the Python/Jinja path.
+            if (itemType == "function_call") {
+                request.chatHistory.push_back({});
+                request.chatHistory.last()["role"] = "assistant";
+                request.chatHistory.last()["content"] = "";
+                continue;
+            }
+
+            // Handle function_call_output items (tool results)
+            if (itemType == "function_call_output") {
+                auto callIdIt = itemObj.FindMember("call_id");
+                auto outputIt = itemObj.FindMember("output");
+                request.chatHistory.push_back({});
+                request.chatHistory.last()["role"] = "tool";
+                if (callIdIt != itemObj.MemberEnd() && callIdIt->value.IsString()) {
+                    request.chatHistory.last()["tool_call_id"] = callIdIt->value.GetString();
+                }
+                const std::string outputContent = (outputIt != itemObj.MemberEnd() && outputIt->value.IsString())
+                    ? outputIt->value.GetString() : "";
+                request.chatHistory.last()["content"] = outputContent;
+                continue;
+            }
+
+            // All remaining items must have a role field
             auto roleIt = itemObj.FindMember("role");
             if (roleIt == itemObj.MemberEnd() || !roleIt->value.IsString()) {
                 return absl::InvalidArgumentError("input item role is missing or invalid");
@@ -105,7 +142,9 @@ absl::Status OpenAIResponsesHandler::parseInput(std::optional<std::string> allow
 
             auto contentIt = itemObj.FindMember("content");
             if (contentIt == itemObj.MemberEnd()) {
-                return absl::InvalidArgumentError("input item content is missing");
+                // Allow messages without content (e.g., assistant message paired with tool calls)
+                request.chatHistory.last()["content"] = "";
+                continue;
             }
 
             if (contentIt->value.IsString()) {
@@ -117,7 +156,9 @@ absl::Status OpenAIResponsesHandler::parseInput(std::optional<std::string> allow
                 return absl::InvalidArgumentError("input item content must be a string or array");
             }
             if (contentIt->value.GetArray().Size() == 0) {
-                return absl::InvalidArgumentError("Invalid message structure - content array is empty");
+                // Empty content array is allowed (e.g., assistant message with only tool calls)
+                request.chatHistory.last()["content"] = "";
+                continue;
             }
 
             std::string contentText = "";
@@ -132,10 +173,10 @@ absl::Status OpenAIResponsesHandler::parseInput(std::optional<std::string> allow
                 }
 
                 const std::string type = typeIt->value.GetString();
-                if (type == "input_text") {
+                if (type == "input_text" || type == "output_text") {
                     auto textIt = contentObj.FindMember("text");
                     if (textIt == contentObj.MemberEnd() || !textIt->value.IsString()) {
-                        return absl::InvalidArgumentError("input_text requires a valid text field");
+                        return absl::InvalidArgumentError(absl::StrCat(type, " requires a valid text field"));
                     }
                     contentText = textIt->value.GetString();
                 } else if (type == "input_image") {
@@ -163,7 +204,8 @@ absl::Status OpenAIResponsesHandler::parseInput(std::optional<std::string> allow
                     }
                     request.imageHistory.push_back({i, tensorResult.value()});
                 } else {
-                    return absl::InvalidArgumentError("Unsupported content type. Supported types are input_text and input_image.");
+                    // Skip unrecognised content item types for forward compatibility
+                    SPDLOG_LOGGER_DEBUG(llm_calculator_logger, "Skipping unsupported content type: {}", type);
                 }
             }
 
@@ -228,27 +270,153 @@ absl::Status OpenAIResponsesHandler::parseResponsesPart(std::optional<uint32_t>
     }
 
 #if (PYTHON_DISABLE == 0)
-    // Build processedJson with "messages" array from chatHistory so that
-    // the Python chat template path (which reads request_json["messages"])
-    // can consume Responses API input without a separate code path.
+    // Build processedJson with a "messages" array in chat/completions format so that
+    // the Python Jinja template path can consume Responses API input without a separate code path.
+    // Handles reasoning (skipped), function_call (merged into assistant tool_calls), and
+    // function_call_output (converted to role:tool messages).
     {
         Document processedDoc;
         processedDoc.SetObject();
         auto& alloc = processedDoc.GetAllocator();
 
         Value messagesArray(kArrayType);
-        for (size_t i = 0; i < request.chatHistory.size(); ++i) {
-            Value msgObj(kObjectType);
-            auto role = request.chatHistory[i]["role"].as_string();
-            if (role.has_value()) {
-                msgObj.AddMember("role", Value(role.value().c_str(), alloc), alloc);
-            }
-            auto content = request.chatHistory[i]["content"].as_string();
-            if (content.has_value()) {
-                msgObj.AddMember("content", Value(content.value().c_str(), alloc), alloc);
+
+        auto inputArrIt = doc.FindMember("input");
+        if (inputArrIt != doc.MemberEnd() && inputArrIt->value.IsArray()) {
+            // Pending function_call items to be merged into the next assistant message
+            std::vector<const rapidjson::Value*> pendingFunctionCalls;
+
+            // Helper: flush pending function_calls as an assistant message with the given text content
+            auto flushPendingFunctionCalls = [&](const std::string& textContent) {
+                if (pendingFunctionCalls.empty()) {
+                    return;
+                }
+                Value msgObj(kObjectType);
+                msgObj.AddMember("role", Value("assistant", alloc), alloc);
+                msgObj.AddMember("content", Value(textContent.c_str(), alloc), alloc);
+                Value toolCallsArray(kArrayType);
+                for (const auto* fc : pendingFunctionCalls) {
+                    auto fcObj = fc->GetObject();
+                    Value tcObj(kObjectType);
+                    auto idIt = fcObj.FindMember("id");
+                    const std::string tcId = (idIt != fcObj.MemberEnd() && idIt->value.IsString())
+                        ? idIt->value.GetString() : "";
+                    tcObj.AddMember("id", Value(tcId.c_str(), alloc), alloc);
+                    tcObj.AddMember("type", Value("function", alloc), alloc);
+                    Value funcObj(kObjectType);
+                    auto nameIt = fcObj.FindMember("name");
+                    const std::string funcName = (nameIt != fcObj.MemberEnd() && nameIt->value.IsString())
+                        ? nameIt->value.GetString() : "";
+                    funcObj.AddMember("name", Value(funcName.c_str(), alloc), alloc);
+                    auto argsIt = fcObj.FindMember("arguments");
+                    const std::string args = (argsIt != fcObj.MemberEnd() && argsIt->value.IsString())
+                        ? argsIt->value.GetString() : "";
+                    funcObj.AddMember("arguments", Value(args.c_str(), alloc), alloc);
+                    tcObj.AddMember("function", funcObj, alloc);
+                    toolCallsArray.PushBack(tcObj, alloc);
+                }
+                msgObj.AddMember("tool_calls", toolCallsArray, alloc);
+                messagesArray.PushBack(msgObj, alloc);
+                pendingFunctionCalls.clear();
+            };
+
+            // Helper: extract text content from a Responses API content field (string or array)
+            auto extractTextContent = [&](const rapidjson::Value& contentVal) -> std::string {
+                if (contentVal.IsString()) {
+                    return contentVal.GetString();
+                }
+                if (contentVal.IsArray()) {
+                    for (auto& ci : contentVal.GetArray()) {
+                        if (!ci.IsObject()) continue;
+                        auto ctTypeIt = ci.GetObject().FindMember("type");
+                        if (ctTypeIt == ci.GetObject().MemberEnd() || !ctTypeIt->value.IsString()) continue;
+                        const std::string ctType = ctTypeIt->value.GetString();
+                        if (ctType == "input_text" || ctType == "output_text") {
+                            auto textIt = ci.GetObject().FindMember("text");
+                            if (textIt != ci.GetObject().MemberEnd() && textIt->value.IsString()) {
+                                return textIt->value.GetString();
+                            }
+                        }
+                    }
+                }
+                return "";
+            };
+
+            for (rapidjson::SizeType i = 0; i < inputArrIt->value.GetArray().Size(); ++i) {
+                const auto& item = inputArrIt->value.GetArray()[i];
+                if (!item.IsObject()) continue;
+                auto itemObj = item.GetObject();
+
+                auto itemTypeIt = itemObj.FindMember("type");
+                const std::string itemType = (itemTypeIt != itemObj.MemberEnd() && itemTypeIt->value.IsString())
+                    ? itemTypeIt->value.GetString() : "";
+
+                // Skip reasoning items
+                if (itemType == "reasoning") {
+                    continue;
+                }
+
+                // Buffer function_call items — they will be merged with the next assistant message
+                if (itemType == "function_call") {
+                    pendingFunctionCalls.push_back(&item);
+                    continue;
+                }
+
+                // Convert function_call_output to role:tool message
+                if (itemType == "function_call_output") {
+                    flushPendingFunctionCalls("");
+                    Value msgObj(kObjectType);
+                    msgObj.AddMember("role", Value("tool", alloc), alloc);
+                    auto callIdIt = itemObj.FindMember("call_id");
+                    if (callIdIt != itemObj.MemberEnd() && callIdIt->value.IsString()) {
+                        msgObj.AddMember("tool_call_id", Value(callIdIt->value.GetString(), alloc), alloc);
+                    }
+                    auto outputIt = itemObj.FindMember("output");
+                    const std::string outputContent = (outputIt != itemObj.MemberEnd() && outputIt->value.IsString())
+                        ? outputIt->value.GetString() : "";
+                    msgObj.AddMember("content", Value(outputContent.c_str(), alloc), alloc);
+                    messagesArray.PushBack(msgObj, alloc);
+                    continue;
+                }
+
+                // All other items must have a role
+                auto roleIt = itemObj.FindMember("role");
+                if (roleIt == itemObj.MemberEnd() || !roleIt->value.IsString()) {
+                    continue;  // Skip unknown items without a role
+                }
+                const std::string role = roleIt->value.GetString();
+
+                std::string contentText = "";
+                auto contentIt = itemObj.FindMember("content");
+                if (contentIt != itemObj.MemberEnd()) {
+                    contentText = extractTextContent(contentIt->value);
+                }
+
+                if (role == "assistant") {
+                    if (!pendingFunctionCalls.empty()) {
+                        // Merge buffered function_call items into this assistant message
+                        flushPendingFunctionCalls(contentText);
+                    } else {
+                        // Plain assistant message with no associated tool calls
+                        Value msgObj(kObjectType);
+                        msgObj.AddMember("role", Value("assistant", alloc), alloc);
+                        msgObj.AddMember("content", Value(contentText.c_str(), alloc), alloc);
+                        messagesArray.PushBack(msgObj, alloc);
+                    }
+                } else {
+                    // Non-assistant message — flush any pending function calls first
+                    flushPendingFunctionCalls("");
+                    Value msgObj(kObjectType);
+                    msgObj.AddMember("role", Value(role.c_str(), alloc), alloc);
+                    msgObj.AddMember("content", Value(contentText.c_str(), alloc), alloc);
+                    messagesArray.PushBack(msgObj, alloc);
+                }
             }
-            messagesArray.PushBack(msgObj, alloc);
+
+            // Flush any trailing buffered function_calls
+            flushPendingFunctionCalls("");
         }
+
         processedDoc.AddMember("messages", messagesArray, alloc);
 
         // Copy tools from original doc if present
diff --git a/src/llm/py_jinja_template_processor.cpp b/src/llm/py_jinja_template_processor.cpp
@@ -40,7 +40,7 @@ bool PyJinjaTemplateProcessor::applyChatTemplate(PyJinjaTemplateProcessor& templ
         output = "Error: Chat template not loaded correctly, so it cannot be applied";
         return false;
     }
-
+    SPDLOG_DEBUG("Before chat template: \n {}", requestBody);
     py::gil_scoped_acquire acquire;
     try {
         auto locals = py::dict("request_body"_a = requestBody, "chat_template"_a = templateProcessor.chatTemplate->getObject(),

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ bool PyJinjaTemplateProcessor::applyChatTemplate(PyJinjaTemplateProcessor& templ`
`40`	`40`	`output = "Error: Chat template not loaded correctly, so it cannot be applied";`
`41`	`41`	`return false;`
`42`	`42`	`}`
`43`		`-`
	`43`	`+ SPDLOG_DEBUG("Before chat template: \n {}", requestBody);`
`44`	`44`	`py::gil_scoped_acquire acquire;`
`45`	`45`	`try {`
`46`	`46`	`auto locals = py::dict("request_body"_a = requestBody, "chat_template"_a = templateProcessor.chatTemplate->getObject(),`