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 WireDialect { V0_3, V1_0 };
 
enum class TaskState {
    Submitted,
    Working,
    InputRequired,
    Completed,
    Canceled,
    Failed,
    Rejected,
    AuthRequired,
    Unknown,
};
 
NEOGRAPH_API std::string task_state_to_string(TaskState s);
NEOGRAPH_API std::string task_state_to_string(TaskState s, WireDialect dialect);
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 std::string role_to_string(Role r, WireDialect dialect);
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;    
    std::string media_type;
 
    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;
        // A Task frame is terminal unless it is the opening snapshot of a
        // 1.0 / 0.3 task lifecycle stream (submitted or still working).
        if (type == Type::Task) {
            if (!task) return true;
            return task->status.state != TaskState::Submitted
                && task->status.state != TaskState::Working;
        }
        return false;
    }
};
 
struct NEOGRAPH_API AgentInterface {
    std::string url;
    std::string protocol_binding;   
    std::string protocol_version;   
    std::string tenant;             
};
 
struct NEOGRAPH_API AgentSkill {
    std::string              id;
    std::string              name;
    std::string              description;
    std::vector<std::string> tags;
    std::vector<std::string> examples;
    std::vector<std::string> input_modes;
    std::vector<std::string> output_modes;
};
 
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                       = true;
    bool                    push_notifications              = false;
    bool                    extended_card                   = false;
    bool                    supports_authenticated_extended = false;
 
    std::vector<AgentInterface> supported_interfaces;
 
    std::vector<std::string> skill_names;
    std::vector<AgentSkill> skills;
 
    json security_schemes;
    json security_requirements;
    json extensions;
 
    json raw;
};
 
// ---------------------------------------------------------------------------
// JSON adapters (defined in src/a2a/types.cpp).
//
// The two-argument to_json overloads emit the 0.3 dialect (unchanged);
// the three-argument overloads select a WireDialect explicitly.
// ---------------------------------------------------------------------------
NEOGRAPH_API void to_json(json& j, const Part& p, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const Message& m, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const Artifact& a, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const TaskStatus& s, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const Task& t, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const MessageSendConfiguration& c, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const MessageSendParams& p, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const TaskStatusUpdateEvent& e, WireDialect dialect);
NEOGRAPH_API void to_json(json& j, const TaskArtifactUpdateEvent& e, WireDialect dialect);
 
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 to_json(json& j, const AgentCard& c, WireDialect dialect);
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);
 
NEOGRAPH_API Task task_from_result(const json& result);
 
} // namespace neograph::a2a