#include "../AiDemos.hpp" #include #include "../../fw/Router.hpp" #include "../../fw/Templates.hpp" #include "vendors/bedrock/agent.h" #include "vendors/bedrock/calls.h" #include "vendors/bedrock/caps.h" #include "vendors/bedrock/chat_model.h" #include "vendors/bedrock/client.h" #include "vendors/bedrock/control.h" #include "vendors/bedrock/credentials.h" #include "vendors/bedrock/runtime.h" #include "vendors/bedrock/sigv4.h" namespace molo::example::app { // Amazon Bedrock over the real src/vendors/bedrock package. GET routes need no // credential. Every route that calls AWS is a POST: 422 on bad input, 503 // not_configured without AWS_BEARER_TOKEN_BEDROCK or AWS_ACCESS_KEY_ID + // AWS_SECRET_ACCESS_KEY. Routes that cost money or change a resource (inference, // guardrail checks, agents, retrieval, batch create / stop) are dry runs that // show the exact request unless the body has "confirm":true. /ai/bedrock/sign // is local: it signs with AWS's documentation credentials only. namespace { namespace bk = bedrock; using Json = clients::body::Json; constexpr std::size_t kMaxBody = 8 * 1024 * 1024; constexpr std::size_t kMaxStreamChunks = 400; const char kPage[] = R"BEDROCK({% extends "base.html" %} {% block content %}

Amazon Bedrock

Converse and ConverseStream, InvokeModel (and stream), count tokens, guardrails, agents, knowledge base retrieval, models, inference profiles, batch jobs, and a local SigV4 signer. Paid and changing calls are dry runs until the body says "confirm":true.

Checking credential...


