chat_out.hpp

Go to the documentation of this file.

#pragma once
 
// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Lloyal Labs
 
#include "common.hpp"
#include <llama/llama.h>
#include <chat.h>
#include <peg-parser.h>
#include <exception>
#include <string>
#include <vector>
 
namespace lloyal::chat_out {
 
struct ToolCall {
  std::string name;        
  std::string arguments;   
  std::string id;          
};
 
struct ParseResult {
  std::string content;              
  std::string reasoning_content;    
  std::vector<ToolCall> tool_calls; 
};
 
inline ParseResult parse(
    const std::string& output,
    common_chat_format format,
    common_reasoning_format reasoning_format = COMMON_REASONING_FORMAT_NONE,
    bool is_partial = false,
    bool thinking_forced_open = false,
    const std::string& parser_data = ""
) {
  ParseResult result;
 
  try {
    // Build parser params
    common_chat_parser_params syntax;
    syntax.format = format;
    syntax.reasoning_format = reasoning_format;
    syntax.thinking_forced_open = thinking_forced_open;
 
    // Load serialized PEG parser if provided (required for PEG format models)
    if (!parser_data.empty()) {
      syntax.parser.load(parser_data);
    }
 
    // Call llama.cpp's output parser
    common_chat_msg msg = common_chat_parse(output, is_partial, syntax);
 
    // Convert to ParseResult
    result.content = msg.content;
    result.reasoning_content = msg.reasoning_content;
 
    for (const auto& tc : msg.tool_calls) {
      result.tool_calls.push_back({tc.name, tc.arguments, tc.id});
    }
 
  } catch (const std::exception& e) {
    LLOYAL_LOG_DEBUG("[chat_out::parse] Parse failed: %s, returning raw output", e.what());
    result.content = output;
  }
 
  return result;
}
 
inline ParseResult parse(
    const llama_model* model,
    const std::string& output,
    bool is_partial = false
) {
  ParseResult result;
 
  try {
    // Init templates to detect format
    common_chat_templates_ptr tmpls = common_chat_templates_init(model, "");
    if (!tmpls) {
      result.content = output;
      return result;
    }
 
    // Apply with empty messages to get format detection
    common_chat_templates_inputs inputs;
    inputs.messages = {{.role = "user", .content = ""}};
    inputs.add_generation_prompt = true;
    inputs.use_jinja = true;
 
    common_chat_params params = common_chat_templates_apply(tmpls.get(), inputs);
 
    // Delegate to explicit-format overload
    return parse(output, params.format, COMMON_REASONING_FORMAT_NONE, is_partial,
                 params.thinking_forced_open);
 
  } catch (const std::exception& e) {
    LLOYAL_LOG_DEBUG("[chat_out::parse] Auto-detect failed: %s", e.what());
    result.content = output;
    return result;
  }
}
 
} // namespace lloyal::chat_out