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::a2a {
 
using json = neograph::json;
 
enum class TaskState {
    Submitted,
    Working,
    InputRequired,
    Completed,
    Canceled,
    Failed,
    Rejected,
    AuthRequired,
    Unknown,
};
 
NEOGRAPH_API std::string task_state_to_string(TaskState s);
NEOGRAPH_API TaskState   task_state_from_string(std::string_view s);
 
enum class Role { User, Agent };
 
NEOGRAPH_API std::string role_to_string(Role r);
NEOGRAPH_API Role        role_from_string(std::string_view s);
 
struct NEOGRAPH_API Part {
    std::string kind;        
    std::string text;        
    json        file;        
    json        data;        
    json        metadata;    
 
    static Part text_part(std::string s);
};
 
struct NEOGRAPH_API Message {
    std::string         message_id;            
    Role                role = Role::User;     
    std::vector<Part>   parts;                 
    std::optional<std::string> task_id;        
    std::optional<std::string> context_id;     
    std::vector<std::string>   reference_task_ids;
    std::vector<std::string>   extensions;
    json                metadata;              
    std::string         kind = "message";      
};
 
struct NEOGRAPH_API Artifact {
    std::string         artifact_id;
    std::vector<Part>   parts;
    std::optional<std::string> name;
    std::optional<std::string> description;
    json                metadata;
};
 
struct NEOGRAPH_API TaskStatus {
    TaskState              state = TaskState::Submitted;
    std::optional<Message> message;
    std::optional<std::string> timestamp;   
};
 
struct NEOGRAPH_API Task {
    std::string             id;             
    std::string             context_id;     
    TaskStatus              status;
    std::vector<Artifact>   artifacts;
    std::vector<Message>    history;
    json                    metadata;
    std::string             kind = "task";
};
 
struct NEOGRAPH_API MessageSendConfiguration {
    std::vector<std::string>   accepted_output_modes;
    std::optional<bool>        blocking;
    std::optional<int>         history_length;
};
 
struct NEOGRAPH_API MessageSendParams {
    Message                                  message;
    std::optional<MessageSendConfiguration>  configuration;
    json                                     metadata;
};
 
struct NEOGRAPH_API TaskStatusUpdateEvent {
    std::string  task_id;
    std::string  context_id;
    TaskStatus   status;
    bool         final = false;
    json         metadata;
    std::string  kind = "status-update";
};
 
struct NEOGRAPH_API TaskArtifactUpdateEvent {
    std::string  task_id;
    std::string  context_id;
    Artifact     artifact;
    bool         append    = false;
    bool         last_chunk = false;
    json         metadata;
    std::string  kind = "artifact-update";
};
 
struct NEOGRAPH_API StreamEvent {
    enum class Type { StatusUpdate, ArtifactUpdate, Task };
    Type                                    type = Type::Task;
    std::optional<TaskStatusUpdateEvent>    status_update;
    std::optional<TaskArtifactUpdateEvent>  artifact_update;
    std::optional<a2a::Task>                task;
 
    bool is_final() const noexcept {
        if (type == Type::StatusUpdate && status_update) return status_update->final;
        if (type == Type::Task) return true;
        return false;
    }
};
 
struct NEOGRAPH_API AgentCard {
    std::string             name;
    std::string             description;
    std::string             url;                
    std::string             version;
    std::string             protocol_version;   
    std::string             preferred_transport = "JSONRPC";
    std::vector<std::string> default_input_modes;
    std::vector<std::string> default_output_modes;
 
    bool                    streaming                       = false;
    bool                    push_notifications              = false;
    bool                    extended_card                   = false;
    bool                    supports_authenticated_extended = false;
 
    std::vector<std::string> skill_names;
 
    json raw;
};
 
// ---------------------------------------------------------------------------
// JSON adapters (defined in src/a2a/types.cpp).
// ---------------------------------------------------------------------------
NEOGRAPH_API void to_json(json& j, const Part& p);
NEOGRAPH_API void from_json(const json& j, Part& p);
 
NEOGRAPH_API void to_json(json& j, const Message& m);
NEOGRAPH_API void from_json(const json& j, Message& m);
 
NEOGRAPH_API void to_json(json& j, const Artifact& a);
NEOGRAPH_API void from_json(const json& j, Artifact& a);
 
NEOGRAPH_API void to_json(json& j, const TaskStatus& s);
NEOGRAPH_API void from_json(const json& j, TaskStatus& s);
 
NEOGRAPH_API void to_json(json& j, const Task& t);
NEOGRAPH_API void from_json(const json& j, Task& t);
 
NEOGRAPH_API void to_json(json& j, const MessageSendConfiguration& c);
NEOGRAPH_API void from_json(const json& j, MessageSendConfiguration& c);
 
NEOGRAPH_API void to_json(json& j, const MessageSendParams& p);
NEOGRAPH_API void from_json(const json& j, MessageSendParams& p);
 
NEOGRAPH_API void to_json(json& j, const AgentCard& c);
NEOGRAPH_API void from_json(const json& j, AgentCard& c);
 
NEOGRAPH_API void to_json(json& j, const TaskStatusUpdateEvent& e);
NEOGRAPH_API void from_json(const json& j, TaskStatusUpdateEvent& e);
 
NEOGRAPH_API void to_json(json& j, const TaskArtifactUpdateEvent& e);
NEOGRAPH_API void from_json(const json& j, TaskArtifactUpdateEvent& e);
 
NEOGRAPH_API StreamEvent parse_stream_event(const json& j);
 
} // namespace neograph::a2a