{% endblock %} )BEDROCK"; [[noreturn]] void bad(const std::string& why) { throw fw::HttpError(422, "validation_error", why); } fw::Response json_out(const Json& j, int status = 200) { fw::Response res = fw::JsonResponse(j.dump(), status); res.headers.set("Cache-Control", "no-store"); return res; } Json parse_body(const fw::Request& req) { if (req.body.size() > kMaxBody) throw fw::HttpError(413, "payload_too_large", "body too large"); if (req.body.empty()) return Json::object(); try { Json j = Json::parse(req.body); if (!j.is_object()) bad("body must be a JSON object"); return j; } catch (const clients::body::JsonError&) { bad("body is not valid JSON"); } } std::string text(const Json& b, const char* key, bool required = false) { const Json* v = b.find(key); if (!v || v->is_null()) { if (required) bad(std::string(key) + " is required"); return ""; } if (!v->is_string()) bad(std::string(key) + " must be a string"); return v->as_string(); } std::optional number(const Json& b, const char* key) { const Json* v = b.find(key); if (!v || v->is_null()) return std::nullopt; if (!v->is_number()) bad(std::string(key) + " must be a number"); return static_cast(v->as_int()); } std::optional real(const Json& b, const char* key) { const Json* v = b.find(key); if (!v || v->is_null()) return std::nullopt; if (!v->is_number()) bad(std::string(key) + " must be a number"); return v->as_number(); } bool flag(const Json& b, const char* key) { const Json* v = b.find(key); if (!v || v->is_null()) return false; if (!v->is_bool()) bad(std::string(key) + " must be true or false"); return v->as_bool(); } std::vector strings(const Json& b, const char* key) { std::vector out; const Json* v = b.find(key); if (!v || v->is_null()) return out; if (!v->is_array()) bad(std::string(key) + " must be an array of strings"); for (const Json& s : v->as_array()) { if (!s.is_string()) bad(std::string(key) + " must be an array of strings"); out.push_back(s.as_string()); } return out; } Json object_at(const Json& b, const char* key, bool required = false) { const Json* v = b.find(key); if (!v || v->is_null()) { if (required) bad(std::string(key) + " is required"); return Json::object(); } if (!v->is_object()) bad(std::string(key) + " must be an object"); return *v; } Json usage_json(const bk::ConverseUsage& u) { Json o = Json::object(); o.set("input_tokens", Json(u.input_tokens)); o.set("output_tokens", Json(u.output_tokens)); o.set("total_tokens", Json(u.total_tokens)); o.set("cache_read_tokens", Json(u.cache_read_tokens)); o.set("cache_write_tokens", Json(u.cache_write_tokens)); return o; } Json converse_json(const bk::ConverseResult& r) { Json o = Json::object(); o.set("text", Json(r.text())); o.set("reasoning", Json(r.reasoning())); o.set("stop_reason", Json(r.stop_reason())); o.set("latency_ms", Json(static_cast(r.latency_ms()))); o.set("usage", usage_json(r.usage())); Json calls = Json::array(); for (const bk::ConverseToolUse& t : r.tool_uses()) { Json x = Json::object(); x.set("id", Json(t.id)); x.set("name", Json(t.name)); x.set("input", t.input); calls.push(x); } o.set("tool_uses", calls); return o; } Json list_json(const bk::ListResult& l, const char* key) { Json o = Json::object(); o.set(key, l.items); o.set("count", Json(static_cast(l.items.as_array().size()))); o.set("pages", Json(static_cast(l.pages))); o.set("truncated", Json(l.truncated)); if (!l.next_token.empty()) o.set("next_token", Json(l.next_token)); return o; } Json dry_run(const Json& request, const std::string& method, const std::string& path) { Json o = Json::object(); o.set("dry_run", Json(true)); o.set("would_send_to", Json(method + " " + path)); o.set("request", request); o.set("hint", Json("send confirm:true to run it")); return o; } bk::ConverseRequest converse_request(const Json& b) { bk::ConverseRequest r; r.model_id = text(b, "model"); if (r.model_id.empty()) r.model_id = bk::BedrockChatModel::kDefaultModel; std::string system = text(b, "system"); if (!system.empty()) r.add_system(system); r.add_user(text(b, "prompt", true)); r.max_tokens = number(b, "max_tokens"); r.temperature = real(b, "temperature"); r.top_p = real(b, "top_p"); r.stop_sequences = strings(b, "stop"); r.effort = text(b, "effort"); r.guardrail_id = text(b, "guardrail_id"); r.guardrail_version = text(b, "guardrail_version"); r.service_tier = text(b, "service_tier"); r.latency = text(b, "latency"); r.additional_fields = object_at(b, "additional_fields"); return r; } // One route = validate into a Plan, then the generic runner decides dry run, // credential, call and error mapping. struct Plan { Json request; // what would be sent (shown in a dry run) std::string method = "POST"; std::string path; bool needs_confirm = false; std::function call; }; class BedrockRoutes { public: explicit BedrockRoutes(std::shared_ptr client) : client_(std::move(client)) {} const bk::BedrockClient& client() const { return *client_; } using Planner = std::function; fw::Response run(const fw::Request& req, const Planner& planner) const { Json body = parse_body(req); Plan plan; try { plan = planner(body); } catch (const llm::ApiError& e) { map(e); } if (plan.needs_confirm && !flag(body, "confirm")) return json_out(dry_run(plan.request, plan.method, plan.path)); try { return json_out(plan.call()); } catch (const llm::ApiError& e) { map(e); } } // ---- planners ----------------------------------------------------------- Plan converse(const Json& b) const { bk::ConverseRequest r = converse_request(b); Json wire = r.to_json(false); auto rt = std::make_shared(client_); Plan pl{wire, "POST", bk::Calls::render(bk::Call::kConverse, {{"modelId", r.model_id}}), true, nullptr}; pl.call = [rt, r] { return converse_json(rt->converse(r)); }; return pl; } Plan converse_stream(const Json& b) const { bk::ConverseRequest r = converse_request(b); Json wire = r.to_json(true); auto rt = std::make_shared(client_); Plan pl{wire, "POST", bk::Calls::render(bk::Call::kConverseStream, {{"modelId", r.model_id}}), true, nullptr}; pl.call = [rt, r] { std::size_t events = 0; bk::ConverseResult res = rt->converse_stream(r, [&](const bk::StreamDelta&) { return ++events < bk::BedrockCaps::kMaxStreamEvents; }); Json o = converse_json(res); o.set("events", Json(static_cast(events))); return o; }; return pl; } Plan invoke(const Json& b) const { std::string model = text(b, "model", true); Json body = object_at(b, "body", true); bk::InvokeOptions opt; if (std::string ct = text(b, "content_type"); !ct.empty()) opt.content_type = ct; opt.trace = text(b, "trace"); opt.guardrail_id = text(b, "guardrail_id"); opt.guardrail_version = text(b, "guardrail_version"); opt.service_tier = text(b, "service_tier"); opt.latency = text(b, "latency"); opt.validate(); if (!bk::Calls::valid_path_value(model)) bad("model has invalid characters"); auto rt = std::make_shared(client_); Plan pl{body, "POST", bk::Calls::render(bk::Call::kInvokeModel, {{"modelId", model}}), true, nullptr}; pl.call = [rt, model, body, opt] { bk::InvokeResult r = rt->invoke_model(model, body, opt); Json o = Json::object(); o.set("content_type", Json(r.content_type)); try { o.set("body", r.json()); } catch (const llm::ApiError&) { o.set("body_text", Json(r.body.substr(0, 20000))); } return o; }; return pl; } Plan invoke_stream(const Json& b) const { std::string model = text(b, "model", true); Json body = object_at(b, "body", true); if (!bk::Calls::valid_path_value(model)) bad("model has invalid characters"); auto rt = std::make_shared(client_); Plan pl{body, "POST", bk::Calls::render(bk::Call::kInvokeModelStream, {{"modelId", model}}), true, nullptr}; pl.call = [rt, model, body] { Json chunks = Json::array(); std::size_t n = rt->invoke_model_stream(model, body, [&](const std::string& c) { chunks.push(Json(c.substr(0, 4000))); return chunks.as_array().size() < kMaxStreamChunks; }); Json o = Json::object(); o.set("chunks", chunks); o.set("count", Json(static_cast(n))); return o; }; return pl; } Plan count_tokens(const Json& b) const { bk::ConverseRequest r = converse_request(b); Json wire = r.to_count_json(); auto rt = std::make_shared(client_); Plan pl{wire, "POST", bk::Calls::render(bk::Call::kCountTokens, {{"modelId", r.model_id}}), false, nullptr}; pl.call = [rt, r] { Json o = Json::object(); o.set("input_tokens", Json(static_cast(rt->count_tokens(r)))); return o; }; return pl; } Plan guardrail(const Json& b) const { std::string id = text(b, "guardrail_id", true); std::string version = text(b, "version"); if (version.empty()) version = "DRAFT"; std::string source = text(b, "source"); if (source.empty()) source = "INPUT"; std::string scope = text(b, "scope"); Json block = bk::Runtime::guardrail_text(text(b, "text", true), strings(b, "qualifiers")); if (!bk::Calls::valid_path_value(id) || !bk::Calls::valid_path_value(version)) bad("guardrail id or version has invalid characters"); if (source != "INPUT" && source != "OUTPUT") bad("source must be INPUT or OUTPUT"); if (!scope.empty() && scope != "INTERVENTIONS" && scope != "FULL") bad("scope must be INTERVENTIONS or FULL"); Json req = Json::object(); req.set("source", Json(source)); Json content = Json::array(); content.push(block); req.set("content", content); auto rt = std::make_shared(client_); Plan pl{req, "POST", bk::Calls::render(bk::Call::kApplyGuardrail, {{"guardrailIdentifier", id}, {"guardrailVersion", version}}), true, nullptr}; pl.call = [rt, id, version, source, block, scope] { bk::GuardrailResult r = rt->apply_guardrail(id, version, source, {block}, scope); Json o = Json::object(); o.set("action", Json(r.action())); o.set("intervened", Json(r.intervened())); o.set("output_text", Json(r.output_text())); o.set("raw", r.raw); return o; }; return pl; } Plan agent(const Json& b) const { bk::AgentInvokeParams p; p.agent_id = text(b, "agent_id", true); p.alias_id = text(b, "alias_id", true); p.session_id = text(b, "session_id", true); p.input_text = text(b, "prompt", true); p.enable_trace = flag(b, "trace"); p.end_session = flag(b, "end_session"); p.memory_id = text(b, "memory_id"); Json wire = p.to_json(); auto ar = std::make_shared(client_); Plan pl{wire, "POST", bk::Calls::render(bk::Call::kInvokeAgent, {{"agentId", p.agent_id}, {"agentAliasId", p.alias_id}, {"sessionId", p.session_id}}), true, nullptr}; pl.call = [ar, p] { bk::AgentResult r = ar->invoke_agent(p); Json o = Json::object(); o.set("text", Json(r.text)); o.set("session_id", Json(r.session_id)); o.set("chunks", Json(static_cast(r.chunks))); o.set("traces", Json(static_cast(r.traces.as_array().size()))); o.set("return_control", r.return_control); return o; }; return pl; } Plan retrieve(const Json& b) const { bk::RetrieveParams p; p.knowledge_base_id = text(b, "knowledge_base_id", true); p.query = text(b, "query", true); p.number_of_results = number(b, "number_of_results").value_or(0); p.search_type = text(b, "search_type"); p.next_token = text(b, "next_token"); if (const Json* f = b.find("filter"); f && f->is_object()) p.filter = *f; Json wire = p.to_json(); auto ar = std::make_shared(client_); Plan pl{wire, "POST", bk::Calls::render(bk::Call::kRetrieve, {{"knowledgeBaseId", p.knowledge_base_id}}), true, nullptr}; pl.call = [ar, p] { bk::RetrieveResult r = ar->retrieve(p); Json o = Json::object(); o.set("results", r.results); o.set("count", Json(static_cast(r.results.as_array().size()))); if (!r.next_token.empty()) o.set("next_token", Json(r.next_token)); if (!r.guardrail_action.empty()) o.set("guardrail_action", Json(r.guardrail_action)); return o; }; return pl; } Plan models(const Json& b) const { std::string action = text(b, "action"); if (action.empty()) action = "list"; auto api = std::make_shared(client_); if (action == "list") { bk::ModelFilter f; f.provider = text(b, "provider"); f.output_modality = text(b, "output_modality"); f.inference_type = text(b, "inference_type"); f.customization_type = text(b, "customization_type"); Json req = Json::object(); req.set("provider", Json(f.provider)); return Plan{req, "GET", "/foundation-models", false, [api, f] { return list_json(api->list(f), "models"); }}; } if (action == "get") { std::string id = text(b, "id", true); if (!bk::Calls::valid_path_value(id)) bad("id has invalid characters"); Json req = Json::object(); req.set("id", Json(id)); return Plan{req, "GET", bk::Calls::render(bk::Call::kGetFoundationModel, {{"modelIdentifier", id}}), false, [api, id] { Json o = Json::object(); o.set("model", api->get(id)); return o; }}; } bad("action must be list or get"); } Plan profiles(const Json& b) const { std::string action = text(b, "action"); if (action.empty()) action = "list"; auto api = std::make_shared(client_); if (action == "list") { std::string type = text(b, "type"); int max = number(b, "max_results").value_or(100); if (max < 1 || max > bk::BedrockCaps::kMaxResults) bad("max_results must be 1..1000"); Json req = Json::object(); req.set("type", Json(type)); return Plan{req, "GET", "/inference-profiles", false, [api, type, max] { return list_json(api->list_profiles(type, max), "profiles"); }}; } if (action == "get") { std::string id = text(b, "id", true); if (!bk::Calls::valid_path_value(id)) bad("id has invalid characters"); Json req = Json::object(); req.set("id", Json(id)); return Plan{req, "GET", bk::Calls::render(bk::Call::kGetInferenceProfile, {{"inferenceProfileIdentifier", id}}), false, [api, id] { Json o = Json::object(); o.set("profile", api->get_profile(id)); return o; }}; } bad("action must be list or get"); } Plan guardrails(const Json& b) const { std::string action = text(b, "action"); if (action.empty()) action = "list"; auto api = std::make_shared(client_); if (action == "list") { std::string id = text(b, "id"); if (!id.empty() && !bk::Calls::valid_path_value(id)) bad("id has invalid characters"); Json req = Json::object(); req.set("id", Json(id)); return Plan{req, "GET", "/guardrails", false, [api, id] { return list_json(api->list(id), "guardrails"); }}; } if (action == "get") { std::string id = text(b, "id", true); std::string version = text(b, "version"); if (!bk::Calls::valid_path_value(id)) bad("id has invalid characters"); Json req = Json::object(); req.set("id", Json(id)); return Plan{req, "GET", bk::Calls::render(bk::Call::kGetGuardrail, {{"guardrailIdentifier", id}}), false, [api, id, version] { Json o = Json::object(); o.set("guardrail", api->get(id, version)); return o; }}; } bad("action must be list or get"); } Plan batch(const Json& b) const { std::string action = text(b, "action", true); auto api = std::make_shared(client_); if (action == "list") { std::string status = text(b, "status"), name = text(b, "name_contains"); Json req = Json::object(); req.set("status", Json(status)); return Plan{req, "GET", "/model-invocation-jobs", false, [api, status, name] { return list_json(api->list(status, name), "jobs"); }}; } if (action == "get" || action == "stop") { std::string id = text(b, "id", true); if (!bk::Calls::valid_path_value(id)) bad("id has invalid characters"); Json req = Json::object(); req.set("id", Json(id)); if (action == "get") return Plan{req, "GET", bk::Calls::render(bk::Call::kGetBatchJob, {{"jobIdentifier", id}}), false, [api, id] { Json o = Json::object(); o.set("job", api->get(id)); return o; }}; return Plan{req, "POST", bk::Calls::render(bk::Call::kStopBatchJob, {{"jobIdentifier", id}}), true, [api, id] { api->stop(id); Json o = Json::object(); o.set("stopping", Json(id)); return o; }}; } if (action == "create") { bk::BatchJobParams p; p.job_name = text(b, "job_name", true); p.role_arn = text(b, "role_arn", true); p.model_id = text(b, "model", true); p.input_s3_uri = text(b, "input_s3_uri", true); p.output_s3_uri = text(b, "output_s3_uri", true); p.invocation_type = text(b, "invocation_type"); p.timeout_hours = number(b, "timeout_hours").value_or(0); Json wire = p.to_json(); return Plan{wire, "POST", "/model-invocation-job", true, [api, p] { Json o = Json::object(); o.set("job_arn", Json(api->create(p))); return o; }}; } bad("action must be list, get, create or stop"); } // Local: signs with AWS's documentation credentials, never a real secret. Plan sign(const Json& b) const { bk::AwsCredentials creds{"AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY", ""}; std::string region = text(b, "region"); if (region.empty()) region = "us-east-1"; if (!bk::Endpoints::valid_region(region)) bad("bad region name"); std::string service = text(b, "service"); if (service.empty()) service = "bedrock"; std::string method = text(b, "method"); if (method.empty()) method = "GET"; if (method != "GET" && method != "POST" && method != "PUT" && method != "DELETE" && method != "PATCH") bad("unsupported method"); bk::SigV4Request r; r.method = method; r.path = text(b, "path"); if (r.path.empty()) r.path = "/"; if (r.path[0] != '/') bad("path must start with /"); r.query = text(b, "query"); r.body = text(b, "body"); std::string host = text(b, "host"); r.headers.emplace_back("Host", host.empty() ? "example.amazonaws.com" : host); std::string date = text(b, "date"); if (date.empty()) date = "20150830T123600Z"; Json req = Json::object(); req.set("method", Json(method)); req.set("path", Json(r.path)); Plan pl{req, "LOCAL", "", false, nullptr}; pl.call = [creds, region, service, r, date] { bk::SigV4Result s = bk::SigV4Signer(creds, region, service).sign(r, date); Json o = Json::object(); o.set("canonical_request", Json(s.canonical_request)); o.set("string_to_sign", Json(s.string_to_sign)); o.set("signed_headers", Json(s.signed_headers)); o.set("signature", Json(s.signature)); o.set("authorization", Json(s.authorization)); o.set("note", Json("signed with AWS documentation credentials, not yours")); return o; }; return pl; } private: [[noreturn]] static void map(const llm::ApiError& e) { if (e.http_status() == 503 && e.type() == "NOT_CONFIGURED") throw fw::HttpError(503, "not_configured", e.message()); if (e.type() == "INVALID_ARGUMENT" && e.http_status() == 400 && e.request_id().empty()) throw fw::HttpError(422, "validation_error", e.message()); throw fw::HttpError(502, "bedrock_error", std::to_string(e.http_status()) + " " + e.type() + ": " + e.message()); } std::shared_ptr client_; }; } // namespace void register_ai_bedrock_demo(fw::Router& router, Services& services) { auto routes = std::make_shared(bk::BedrockClient::from_env()); fw::Environment* env = services.templates.get(); services.templates->add_template("ai_bedrock.html", kPage); services.add_feature("ai-bedrock", "/ai/bedrock"); router.get("/ai/bedrock", "ai-bedrock-page", [env](fw::Request req) { (void)req; fw::TemplateCtx ctx; ctx["title"] = std::string("Amazon Bedrock"); return fw::Response(200, env->render("ai_bedrock.html", ctx), "text/html; charset=utf-8"); }); router.get("/ai/bedrock/status", "ai-bedrock-status", [routes](fw::Request req) { (void)req; const bk::Credentials& c = routes->client().credentials(); Json o = Json::object(); o.set("configured", Json(routes->client().configured())); o.set("auth_mode", Json(c.mode_name())); o.set("region", Json(c.region)); Json env = Json::array(); for (const char* n : {bk::Credentials::kEnvBearer, bk::Credentials::kEnvAccessKey, bk::Credentials::kEnvSecretKey, bk::Credentials::kEnvSessionToken, bk::Credentials::kEnvRegion}) env.push(Json(n)); o.set("credential_env", env); Json hosts = Json::object(); hosts.set("runtime", Json(bk::Endpoints::host(bk::AwsService::kRuntime, c.region))); hosts.set("control", Json(bk::Endpoints::host(bk::AwsService::kControl, c.region))); hosts.set("agent_runtime", Json(bk::Endpoints::host(bk::AwsService::kAgentRuntime, c.region))); o.set("hosts", hosts); o.set("default_model", Json(bk::BedrockChatModel::kDefaultModel)); o.set("calls", Json(static_cast(bk::Calls::count()))); o.set("max_invoke_body_bytes", Json(static_cast(bk::BedrockCaps::kMaxInvokeBodyBytes))); o.set("max_pages", Json(static_cast(bk::BedrockCaps::kMaxPages))); return json_out(o); }); router.get("/ai/bedrock/calls", "ai-bedrock-calls", [](fw::Request req) { (void)req; Json arr = Json::array(); for (std::size_t i = 0; i < bk::Calls::count(); ++i) { const bk::CallSpec& s = bk::Calls::at(i); Json row = Json::object(); row.set("operation", Json(s.op)); row.set("http", Json(s.http_method)); row.set("path", Json(s.uri)); row.set("host", Json(bk::Endpoints::prefix(s.service))); row.set("bearer_ok", Json(s.bearer_ok)); row.set("event_stream", Json(s.event_stream)); arr.push(row); } Json o = Json::object(); o.set("calls", arr); return json_out(o); }); using Member = BedrockRoutes::Planner; auto add = [&](const char* path, const char* name, Member planner) { router.post(path, name, [routes, planner](fw::Request req) { return routes->run(req, planner); }); }; BedrockRoutes* r = routes.get(); auto bind = [r](Plan (BedrockRoutes::*m)(const Json&) const) { return Member([r, m](const Json& b) { return (r->*m)(b); }); }; add("/ai/bedrock/converse", "ai-bedrock-converse", bind(&BedrockRoutes::converse)); add("/ai/bedrock/converse-stream", "ai-bedrock-converse-stream", bind(&BedrockRoutes::converse_stream)); add("/ai/bedrock/invoke", "ai-bedrock-invoke", bind(&BedrockRoutes::invoke)); add("/ai/bedrock/invoke-stream", "ai-bedrock-invoke-stream", bind(&BedrockRoutes::invoke_stream)); add("/ai/bedrock/count-tokens", "ai-bedrock-count-tokens", bind(&BedrockRoutes::count_tokens)); add("/ai/bedrock/guardrail", "ai-bedrock-guardrail", bind(&BedrockRoutes::guardrail)); add("/ai/bedrock/agent", "ai-bedrock-agent", bind(&BedrockRoutes::agent)); add("/ai/bedrock/retrieve", "ai-bedrock-retrieve", bind(&BedrockRoutes::retrieve)); add("/ai/bedrock/models", "ai-bedrock-models", bind(&BedrockRoutes::models)); add("/ai/bedrock/profiles", "ai-bedrock-profiles", bind(&BedrockRoutes::profiles)); add("/ai/bedrock/guardrails", "ai-bedrock-guardrails", bind(&BedrockRoutes::guardrails)); add("/ai/bedrock/batch", "ai-bedrock-batch", bind(&BedrockRoutes::batch)); add("/ai/bedrock/sign", "ai-bedrock-sign", bind(&BedrockRoutes::sign)); } } // namespace molo::example::app