types.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/json.h>
 
#include <optional>
#include <string>
#include <vector>
 
namespace neograph::acp {
 
using json = neograph::json;
 
// ---------------------------------------------------------------------------
// Capabilities
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API PromptCapabilities {
    bool image            = false;  
    bool audio            = false;  
    bool embedded_context = false;  
};
 
struct NEOGRAPH_API McpCapabilities {
    bool http = false;
    bool sse  = false;
};
 
struct NEOGRAPH_API SessionCapabilities {
    bool close  = false;  
    bool list   = false;  
    bool resume = false;  
};
 
struct NEOGRAPH_API AgentCapabilities {
    bool                load_session = false;  
    PromptCapabilities  prompt;
    McpCapabilities     mcp;
    SessionCapabilities session;
};
 
struct NEOGRAPH_API FsCapabilities {
    bool read_text_file  = false;
    bool write_text_file = false;
};
 
struct NEOGRAPH_API ClientCapabilities {
    FsCapabilities fs;
    bool           terminal = false;  
};
 
// ---------------------------------------------------------------------------
// Content blocks — the unit of payload in prompts and updates.
// Discriminated by `type` ∈ {"text","image","audio","resource","resource_link"}.
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API ContentBlock {
    std::string type;        
    std::string text;        
    std::string data;        
    std::string mime_type;   
    std::string uri;         
    std::string name;        
    std::optional<std::string> title;       
    std::optional<std::string> description; 
    std::optional<std::int64_t> size;       
 
    json        resource;
 
    json        annotations;
 
    static ContentBlock text_block(std::string s);
 
    static ContentBlock resource_link(std::string uri,
                                      std::string name,
                                      std::string mime_type = {});
};
 
// ---------------------------------------------------------------------------
// initialize
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API InitializeRequest {
    int                protocol_version = 1;
    ClientCapabilities client_capabilities;
    json               client_info;  
};
 
struct NEOGRAPH_API InitializeResponse {
    int               protocol_version = 1;
    AgentCapabilities agent_capabilities;
    std::vector<json> auth_methods;
    json              agent_info;  
};
 
// ---------------------------------------------------------------------------
// session/new
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API McpServerConfig {
    json raw;
};
 
struct NEOGRAPH_API NewSessionRequest {
    std::string                 cwd;          
    std::vector<McpServerConfig> mcp_servers;
};
 
struct NEOGRAPH_API NewSessionResponse {
    std::string session_id;
    json        config_options;
    json        modes;
};
 
// ---------------------------------------------------------------------------
// session/prompt
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API PromptRequest {
    std::string                session_id;
    std::vector<ContentBlock>  prompt;
};
 
enum class StopReason {
    EndTurn,         
    MaxTokens,       
    MaxTurnRequests, 
    Refusal,         
    Cancelled,       
};
 
NEOGRAPH_API std::string stop_reason_to_string(StopReason s);
NEOGRAPH_API StopReason  stop_reason_from_string(std::string_view s);
 
struct NEOGRAPH_API PromptResponse {
    StopReason stop_reason = StopReason::EndTurn;
};
 
// ---------------------------------------------------------------------------
// session/cancel — JSON-RPC notification (no response)
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API CancelNotification {
    std::string session_id;
};
 
// ---------------------------------------------------------------------------
// fs/read_text_file, fs/write_text_file — agent → client requests
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API ReadTextFileRequest {
    std::string session_id;
    std::string path;
    std::optional<int> line;   
    std::optional<int> limit;  
};
 
struct NEOGRAPH_API ReadTextFileResponse {
    std::string content;
};
 
struct NEOGRAPH_API WriteTextFileRequest {
    std::string session_id;
    std::string path;
    std::string content;
};
 
NEOGRAPH_API void to_json(json& j, const ReadTextFileRequest& r);
NEOGRAPH_API void from_json(const json& j, ReadTextFileRequest& r);
NEOGRAPH_API void to_json(json& j, const ReadTextFileResponse& r);
NEOGRAPH_API void from_json(const json& j, ReadTextFileResponse& r);
NEOGRAPH_API void to_json(json& j, const WriteTextFileRequest& r);
NEOGRAPH_API void from_json(const json& j, WriteTextFileRequest& r);
 
// ---------------------------------------------------------------------------
// ToolCallUpdate — name matches the official ACP schema
// (`session/request_permission.toolCall: ToolCallUpdate`). Modeled
// minimally: spec carries more fields, preserved verbatim in `raw`.
//
// Renamed from `ToolCall` (which collided with the LLM-side
// `neograph::ToolCall` in `<neograph/types.h>` whenever both
// namespaces were brought in via `using namespace`). The two are
// genuinely different concepts — keep them under distinct names.
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API ToolCallUpdate {
    std::string tool_call_id;   
    std::string tool_name;      
    json        input;          
    std::string kind;           
    std::string status;         
    std::vector<ContentBlock> content;  
    json        raw;
};
 
NEOGRAPH_API void to_json(json& j, const ToolCallUpdate& t);
NEOGRAPH_API void from_json(const json& j, ToolCallUpdate& t);
 
// ---------------------------------------------------------------------------
// session/request_permission — agent → client (the agent asks the editor
// to surface a permission prompt before executing a tool call)
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API PermissionOption {
    std::string option_id;   
    std::string name;        
    std::string kind;        
};
 
NEOGRAPH_API void to_json(json& j, const PermissionOption& o);
NEOGRAPH_API void from_json(const json& j, PermissionOption& o);
 
struct NEOGRAPH_API RequestPermissionRequest {
    std::string                 session_id;
    ToolCallUpdate                    tool_call;
    std::vector<PermissionOption> options;
};
 
NEOGRAPH_API void to_json(json& j, const RequestPermissionRequest& r);
NEOGRAPH_API void from_json(const json& j, RequestPermissionRequest& r);
 
enum class PermissionOutcomeKind { Selected, Cancelled };
 
struct NEOGRAPH_API RequestPermissionOutcome {
    PermissionOutcomeKind kind     = PermissionOutcomeKind::Cancelled;
    std::string           option_id;  
};
 
NEOGRAPH_API void to_json(json& j, const RequestPermissionOutcome& o);
NEOGRAPH_API void from_json(const json& j, RequestPermissionOutcome& o);
 
struct NEOGRAPH_API RequestPermissionResponse {
    RequestPermissionOutcome outcome;
};
 
NEOGRAPH_API void to_json(json& j, const RequestPermissionResponse& r);
NEOGRAPH_API void from_json(const json& j, RequestPermissionResponse& r);
 
// ---------------------------------------------------------------------------
// session/update — agent-emitted streaming notification
// ---------------------------------------------------------------------------
 
struct NEOGRAPH_API SessionUpdate {
    std::string  session_update;  
    ContentBlock content;         
    json         raw;             
};
 
struct NEOGRAPH_API SessionNotification {
    std::string   session_id;
    SessionUpdate update;
};
 
// ---------------------------------------------------------------------------
// JSON adapters (defined in src/acp/types.cpp).
// ---------------------------------------------------------------------------
NEOGRAPH_API void to_json(json& j, const PromptCapabilities& c);
NEOGRAPH_API void from_json(const json& j, PromptCapabilities& c);
 
NEOGRAPH_API void to_json(json& j, const McpCapabilities& c);
NEOGRAPH_API void from_json(const json& j, McpCapabilities& c);
 
NEOGRAPH_API void to_json(json& j, const SessionCapabilities& c);
NEOGRAPH_API void from_json(const json& j, SessionCapabilities& c);
 
NEOGRAPH_API void to_json(json& j, const AgentCapabilities& c);
NEOGRAPH_API void from_json(const json& j, AgentCapabilities& c);
 
NEOGRAPH_API void to_json(json& j, const FsCapabilities& c);
NEOGRAPH_API void from_json(const json& j, FsCapabilities& c);
 
NEOGRAPH_API void to_json(json& j, const ClientCapabilities& c);
NEOGRAPH_API void from_json(const json& j, ClientCapabilities& c);
 
NEOGRAPH_API void to_json(json& j, const ContentBlock& b);
NEOGRAPH_API void from_json(const json& j, ContentBlock& b);
 
NEOGRAPH_API void to_json(json& j, const InitializeRequest& r);
NEOGRAPH_API void from_json(const json& j, InitializeRequest& r);
 
NEOGRAPH_API void to_json(json& j, const InitializeResponse& r);
NEOGRAPH_API void from_json(const json& j, InitializeResponse& r);
 
NEOGRAPH_API void to_json(json& j, const McpServerConfig& c);
NEOGRAPH_API void from_json(const json& j, McpServerConfig& c);
 
NEOGRAPH_API void to_json(json& j, const NewSessionRequest& r);
NEOGRAPH_API void from_json(const json& j, NewSessionRequest& r);
 
NEOGRAPH_API void to_json(json& j, const NewSessionResponse& r);
NEOGRAPH_API void from_json(const json& j, NewSessionResponse& r);
 
NEOGRAPH_API void to_json(json& j, const PromptRequest& r);
NEOGRAPH_API void from_json(const json& j, PromptRequest& r);
 
NEOGRAPH_API void to_json(json& j, const PromptResponse& r);
NEOGRAPH_API void from_json(const json& j, PromptResponse& r);
 
NEOGRAPH_API void to_json(json& j, const CancelNotification& n);
NEOGRAPH_API void from_json(const json& j, CancelNotification& n);
 
NEOGRAPH_API void to_json(json& j, const SessionUpdate& u);
NEOGRAPH_API void from_json(const json& j, SessionUpdate& u);
 
NEOGRAPH_API void to_json(json& j, const SessionNotification& n);
NEOGRAPH_API void from_json(const json& j, SessionNotification& n);
 
}  // namespace neograph::acp