Refactor to plugin architecture with B3 CLI UX, C2 smoke tests, C3 CI scripts
Architecture overhaul (Wave 1-4 collaborative work): - Migrated dstalk-core from monolithic api.cpp to plugin-based design with host/service_registry/event_bus/plugin_loader and topological initialization. - Split public headers into dstalk_host.h / dstalk_services.h / dstalk_lsp.h / dstalk_types.h; deleted obsolete dstalk_api.h and inlined TLS/file/net code now provided by plugins. - Added 9 plugins: deepseek, anthropic, network, session, context, tools, config, file-io, lsp; AI plugins register as "ai.<provider>" services. B3 CLI interaction enhancement: - Prompt now shows current model name (A1). - /status command prints model/base_url/api_key (sanitized: shown only as set/unset)/services readiness (A2). - SIGINT/Ctrl+C handled on POSIX (signal) and Windows (SetConsoleCtrlHandler); /quit no longer std::exit(0) but sets a quit flag so dstalk_shutdown runs exactly once via natural control flow (B1+B2). - Cross-DLL free fixed: print_file uses dstalk_free instead of std::free (B4). - --batch mode plus isatty auto-detection for piped stdin (C1). - fgets truncation detection with friendly error and stdin draining (C3). - Distinct exit codes (init/AI/service-unavailable) (C4). - /model rejects empty model name (C5). C2 smoke test extension: - 4 new test blocks: null-safety (file_io/session/tools/config), escape-boundary round-trip, tools->execute call chain, session robustness (add(nullptr), clear -> token_count == 0). C3 CI build scripts: - scripts/ci-build.sh and scripts/ci-build.bat invoke cmake configure + parallel build + ctest, suitable for GitHub Actions. Build verified: dstalk-cli compiles, smoke test passes via ctest. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
18
plugins/CMakeLists.txt
Normal file
18
plugins/CMakeLists.txt
Normal file
@@ -0,0 +1,18 @@
|
||||
# ============================================================
|
||||
# 插件目录 — 所有功能插件
|
||||
# ============================================================
|
||||
|
||||
# 基础插件（无外部服务依赖）
|
||||
add_subdirectory(config)
|
||||
add_subdirectory(file-io)
|
||||
add_subdirectory(network)
|
||||
|
||||
# 中间插件（依赖基础插件）
|
||||
add_subdirectory(session)
|
||||
add_subdirectory(context)
|
||||
|
||||
# 上层插件（依赖中间插件）
|
||||
add_subdirectory(deepseek)
|
||||
add_subdirectory(anthropic)
|
||||
add_subdirectory(tools)
|
||||
add_subdirectory(lsp)
|
||||
32
plugins/anthropic/CMakeLists.txt
Normal file
32
plugins/anthropic/CMakeLists.txt
Normal file
@@ -0,0 +1,32 @@
|
||||
cmake_minimum_required(VERSION 3.21)
|
||||
|
||||
# ============================================================
|
||||
# plugin-anthropic — Anthropic Claude AI 服务
|
||||
# 依赖: http 服务 (查询), config 服务 (查询)
|
||||
# ============================================================
|
||||
|
||||
add_library(plugin-anthropic SHARED
|
||||
src/anthropic_plugin.cpp
|
||||
)
|
||||
|
||||
target_include_directories(plugin-anthropic PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-anthropic PRIVATE dstalk)
|
||||
|
||||
# Boost.JSON 用于构建/解析请求和响应
|
||||
find_package(Boost REQUIRED CONFIG)
|
||||
target_link_libraries(plugin-anthropic PRIVATE boost::boost)
|
||||
|
||||
target_compile_definitions(plugin-anthropic PRIVATE
|
||||
BOOST_ALL_NO_LIB
|
||||
BOOST_ERROR_CODE_HEADER_ONLY
|
||||
BOOST_JSON_HEADER_ONLY
|
||||
)
|
||||
|
||||
set_target_properties(plugin-anthropic PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
486
plugins/anthropic/src/anthropic_plugin.cpp
Normal file
486
plugins/anthropic/src/anthropic_plugin.cpp
Normal file
@@ -0,0 +1,486 @@
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <boost/json.hpp>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
namespace json = boost::json;
|
||||
|
||||
// ============================================================================
|
||||
// 全局指针
|
||||
// ============================================================================
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
static dstalk_http_service_t* g_http = nullptr;
|
||||
static dstalk_config_service_t* g_config = nullptr;
|
||||
|
||||
// ============================================================================
|
||||
// 配置数据
|
||||
// ============================================================================
|
||||
struct PluginConfig {
|
||||
std::string provider;
|
||||
std::string base_url;
|
||||
std::string api_key;
|
||||
std::string model;
|
||||
int max_tokens = 4096;
|
||||
double temperature = 0.7;
|
||||
};
|
||||
static PluginConfig g_cfg;
|
||||
|
||||
// ============================================================================
|
||||
// 辅助：提取 host / target
|
||||
// ============================================================================
|
||||
static bool extract_host_port(const std::string& url,
|
||||
std::string& scheme_out, std::string& host_out,
|
||||
std::string& port_out, std::string& target_out)
|
||||
{
|
||||
size_t scheme_end = url.find("://");
|
||||
if (scheme_end == std::string::npos) return false;
|
||||
scheme_out = url.substr(0, scheme_end);
|
||||
std::string rest = url.substr(scheme_end + 3);
|
||||
size_t slash = rest.find('/');
|
||||
std::string authority = (slash != std::string::npos) ? rest.substr(0, slash) : rest;
|
||||
target_out = (slash != std::string::npos) ? rest.substr(slash) : "/";
|
||||
size_t colon = authority.rfind(':');
|
||||
if (colon != std::string::npos) {
|
||||
host_out = authority.substr(0, colon);
|
||||
port_out = authority.substr(colon + 1);
|
||||
} else {
|
||||
host_out = authority;
|
||||
port_out = (scheme_out == "https") ? "443" : "80";
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 构建 Anthropic headers JSON
|
||||
// ============================================================================
|
||||
static std::string build_headers_json()
|
||||
{
|
||||
json::object h;
|
||||
h["x-api-key"] = g_cfg.api_key;
|
||||
h["anthropic-version"] = "2023-06-01";
|
||||
return json::serialize(h);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 构建 Anthropic JSON 请求体
|
||||
// ============================================================================
|
||||
static std::string build_request_json(
|
||||
const dstalk_message_t* history, int history_len,
|
||||
const std::string& user_input,
|
||||
bool stream)
|
||||
{
|
||||
json::object root;
|
||||
root["model"] = g_cfg.model;
|
||||
root["max_tokens"] = g_cfg.max_tokens;
|
||||
root["stream"] = stream;
|
||||
|
||||
// 提取 system 消息作为顶层字段
|
||||
std::string system_prompt;
|
||||
json::array msgs;
|
||||
|
||||
for (int i = 0; i < history_len; ++i) {
|
||||
const auto& m = history[i];
|
||||
if (m.role && std::strcmp(m.role, "system") == 0) {
|
||||
if (!system_prompt.empty()) system_prompt += "\n\n";
|
||||
system_prompt += m.content ? m.content : "";
|
||||
continue;
|
||||
}
|
||||
json::object obj;
|
||||
obj["role"] = m.role ? m.role : "";
|
||||
obj["content"] = m.content ? m.content : "";
|
||||
msgs.push_back(obj);
|
||||
}
|
||||
|
||||
// 追加当前用户输入
|
||||
{
|
||||
json::object obj;
|
||||
obj["role"] = "user";
|
||||
obj["content"] = user_input;
|
||||
msgs.push_back(obj);
|
||||
}
|
||||
|
||||
root["messages"] = msgs;
|
||||
|
||||
if (!system_prompt.empty()) {
|
||||
root["system"] = system_prompt;
|
||||
}
|
||||
|
||||
if (g_cfg.temperature >= 0.0 && g_cfg.temperature <= 1.0) {
|
||||
root["temperature"] = g_cfg.temperature;
|
||||
}
|
||||
|
||||
return json::serialize(root);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 解析非流式响应
|
||||
// ============================================================================
|
||||
static void parse_response(const char* body, int http_status,
|
||||
dstalk_chat_result_t& r)
|
||||
{
|
||||
r.http_status = http_status;
|
||||
|
||||
if (http_status < 200 || http_status >= 300) {
|
||||
r.ok = 0;
|
||||
try {
|
||||
auto jv = json::parse(body ? body : "{}");
|
||||
auto obj = jv.as_object();
|
||||
if (obj.contains("error")) {
|
||||
auto err = obj["error"].as_object();
|
||||
r.error = g_host->strdup(
|
||||
json::value_to<std::string>(err["message"]).c_str());
|
||||
}
|
||||
} catch (...) {
|
||||
std::string msg = "HTTP " + std::to_string(http_status);
|
||||
r.error = g_host->strdup(msg.c_str());
|
||||
}
|
||||
if (!r.error) {
|
||||
std::string msg = "HTTP " + std::to_string(http_status);
|
||||
r.error = g_host->strdup(msg.c_str());
|
||||
}
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
auto jv = json::parse(body ? body : "{}");
|
||||
auto obj = jv.as_object();
|
||||
auto content = obj["content"].as_array();
|
||||
if (!content.empty()) {
|
||||
// 取第一个 text block
|
||||
for (const auto& block : content) {
|
||||
auto bobj = block.as_object();
|
||||
if (bobj.contains("type") &&
|
||||
json::value_to<std::string>(bobj["type"]) == "text") {
|
||||
std::string text = json::value_to<std::string>(bobj["text"]);
|
||||
r.content = g_host->strdup(text.c_str());
|
||||
r.ok = 1;
|
||||
r.error = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
return;
|
||||
}
|
||||
}
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("no text content block found");
|
||||
} else {
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("empty response");
|
||||
}
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
} catch (std::exception& e) {
|
||||
r.ok = 0;
|
||||
std::string msg = std::string("json parse: ") + e.what();
|
||||
r.error = g_host->strdup(msg.c_str());
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
} catch (...) {
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("json parse error");
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// SSE 事件解析（Anthropic 格式: event/content_block_delta)
|
||||
// ============================================================================
|
||||
|
||||
// 状态机：记录当前正在处理的事件类型
|
||||
// 简化版：直接从 data: 行解析，不依赖 event: 行
|
||||
static bool parse_sse_data(const std::string& data, std::string& token_out)
|
||||
{
|
||||
try {
|
||||
auto jv = json::parse(data);
|
||||
auto obj = jv.as_object();
|
||||
|
||||
auto* type_ptr = obj.if_contains("type");
|
||||
if (!type_ptr || !type_ptr->is_string()) return false;
|
||||
std::string type = json::value_to<std::string>(*type_ptr);
|
||||
|
||||
if (type == "content_block_delta") {
|
||||
auto* delta = obj.if_contains("delta");
|
||||
if (!delta || !delta->is_object()) return false;
|
||||
auto& dobj = delta->as_object();
|
||||
|
||||
auto* dtype = dobj.if_contains("type");
|
||||
if (!dtype || !dtype->is_string()) return false;
|
||||
std::string delta_type = json::value_to<std::string>(*dtype);
|
||||
|
||||
if (delta_type == "text_delta") {
|
||||
auto* text = dobj.if_contains("text");
|
||||
if (text && text->is_string()) {
|
||||
token_out = json::value_to<std::string>(*text);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} else if (type == "message_stop") {
|
||||
token_out.clear();
|
||||
return true; // 流结束
|
||||
}
|
||||
// 忽略: message_start, content_block_start, content_block_stop, ping, message_delta
|
||||
} catch (...) {
|
||||
// 解析失败忽略
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// configure
|
||||
// ============================================================================
|
||||
static int my_configure(const char* provider, const char* base_url,
|
||||
const char* api_key, const char* model,
|
||||
int max_tokens, double temperature)
|
||||
{
|
||||
if (provider) g_cfg.provider = provider;
|
||||
if (base_url) g_cfg.base_url = base_url;
|
||||
if (api_key) g_cfg.api_key = api_key;
|
||||
if (model) g_cfg.model = model;
|
||||
g_cfg.max_tokens = max_tokens;
|
||||
g_cfg.temperature = temperature;
|
||||
|
||||
if (g_host) {
|
||||
g_host->log(DSTALK_LOG_INFO,
|
||||
"[anthropic] configured: model=%s base_url=%s max_tokens=%d temperature=%.2f",
|
||||
g_cfg.model.c_str(), g_cfg.base_url.c_str(),
|
||||
g_cfg.max_tokens, g_cfg.temperature);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// chat
|
||||
// ============================================================================
|
||||
static dstalk_chat_result_t my_chat(
|
||||
const dstalk_message_t* history, int history_len,
|
||||
const char* user_input,
|
||||
const char* /*tools_json*/)
|
||||
{
|
||||
dstalk_chat_result_t r = {};
|
||||
r.ok = 0;
|
||||
|
||||
if (!g_http) {
|
||||
r.error = g_host->strdup("http service not available");
|
||||
return r;
|
||||
}
|
||||
|
||||
std::string scheme, host, port, target;
|
||||
extract_host_port(g_cfg.base_url, scheme, host, port, target);
|
||||
std::string target_path = target + "/v1/messages";
|
||||
|
||||
std::string body = build_request_json(history, history_len,
|
||||
user_input ? user_input : "", false);
|
||||
|
||||
std::string headers_json = build_headers_json();
|
||||
|
||||
char* response_body = nullptr;
|
||||
int status_code = 0;
|
||||
|
||||
int ret = g_http->post_json(
|
||||
host.c_str(), port.c_str(), target_path.c_str(), body.c_str(),
|
||||
headers_json.c_str(), &response_body, &status_code);
|
||||
|
||||
if (ret != 0) {
|
||||
r.error = g_host->strdup("http request failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
parse_response(response_body, status_code, r);
|
||||
|
||||
if (response_body) {
|
||||
g_host->free(response_body);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// chat_stream
|
||||
// ============================================================================
|
||||
|
||||
struct StreamContext {
|
||||
const dstalk_host_api_t* host;
|
||||
dstalk_stream_cb user_cb;
|
||||
void* userdata;
|
||||
std::string accumulated;
|
||||
bool saw_data_line = false;
|
||||
};
|
||||
|
||||
// 行回调
|
||||
static int sse_line_callback(const char* line, void* userdata)
|
||||
{
|
||||
auto* ctx = static_cast<StreamContext*>(userdata);
|
||||
if (!line || !line[0]) return 1; // 空行，继续
|
||||
|
||||
std::string line_str(line);
|
||||
|
||||
// SSE 格式: "data: <json>"
|
||||
if (line_str.rfind("data: ", 0) == 0) {
|
||||
std::string data = line_str.substr(6);
|
||||
std::string token;
|
||||
if (parse_sse_data(data, token)) {
|
||||
ctx->saw_data_line = true;
|
||||
if (token.empty()) {
|
||||
// message_stop
|
||||
return 0;
|
||||
}
|
||||
ctx->accumulated += token;
|
||||
if (ctx->user_cb) {
|
||||
return ctx->user_cb(token.c_str(), ctx->userdata);
|
||||
}
|
||||
}
|
||||
}
|
||||
// "event: ..." 行和其他 -> 忽略
|
||||
return 1;
|
||||
}
|
||||
|
||||
static dstalk_chat_result_t my_chat_stream(
|
||||
const dstalk_message_t* history, int history_len,
|
||||
const char* user_input,
|
||||
dstalk_stream_cb cb, void* userdata)
|
||||
{
|
||||
dstalk_chat_result_t r = {};
|
||||
r.ok = 0;
|
||||
|
||||
if (!g_http) {
|
||||
r.error = g_host->strdup("http service not available");
|
||||
return r;
|
||||
}
|
||||
|
||||
std::string scheme, host, port, target;
|
||||
extract_host_port(g_cfg.base_url, scheme, host, port, target);
|
||||
std::string target_path = target + "/v1/messages";
|
||||
|
||||
std::string body = build_request_json(history, history_len,
|
||||
user_input ? user_input : "", true);
|
||||
|
||||
std::string headers_json = build_headers_json();
|
||||
|
||||
StreamContext ctx;
|
||||
ctx.host = g_host;
|
||||
ctx.user_cb = cb;
|
||||
ctx.userdata = userdata;
|
||||
ctx.saw_data_line = false;
|
||||
|
||||
char* response_body = nullptr;
|
||||
int status_code = 0;
|
||||
|
||||
int ret = g_http->post_stream(
|
||||
host.c_str(), port.c_str(), target_path.c_str(), body.c_str(),
|
||||
headers_json.c_str(),
|
||||
sse_line_callback, &ctx,
|
||||
&response_body, &status_code);
|
||||
|
||||
r.http_status = status_code;
|
||||
|
||||
// 检查错误状态
|
||||
if (status_code < 200 || status_code >= 300) {
|
||||
r.ok = 0;
|
||||
if (response_body && response_body[0]) {
|
||||
try {
|
||||
auto jv = json::parse(response_body);
|
||||
auto obj = jv.as_object();
|
||||
if (obj.contains("error")) {
|
||||
auto err = obj["error"].as_object();
|
||||
r.error = g_host->strdup(
|
||||
json::value_to<std::string>(err["message"]).c_str());
|
||||
}
|
||||
} catch (...) {}
|
||||
}
|
||||
if (!r.error) {
|
||||
if (status_code <= 0)
|
||||
r.error = g_host->strdup("transport error");
|
||||
else
|
||||
r.error = g_host->strdup(
|
||||
("HTTP " + std::to_string(status_code)).c_str());
|
||||
}
|
||||
if (response_body) g_host->free(response_body);
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
return r;
|
||||
}
|
||||
|
||||
if (response_body) g_host->free(response_body);
|
||||
|
||||
if (ctx.accumulated.empty() && !ctx.saw_data_line) {
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("no content received");
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
} else {
|
||||
r.ok = 1;
|
||||
r.error = nullptr;
|
||||
r.content = g_host->strdup(ctx.accumulated.c_str());
|
||||
r.tool_calls_json = nullptr;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// free_result
|
||||
// ============================================================================
|
||||
static void my_free_result(dstalk_chat_result_t* result)
|
||||
{
|
||||
if (!result || !g_host) return;
|
||||
if (result->content) { g_host->free((void*)result->content); result->content = nullptr; }
|
||||
if (result->error) { g_host->free((void*)result->error); result->error = nullptr; }
|
||||
if (result->tool_calls_json) { g_host->free((void*)result->tool_calls_json); result->tool_calls_json = nullptr; }
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 服务 vtable
|
||||
// ============================================================================
|
||||
static dstalk_ai_service_t g_service = {
|
||||
&my_configure,
|
||||
&my_chat,
|
||||
&my_chat_stream,
|
||||
&my_free_result,
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// 生命周期
|
||||
// ============================================================================
|
||||
static int on_init(const dstalk_host_api_t* host)
|
||||
{
|
||||
g_host = host;
|
||||
g_http = (dstalk_http_service_t*)host->query_service("http", 1);
|
||||
g_config = (dstalk_config_service_t*)host->query_service("config", 1);
|
||||
|
||||
if (!g_http) {
|
||||
if (g_host) g_host->log(DSTALK_LOG_ERROR, "[anthropic] http service not found");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[anthropic] initializing Anthropic AI plugin");
|
||||
|
||||
return host->register_service("ai.anthropic", 1, &g_service);
|
||||
}
|
||||
|
||||
static void on_shutdown()
|
||||
{
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[anthropic] shutdown");
|
||||
g_http = nullptr;
|
||||
g_config = nullptr;
|
||||
g_host = nullptr;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 插件描述符
|
||||
// ============================================================================
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
/* .name = */ "anthropic-ai",
|
||||
/* .version = */ "1.0.0",
|
||||
/* .description = */ "Anthropic Claude AI provider (Messages API)",
|
||||
/* .api_version = */ DSTALK_API_VERSION,
|
||||
/* .dependencies = */ { "http", "config", NULL },
|
||||
/* .on_init = */ on_init,
|
||||
/* .on_shutdown = */ on_shutdown,
|
||||
/* .on_event = */ nullptr,
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void)
|
||||
{
|
||||
return &g_info;
|
||||
}
|
||||
13
plugins/config/CMakeLists.txt
Normal file
13
plugins/config/CMakeLists.txt
Normal file
@@ -0,0 +1,13 @@
|
||||
add_library(plugin-config SHARED src/config_plugin.cpp)
|
||||
|
||||
target_include_directories(plugin-config PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-config PRIVATE dstalk)
|
||||
|
||||
set_target_properties(plugin-config PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
146
plugins/config/src/config_plugin.cpp
Normal file
146
plugins/config/src/config_plugin.cpp
Normal file
@@ -0,0 +1,146 @@
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <mutex>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <cstdio>
|
||||
|
||||
// ============================================================
|
||||
// ConfigStore - independent TOML key-value store
|
||||
// ============================================================
|
||||
namespace {
|
||||
|
||||
class ConfigStore {
|
||||
public:
|
||||
int load_file(const char* path) {
|
||||
if (!path) return -1;
|
||||
|
||||
std::ifstream file(path);
|
||||
if (!file.is_open()) return -1;
|
||||
|
||||
std::stringstream ss;
|
||||
ss << file.rdbuf();
|
||||
std::string data = ss.str();
|
||||
|
||||
std::string current_section;
|
||||
size_t pos = 0;
|
||||
while (pos < data.size()) {
|
||||
while (pos < data.size() && (data[pos] == ' ' || data[pos] == '\t'))
|
||||
pos++;
|
||||
if (pos >= data.size()) break;
|
||||
|
||||
size_t nl = data.find('\n', pos);
|
||||
std::string line = (nl != std::string::npos)
|
||||
? data.substr(pos, nl - pos) : data.substr(pos);
|
||||
pos = (nl != std::string::npos) ? nl + 1 : data.size();
|
||||
|
||||
while (!line.empty() && (line.back() == '\r' || line.back() == ' '))
|
||||
line.pop_back();
|
||||
|
||||
if (line.empty() || line[0] == '#') continue;
|
||||
|
||||
if (line[0] == '[' && line.back() == ']') {
|
||||
current_section = line.substr(1, line.size() - 2);
|
||||
continue;
|
||||
}
|
||||
|
||||
size_t eq = line.find('=');
|
||||
if (eq == std::string::npos) continue;
|
||||
|
||||
std::string key = line.substr(0, eq);
|
||||
while (!key.empty() && key.back() == ' ') key.pop_back();
|
||||
if (key.empty()) continue;
|
||||
|
||||
std::string val = line.substr(eq + 1);
|
||||
while (!val.empty() && (val.front() == ' ' || val.front() == '\t'))
|
||||
val.erase(0, 1);
|
||||
if (val.size() >= 2 && val.front() == '"' && val.back() == '"')
|
||||
val = val.substr(1, val.size() - 2);
|
||||
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
std::string full_key = current_section.empty()
|
||||
? key : current_section + "." + key;
|
||||
data_[full_key] = val;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char* get(const char* key) const {
|
||||
if (!key) return nullptr;
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
auto it = data_.find(key);
|
||||
if (it == data_.end()) return nullptr;
|
||||
return it->second.c_str();
|
||||
}
|
||||
|
||||
int set(const char* key, const char* value) {
|
||||
if (!key || !value) return -1;
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
data_[key] = value;
|
||||
return 0;
|
||||
}
|
||||
|
||||
private:
|
||||
mutable std::mutex mutex_;
|
||||
std::unordered_map<std::string, std::string> data_;
|
||||
};
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
// ============================================================
|
||||
// Global state
|
||||
// ============================================================
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
static ConfigStore g_config;
|
||||
|
||||
// ============================================================
|
||||
// Service implementations
|
||||
// ============================================================
|
||||
static const char* config_get(const char* key) {
|
||||
return g_config.get(key);
|
||||
}
|
||||
|
||||
static int config_set(const char* key, const char* value) {
|
||||
return g_config.set(key, value);
|
||||
}
|
||||
|
||||
static int config_load_file(const char* path) {
|
||||
return g_config.load_file(path);
|
||||
}
|
||||
|
||||
static dstalk_config_service_t g_service = {
|
||||
config_get,
|
||||
config_set,
|
||||
config_load_file
|
||||
};
|
||||
|
||||
// ============================================================
|
||||
// Plugin lifecycle
|
||||
// ============================================================
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
return host->register_service("config", 1, &g_service);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
// nothing to clean up
|
||||
}
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
"config", // name
|
||||
"1.0.0", // version
|
||||
"Configuration service with TOML file support", // description
|
||||
DSTALK_API_VERSION, // api_version
|
||||
{nullptr}, // dependencies (none)
|
||||
on_init, // on_init
|
||||
on_shutdown, // on_shutdown
|
||||
nullptr // on_event
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
13
plugins/context/CMakeLists.txt
Normal file
13
plugins/context/CMakeLists.txt
Normal file
@@ -0,0 +1,13 @@
|
||||
add_library(plugin-context SHARED src/context_plugin.cpp)
|
||||
|
||||
target_include_directories(plugin-context PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-context PRIVATE dstalk)
|
||||
|
||||
set_target_properties(plugin-context PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
289
plugins/context/src/context_plugin.cpp
Normal file
289
plugins/context/src/context_plugin.cpp
Normal file
@@ -0,0 +1,289 @@
|
||||
// plugin-context: 上下文管理服务插件
|
||||
// 提供 dstalk_context_service_t vtable 实现
|
||||
// 依赖: session (获取历史消息做 token 计数)
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_types.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
// ============================================================
|
||||
// 全局状态
|
||||
// ============================================================
|
||||
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
static const dstalk_session_service_t* g_session = nullptr;
|
||||
static size_t g_max_tokens = 4096;
|
||||
|
||||
// ============================================================
|
||||
// 内部 C++ 辅助：token 计数
|
||||
// ============================================================
|
||||
|
||||
static bool cjk_is_ascii(unsigned char c) { return c < 0x80; }
|
||||
|
||||
static bool cjk_starts_cjk(unsigned char c) {
|
||||
// U+4E00-U+9FFF 在 UTF-8 中编码为 0xE4-0xE9 开头的三字节
|
||||
return c >= 0xE4 && c <= 0xE9;
|
||||
}
|
||||
|
||||
static size_t count_tokens_one_message(const dstalk_message_t& msg) {
|
||||
const char* text = msg.content;
|
||||
if (!text) return 4; // 只有 overhead
|
||||
|
||||
size_t ascii_chars = 0;
|
||||
size_t chinese_chars = 0;
|
||||
size_t other_chars = 0;
|
||||
|
||||
size_t i = 0;
|
||||
while (text[i] != '\0') {
|
||||
unsigned char c = static_cast<unsigned char>(text[i]);
|
||||
|
||||
if (cjk_is_ascii(c)) {
|
||||
ascii_chars++;
|
||||
i += 1;
|
||||
} else if (cjk_starts_cjk(c)) {
|
||||
chinese_chars++;
|
||||
i += 3;
|
||||
} else if (c >= 0xC0 && c < 0xE0) {
|
||||
other_chars++;
|
||||
i += 2;
|
||||
} else if (c >= 0xE0 && c < 0xF0) {
|
||||
other_chars++;
|
||||
i += 3;
|
||||
} else if (c >= 0xF0 && c < 0xF8) {
|
||||
other_chars++;
|
||||
i += 4;
|
||||
} else {
|
||||
other_chars++;
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
size_t content_tokens = (ascii_chars / 4) + (chinese_chars / 2) + (other_chars / 3);
|
||||
return content_tokens + 4; // +4 条消息开销 (role + separators)
|
||||
}
|
||||
|
||||
static size_t count_tokens_all(const dstalk_message_t* msgs, int count) {
|
||||
size_t total = 0;
|
||||
for (int i = 0; i < count; ++i) {
|
||||
total += count_tokens_one_message(msgs[i]);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// 内部 trim 逻辑
|
||||
// ============================================================
|
||||
|
||||
// 为 trim 操作将 C 消息数组复制到内部 struct
|
||||
struct TrimMessage {
|
||||
std::string role;
|
||||
std::string content;
|
||||
std::string tool_call_id;
|
||||
std::string tool_calls_json;
|
||||
};
|
||||
|
||||
static size_t count_tokens_trim(const TrimMessage& msg) {
|
||||
if (msg.content.empty()) return 4;
|
||||
const std::string& text = msg.content;
|
||||
size_t ascii_chars = 0, chinese_chars = 0, other_chars = 0;
|
||||
size_t i = 0;
|
||||
while (i < text.size()) {
|
||||
unsigned char c = static_cast<unsigned char>(text[i]);
|
||||
if (cjk_is_ascii(c)) { ascii_chars++; i += 1; }
|
||||
else if (cjk_starts_cjk(c)) { chinese_chars++; i += 3; }
|
||||
else if (c >= 0xC0 && c < 0xE0) { other_chars++; i += 2; }
|
||||
else if (c >= 0xE0 && c < 0xF0) { other_chars++; i += 3; }
|
||||
else if (c >= 0xF0 && c < 0xF8) { other_chars++; i += 4; }
|
||||
else { other_chars++; i += 1; }
|
||||
}
|
||||
return (ascii_chars / 4) + (chinese_chars / 2) + (other_chars / 3) + 4;
|
||||
}
|
||||
|
||||
static size_t count_tokens_trim_vec(const std::vector<TrimMessage>& msgs) {
|
||||
size_t total = 0;
|
||||
for (const auto& m : msgs) total += count_tokens_trim(m);
|
||||
return total;
|
||||
}
|
||||
|
||||
static int trim_impl(const dstalk_message_t* in, int in_count,
|
||||
dstalk_message_t** out, int* out_count,
|
||||
size_t max_tokens) {
|
||||
if (!in || in_count <= 0 || !out || !out_count) return -1;
|
||||
|
||||
// 将 C 数组转换为内部 vector
|
||||
std::vector<TrimMessage> messages;
|
||||
messages.reserve(in_count);
|
||||
for (int i = 0; i < in_count; ++i) {
|
||||
TrimMessage tm;
|
||||
if (in[i].role) tm.role = in[i].role;
|
||||
if (in[i].content) tm.content = in[i].content;
|
||||
if (in[i].tool_call_id) tm.tool_call_id = in[i].tool_call_id;
|
||||
if (in[i].tool_calls_json) tm.tool_calls_json = in[i].tool_calls_json;
|
||||
messages.push_back(std::move(tm));
|
||||
}
|
||||
|
||||
// 如果已在限制内，直接返回完整副本
|
||||
size_t current = count_tokens_trim_vec(messages);
|
||||
if (current <= max_tokens) {
|
||||
*out_count = in_count;
|
||||
*out = static_cast<dstalk_message_t*>(g_host->alloc(sizeof(dstalk_message_t) * in_count));
|
||||
if (!*out) return -1;
|
||||
for (int i = 0; i < in_count; ++i) {
|
||||
(*out)[i].role = messages[i].role.empty() ? nullptr : g_host->strdup(messages[i].role.c_str());
|
||||
(*out)[i].content = messages[i].content.empty() ? nullptr : g_host->strdup(messages[i].content.c_str());
|
||||
(*out)[i].tool_call_id = messages[i].tool_call_id.empty() ? nullptr : g_host->strdup(messages[i].tool_call_id.c_str());
|
||||
(*out)[i].tool_calls_json = messages[i].tool_calls_json.empty() ? nullptr : g_host->strdup(messages[i].tool_calls_json.c_str());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 分离 system 消息和非 system 消息
|
||||
std::vector<TrimMessage> system_msgs;
|
||||
std::vector<TrimMessage> non_system_msgs;
|
||||
for (const auto& msg : messages) {
|
||||
if (msg.role == "system") {
|
||||
system_msgs.push_back(msg);
|
||||
} else {
|
||||
non_system_msgs.push_back(msg);
|
||||
}
|
||||
}
|
||||
|
||||
size_t system_tokens = count_tokens_trim_vec(system_msgs);
|
||||
if (system_tokens > max_tokens) {
|
||||
std::fprintf(stderr, "[context] WARNING: system messages alone "
|
||||
"(%zu tokens) exceed max_context_tokens (%zu)\n",
|
||||
system_tokens, max_tokens);
|
||||
}
|
||||
|
||||
// 检查是否有单条消息超过限制
|
||||
for (const auto& msg : non_system_msgs) {
|
||||
size_t msg_tokens = count_tokens_trim(msg);
|
||||
if (msg_tokens > max_tokens) {
|
||||
std::fprintf(stderr, "[context] WARNING: single message "
|
||||
"(%s, %zu tokens) exceeds max_context_tokens (%zu). "
|
||||
"Returning empty list.\n",
|
||||
msg.role.c_str(), msg_tokens, max_tokens);
|
||||
*out = nullptr;
|
||||
*out_count = 0;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
// 从最早的非 system 消息开始裁剪，确保 user/assistant 成对移除
|
||||
while (!non_system_msgs.empty()) {
|
||||
current = system_tokens + count_tokens_trim_vec(non_system_msgs);
|
||||
if (current <= max_tokens) break;
|
||||
|
||||
// 找第一个 "user" 消息
|
||||
auto user_it = non_system_msgs.begin();
|
||||
while (user_it != non_system_msgs.end() && user_it->role != "user") {
|
||||
++user_it;
|
||||
}
|
||||
if (user_it == non_system_msgs.end()) break;
|
||||
|
||||
// 找下一个 "assistant"
|
||||
auto assistant_it = user_it + 1;
|
||||
while (assistant_it != non_system_msgs.end() && assistant_it->role != "assistant") {
|
||||
++assistant_it;
|
||||
}
|
||||
|
||||
if (assistant_it == non_system_msgs.end()) {
|
||||
non_system_msgs.erase(user_it);
|
||||
} else {
|
||||
// 先删 assistant 再删 user 避免迭代器失效
|
||||
non_system_msgs.erase(assistant_it);
|
||||
user_it = non_system_msgs.begin();
|
||||
while (user_it != non_system_msgs.end() && user_it->role != "user") ++user_it;
|
||||
if (user_it != non_system_msgs.end()) non_system_msgs.erase(user_it);
|
||||
}
|
||||
}
|
||||
|
||||
// 组装结果
|
||||
std::vector<TrimMessage> result;
|
||||
result.reserve(system_msgs.size() + non_system_msgs.size());
|
||||
result.insert(result.end(), system_msgs.begin(), system_msgs.end());
|
||||
result.insert(result.end(), non_system_msgs.begin(), non_system_msgs.end());
|
||||
|
||||
int result_count = static_cast<int>(result.size());
|
||||
*out_count = result_count;
|
||||
*out = static_cast<dstalk_message_t*>(g_host->alloc(sizeof(dstalk_message_t) * result_count));
|
||||
if (!*out) return -1;
|
||||
|
||||
for (int i = 0; i < result_count; ++i) {
|
||||
(*out)[i].role = result[i].role.empty() ? nullptr : g_host->strdup(result[i].role.c_str());
|
||||
(*out)[i].content = result[i].content.empty() ? nullptr : g_host->strdup(result[i].content.c_str());
|
||||
(*out)[i].tool_call_id = result[i].tool_call_id.empty() ? nullptr : g_host->strdup(result[i].tool_call_id.c_str());
|
||||
(*out)[i].tool_calls_json = result[i].tool_calls_json.empty() ? nullptr : g_host->strdup(result[i].tool_calls_json.c_str());
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Context 服务 vtable 实现
|
||||
// ============================================================
|
||||
|
||||
static size_t context_count_tokens(const dstalk_message_t* msgs, int count) {
|
||||
if (!msgs || count <= 0) return 0;
|
||||
return count_tokens_all(msgs, count);
|
||||
}
|
||||
|
||||
static int context_trim(const dstalk_message_t* in, int in_count,
|
||||
dstalk_message_t** out, int* out_count,
|
||||
size_t max_tokens) {
|
||||
return trim_impl(in, in_count, out, out_count, max_tokens);
|
||||
}
|
||||
|
||||
static void context_set_max_tokens(size_t max) {
|
||||
g_max_tokens = max;
|
||||
}
|
||||
|
||||
static dstalk_context_service_t g_context_service = {
|
||||
context_count_tokens,
|
||||
context_trim,
|
||||
context_set_max_tokens
|
||||
};
|
||||
|
||||
// ============================================================
|
||||
// 插件生命周期
|
||||
// ============================================================
|
||||
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
|
||||
// 查询依赖服务: session
|
||||
void* raw = host->query_service("session", 1);
|
||||
if (!raw) {
|
||||
host->log(DSTALK_LOG_ERROR, "[plugin-context] required service 'session' not found");
|
||||
return -1;
|
||||
}
|
||||
g_session = static_cast<const dstalk_session_service_t*>(raw);
|
||||
|
||||
return host->register_service("context", 1, &g_context_service);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
g_session = nullptr;
|
||||
g_host = nullptr;
|
||||
}
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
"context",
|
||||
"1.0.0",
|
||||
"Context management plugin with token counting and trim support",
|
||||
DSTALK_API_VERSION,
|
||||
{"session", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
|
||||
on_init,
|
||||
on_shutdown,
|
||||
nullptr
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
32
plugins/deepseek/CMakeLists.txt
Normal file
32
plugins/deepseek/CMakeLists.txt
Normal file
@@ -0,0 +1,32 @@
|
||||
cmake_minimum_required(VERSION 3.21)
|
||||
|
||||
# ============================================================
|
||||
# plugin-deepseek — DeepSeek AI 服务 (OpenAI 兼容)
|
||||
# 依赖: http 服务 (查询), config 服务 (查询)
|
||||
# ============================================================
|
||||
|
||||
add_library(plugin-deepseek SHARED
|
||||
src/deepseek_plugin.cpp
|
||||
)
|
||||
|
||||
target_include_directories(plugin-deepseek PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-deepseek PRIVATE dstalk)
|
||||
|
||||
# Boost.JSON 用于构建/解析请求和响应
|
||||
find_package(Boost REQUIRED CONFIG)
|
||||
target_link_libraries(plugin-deepseek PRIVATE boost::boost)
|
||||
|
||||
target_compile_definitions(plugin-deepseek PRIVATE
|
||||
BOOST_ALL_NO_LIB
|
||||
BOOST_ERROR_CODE_HEADER_ONLY
|
||||
BOOST_JSON_HEADER_ONLY
|
||||
)
|
||||
|
||||
set_target_properties(plugin-deepseek PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
475
plugins/deepseek/src/deepseek_plugin.cpp
Normal file
475
plugins/deepseek/src/deepseek_plugin.cpp
Normal file
@@ -0,0 +1,475 @@
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <boost/json.hpp>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
namespace json = boost::json;
|
||||
|
||||
// ============================================================================
|
||||
// 全局指针：从 on_init 获取
|
||||
// ============================================================================
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
static dstalk_http_service_t* g_http = nullptr;
|
||||
static dstalk_config_service_t* g_config = nullptr;
|
||||
|
||||
// ============================================================================
|
||||
// 配置数据（由 configure() 设置）
|
||||
// ============================================================================
|
||||
struct PluginConfig {
|
||||
std::string provider;
|
||||
std::string base_url;
|
||||
std::string api_key;
|
||||
std::string model;
|
||||
int max_tokens = 4096;
|
||||
double temperature = 0.7;
|
||||
};
|
||||
static PluginConfig g_cfg;
|
||||
|
||||
// ============================================================================
|
||||
// 辅助：从 base_url 提取 host 和 target
|
||||
// ============================================================================
|
||||
static bool extract_host_port(const std::string& url,
|
||||
std::string& scheme_out, std::string& host_out,
|
||||
std::string& port_out, std::string& target_out)
|
||||
{
|
||||
size_t scheme_end = url.find("://");
|
||||
if (scheme_end == std::string::npos) return false;
|
||||
scheme_out = url.substr(0, scheme_end);
|
||||
std::string rest = url.substr(scheme_end + 3);
|
||||
size_t slash = rest.find('/');
|
||||
std::string authority = (slash != std::string::npos) ? rest.substr(0, slash) : rest;
|
||||
target_out = (slash != std::string::npos) ? rest.substr(slash) : "/";
|
||||
size_t colon = authority.rfind(':');
|
||||
if (colon != std::string::npos) {
|
||||
host_out = authority.substr(0, colon);
|
||||
port_out = authority.substr(colon + 1);
|
||||
} else {
|
||||
host_out = authority;
|
||||
port_out = (scheme_out == "https") ? "443" : "80";
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 辅助：构建 headers JSON 字符串
|
||||
// ============================================================================
|
||||
static std::string build_headers_json(const std::string& auth_header_value)
|
||||
{
|
||||
json::object h;
|
||||
h["Authorization"] = "Bearer " + auth_header_value;
|
||||
return json::serialize(h);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 辅助：dstalk_message_t[] -> boost::json::array
|
||||
// ============================================================================
|
||||
static void append_history(json::array& msgs,
|
||||
const dstalk_message_t* history, int history_len)
|
||||
{
|
||||
for (int i = 0; i < history_len; ++i) {
|
||||
const auto& m = history[i];
|
||||
json::object obj;
|
||||
obj["role"] = m.role ? m.role : "";
|
||||
|
||||
if (m.role && std::strcmp(m.role, "tool") == 0) {
|
||||
obj["tool_call_id"] = m.tool_call_id ? m.tool_call_id : "";
|
||||
obj["content"] = m.content ? m.content : "";
|
||||
} else if (m.role && std::strcmp(m.role, "assistant") == 0 &&
|
||||
m.tool_calls_json && m.tool_calls_json[0] != '\0') {
|
||||
obj["content"] = m.content ? m.content : "";
|
||||
obj["tool_calls"] = json::parse(m.tool_calls_json);
|
||||
} else {
|
||||
obj["content"] = m.content ? m.content : "";
|
||||
}
|
||||
msgs.push_back(obj);
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 构建 DeepSeek JSON 请求体
|
||||
// ============================================================================
|
||||
static std::string build_request_json(
|
||||
const dstalk_message_t* history, int history_len,
|
||||
const std::string& user_input,
|
||||
const std::string& tools_json,
|
||||
bool stream)
|
||||
{
|
||||
json::object root;
|
||||
root["model"] = g_cfg.model;
|
||||
root["max_tokens"] = g_cfg.max_tokens;
|
||||
root["temperature"] = g_cfg.temperature;
|
||||
root["stream"] = stream;
|
||||
|
||||
json::array msgs;
|
||||
append_history(msgs, history, history_len);
|
||||
|
||||
// 追加当前用户输入
|
||||
if (!user_input.empty()) {
|
||||
json::object obj;
|
||||
obj["role"] = "user";
|
||||
obj["content"] = user_input;
|
||||
msgs.push_back(obj);
|
||||
}
|
||||
|
||||
root["messages"] = msgs;
|
||||
|
||||
// tools 定义
|
||||
if (!tools_json.empty()) {
|
||||
root["tools"] = json::parse(tools_json);
|
||||
}
|
||||
|
||||
return json::serialize(root);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 解析非流式 JSON 响应
|
||||
// ============================================================================
|
||||
static void parse_response(const char* body, int http_status,
|
||||
dstalk_chat_result_t& r)
|
||||
{
|
||||
r.http_status = http_status;
|
||||
|
||||
if (http_status < 200 || http_status >= 300) {
|
||||
r.ok = 0;
|
||||
try {
|
||||
auto jv = json::parse(body ? body : "{}");
|
||||
auto obj = jv.as_object();
|
||||
if (obj.contains("error")) {
|
||||
auto err = obj["error"].as_object();
|
||||
r.error = g_host->strdup(
|
||||
json::value_to<std::string>(err["message"]).c_str());
|
||||
}
|
||||
} catch (...) {
|
||||
std::string msg = "HTTP " + std::to_string(http_status);
|
||||
r.error = g_host->strdup(msg.c_str());
|
||||
}
|
||||
if (!r.error) {
|
||||
std::string msg = "HTTP " + std::to_string(http_status);
|
||||
r.error = g_host->strdup(msg.c_str());
|
||||
}
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
auto jv = json::parse(body ? body : "{}");
|
||||
auto obj = jv.as_object();
|
||||
auto choices = obj["choices"].as_array();
|
||||
if (!choices.empty()) {
|
||||
auto msg = choices[0].as_object()["message"].as_object();
|
||||
|
||||
std::string content = json::value_to<std::string>(msg["content"]);
|
||||
r.content = g_host->strdup(content.c_str());
|
||||
|
||||
if (msg.contains("tool_calls")) {
|
||||
std::string tc = json::serialize(msg["tool_calls"]);
|
||||
r.tool_calls_json = g_host->strdup(tc.c_str());
|
||||
} else {
|
||||
r.tool_calls_json = nullptr;
|
||||
}
|
||||
|
||||
r.ok = 1;
|
||||
r.error = nullptr;
|
||||
} else {
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("empty response");
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
}
|
||||
} catch (std::exception& e) {
|
||||
r.ok = 0;
|
||||
std::string msg = std::string("json parse: ") + e.what();
|
||||
r.error = g_host->strdup(msg.c_str());
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
} catch (...) {
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("json parse error");
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// SSE 行解析（OpenAI 兼容格式）
|
||||
// ============================================================================
|
||||
static bool parse_sse_line(const std::string& line, std::string& token_out)
|
||||
{
|
||||
if (line.rfind("data: ", 0) != 0) return false;
|
||||
|
||||
std::string data = line.substr(6);
|
||||
if (data == "[DONE]") {
|
||||
token_out.clear();
|
||||
return true; // 流结束信号
|
||||
}
|
||||
|
||||
try {
|
||||
auto jv = json::parse(data);
|
||||
auto obj = jv.as_object();
|
||||
auto choices = obj["choices"].as_array();
|
||||
if (!choices.empty()) {
|
||||
auto delta = choices[0].as_object()["delta"].as_object();
|
||||
if (delta.contains("content")) {
|
||||
token_out = json::value_to<std::string>(delta["content"]);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} catch (...) {
|
||||
// 忽略解析失败
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// configure 实现
|
||||
// ============================================================================
|
||||
static int my_configure(const char* provider, const char* base_url,
|
||||
const char* api_key, const char* model,
|
||||
int max_tokens, double temperature)
|
||||
{
|
||||
if (provider) g_cfg.provider = provider;
|
||||
if (base_url) g_cfg.base_url = base_url;
|
||||
if (api_key) g_cfg.api_key = api_key;
|
||||
if (model) g_cfg.model = model;
|
||||
g_cfg.max_tokens = max_tokens;
|
||||
g_cfg.temperature = temperature;
|
||||
|
||||
if (g_host) {
|
||||
g_host->log(DSTALK_LOG_INFO,
|
||||
"[deepseek] configured: model=%s base_url=%s max_tokens=%d temperature=%.2f",
|
||||
g_cfg.model.c_str(), g_cfg.base_url.c_str(),
|
||||
g_cfg.max_tokens, g_cfg.temperature);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// chat 实现
|
||||
// ============================================================================
|
||||
static dstalk_chat_result_t my_chat(
|
||||
const dstalk_message_t* history, int history_len,
|
||||
const char* user_input,
|
||||
const char* tools_json)
|
||||
{
|
||||
dstalk_chat_result_t r = {};
|
||||
r.ok = 0;
|
||||
|
||||
if (!g_http) {
|
||||
r.error = g_host->strdup("http service not available");
|
||||
return r;
|
||||
}
|
||||
|
||||
std::string scheme, host, port, target;
|
||||
extract_host_port(g_cfg.base_url, scheme, host, port, target);
|
||||
std::string target_path = target + "/chat/completions";
|
||||
|
||||
std::string body = build_request_json(history, history_len,
|
||||
user_input ? user_input : "", tools_json ? tools_json : "", false);
|
||||
|
||||
std::string headers_json = build_headers_json(g_cfg.api_key);
|
||||
|
||||
char* response_body = nullptr;
|
||||
int status_code = 0;
|
||||
|
||||
int ret = g_http->post_json(
|
||||
host.c_str(), port.c_str(), target_path.c_str(), body.c_str(),
|
||||
headers_json.c_str(), &response_body, &status_code);
|
||||
|
||||
if (ret != 0) {
|
||||
r.error = g_host->strdup("http request failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
parse_response(response_body, status_code, r);
|
||||
|
||||
if (response_body) {
|
||||
g_host->free(response_body);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// chat_stream 实现
|
||||
// ============================================================================
|
||||
|
||||
// 回调上下文：在流式传输中收集累积内容和最终状态
|
||||
struct StreamContext {
|
||||
const dstalk_host_api_t* host;
|
||||
dstalk_stream_cb user_cb;
|
||||
void* userdata;
|
||||
std::string accumulated;
|
||||
bool streaming_ok = true;
|
||||
};
|
||||
|
||||
// 行回调：解析 SSE line，将 token 传递给用户回调
|
||||
static int sse_line_callback(const char* line, void* userdata)
|
||||
{
|
||||
auto* ctx = static_cast<StreamContext*>(userdata);
|
||||
if (!line || !line[0]) return 1; // 空行，继续
|
||||
|
||||
std::string line_str(line);
|
||||
std::string token;
|
||||
|
||||
if (!parse_sse_line(line_str, token)) return 1; // 非 data 行，继续
|
||||
|
||||
if (token.empty()) return 0; // [DONE]，停止
|
||||
|
||||
ctx->accumulated += token;
|
||||
|
||||
if (ctx->user_cb) {
|
||||
return ctx->user_cb(token.c_str(), ctx->userdata);
|
||||
}
|
||||
return 1; // 继续
|
||||
}
|
||||
|
||||
static dstalk_chat_result_t my_chat_stream(
|
||||
const dstalk_message_t* history, int history_len,
|
||||
const char* user_input,
|
||||
dstalk_stream_cb cb, void* userdata)
|
||||
{
|
||||
dstalk_chat_result_t r = {};
|
||||
r.ok = 0;
|
||||
|
||||
if (!g_http) {
|
||||
r.error = g_host->strdup("http service not available");
|
||||
return r;
|
||||
}
|
||||
|
||||
std::string scheme, host, port, target;
|
||||
extract_host_port(g_cfg.base_url, scheme, host, port, target);
|
||||
std::string target_path = target + "/chat/completions";
|
||||
|
||||
std::string body = build_request_json(history, history_len,
|
||||
user_input ? user_input : "", "", true); // stream=true, no tools
|
||||
|
||||
std::string headers_json = build_headers_json(g_cfg.api_key);
|
||||
|
||||
StreamContext ctx;
|
||||
ctx.host = g_host;
|
||||
ctx.user_cb = cb;
|
||||
ctx.userdata = userdata;
|
||||
|
||||
char* response_body = nullptr;
|
||||
int status_code = 0;
|
||||
|
||||
int ret = g_http->post_stream(
|
||||
host.c_str(), port.c_str(), target_path.c_str(), body.c_str(),
|
||||
headers_json.c_str(),
|
||||
sse_line_callback, &ctx,
|
||||
&response_body, &status_code);
|
||||
|
||||
r.http_status = status_code;
|
||||
|
||||
// 检查传输层错误或非 2xx 状态
|
||||
if (status_code < 200 || status_code >= 300) {
|
||||
r.ok = 0;
|
||||
// 尝试从响应体提取错误信息
|
||||
if (response_body && response_body[0]) {
|
||||
try {
|
||||
auto jv = json::parse(response_body);
|
||||
auto obj = jv.as_object();
|
||||
if (obj.contains("error")) {
|
||||
auto err = obj["error"].as_object();
|
||||
r.error = g_host->strdup(
|
||||
json::value_to<std::string>(err["message"]).c_str());
|
||||
}
|
||||
} catch (...) {}
|
||||
}
|
||||
if (!r.error) {
|
||||
if (status_code <= 0)
|
||||
r.error = g_host->strdup("transport error");
|
||||
else
|
||||
r.error = g_host->strdup(
|
||||
("HTTP " + std::to_string(status_code)).c_str());
|
||||
}
|
||||
if (response_body) g_host->free(response_body);
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
return r;
|
||||
}
|
||||
|
||||
if (response_body) g_host->free(response_body);
|
||||
|
||||
if (ctx.accumulated.empty()) {
|
||||
r.ok = 0;
|
||||
r.error = g_host->strdup("no content received");
|
||||
r.content = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
} else {
|
||||
r.ok = 1;
|
||||
r.error = nullptr;
|
||||
r.content = g_host->strdup(ctx.accumulated.c_str());
|
||||
r.tool_calls_json = nullptr;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// free_result 实现
|
||||
// ============================================================================
|
||||
static void my_free_result(dstalk_chat_result_t* result)
|
||||
{
|
||||
if (!result || !g_host) return;
|
||||
if (result->content) { g_host->free((void*)result->content); result->content = nullptr; }
|
||||
if (result->error) { g_host->free((void*)result->error); result->error = nullptr; }
|
||||
if (result->tool_calls_json) { g_host->free((void*)result->tool_calls_json); result->tool_calls_json = nullptr; }
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 服务 vtable
|
||||
// ============================================================================
|
||||
static dstalk_ai_service_t g_service = {
|
||||
&my_configure,
|
||||
&my_chat,
|
||||
&my_chat_stream,
|
||||
&my_free_result,
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// 生命周期
|
||||
// ============================================================================
|
||||
static int on_init(const dstalk_host_api_t* host)
|
||||
{
|
||||
g_host = host;
|
||||
g_http = (dstalk_http_service_t*)host->query_service("http", 1);
|
||||
g_config = (dstalk_config_service_t*)host->query_service("config", 1);
|
||||
|
||||
if (!g_http) {
|
||||
if (g_host) g_host->log(DSTALK_LOG_ERROR, "[deepseek] http service not found");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[deepseek] initializing DeepSeek AI plugin");
|
||||
|
||||
return host->register_service("ai.deepseek", 1, &g_service);
|
||||
}
|
||||
|
||||
static void on_shutdown()
|
||||
{
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[deepseek] shutdown");
|
||||
g_http = nullptr;
|
||||
g_config = nullptr;
|
||||
g_host = nullptr;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 插件描述符
|
||||
// ============================================================================
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
/* .name = */ "deepseek-ai",
|
||||
/* .version = */ "1.0.0",
|
||||
/* .description = */ "DeepSeek AI provider (OpenAI-compatible API)",
|
||||
/* .api_version = */ DSTALK_API_VERSION,
|
||||
/* .dependencies = */ { "http", "config", NULL },
|
||||
/* .on_init = */ on_init,
|
||||
/* .on_shutdown = */ on_shutdown,
|
||||
/* .on_event = */ nullptr,
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void)
|
||||
{
|
||||
return &g_info;
|
||||
}
|
||||
13
plugins/file-io/CMakeLists.txt
Normal file
13
plugins/file-io/CMakeLists.txt
Normal file
@@ -0,0 +1,13 @@
|
||||
add_library(plugin-file-io SHARED src/file_io_plugin.cpp)
|
||||
|
||||
target_include_directories(plugin-file-io PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-file-io PRIVATE dstalk)
|
||||
|
||||
set_target_properties(plugin-file-io PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
95
plugins/file-io/src/file_io_plugin.cpp
Normal file
95
plugins/file-io/src/file_io_plugin.cpp
Normal file
@@ -0,0 +1,95 @@
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
// ============================================================
|
||||
// Global state
|
||||
// ============================================================
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
|
||||
// ============================================================
|
||||
// Service implementations
|
||||
// ============================================================
|
||||
static int file_read(const char* path, char** content) {
|
||||
if (!path || !content) return -1;
|
||||
|
||||
FILE* fp = fopen(path, "rb");
|
||||
if (!fp) return -1;
|
||||
|
||||
// Get file size
|
||||
fseek(fp, 0, SEEK_END);
|
||||
long fsize = ftell(fp);
|
||||
fseek(fp, 0, SEEK_SET);
|
||||
|
||||
if (fsize < 0) {
|
||||
fclose(fp);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Allocate buffer (+1 for null terminator)
|
||||
char* buf = (char*)malloc((size_t)fsize + 1);
|
||||
if (!buf) {
|
||||
fclose(fp);
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t read_bytes = fread(buf, 1, (size_t)fsize, fp);
|
||||
fclose(fp);
|
||||
|
||||
if (read_bytes != (size_t)fsize) {
|
||||
free(buf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
buf[read_bytes] = '\0';
|
||||
*content = buf;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int file_write(const char* path, const char* content) {
|
||||
if (!path || !content) return -1;
|
||||
|
||||
FILE* fp = fopen(path, "wb");
|
||||
if (!fp) return -1;
|
||||
|
||||
size_t len = strlen(content);
|
||||
size_t written = fwrite(content, 1, len, fp);
|
||||
fclose(fp);
|
||||
|
||||
return (written == len) ? 0 : -1;
|
||||
}
|
||||
|
||||
static dstalk_file_io_service_t g_service = {
|
||||
file_read,
|
||||
file_write
|
||||
};
|
||||
|
||||
// ============================================================
|
||||
// Plugin lifecycle
|
||||
// ============================================================
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
return host->register_service("file_io", 1, &g_service);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
// nothing to clean up
|
||||
}
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
"file-io", // name
|
||||
"1.0.0", // version
|
||||
"Basic file I/O service", // description
|
||||
DSTALK_API_VERSION, // api_version
|
||||
{nullptr}, // dependencies (none)
|
||||
on_init, // on_init
|
||||
on_shutdown, // on_shutdown
|
||||
nullptr // on_event
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
38
plugins/lsp/CMakeLists.txt
Normal file
38
plugins/lsp/CMakeLists.txt
Normal file
@@ -0,0 +1,38 @@
|
||||
cmake_minimum_required(VERSION 3.21)
|
||||
|
||||
# ============================================================
|
||||
# plugin-lsp — LSP (Language Server Protocol) 服务
|
||||
# 自行管理子进程，无外部服务依赖
|
||||
# ============================================================
|
||||
|
||||
add_library(plugin-lsp SHARED
|
||||
src/lsp_plugin.cpp
|
||||
)
|
||||
|
||||
target_include_directories(plugin-lsp PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-lsp PRIVATE dstalk)
|
||||
|
||||
# Boost.JSON 用于 JSON-RPC 消息构建/解析
|
||||
find_package(Boost REQUIRED CONFIG)
|
||||
target_link_libraries(plugin-lsp PRIVATE boost::boost)
|
||||
|
||||
target_compile_definitions(plugin-lsp PRIVATE
|
||||
BOOST_ALL_NO_LIB
|
||||
BOOST_ERROR_CODE_HEADER_ONLY
|
||||
BOOST_JSON_HEADER_ONLY
|
||||
)
|
||||
|
||||
# POSIX 平台需要 pthread (用于 std::thread)
|
||||
if(NOT WIN32)
|
||||
find_package(Threads REQUIRED)
|
||||
target_link_libraries(plugin-lsp PRIVATE Threads::Threads)
|
||||
endif()
|
||||
|
||||
set_target_properties(plugin-lsp PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
733
plugins/lsp/src/lsp_plugin.cpp
Normal file
733
plugins/lsp/src/lsp_plugin.cpp
Normal file
@@ -0,0 +1,733 @@
|
||||
/*
|
||||
* plugin-lsp — LSP (Language Server Protocol) 服务
|
||||
*
|
||||
* 自行管理语言服务器子进程，使用 JSON-RPC 2.0 over stdio 通信。
|
||||
* 无外部服务依赖（不依赖 http/config 等其他插件）。
|
||||
*/
|
||||
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <boost/json.hpp>
|
||||
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <condition_variable>
|
||||
#include <cstring>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <thread>
|
||||
#include <unordered_map>
|
||||
|
||||
// ============================================================================
|
||||
// 平台相关 — 子进程管理 (内嵌 subprocess::Process)
|
||||
// ============================================================================
|
||||
|
||||
#ifdef _WIN32
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <cerrno>
|
||||
#include <csignal>
|
||||
#include <cstdlib>
|
||||
#include <fcntl.h>
|
||||
#include <sys/wait.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
namespace json = boost::json;
|
||||
|
||||
// ============================================================================
|
||||
// 全局指针
|
||||
// ============================================================================
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
|
||||
// ============================================================================
|
||||
// 子进程封装 (内嵌 subprocess.hpp)
|
||||
// ============================================================================
|
||||
struct Process {
|
||||
#ifdef _WIN32
|
||||
HANDLE hProcess = INVALID_HANDLE_VALUE;
|
||||
HANDLE hThread = INVALID_HANDLE_VALUE;
|
||||
HANDLE hStdIn = INVALID_HANDLE_VALUE;
|
||||
HANDLE hStdOut = INVALID_HANDLE_VALUE;
|
||||
#else
|
||||
pid_t pid = -1;
|
||||
int stdin_fd = -1;
|
||||
int stdout_fd = -1;
|
||||
#endif
|
||||
|
||||
bool start(const char* cmd) {
|
||||
if (!cmd || !cmd[0]) return false;
|
||||
stop();
|
||||
|
||||
#ifdef _WIN32
|
||||
SECURITY_ATTRIBUTES sa = {};
|
||||
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
|
||||
sa.bInheritHandle = TRUE;
|
||||
|
||||
HANDLE child_stdin_read = INVALID_HANDLE_VALUE;
|
||||
HANDLE child_stdout_write = INVALID_HANDLE_VALUE;
|
||||
|
||||
if (!CreatePipe(&child_stdin_read, &hStdIn, &sa, 0)) goto win32_fail;
|
||||
if (!SetHandleInformation(hStdIn, HANDLE_FLAG_INHERIT, 0)) goto win32_fail;
|
||||
if (!CreatePipe(&hStdOut, &child_stdout_write, &sa, 0)) goto win32_fail;
|
||||
if (!SetHandleInformation(hStdOut, HANDLE_FLAG_INHERIT, 0)) goto win32_fail;
|
||||
|
||||
{
|
||||
STARTUPINFOW si = {};
|
||||
si.cb = sizeof(STARTUPINFOW);
|
||||
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
|
||||
si.wShowWindow = SW_HIDE;
|
||||
si.hStdInput = child_stdin_read;
|
||||
si.hStdOutput = child_stdout_write;
|
||||
si.hStdError = child_stdout_write;
|
||||
|
||||
PROCESS_INFORMATION pi = {};
|
||||
std::string cmd_copy(cmd);
|
||||
wchar_t wcmd[4096] = {};
|
||||
if (MultiByteToWideChar(CP_UTF8, 0, cmd_copy.c_str(), -1, wcmd, 4096) == 0)
|
||||
goto win32_fail;
|
||||
|
||||
if (!CreateProcessW(nullptr, wcmd, nullptr, nullptr, TRUE,
|
||||
CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi))
|
||||
goto win32_fail;
|
||||
|
||||
hProcess = pi.hProcess;
|
||||
hThread = pi.hThread;
|
||||
}
|
||||
|
||||
CloseHandle(child_stdin_read);
|
||||
CloseHandle(child_stdout_write);
|
||||
return true;
|
||||
|
||||
win32_fail:
|
||||
if (child_stdin_read != INVALID_HANDLE_VALUE) CloseHandle(child_stdin_read);
|
||||
if (child_stdout_write != INVALID_HANDLE_VALUE) CloseHandle(child_stdout_write);
|
||||
if (hStdIn != INVALID_HANDLE_VALUE) { CloseHandle(hStdIn); hStdIn = INVALID_HANDLE_VALUE; }
|
||||
if (hStdOut != INVALID_HANDLE_VALUE) { CloseHandle(hStdOut); hStdOut = INVALID_HANDLE_VALUE; }
|
||||
if (hProcess != INVALID_HANDLE_VALUE) { CloseHandle(hProcess); hProcess = INVALID_HANDLE_VALUE; }
|
||||
if (hThread != INVALID_HANDLE_VALUE) { CloseHandle(hThread); hThread = INVALID_HANDLE_VALUE; }
|
||||
return false;
|
||||
|
||||
#else
|
||||
int pin[2] = {-1, -1};
|
||||
int pout[2] = {-1, -1};
|
||||
|
||||
if (pipe(pin) != 0) goto posix_fail;
|
||||
if (pipe(pout) != 0) goto posix_fail;
|
||||
|
||||
pid = fork();
|
||||
if (pid < 0) goto posix_fail;
|
||||
|
||||
if (pid == 0) {
|
||||
dup2(pin[0], STDIN_FILENO);
|
||||
close(pin[0]); close(pin[1]);
|
||||
dup2(pout[1], STDOUT_FILENO);
|
||||
close(pout[0]); close(pout[1]);
|
||||
|
||||
int max_fd = static_cast<int>(sysconf(_SC_OPEN_MAX));
|
||||
if (max_fd > 3) {
|
||||
for (int i = 3; i < max_fd; ++i) close(i);
|
||||
}
|
||||
|
||||
char* argv[64] = {};
|
||||
int argc = 0;
|
||||
char* cmd_copy = strdup(cmd);
|
||||
char* token = strtok(cmd_copy, " \t");
|
||||
while (token && argc < 63) {
|
||||
argv[argc++] = token;
|
||||
token = strtok(nullptr, " \t");
|
||||
}
|
||||
argv[argc] = nullptr;
|
||||
execvp(argv[0], argv);
|
||||
_exit(127);
|
||||
}
|
||||
|
||||
close(pin[0]);
|
||||
close(pout[1]);
|
||||
stdin_fd = pin[1];
|
||||
stdout_fd = pout[0];
|
||||
return true;
|
||||
|
||||
posix_fail:
|
||||
if (pin[0] != -1) close(pin[0]);
|
||||
if (pin[1] != -1) close(pin[1]);
|
||||
if (pout[0] != -1) close(pout[0]);
|
||||
if (pout[1] != -1) close(pout[1]);
|
||||
stdin_fd = -1;
|
||||
stdout_fd = -1;
|
||||
pid = -1;
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
void stop() {
|
||||
#ifdef _WIN32
|
||||
if (hProcess != INVALID_HANDLE_VALUE) {
|
||||
WaitForSingleObject(hProcess, 2000);
|
||||
TerminateProcess(hProcess, 1);
|
||||
CloseHandle(hProcess); hProcess = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (hThread != INVALID_HANDLE_VALUE) { CloseHandle(hThread); hThread = INVALID_HANDLE_VALUE; }
|
||||
if (hStdIn != INVALID_HANDLE_VALUE) { CloseHandle(hStdIn); hStdIn = INVALID_HANDLE_VALUE; }
|
||||
if (hStdOut != INVALID_HANDLE_VALUE) { CloseHandle(hStdOut); hStdOut = INVALID_HANDLE_VALUE; }
|
||||
#else
|
||||
if (pid > 0) {
|
||||
kill(pid, SIGTERM);
|
||||
int status = 0;
|
||||
for (int i = 0; i < 20; ++i) {
|
||||
if (waitpid(pid, &status, WNOHANG) > 0) break;
|
||||
usleep(100000);
|
||||
}
|
||||
if (waitpid(pid, &status, WNOHANG) == 0) {
|
||||
kill(pid, SIGKILL);
|
||||
waitpid(pid, &status, 0);
|
||||
}
|
||||
pid = -1;
|
||||
}
|
||||
if (stdin_fd != -1) { close(stdin_fd); stdin_fd = -1; }
|
||||
if (stdout_fd != -1) { close(stdout_fd); stdout_fd = -1; }
|
||||
#endif
|
||||
}
|
||||
|
||||
bool write(const std::string& data) {
|
||||
if (data.empty()) return true;
|
||||
#ifdef _WIN32
|
||||
if (hStdIn == INVALID_HANDLE_VALUE) return false;
|
||||
DWORD written = 0;
|
||||
return WriteFile(hStdIn, data.c_str(), static_cast<DWORD>(data.size()), &written, nullptr)
|
||||
&& written == data.size();
|
||||
#else
|
||||
if (stdin_fd < 0) return false;
|
||||
size_t total = 0;
|
||||
const char* buf = data.c_str();
|
||||
size_t len = data.size();
|
||||
while (total < len) {
|
||||
ssize_t n = ::write(stdin_fd, buf + total, len - total);
|
||||
if (n <= 0) return false;
|
||||
total += static_cast<size_t>(n);
|
||||
}
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool read_line(std::string& line) {
|
||||
line.clear();
|
||||
#ifdef _WIN32
|
||||
if (hStdOut == INVALID_HANDLE_VALUE) return false;
|
||||
char ch; DWORD nread = 0;
|
||||
while (true) {
|
||||
if (!ReadFile(hStdOut, &ch, 1, &nread, nullptr)) return false;
|
||||
if (nread == 0) return false;
|
||||
line += ch;
|
||||
if (ch == '\n') return true;
|
||||
}
|
||||
#else
|
||||
if (stdout_fd < 0) return false;
|
||||
char ch;
|
||||
while (true) {
|
||||
ssize_t n = ::read(stdout_fd, &ch, 1);
|
||||
if (n <= 0) return false;
|
||||
line += ch;
|
||||
if (ch == '\n') return true;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
bool read_bytes(std::string& buf, int count) {
|
||||
if (count <= 0) { buf.clear(); return true; }
|
||||
#ifdef _WIN32
|
||||
if (hStdOut == INVALID_HANDLE_VALUE) return false;
|
||||
buf.resize(static_cast<size_t>(count) + 1);
|
||||
DWORD total = 0, nread = 0;
|
||||
while (total < static_cast<DWORD>(count)) {
|
||||
if (!ReadFile(hStdOut, const_cast<char*>(buf.data()) + total,
|
||||
static_cast<DWORD>(count) - total, &nread, nullptr))
|
||||
return false;
|
||||
if (nread == 0) return false;
|
||||
total += nread;
|
||||
}
|
||||
buf[count] = '\0';
|
||||
buf.resize(count);
|
||||
return true;
|
||||
#else
|
||||
if (stdout_fd < 0) return false;
|
||||
buf.resize(count);
|
||||
size_t total = 0;
|
||||
while (total < static_cast<size_t>(count)) {
|
||||
ssize_t n = ::read(stdout_fd, const_cast<char*>(buf.data()) + total,
|
||||
static_cast<size_t>(count) - total);
|
||||
if (n <= 0) return false;
|
||||
total += static_cast<size_t>(n);
|
||||
}
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// LSP 状态（静态单例）
|
||||
// ============================================================================
|
||||
struct LspState {
|
||||
Process proc;
|
||||
std::atomic<bool> running{false};
|
||||
std::string language;
|
||||
|
||||
std::atomic<int> next_id{1};
|
||||
|
||||
// 响应用于同步等待
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
std::unordered_map<int, std::string> pending_responses;
|
||||
|
||||
// 诊断缓存: URI -> JSON 字符串
|
||||
std::unordered_map<std::string, std::string> diagnostics;
|
||||
|
||||
// 读取线程
|
||||
std::thread reader_thread;
|
||||
};
|
||||
static LspState g_lsp;
|
||||
|
||||
// ============================================================================
|
||||
// 辅助函数
|
||||
// ============================================================================
|
||||
|
||||
static std::string_view trim(std::string_view sv) {
|
||||
while (!sv.empty() && (sv.front() == ' ' || sv.front() == '\t' ||
|
||||
sv.front() == '\r' || sv.front() == '\n'))
|
||||
sv.remove_prefix(1);
|
||||
while (!sv.empty() && (sv.back() == ' ' || sv.back() == '\t' ||
|
||||
sv.back() == '\r' || sv.back() == '\n'))
|
||||
sv.remove_suffix(1);
|
||||
return sv;
|
||||
}
|
||||
|
||||
static std::string frame_message(const std::string& body) {
|
||||
std::string frame;
|
||||
frame.reserve(64 + body.size());
|
||||
frame += "Content-Length: ";
|
||||
frame += std::to_string(body.size());
|
||||
frame += "\r\n\r\n";
|
||||
frame += body;
|
||||
return frame;
|
||||
}
|
||||
|
||||
static int parse_content_length(const std::string& line) {
|
||||
auto sv = trim(std::string_view(line));
|
||||
const char prefix[] = "Content-Length:";
|
||||
const size_t prefix_len = sizeof(prefix) - 1;
|
||||
|
||||
if (sv.size() <= prefix_len) return -1;
|
||||
for (size_t i = 0; i < prefix_len; ++i) {
|
||||
if (std::tolower(static_cast<unsigned char>(sv[i])) !=
|
||||
std::tolower(static_cast<unsigned char>(prefix[i])))
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::string_view num_sv = sv.substr(prefix_len);
|
||||
while (!num_sv.empty() && (num_sv.front() == ' ' || num_sv.front() == '\t'))
|
||||
num_sv.remove_prefix(1);
|
||||
|
||||
try { return std::stoi(std::string(num_sv)); }
|
||||
catch (...) { return -1; }
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// JSON-RPC 消息发送
|
||||
// ============================================================================
|
||||
|
||||
static int send_request(const std::string& method, const json::object& params) {
|
||||
int id = g_lsp.next_id.fetch_add(1);
|
||||
|
||||
json::object msg;
|
||||
msg["jsonrpc"] = "2.0";
|
||||
msg["id"] = id;
|
||||
msg["method"] = method;
|
||||
msg["params"] = params;
|
||||
|
||||
std::string body = json::serialize(msg);
|
||||
g_lsp.proc.write(frame_message(body));
|
||||
return id;
|
||||
}
|
||||
|
||||
static void send_notification(const std::string& method, const json::object& params) {
|
||||
json::object msg;
|
||||
msg["jsonrpc"] = "2.0";
|
||||
msg["method"] = method;
|
||||
msg["params"] = params;
|
||||
|
||||
std::string body = json::serialize(msg);
|
||||
g_lsp.proc.write(frame_message(body));
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 消息处理
|
||||
// ============================================================================
|
||||
|
||||
static void handle_message(const std::string& body) {
|
||||
json::value val;
|
||||
try { val = json::parse(body); }
|
||||
catch (...) { return; }
|
||||
|
||||
json::object msg;
|
||||
try { msg = val.as_object(); }
|
||||
catch (...) { return; }
|
||||
|
||||
if (msg.contains("id") && !msg.contains("method")) {
|
||||
// 响应 (有 id, 无 method)
|
||||
int id = static_cast<int>(msg["id"].as_int64());
|
||||
std::lock_guard<std::mutex> lock(g_lsp.mutex);
|
||||
g_lsp.pending_responses[id] = body;
|
||||
g_lsp.cv.notify_all();
|
||||
|
||||
} else if (msg.contains("method") && !msg.contains("id")) {
|
||||
// 通知 (有 method, 无 id)
|
||||
std::string method;
|
||||
try { method = json::value_to<std::string>(msg["method"]); }
|
||||
catch (...) { return; }
|
||||
|
||||
if (method == "textDocument/publishDiagnostics") {
|
||||
if (!msg.contains("params")) return;
|
||||
auto params = msg["params"].as_object();
|
||||
if (!params.contains("uri")) return;
|
||||
|
||||
std::string uri = json::value_to<std::string>(params["uri"]);
|
||||
std::string diag_json;
|
||||
if (params.contains("diagnostics"))
|
||||
diag_json = json::serialize(params["diagnostics"]);
|
||||
else
|
||||
diag_json = "[]";
|
||||
|
||||
std::lock_guard<std::mutex> lock(g_lsp.mutex);
|
||||
g_lsp.diagnostics[uri] = diag_json;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 读取线程主循环
|
||||
// ============================================================================
|
||||
|
||||
static void reader_loop() {
|
||||
while (g_lsp.running) {
|
||||
std::string header_line;
|
||||
if (!g_lsp.proc.read_line(header_line)) break;
|
||||
|
||||
int content_length = parse_content_length(header_line);
|
||||
if (content_length < 0) continue;
|
||||
|
||||
// 跳过后续头直到空行 (\r\n 换行被视为非空行，只检查空行)
|
||||
while (true) {
|
||||
std::string line;
|
||||
if (!g_lsp.proc.read_line(line)) break;
|
||||
auto sv = trim(std::string_view(line));
|
||||
if (sv.empty()) break;
|
||||
}
|
||||
|
||||
std::string body;
|
||||
if (!g_lsp.proc.read_bytes(body, content_length)) break;
|
||||
|
||||
handle_message(body);
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(g_lsp.mutex);
|
||||
g_lsp.running = false;
|
||||
g_lsp.cv.notify_all();
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// LSP 服务 vtable 实现 (定义在 vtable 变量之前)
|
||||
// ============================================================================
|
||||
|
||||
static int g_lsp_impl_stop();
|
||||
|
||||
static int g_lsp_impl_start(const char* server_cmd, const char* language) {
|
||||
if (!server_cmd || !server_cmd[0]) return -1;
|
||||
|
||||
// 如果已在运行, 先停止
|
||||
if (g_lsp.running) {
|
||||
g_lsp_impl_stop();
|
||||
}
|
||||
|
||||
g_lsp.language = language ? language : "";
|
||||
|
||||
// 启动进程
|
||||
if (!g_lsp.proc.start(server_cmd)) {
|
||||
if (g_host) g_host->log(DSTALK_LOG_ERROR, "[lsp] failed to start: %s", server_cmd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// 重置 ID 计数器
|
||||
g_lsp.next_id = 1;
|
||||
|
||||
// 启动读取线程
|
||||
g_lsp.running = true;
|
||||
g_lsp.reader_thread = std::thread(reader_loop);
|
||||
|
||||
// 构建 initialize 参数
|
||||
json::object text_doc_caps;
|
||||
{
|
||||
json::object hover;
|
||||
hover["dynamicRegistration"] = false;
|
||||
text_doc_caps["hover"] = hover;
|
||||
|
||||
json::object completion;
|
||||
completion["dynamicRegistration"] = false;
|
||||
text_doc_caps["completion"] = completion;
|
||||
|
||||
json::object diagnostic;
|
||||
diagnostic["dynamicRegistration"] = false;
|
||||
text_doc_caps["diagnostic"] = diagnostic;
|
||||
}
|
||||
|
||||
json::object capabilities;
|
||||
capabilities["textDocument"] = text_doc_caps;
|
||||
|
||||
json::object init_params;
|
||||
init_params["processId"] = nullptr;
|
||||
init_params["rootUri"] = nullptr;
|
||||
init_params["capabilities"] = capabilities;
|
||||
|
||||
// 发送 initialize 请求
|
||||
int init_id = send_request("initialize", init_params);
|
||||
|
||||
// 等待 initialize 响应 (最多 10 秒)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(g_lsp.mutex);
|
||||
bool got = g_lsp.cv.wait_for(lock, std::chrono::seconds(10), [init_id]() {
|
||||
return !g_lsp.running || g_lsp.pending_responses.count(init_id) > 0;
|
||||
});
|
||||
|
||||
if (!got || !g_lsp.running) {
|
||||
if (g_host) g_host->log(DSTALK_LOG_ERROR, "[lsp] initialize timed out");
|
||||
g_lsp_impl_stop();
|
||||
return -1;
|
||||
}
|
||||
g_lsp.pending_responses.erase(init_id);
|
||||
}
|
||||
|
||||
// 发送 initialized 通知
|
||||
send_notification("initialized", json::object{});
|
||||
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[lsp] server started: %s", server_cmd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void g_lsp_impl_stop() {
|
||||
if (!g_lsp.running) return;
|
||||
|
||||
// 发送 shutdown 请求
|
||||
int shutdown_id = send_request("shutdown", json::object{});
|
||||
|
||||
// 等待 shutdown 响应 (最多 2 秒)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(g_lsp.mutex);
|
||||
g_lsp.cv.wait_for(lock, std::chrono::seconds(2), [shutdown_id]() {
|
||||
return !g_lsp.running || g_lsp.pending_responses.count(shutdown_id) > 0;
|
||||
});
|
||||
g_lsp.pending_responses.clear();
|
||||
}
|
||||
|
||||
// 发送 exit 通知
|
||||
send_notification("exit", json::object{});
|
||||
|
||||
// 停止读取线程
|
||||
g_lsp.running = false;
|
||||
g_lsp.proc.stop();
|
||||
|
||||
if (g_lsp.reader_thread.joinable())
|
||||
g_lsp.reader_thread.join();
|
||||
|
||||
g_lsp.diagnostics.clear();
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[lsp] server stopped");
|
||||
}
|
||||
|
||||
static int g_lsp_impl_open_document(const char* uri, const char* content,
|
||||
const char* lang_id) {
|
||||
if (!g_lsp.running) return -1;
|
||||
if (!uri || !content || !lang_id) return -1;
|
||||
|
||||
json::object text_doc;
|
||||
text_doc["uri"] = uri;
|
||||
text_doc["languageId"] = lang_id;
|
||||
text_doc["version"] = 1;
|
||||
text_doc["text"] = content;
|
||||
|
||||
json::object params;
|
||||
params["textDocument"] = text_doc;
|
||||
|
||||
send_notification("textDocument/didOpen", params);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int g_lsp_impl_close_document(const char* uri) {
|
||||
if (!g_lsp.running) return -1;
|
||||
if (!uri) return -1;
|
||||
|
||||
json::object text_doc;
|
||||
text_doc["uri"] = uri;
|
||||
|
||||
json::object params;
|
||||
params["textDocument"] = text_doc;
|
||||
|
||||
send_notification("textDocument/didClose", params);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int g_lsp_impl_get_diagnostics(const char* uri, char** json_out) {
|
||||
if (!g_lsp.running) return -1;
|
||||
if (!uri || !json_out) return -1;
|
||||
|
||||
std::lock_guard<std::mutex> lock(g_lsp.mutex);
|
||||
auto it = g_lsp.diagnostics.find(uri);
|
||||
if (it == g_lsp.diagnostics.end()) {
|
||||
*json_out = g_host->strdup("[]");
|
||||
} else {
|
||||
*json_out = g_host->strdup(it->second.c_str());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int g_lsp_impl_get_hover(const char* uri, int line, int col, char** json_out) {
|
||||
if (!g_lsp.running) return -1;
|
||||
if (!uri || !json_out) return -1;
|
||||
|
||||
json::object position;
|
||||
position["line"] = line;
|
||||
position["character"] = col;
|
||||
|
||||
json::object text_doc;
|
||||
text_doc["uri"] = uri;
|
||||
|
||||
json::object params;
|
||||
params["textDocument"] = text_doc;
|
||||
params["position"] = position;
|
||||
|
||||
int req_id = send_request("textDocument/hover", params);
|
||||
|
||||
std::unique_lock<std::mutex> lock(g_lsp.mutex);
|
||||
bool got = g_lsp.cv.wait_for(lock, std::chrono::seconds(10), [req_id]() {
|
||||
return !g_lsp.running || g_lsp.pending_responses.count(req_id) > 0;
|
||||
});
|
||||
|
||||
if (!got || !g_lsp.running || g_lsp.pending_responses.count(req_id) == 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::string response_body = g_lsp.pending_responses[req_id];
|
||||
g_lsp.pending_responses.erase(req_id);
|
||||
|
||||
json::value val;
|
||||
try { val = json::parse(response_body); }
|
||||
catch (...) { return -1; }
|
||||
|
||||
json::object resp;
|
||||
try { resp = val.as_object(); }
|
||||
catch (...) { return -1; }
|
||||
|
||||
if (!resp.contains("result")) return -1;
|
||||
|
||||
*json_out = g_host->strdup(json::serialize(resp["result"]).c_str());
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int g_lsp_impl_get_completion(const char* uri, int line, int col, char** json_out) {
|
||||
if (!g_lsp.running) return -1;
|
||||
if (!uri || !json_out) return -1;
|
||||
|
||||
json::object position;
|
||||
position["line"] = line;
|
||||
position["character"] = col;
|
||||
|
||||
json::object text_doc;
|
||||
text_doc["uri"] = uri;
|
||||
|
||||
json::object params;
|
||||
params["textDocument"] = text_doc;
|
||||
params["position"] = position;
|
||||
|
||||
int req_id = send_request("textDocument/completion", params);
|
||||
|
||||
std::unique_lock<std::mutex> lock(g_lsp.mutex);
|
||||
bool got = g_lsp.cv.wait_for(lock, std::chrono::seconds(10), [req_id]() {
|
||||
return !g_lsp.running || g_lsp.pending_responses.count(req_id) > 0;
|
||||
});
|
||||
|
||||
if (!got || !g_lsp.running || g_lsp.pending_responses.count(req_id) == 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::string response_body = g_lsp.pending_responses[req_id];
|
||||
g_lsp.pending_responses.erase(req_id);
|
||||
|
||||
json::value val;
|
||||
try { val = json::parse(response_body); }
|
||||
catch (...) { return -1; }
|
||||
|
||||
json::object resp;
|
||||
try { resp = val.as_object(); }
|
||||
catch (...) { return -1; }
|
||||
|
||||
if (!resp.contains("result")) return -1;
|
||||
|
||||
*json_out = g_host->strdup(json::serialize(resp["result"]).c_str());
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 服务 vtable
|
||||
// ============================================================================
|
||||
|
||||
static dstalk_lsp_service_t g_service_vtable = {
|
||||
&g_lsp_impl_start,
|
||||
&g_lsp_impl_stop,
|
||||
&g_lsp_impl_open_document,
|
||||
&g_lsp_impl_close_document,
|
||||
&g_lsp_impl_get_diagnostics,
|
||||
&g_lsp_impl_get_hover,
|
||||
&g_lsp_impl_get_completion,
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// 生命周期回调
|
||||
// ============================================================================
|
||||
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[lsp] initializing LSP service plugin");
|
||||
return host->register_service("lsp", 1, &g_service_vtable);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
if (g_lsp.running) {
|
||||
g_lsp_impl_stop();
|
||||
}
|
||||
if (g_host) g_host->log(DSTALK_LOG_INFO, "[lsp] shutdown");
|
||||
g_host = nullptr;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// 插件描述符
|
||||
// ============================================================================
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
/* .name = */ "lsp",
|
||||
/* .version = */ "1.0.0",
|
||||
/* .description = */ "Language Server Protocol client (subprocess manager)",
|
||||
/* .api_version = */ DSTALK_API_VERSION,
|
||||
/* .dependencies = */ { NULL }, // 无依赖，自行管理子进程
|
||||
/* .on_init = */ on_init,
|
||||
/* .on_shutdown = */ on_shutdown,
|
||||
/* .on_event = */ nullptr,
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
20
plugins/network/CMakeLists.txt
Normal file
20
plugins/network/CMakeLists.txt
Normal file
@@ -0,0 +1,20 @@
|
||||
find_package(Boost REQUIRED CONFIG)
|
||||
find_package(OpenSSL REQUIRED CONFIG)
|
||||
|
||||
add_library(plugin-network SHARED src/network_plugin.cpp)
|
||||
|
||||
target_include_directories(plugin-network PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-network PRIVATE
|
||||
dstalk
|
||||
boost::boost
|
||||
openssl::openssl
|
||||
)
|
||||
|
||||
set_target_properties(plugin-network PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
322
plugins/network/src/network_plugin.cpp
Normal file
322
plugins/network/src/network_plugin.cpp
Normal file
@@ -0,0 +1,322 @@
|
||||
// MSVC 14.16 (VS 2017) doesn't provide std::to_address (C++20)
|
||||
#define BOOST_ASIO_DISABLE_STD_TO_ADDRESS
|
||||
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <boost/asio/connect.hpp>
|
||||
#include <boost/asio/ip/tcp.hpp>
|
||||
#include <boost/asio/ssl.hpp>
|
||||
#include <boost/beast/core.hpp>
|
||||
#include <boost/beast/http.hpp>
|
||||
#include <boost/beast/ssl.hpp>
|
||||
#include <boost/beast/version.hpp>
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace beast = boost::beast;
|
||||
namespace http = beast::http;
|
||||
namespace asio = boost::asio;
|
||||
namespace ssl = boost::asio::ssl;
|
||||
using tcp = asio::ip::tcp;
|
||||
|
||||
// ============================================================
|
||||
// Global state
|
||||
// ============================================================
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
static dstalk_config_service_t* g_config_svc = nullptr;
|
||||
|
||||
// ============================================================
|
||||
// Minimal JSON header parser
|
||||
// Parses {"key1":"value1","key2":"value2"} into unordered_map
|
||||
// ============================================================
|
||||
static std::unordered_map<std::string, std::string> parse_headers_json(const char* json) {
|
||||
std::unordered_map<std::string, std::string> headers;
|
||||
if (!json || !*json) return headers;
|
||||
|
||||
std::string s(json);
|
||||
// Very simple state-machine parser for flat string-key/value objects
|
||||
enum { OUTSIDE, IN_KEY, AFTER_KEY, IN_VALUE } state = OUTSIDE;
|
||||
std::string current_key;
|
||||
std::string current_value;
|
||||
|
||||
for (size_t i = 0; i < s.size(); ++i) {
|
||||
char c = s[i];
|
||||
switch (state) {
|
||||
case OUTSIDE:
|
||||
if (c == '"') { state = IN_KEY; current_key.clear(); }
|
||||
break;
|
||||
case IN_KEY:
|
||||
if (c == '"') { state = AFTER_KEY; }
|
||||
else if (c == '\\' && i + 1 < s.size()) { current_key += s[++i]; }
|
||||
else { current_key += c; }
|
||||
break;
|
||||
case AFTER_KEY:
|
||||
if (c == ':') { state = IN_VALUE; current_value.clear(); }
|
||||
break;
|
||||
case IN_VALUE:
|
||||
if (c == '"') {
|
||||
// Read until closing quote
|
||||
++i;
|
||||
while (i < s.size() && s[i] != '"') {
|
||||
if (s[i] == '\\' && i + 1 < s.size()) { current_value += s[++i]; }
|
||||
else { current_value += s[i]; }
|
||||
++i;
|
||||
}
|
||||
headers[current_key] = current_value;
|
||||
state = OUTSIDE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return headers;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// HTTP Client implementation (adapted from dstalk-core HttpClient)
|
||||
// ============================================================
|
||||
struct HttpClientCtx {
|
||||
asio::io_context ioc;
|
||||
ssl::context ssl_ctx{ssl::context::tlsv12_client};
|
||||
int connect_timeout = 30;
|
||||
int request_timeout = 120;
|
||||
|
||||
HttpClientCtx() {
|
||||
ssl_ctx.set_default_verify_paths();
|
||||
}
|
||||
};
|
||||
|
||||
static int do_post_stream(
|
||||
const char* host,
|
||||
const char* port,
|
||||
const char* target,
|
||||
const char* body,
|
||||
const char* headers_json,
|
||||
dstalk_stream_cb cb,
|
||||
void* userdata,
|
||||
char** response_body,
|
||||
int* status_code)
|
||||
{
|
||||
if (!host || !port || !target || !body || !response_body || !status_code) {
|
||||
if (response_body) *response_body = nullptr;
|
||||
if (status_code) *status_code = -1;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Initialize output
|
||||
*response_body = nullptr;
|
||||
*status_code = -1;
|
||||
|
||||
// Build C++ lambda from C callback
|
||||
std::function<bool(const std::string&)> on_line;
|
||||
if (cb) {
|
||||
on_line = [cb, userdata](const std::string& line) -> bool {
|
||||
return cb(line.c_str(), userdata) == 0;
|
||||
};
|
||||
}
|
||||
|
||||
HttpClientCtx ctx;
|
||||
|
||||
// Read timeouts from config if available
|
||||
if (g_config_svc) {
|
||||
const char* ct = g_config_svc->get("http.connect_timeout");
|
||||
const char* rt = g_config_svc->get("http.request_timeout");
|
||||
if (ct) ctx.connect_timeout = std::atoi(ct);
|
||||
if (rt) ctx.request_timeout = std::atoi(rt);
|
||||
if (ctx.connect_timeout <= 0) ctx.connect_timeout = 30;
|
||||
if (ctx.request_timeout <= 0) ctx.request_timeout = 120;
|
||||
}
|
||||
|
||||
std::string result_body;
|
||||
int result_code = -1;
|
||||
|
||||
try {
|
||||
tcp::resolver resolver(ctx.ioc);
|
||||
auto endpoints = resolver.resolve(host, port);
|
||||
|
||||
beast::ssl_stream<beast::tcp_stream> stream(ctx.ioc, ctx.ssl_ctx);
|
||||
beast::flat_buffer buffer;
|
||||
|
||||
// SNI hostname
|
||||
if (!SSL_set_tlsext_host_name(stream.native_handle(), host)) {
|
||||
result_body = "SNI hostname set failed";
|
||||
goto done;
|
||||
}
|
||||
|
||||
// Connect
|
||||
beast::get_lowest_layer(stream).expires_after(
|
||||
std::chrono::seconds(ctx.connect_timeout));
|
||||
beast::get_lowest_layer(stream).connect(endpoints);
|
||||
beast::get_lowest_layer(stream).expires_never();
|
||||
|
||||
// SSL handshake
|
||||
beast::get_lowest_layer(stream).expires_after(
|
||||
std::chrono::seconds(ctx.connect_timeout));
|
||||
stream.handshake(ssl::stream_base::client);
|
||||
beast::get_lowest_layer(stream).expires_never();
|
||||
|
||||
// Build HTTP POST request
|
||||
http::request<http::string_body> req{http::verb::post, target, 11};
|
||||
req.set(http::field::host, host);
|
||||
req.set(http::field::user_agent, "dstalk/0.1");
|
||||
req.set(http::field::content_type, "application/json");
|
||||
req.body() = body;
|
||||
req.prepare_payload();
|
||||
|
||||
// Add extra headers from JSON
|
||||
auto extra_headers = parse_headers_json(headers_json);
|
||||
for (const auto& h : extra_headers) {
|
||||
req.set(h.first, h.second);
|
||||
}
|
||||
|
||||
// Send
|
||||
beast::get_lowest_layer(stream).expires_after(
|
||||
std::chrono::seconds(ctx.request_timeout));
|
||||
http::write(stream, req);
|
||||
beast::get_lowest_layer(stream).expires_never();
|
||||
|
||||
// Read response
|
||||
http::response_parser<http::string_body> parser;
|
||||
parser.body_limit(16 * 1024 * 1024);
|
||||
beast::get_lowest_layer(stream).expires_after(
|
||||
std::chrono::seconds(ctx.request_timeout));
|
||||
http::read_header(stream, buffer, parser);
|
||||
beast::get_lowest_layer(stream).expires_never();
|
||||
|
||||
result_code = parser.get().result_int();
|
||||
|
||||
beast::error_code ec;
|
||||
|
||||
if (on_line) {
|
||||
std::string fragment = parser.get().body();
|
||||
auto emit_lines = [&]() -> bool {
|
||||
size_t pos = 0;
|
||||
while (pos < fragment.size()) {
|
||||
size_t nl = fragment.find('\n', pos);
|
||||
if (nl == std::string::npos) break;
|
||||
std::string line = fragment.substr(pos, nl - pos);
|
||||
if (!line.empty() && line.back() == '\r')
|
||||
line.pop_back();
|
||||
if (!on_line(line)) return false;
|
||||
pos = nl + 1;
|
||||
}
|
||||
if (pos > 0)
|
||||
fragment = fragment.substr(pos);
|
||||
return true;
|
||||
};
|
||||
if (!emit_lines()) goto done;
|
||||
|
||||
size_t processed = parser.get().body().size();
|
||||
while (!parser.is_done()) {
|
||||
beast::get_lowest_layer(stream).expires_after(
|
||||
std::chrono::seconds(ctx.request_timeout));
|
||||
http::read_some(stream, buffer, parser, ec);
|
||||
if (ec) break;
|
||||
|
||||
const std::string& full_body = parser.get().body();
|
||||
if (full_body.size() > processed) {
|
||||
std::string_view new_data(full_body.data() + processed,
|
||||
full_body.size() - processed);
|
||||
processed = full_body.size();
|
||||
|
||||
fragment.append(new_data.data(), new_data.size());
|
||||
if (!emit_lines()) goto done;
|
||||
}
|
||||
}
|
||||
if (!fragment.empty()) {
|
||||
if (fragment.back() == '\r')
|
||||
fragment.pop_back();
|
||||
if (!fragment.empty())
|
||||
on_line(fragment);
|
||||
}
|
||||
} else {
|
||||
while (!parser.is_done()) {
|
||||
beast::get_lowest_layer(stream).expires_after(
|
||||
std::chrono::seconds(ctx.request_timeout));
|
||||
http::read_some(stream, buffer, parser, ec);
|
||||
if (ec) break;
|
||||
}
|
||||
}
|
||||
|
||||
result_body = parser.get().body();
|
||||
beast::get_lowest_layer(stream).cancel();
|
||||
stream.shutdown(ec);
|
||||
} catch (std::exception& e) {
|
||||
result_code = -1;
|
||||
result_body = e.what();
|
||||
}
|
||||
|
||||
done:
|
||||
*status_code = result_code;
|
||||
if (!result_body.empty()) {
|
||||
*response_body = g_host->strdup(result_body.c_str());
|
||||
}
|
||||
return (result_code >= 200 && result_code < 300) ? 0 : -1;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Service implementations
|
||||
// ============================================================
|
||||
static int http_post_json(
|
||||
const char* host, const char* port,
|
||||
const char* target, const char* body,
|
||||
const char* headers_json,
|
||||
char** response_body, int* status_code)
|
||||
{
|
||||
return do_post_stream(host, port, target, body, headers_json,
|
||||
nullptr, nullptr, response_body, status_code);
|
||||
}
|
||||
|
||||
static int http_post_stream(
|
||||
const char* host, const char* port,
|
||||
const char* target, const char* body,
|
||||
const char* headers_json,
|
||||
dstalk_stream_cb cb, void* userdata,
|
||||
char** response_body, int* status_code)
|
||||
{
|
||||
return do_post_stream(host, port, target, body, headers_json,
|
||||
cb, userdata, response_body, status_code);
|
||||
}
|
||||
|
||||
static dstalk_http_service_t g_service = {
|
||||
http_post_json,
|
||||
http_post_stream
|
||||
};
|
||||
|
||||
// ============================================================
|
||||
// Plugin lifecycle
|
||||
// ============================================================
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
|
||||
// Query config service (declared dependency)
|
||||
g_config_svc = (dstalk_config_service_t*)host->query_service("config", 1);
|
||||
|
||||
return host->register_service("http", 1, &g_service);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
// nothing to clean up
|
||||
}
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
"http", // name
|
||||
"1.0.0", // version
|
||||
"HTTP/HTTPS client service using Boost.Beast + OpenSSL", // description
|
||||
DSTALK_API_VERSION, // api_version
|
||||
{"config", nullptr}, // dependencies
|
||||
on_init, // on_init
|
||||
on_shutdown, // on_shutdown
|
||||
nullptr // on_event
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
18
plugins/session/CMakeLists.txt
Normal file
18
plugins/session/CMakeLists.txt
Normal file
@@ -0,0 +1,18 @@
|
||||
add_library(plugin-session SHARED src/session_plugin.cpp)
|
||||
|
||||
target_include_directories(plugin-session PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-session PRIVATE dstalk)
|
||||
|
||||
find_package(Boost REQUIRED CONFIG)
|
||||
target_link_libraries(plugin-session PRIVATE boost::boost)
|
||||
target_compile_definitions(plugin-session PRIVATE
|
||||
BOOST_ALL_NO_LIB BOOST_ERROR_CODE_HEADER_ONLY BOOST_JSON_HEADER_ONLY)
|
||||
|
||||
set_target_properties(plugin-session PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
263
plugins/session/src/session_plugin.cpp
Normal file
263
plugins/session/src/session_plugin.cpp
Normal file
@@ -0,0 +1,263 @@
|
||||
// plugin-session: 会话管理服务插件
|
||||
// 提供 dstalk_session_service_t vtable 实现
|
||||
// 依赖: file_io (save/load 需要文件操作)
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_types.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <boost/json.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <exception>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace json = boost::json;
|
||||
|
||||
// ============================================================
|
||||
// 内部 C++ 数据结构
|
||||
// ============================================================
|
||||
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
|
||||
// 缓存 file_io 服务指针
|
||||
static const dstalk_file_io_service_t* g_file_io = nullptr;
|
||||
|
||||
// 内部消息结构（C++ 易用，外部暴露 C struct）
|
||||
struct InternalMessage {
|
||||
std::string role;
|
||||
std::string content;
|
||||
std::string tool_call_id;
|
||||
std::string tool_calls_json;
|
||||
};
|
||||
|
||||
// 会话历史
|
||||
static std::vector<InternalMessage> g_history;
|
||||
|
||||
// history() 返回的 C 数组缓存（生命周期到下次 history() 或 shutdown）
|
||||
static std::vector<dstalk_message_t> g_cached_history;
|
||||
|
||||
// ============================================================
|
||||
// Token 计数工具（内联，避免硬依赖 context 头文件）
|
||||
// ============================================================
|
||||
|
||||
static bool is_ascii(unsigned char c) { return c < 0x80; }
|
||||
|
||||
static bool starts_cjk(unsigned char c) {
|
||||
return c >= 0xE4 && c <= 0xE9;
|
||||
}
|
||||
|
||||
static size_t count_tokens_one(const std::string& text) {
|
||||
size_t ascii_chars = 0;
|
||||
size_t chinese_chars = 0;
|
||||
size_t other_chars = 0;
|
||||
|
||||
size_t i = 0;
|
||||
while (i < text.size()) {
|
||||
unsigned char c = static_cast<unsigned char>(text[i]);
|
||||
|
||||
if (is_ascii(c)) {
|
||||
ascii_chars++;
|
||||
i += 1;
|
||||
} else if (starts_cjk(c)) {
|
||||
chinese_chars++;
|
||||
i += 3;
|
||||
} else if (c >= 0xC0 && c < 0xE0) {
|
||||
other_chars++;
|
||||
i += 2;
|
||||
} else if (c >= 0xE0 && c < 0xF0) {
|
||||
other_chars++;
|
||||
i += 3;
|
||||
} else if (c >= 0xF0 && c < 0xF8) {
|
||||
other_chars++;
|
||||
i += 4;
|
||||
} else {
|
||||
other_chars++;
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
size_t content_tokens = (ascii_chars / 4) + (chinese_chars / 2) + (other_chars / 3);
|
||||
return content_tokens + 4; // +4 per message overhead
|
||||
}
|
||||
|
||||
static size_t count_tokens_all(const std::vector<InternalMessage>& msgs) {
|
||||
size_t total = 0;
|
||||
for (const auto& m : msgs) {
|
||||
total += count_tokens_one(m.content);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// 辅助：刷新 C 缓存数组
|
||||
// ============================================================
|
||||
|
||||
static void rebuild_cached_history() {
|
||||
// 释放旧的字符串
|
||||
for (auto& m : g_cached_history) {
|
||||
if (m.role) { g_host->free(const_cast<char*>(m.role)); }
|
||||
if (m.content) { g_host->free(const_cast<char*>(m.content)); }
|
||||
if (m.tool_call_id) { g_host->free(const_cast<char*>(m.tool_call_id)); }
|
||||
if (m.tool_calls_json){ g_host->free(const_cast<char*>(m.tool_calls_json)); }
|
||||
}
|
||||
g_cached_history.clear();
|
||||
|
||||
// 重建
|
||||
g_cached_history.reserve(g_history.size());
|
||||
for (const auto& im : g_history) {
|
||||
dstalk_message_t cm;
|
||||
cm.role = im.role.empty() ? nullptr : g_host->strdup(im.role.c_str());
|
||||
cm.content = im.content.empty() ? nullptr : g_host->strdup(im.content.c_str());
|
||||
cm.tool_call_id = im.tool_call_id.empty() ? nullptr : g_host->strdup(im.tool_call_id.c_str());
|
||||
cm.tool_calls_json = im.tool_calls_json.empty() ? nullptr : g_host->strdup(im.tool_calls_json.c_str());
|
||||
g_cached_history.push_back(cm);
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Session 服务 vtable 实现
|
||||
// ============================================================
|
||||
|
||||
static void session_add(const dstalk_message_t* msg) {
|
||||
if (!msg) return;
|
||||
InternalMessage im;
|
||||
if (msg->role) im.role = msg->role;
|
||||
if (msg->content) im.content = msg->content;
|
||||
if (msg->tool_call_id) im.tool_call_id = msg->tool_call_id;
|
||||
if (msg->tool_calls_json) im.tool_calls_json = msg->tool_calls_json;
|
||||
g_history.push_back(std::move(im));
|
||||
}
|
||||
|
||||
static void session_clear() {
|
||||
g_history.clear();
|
||||
}
|
||||
|
||||
static int session_save(const char* path) {
|
||||
if (!path || !g_file_io) return -1;
|
||||
|
||||
std::string data;
|
||||
for (const auto& m : g_history) {
|
||||
json::object entry;
|
||||
entry["role"] = m.role;
|
||||
entry["content"] = m.content;
|
||||
if (!m.tool_call_id.empty())
|
||||
entry["tool_call_id"] = m.tool_call_id;
|
||||
if (!m.tool_calls_json.empty())
|
||||
entry["tool_calls_json"] = m.tool_calls_json;
|
||||
data += json::serialize(entry);
|
||||
data += '\n';
|
||||
}
|
||||
return g_file_io->write(path, data.c_str());
|
||||
}
|
||||
|
||||
static int session_load(const char* path) {
|
||||
if (!path || !g_file_io) return -1;
|
||||
|
||||
char* content = nullptr;
|
||||
int ret = g_file_io->read(path, &content);
|
||||
if (ret != 0 || !content) return -1;
|
||||
|
||||
std::string data(content);
|
||||
std::free(content);
|
||||
|
||||
std::vector<InternalMessage> parsed;
|
||||
size_t pos = 0;
|
||||
while (pos < data.size()) {
|
||||
size_t nl = data.find('\n', pos);
|
||||
std::string line = (nl != std::string::npos)
|
||||
? data.substr(pos, nl - pos) : data.substr(pos);
|
||||
pos = (nl != std::string::npos) ? nl + 1 : data.size();
|
||||
if (line.empty()) continue;
|
||||
|
||||
try {
|
||||
auto obj = json::parse(line).as_object();
|
||||
auto* role_j = obj.if_contains("role");
|
||||
auto* content_j = obj.if_contains("content");
|
||||
if (role_j && content_j && role_j->is_string() && content_j->is_string()) {
|
||||
InternalMessage im;
|
||||
im.role = json::value_to<std::string>(*role_j);
|
||||
im.content = json::value_to<std::string>(*content_j);
|
||||
auto* tci = obj.if_contains("tool_call_id");
|
||||
if (tci && tci->is_string())
|
||||
im.tool_call_id = json::value_to<std::string>(*tci);
|
||||
auto* tcj = obj.if_contains("tool_calls_json");
|
||||
if (tcj && tcj->is_string())
|
||||
im.tool_calls_json = json::value_to<std::string>(*tcj);
|
||||
parsed.push_back(std::move(im));
|
||||
}
|
||||
} catch (const std::exception&) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (parsed.empty()) return -1;
|
||||
g_history = std::move(parsed);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const dstalk_message_t* session_history(int* out_count) {
|
||||
rebuild_cached_history();
|
||||
if (out_count) *out_count = static_cast<int>(g_cached_history.size());
|
||||
return g_cached_history.empty() ? nullptr : g_cached_history.data();
|
||||
}
|
||||
|
||||
static int session_token_count() {
|
||||
return static_cast<int>(count_tokens_all(g_history));
|
||||
}
|
||||
|
||||
static dstalk_session_service_t g_session_service = {
|
||||
session_add,
|
||||
session_clear,
|
||||
session_save,
|
||||
session_load,
|
||||
session_history,
|
||||
session_token_count
|
||||
};
|
||||
|
||||
// ============================================================
|
||||
// 插件生命周期
|
||||
// ============================================================
|
||||
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
|
||||
// 查询依赖服务: file_io
|
||||
void* raw = host->query_service("file_io", 1);
|
||||
if (!raw) {
|
||||
host->log(DSTALK_LOG_ERROR, "[plugin-session] required service 'file_io' not found");
|
||||
return -1;
|
||||
}
|
||||
g_file_io = static_cast<const dstalk_file_io_service_t*>(raw);
|
||||
|
||||
// 注册自身服务
|
||||
return host->register_service("session", 1, &g_session_service);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
// 释放缓存
|
||||
rebuild_cached_history(); // 这会先清理旧字符串再清空
|
||||
g_cached_history.clear(); // 确保空
|
||||
g_history.clear();
|
||||
g_file_io = nullptr;
|
||||
g_host = nullptr;
|
||||
}
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
"session",
|
||||
"1.0.0",
|
||||
"Session management plugin with save/load support",
|
||||
DSTALK_API_VERSION,
|
||||
{"file_io", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
|
||||
on_init,
|
||||
on_shutdown,
|
||||
nullptr
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
18
plugins/tools/CMakeLists.txt
Normal file
18
plugins/tools/CMakeLists.txt
Normal file
@@ -0,0 +1,18 @@
|
||||
add_library(plugin-tools SHARED src/tools_plugin.cpp)
|
||||
|
||||
target_include_directories(plugin-tools PRIVATE
|
||||
${CMAKE_SOURCE_DIR}/dstalk-core/include
|
||||
)
|
||||
|
||||
target_link_libraries(plugin-tools PRIVATE dstalk)
|
||||
|
||||
find_package(Boost REQUIRED CONFIG)
|
||||
target_link_libraries(plugin-tools PRIVATE boost::boost)
|
||||
target_compile_definitions(plugin-tools PRIVATE
|
||||
BOOST_ALL_NO_LIB BOOST_ERROR_CODE_HEADER_ONLY BOOST_JSON_HEADER_ONLY)
|
||||
|
||||
set_target_properties(plugin-tools PROPERTIES
|
||||
PREFIX ""
|
||||
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plugins"
|
||||
)
|
||||
248
plugins/tools/src/tools_plugin.cpp
Normal file
248
plugins/tools/src/tools_plugin.cpp
Normal file
@@ -0,0 +1,248 @@
|
||||
// plugin-tools: 工具注册服务插件
|
||||
// 提供 dstalk_tools_service_t vtable 实现
|
||||
// 依赖: file_io (内置 file_read / file_write 工具)
|
||||
#include "dstalk/dstalk_host.h"
|
||||
#include "dstalk/dstalk_types.h"
|
||||
#include "dstalk/dstalk_services.h"
|
||||
|
||||
#include <boost/json.hpp>
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <exception>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace json = boost::json;
|
||||
|
||||
// ============================================================
|
||||
// 内部数据结构
|
||||
// ============================================================
|
||||
|
||||
static const dstalk_host_api_t* g_host = nullptr;
|
||||
static const dstalk_file_io_service_t* g_file_io = nullptr;
|
||||
|
||||
struct ToolDef {
|
||||
std::string name;
|
||||
std::string description;
|
||||
std::string parameters_schema;
|
||||
dstalk_tool_handler_fn handler;
|
||||
};
|
||||
|
||||
static std::vector<ToolDef> g_tools;
|
||||
|
||||
// ============================================================
|
||||
// 内置工具: file_read, file_write
|
||||
// ============================================================
|
||||
|
||||
static char* builtin_file_read(const char* args_json) {
|
||||
if (!g_file_io) {
|
||||
return g_host->strdup("{\"error\":\"file_io service not available\"}");
|
||||
}
|
||||
|
||||
try {
|
||||
auto args = json::parse(args_json).as_object();
|
||||
auto* path_j = args.if_contains("path");
|
||||
if (!path_j || !path_j->is_string()) {
|
||||
return g_host->strdup("{\"error\":\"missing 'path' argument\"}");
|
||||
}
|
||||
std::string path = json::value_to<std::string>(*path_j);
|
||||
|
||||
char* content = nullptr;
|
||||
int ret = g_file_io->read(path.c_str(), &content);
|
||||
if (ret != 0 || !content) {
|
||||
return g_host->strdup("{\"error\":\"failed to read file\"}");
|
||||
}
|
||||
|
||||
std::string escaped_content = json::serialize(json::string(content));
|
||||
std::free(content);
|
||||
|
||||
std::string result = "{\"content\":" + escaped_content + "}";
|
||||
return g_host->strdup(result.c_str());
|
||||
} catch (const std::exception& e) {
|
||||
std::string err = "{\"error\":\"file_read error: " + std::string(e.what()) + "\"}";
|
||||
return g_host->strdup(err.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
static char* builtin_file_write(const char* args_json) {
|
||||
if (!g_file_io) {
|
||||
return g_host->strdup("{\"error\":\"file_io service not available\"}");
|
||||
}
|
||||
|
||||
try {
|
||||
auto args = json::parse(args_json).as_object();
|
||||
auto* path_j = args.if_contains("path");
|
||||
auto* content_j = args.if_contains("content");
|
||||
if (!path_j || !path_j->is_string()) {
|
||||
return g_host->strdup("{\"error\":\"missing 'path' argument\"}");
|
||||
}
|
||||
if (!content_j || !content_j->is_string()) {
|
||||
return g_host->strdup("{\"error\":\"missing 'content' argument\"}");
|
||||
}
|
||||
|
||||
std::string path = json::value_to<std::string>(*path_j);
|
||||
std::string content = json::value_to<std::string>(*content_j);
|
||||
|
||||
int ret = g_file_io->write(path.c_str(), content.c_str());
|
||||
if (ret != 0) {
|
||||
return g_host->strdup("{\"error\":\"failed to write file\"}");
|
||||
}
|
||||
|
||||
return g_host->strdup("{\"success\":true}");
|
||||
} catch (const std::exception& e) {
|
||||
std::string err = "{\"error\":\"file_write error: " + std::string(e.what()) + "\"}";
|
||||
return g_host->strdup(err.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Tools 服务 vtable 实现
|
||||
// ============================================================
|
||||
|
||||
static int tools_register_tool(const char* name, const char* desc,
|
||||
const char* params_schema,
|
||||
dstalk_tool_handler_fn handler) {
|
||||
if (!name || !handler) return -1;
|
||||
|
||||
// 如果已存在同名工具，先注销
|
||||
tools_unregister_tool(name);
|
||||
|
||||
ToolDef td;
|
||||
td.name = name;
|
||||
td.description = desc ? desc : "";
|
||||
td.parameters_schema = params_schema ? params_schema : "";
|
||||
td.handler = handler;
|
||||
g_tools.push_back(std::move(td));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tools_unregister_tool(const char* name) {
|
||||
if (!name) return;
|
||||
std::string n(name);
|
||||
g_tools.erase(
|
||||
std::remove_if(g_tools.begin(), g_tools.end(),
|
||||
[&n](const ToolDef& t) { return t.name == n; }),
|
||||
g_tools.end());
|
||||
}
|
||||
|
||||
static char* tools_get_tools_json() {
|
||||
json::array tools_arr;
|
||||
|
||||
for (const auto& t : g_tools) {
|
||||
json::object tool_obj;
|
||||
tool_obj["type"] = "function";
|
||||
|
||||
json::object func_obj;
|
||||
func_obj["name"] = t.name;
|
||||
func_obj["description"] = t.description;
|
||||
|
||||
if (!t.parameters_schema.empty()) {
|
||||
func_obj["parameters"] = json::parse(t.parameters_schema);
|
||||
} else {
|
||||
json::object empty_params;
|
||||
empty_params["type"] = "object";
|
||||
empty_params["properties"] = json::object{};
|
||||
func_obj["parameters"] = empty_params;
|
||||
}
|
||||
|
||||
tool_obj["function"] = func_obj;
|
||||
tools_arr.push_back(tool_obj);
|
||||
}
|
||||
|
||||
std::string result = json::serialize(tools_arr);
|
||||
return g_host->strdup(result.c_str());
|
||||
}
|
||||
|
||||
static char* tools_execute(const char* name, const char* args_json) {
|
||||
if (!name) {
|
||||
return g_host->strdup("{\"error\":\"tool name is null\"}");
|
||||
}
|
||||
|
||||
std::string n(name);
|
||||
ToolDef* found = nullptr;
|
||||
for (auto& t : g_tools) {
|
||||
if (t.name == n) {
|
||||
found = &t;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) {
|
||||
json::object err_obj;
|
||||
err_obj["error"] = "unknown tool: " + n;
|
||||
return g_host->strdup(json::serialize(err_obj).c_str());
|
||||
}
|
||||
|
||||
try {
|
||||
const char* args = args_json ? args_json : "{}";
|
||||
return found->handler(args);
|
||||
} catch (const std::exception& e) {
|
||||
json::object err_obj;
|
||||
err_obj["error"] = std::string("tool execution failed: ") + e.what();
|
||||
return g_host->strdup(json::serialize(err_obj).c_str());
|
||||
} catch (...) {
|
||||
return g_host->strdup("{\"error\":\"tool execution failed: unknown error\"}");
|
||||
}
|
||||
}
|
||||
|
||||
static dstalk_tools_service_t g_tools_service = {
|
||||
tools_register_tool,
|
||||
tools_unregister_tool,
|
||||
tools_get_tools_json,
|
||||
tools_execute
|
||||
};
|
||||
|
||||
// ============================================================
|
||||
// 插件生命周期
|
||||
// ============================================================
|
||||
|
||||
static int on_init(const dstalk_host_api_t* host) {
|
||||
g_host = host;
|
||||
|
||||
// 查询依赖服务: file_io
|
||||
void* raw = host->query_service("file_io", 1);
|
||||
if (!raw) {
|
||||
host->log(DSTALK_LOG_ERROR, "[plugin-tools] required service 'file_io' not found");
|
||||
return -1;
|
||||
}
|
||||
g_file_io = static_cast<const dstalk_file_io_service_t*>(raw);
|
||||
|
||||
// 向自身注册内置工具
|
||||
tools_register_tool(
|
||||
"file_read",
|
||||
"Read the contents of a file at the given path",
|
||||
"{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"Path to the file to read\"}},\"required\":[\"path\"]}",
|
||||
builtin_file_read
|
||||
);
|
||||
|
||||
tools_register_tool(
|
||||
"file_write",
|
||||
"Write content to a file at the given path",
|
||||
"{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"Path to the file to write\"},\"content\":{\"type\":\"string\",\"description\":\"Content to write to the file\"}},\"required\":[\"path\",\"content\"]}",
|
||||
builtin_file_write
|
||||
);
|
||||
|
||||
return host->register_service("tools", 1, &g_tools_service);
|
||||
}
|
||||
|
||||
static void on_shutdown() {
|
||||
g_tools.clear();
|
||||
g_file_io = nullptr;
|
||||
g_host = nullptr;
|
||||
}
|
||||
|
||||
static dstalk_plugin_info_t g_info = {
|
||||
"tools",
|
||||
"1.0.0",
|
||||
"Tool registration and execution plugin with built-in file tools",
|
||||
DSTALK_API_VERSION,
|
||||
{"file_io", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
|
||||
on_init,
|
||||
on_shutdown,
|
||||
nullptr
|
||||
};
|
||||
|
||||
extern "C" DSTALK_PLUGIN_EXPORT dstalk_plugin_info_t* dstalk_plugin_init(void) {
|
||||
return &g_info;
|
||||
}
|
||||
Reference in New Issue
Block a user