agent_card_candidate.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/a2a/types.h>
#include <neograph/api.h>
#include <neograph/graph/node.h>
 
#include <cstddef>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::a2a {
 
struct NEOGRAPH_API AgentCardSourceProvenance {
    std::string discovery_url;
    std::string source_url;
    std::string source_revision;
    std::string source_license;
};
 
struct NEOGRAPH_API AgentCardCollectionPolicy {
    std::size_t max_card_bytes = 64 * 1024;
    bool allow_loopback_http = false;
};
 
struct NEOGRAPH_API CollectedAgentCard {
    AgentCard                 card;
    AgentCardSourceProvenance provenance;
    std::string               card_sha256;
    json                      raw_card;
};
 
class NEOGRAPH_API AgentCardCollector {
public:
    explicit AgentCardCollector(AgentCardCollectionPolicy policy = {});
 
    CollectedAgentCard collect(std::string               discovery_url,
                               AgentCardSourceProvenance provenance) const;
 
private:
    AgentCardCollectionPolicy policy_;
};
 
class AgentCardCandidateCompiler;
 
class NEOGRAPH_API AgentCardCompatibilityCandidate {
public:
    AgentCardCompatibilityCandidate(const AgentCardCompatibilityCandidate&)            = default;
    AgentCardCompatibilityCandidate(AgentCardCompatibilityCandidate&&)                 = default;
    AgentCardCompatibilityCandidate& operator=(const AgentCardCompatibilityCandidate&) = delete;
    AgentCardCompatibilityCandidate& operator=(AgentCardCompatibilityCandidate&&)      = delete;
 
    [[nodiscard]] const std::string& id() const noexcept { return id_; }
    [[nodiscard]] const std::string& source_card_sha256() const noexcept {
        return source_card_sha256_;
    }
    [[nodiscard]] const json& descriptor() const noexcept { return descriptor_; }
 
private:
    friend class AgentCardCandidateCompiler;
 
    AgentCardCompatibilityCandidate(std::string id,
                                    std::string source_card_sha256,
                                    json        descriptor);
 
    std::string id_;
    std::string source_card_sha256_;
    json        descriptor_;
};
 
class NEOGRAPH_API AgentCardCandidateCompiler {
public:
    static AgentCardCompatibilityCandidate compile(const CollectedAgentCard& collected);
};
 
struct NEOGRAPH_API CopyNinjaBehavioralProbe {
    std::string input;
    std::string expected_output;
};
 
struct NEOGRAPH_API CopyNinjaBehavioralProfile {
    std::string                           source_card_sha256;
    std::string                           template_id;
    std::vector<CopyNinjaBehavioralProbe> development_probes;
};
 
class CopyNinjaHarness;
NEOGRAPH_API CopyNinjaHarness materialize_copy_ninja(
    const AgentCardCompatibilityCandidate& candidate, CopyNinjaBehavioralProfile profile);
 
class NEOGRAPH_API CopyNinjaHarness {
public:
    const AgentCardCompatibilityCandidate& candidate() const noexcept;
    const CopyNinjaBehavioralProfile&      profile() const noexcept;
 
    std::string respond(std::string_view input) const;
 
    AgentCard agent_card(std::string endpoint) const;
 
private:
    friend CopyNinjaHarness materialize_copy_ninja(const AgentCardCompatibilityCandidate& candidate,
                                                   CopyNinjaBehavioralProfile             profile);
 
    CopyNinjaHarness(AgentCardCompatibilityCandidate candidate, CopyNinjaBehavioralProfile profile);
 
    AgentCardCompatibilityCandidate candidate_;
    CopyNinjaBehavioralProfile      profile_;
};
 
class NEOGRAPH_API CopyNinjaNode final : public graph::GraphNode {
public:
    CopyNinjaNode(std::string name, std::shared_ptr<const CopyNinjaHarness> harness);
    asio::awaitable<graph::NodeOutput> run(graph::NodeInput input) override;
 
    std::string get_name() const override;
 
private:
    std::string                             name_;
    std::shared_ptr<const CopyNinjaHarness> harness_;
};
 
}  // namespace neograph::a2a