adapter_base.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/inference/adapters/adapter_base.h>
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <algorithm>
#include <atomic>
#include <cstdint>
#include <regex>
#include <sstream>
#include <unordered_set>
 
namespace entropic {
 
namespace {
auto logger = entropic::log::get("inference.adapter");
 
constexpr const char* TOOL_RESULT_SUFFIX =
    "Continue. Batch multiple tool calls in one response when possible.";
 
std::string generate_uuid() {
    // Simple counter-based ID for now. Replace with proper UUID if needed.
    static std::atomic<uint64_t> counter{0};
    return "tc-" + std::to_string(counter.fetch_add(1, std::memory_order_relaxed));
}
 
std::string tool_name_from_json(const nlohmann::json& j) {
    for (const char* key : {"name", "tool_name", "function", "function_name"}) {
        if (j.contains(key) && j[key].is_string()) {
            return j[key].get<std::string>();
        }
    }
    return "";
}
 
std::optional<ToolCall> tool_call_from_json(const nlohmann::json& j) {
    std::string name = tool_name_from_json(j);
    if (name.empty()) { return std::nullopt; }
    ToolCall tc;
    tc.id = generate_uuid();
    tc.name = std::move(name);
    auto args = j.value("arguments", j.value("parameters", nlohmann::json::object()));
    for (auto& [k, v] : args.items()) { tc.arguments[k] = v.dump(); }
    return tc;
}
 
} // anonymous namespace
 
// ── Constructor ────────────────────────────────────────────
 
ChatAdapter::ChatAdapter(std::string tier_name, std::string identity_prompt)
    : tier_name_(std::move(tier_name))
    , identity_prompt_(std::move(identity_prompt))
{
}
 
// ── System prompt assembly ─────────────────────────────────
 
// ── Tool result formatting ─────────────────────────────────
 
Message ChatAdapter::format_tool_result(
    const ToolCall& tool_call,
    const std::string& result) const
{
    Message msg;
    msg.role = "user";
    msg.content = "Tool `" + tool_call.name + "` returned:\n\n" +
                  result + "\n\n" + TOOL_RESULT_SUFFIX;
    return msg;
}
 
// ── Response completeness ──────────────────────────────────
 
bool ChatAdapter::is_response_complete(
    const std::string& content,
    const std::vector<ToolCall>& tool_calls) const
{
    // Has tool calls → not complete (needs execution)
    if (!tool_calls.empty()) {
        return false;
    }
 
    // Unclosed think block → still thinking
    if (content.find("<think>") != std::string::npos &&
        content.find("</think>") == std::string::npos)
    {
        return false;
    }
 
    // Strip think blocks and check for real content
    std::string stripped = strip_think_blocks(content);
    return !stripped.empty();
}
 
// ── Tagged tool call parsing ───────────────────────────────
 
std::vector<ToolCall> ChatAdapter::parse_tagged_tool_calls(
    const std::string& content) const
{
    std::vector<ToolCall> calls;
    // gh#65 (v2.3.3): accept asymmetric open tags. Gemma 4 emits
    // `<|tool_call>` (pipe-prefixed open, plain close) — the special
    // token `<|tool_call|>` decodes through llama.cpp's current pin
    // as `<|tool_call>` (trailing `|>` lost). Pre-v2.3.3 the regex
    // required a plain `<tool_call>` open, so Gemma 4's actual output
    // produced 0 tool calls and the engine looped on the retry banner.
    //
    // gh#69 (v2.3.8): add `<|im_start|>tool_call` as a fourth open
    // variant. Gemma 4 (E2B + E4B) emits its tool calls inside a
    // ChatML-style channel whose opening header is `<|im_start|>tool_call`
    // but whose close is the plain `</tool_call>` — an asymmetric pair
    // the prior three alternatives didn't cover, so both Gemma 4 sizes
    // scored 0/6 completion (agent loop spiralled to the iteration cap).
    //
    // Open alternatives: `<tool_call>`, `<|tool_call>`, `<|tool_call|>`,
    // `<|im_start|>tool_call`. Close tag stays `</tool_call>` — that's
    // what the consumer's transcripts consistently show.
    std::regex pattern(
        R"((?:<tool_call>|<\|tool_call\|?>|<\|im_start\|>tool_call)\s*)"
        R"(([\s\S]*?)\s*</tool_call>)");
 
    auto begin = std::sregex_iterator(content.begin(), content.end(), pattern);
    auto end = std::sregex_iterator();
 
    for (auto it = begin; it != end; ++it) {
        std::string json_str = (*it)[1].str();
        auto parsed = parse_single_tool_call(json_str);
        if (parsed) {
            calls.push_back(*parsed);
            logger->info("Parsed tagged tool call: {}", parsed->name);
        } else {
            // gh#65: when the regex matches but parse_single_tool_call
            // returns nullopt, the JSON payload was malformed in a way
            // try_recover_json could not fix. Log the offending text so
            // future investigations have something to grep, instead of
            // silently producing zero tool calls.
            logger->warn(
                "Tagged tool_call matched but JSON failed to parse: {}",
                json_str);
        }
    }
    // gh#65/gh#69: model emitted tool_call markup but no regex match.
    // Catches plain `<tool_call>`, pipe-prefixed `<|tool_call`, and the
    // Gemma 4 channel header `<|im_start|>tool_call` substrings — if
    // none matched the full pattern, surface the raw content's length so
    // the consumer can attach it for triage instead of seeing a silent
    // "tool_calls: 0".
    if (calls.empty()
        && (content.find("<tool_call>") != std::string::npos
            || content.find("<|tool_call") != std::string::npos
            || content.find("<|im_start|>tool_call") != std::string::npos)) {
        logger->warn(
            "Content contains tool_call markup but no tagged calls "
            "were extracted — possible tag/encoding mismatch. "
            "Raw content length={}", content.size());
    }
    return calls;
}
 
// ── Bare JSON parsing ──────────────────────────────────────
 
// ── gh#88 action-envelope recovery (free functions) ─────────
 
static std::optional<ToolCall> action_envelope_to_call(
    const nlohmann::json& j) {
    if (auto tc = tool_call_from_json(j)) { return tc; }
    // gh#88: meta-tools whose result `action` verb equals their tool name.
    // TodoTool (add/update/remove) and free-text actions are excluded.
    static const std::unordered_set<std::string> kMetaActions = {
        "delegate", "pipeline", "complete",
        "phase_change", "prune_context", "resume_delegation"};
    std::string action;
    if (j.contains("action") && j["action"].is_string()) {
        action = j["action"].get<std::string>();
    }
    if (kMetaActions.find(action) == kMetaActions.end()) {
        return std::nullopt;
    }
    ToolCall tc;
    tc.id = generate_uuid();
    tc.name = "entropic." + action;
    nlohmann::json args = j;
    args.erase("action");
    tc.arguments_json = args.dump();
    for (auto& [k, v] : args.items()) { tc.arguments[k] = v.dump(); }
    return tc;
}
 
std::vector<ToolCall> recover_action_envelope_calls(const std::string& raw) {
    std::vector<ToolCall> calls;
    std::istringstream stream(raw);
    std::string line;
    while (std::getline(stream, line)) {
        size_t start = line.find_first_not_of(" \t");
        if (start == std::string::npos || line[start] != '{') { continue; }
        auto j = nlohmann::json::parse(line.substr(start), nullptr, false);
        if (!j.is_object()) { continue; }
        if (auto tc = action_envelope_to_call(j)) {
            calls.push_back(std::move(*tc));
        }
    }
    return calls;
}
 
void apply_action_envelope_recovery(std::vector<ToolCall>& calls,
                                    const std::string& raw) {
    if (!calls.empty()) { return; }
    auto recovered = recover_action_envelope_calls(raw);
    if (recovered.empty()) { return; }
    logger->warn(
        "gh#88: PEG_GEMMA4 parsed 0 tool calls; recovered {} from a "
        "bare-JSON {{\"action\":...}} envelope (possible context priming)",
        recovered.size());
    calls = std::move(recovered);
}
 
// ── gh#90 string-typed-arg coercion (free functions) ────────
 
static std::unordered_set<std::string> tool_string_props(
    const nlohmann::json& tools, const std::string& name) {
    std::unordered_set<std::string> props;
    for (const auto& t : tools) {
        if (!t.is_object() || t.value("name", std::string()) != name) {
            continue;
        }
        auto schema = t.value("inputSchema", nlohmann::json::object());
        auto properties = schema.value("properties", nlohmann::json::object());
        for (auto it = properties.begin(); it != properties.end(); ++it) {
            if (it->is_object()
                && it->value("type", std::string()) == "string") {
                props.insert(it.key());
            }
        }
        break;
    }
    return props;
}
 
static void coerce_call_string_args(ToolCall& tc, const nlohmann::json& tools) {
    auto props = tool_string_props(tools, tc.name);
    if (props.empty()) { return; }
    auto args = nlohmann::json::parse(tc.arguments_json, nullptr, false);
    if (!args.is_object()) { return; }
    bool changed = false;
    for (const auto& key : props) {
        auto it = args.find(key);
        if (it != args.end() && it->is_number()) {
            *it = it->dump();  // JSON number 3 → JSON string "3"
            changed = true;
        }
    }
    if (!changed) { return; }
    tc.arguments_json = args.dump();
    for (auto it = args.begin(); it != args.end(); ++it) {
        tc.arguments[it.key()] =
            it->is_string() ? it->get<std::string>() : it->dump();
    }
}
 
void coerce_string_typed_args(std::vector<ToolCall>& calls,
                              const std::string& tools_json) {
    if (calls.empty() || tools_json.empty()) { return; }
    auto tools = nlohmann::json::parse(tools_json, nullptr, false);
    if (!tools.is_array()) { return; }
    for (auto& tc : calls) { coerce_call_string_args(tc, tools); }
}
 
// ── Think block handling ───────────────────────────────────
 
std::string ChatAdapter::strip_think_blocks(const std::string& content) const {
    const auto markers = thinking_markers();
    std::string result = content;
 
    bool truncated_unclosed = false;
    std::size_t pos;
    while ((pos = result.find(markers.open)) != std::string::npos) {
        auto close = result.find(markers.close, pos + markers.open.size());
        // Unclosed: generation stopped mid-reasoning, so no answer was ever
        // produced. Erasing to the end beats surfacing raw reasoning.
        if (close == std::string::npos) { truncated_unclosed = true; }
        auto span_end = (close == std::string::npos)
            ? result.size() : close + markers.close.size();
        result.erase(pos, span_end - pos);
    }
 
    // gh#108 (v2.10.3): without this the caller sees empty content and cannot
    // tell a stalled generation from a parse failure or an engine bug — the
    // same diagnostic dead end gh#130 fixed on the bridge. Carried over from
    // strip_thinking_channels, whose behaviour this consolidates.
    if (truncated_unclosed && result.find_first_not_of(" \t\r\n")
            == std::string::npos) {
        logger->warn(
            "Reasoning block '{}' was never closed with '{}', so the strip "
            "removed the whole generation and content is empty. Not a parse "
            "error. The orchestrator reports the actual cause (budget vs the "
            "model ending the turn) — it is the only layer holding "
            "finish_reason. gh#137.",
            markers.open, markers.close);
    }
 
    size_t start = result.find_first_not_of(" \t\n\r");
    if (start == std::string::npos) { return ""; }
    size_t end_pos = result.find_last_not_of(" \t\n\r");
    return result.substr(start, end_pos - start + 1);
}
 
// ── JSON recovery ──────────────────────────────────────────
 
static std::optional<ToolCall> parse_recovered_tool_call(
    const std::string& fixed) {
    auto j = nlohmann::json::parse(fixed);
    return tool_call_from_json(j);
}
 
static std::optional<ToolCall> regex_recovered_tool_call(
    const std::string& json_str) {
    std::regex name_pattern(R"re("name"\s*:\s*"([^"]+)")re");
    std::smatch match;
    if (!std::regex_search(json_str, match, name_pattern)) {
        return std::nullopt;
    }
    ToolCall tc;
    tc.id = generate_uuid();
    tc.name = match[1].str();
    return tc;
}
 
std::optional<ToolCall> ChatAdapter::try_recover_json(
    const std::string& json_str) const
{
    // Fix trailing commas and single quotes
    std::string fixed = std::regex_replace(json_str, std::regex(R"(,\s*\})"), "}");
    fixed = std::regex_replace(fixed, std::regex(R"(,\s*\])"), "]");
    std::replace(fixed.begin(), fixed.end(), '\'', '"');
 
    logger->info("JSON recovery attempt: {} chars", json_str.size());
    try {
        if (auto tc = parse_recovered_tool_call(fixed)) { return tc; }
    } catch (...) {
        return regex_recovered_tool_call(json_str);
    }
    return std::nullopt;
}
 
// ── Tool formatting (default) ──────────────────────────────
 
std::string ChatAdapter::format_tools(
    const std::vector<std::string>& tool_jsons) const
{
    std::ostringstream out;
    out << "## Tools\n\n"
        << "Call tools with: `<tool_call>{\"name\": \"tool.name\", \"arguments\": {...}}</tool_call>`\n"
        << "Batch independent calls in one response with multiple `<tool_call>` blocks.\n\n";
 
    for (const auto& json_str : tool_jsons) {
        try {
            auto j = nlohmann::json::parse(json_str);
            out << "### " << j.value("name", "unknown") << "\n"
                << j.value("description", "No description") << "\n\n"
                << "Schema:\n```json\n"
                << j.value("inputSchema", nlohmann::json::object()).dump(2)
                << "\n```\n\n";
        } catch (...) {
            out << "### (malformed tool definition)\n\n";
        }
    }
    return out.str();
}
 
// ── Internal helper ────────────────────────────────────────
 
std::optional<ToolCall> ChatAdapter::parse_single_tool_call(
    const std::string& json_str) const
{
    try {
        auto j = nlohmann::json::parse(json_str);
        if (auto tc = tool_call_from_json(j)) {
            return tc;
        }
    } catch (...) {
        return try_recover_json(json_str);
    }
    return std::nullopt;
}
 
// ── Vision / multimodal (v1.9.11) ──────────────────────────
 
std::string ChatAdapter::format_system_with_vision(
    const std::string& base_system,
    bool /*has_vision*/) const {
    return base_system;
}
 
std::string ChatAdapter::format_content_parts(
    const std::vector<ContentPart>& parts) const {
    nlohmann::json arr = nlohmann::json::array();
    for (const auto& part : parts) {
        nlohmann::json obj;
        if (part.type == ContentPartType::TEXT) {
            obj["type"] = "text";
            obj["text"] = part.text;
        } else {
            obj["type"] = "image";
            if (!part.image_path.empty()) {
                obj["path"] = part.image_path;
            }
            if (!part.image_url.empty()) {
                obj["url"] = part.image_url;
            }
        }
        arr.push_back(std::move(obj));
    }
    return arr.dump();
}
 
} // namespace entropic