mirror of
https://github.com/hanzo-cpp/sdk.git
synced 2026-11-20 19:55:32 +00:00
The lock sat at 574d1f1d while the product moved on. The team surface stopped at rooms — no messages path, no way to open one — so anything built on this client had to reach past it with its own HTTP calls, which is the duplication a generated client exists to prevent.
2914 lines
162 KiB
C++
2914 lines
162 KiB
C++
/**
|
|
* Hanzo Cloud API
|
|
* The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
*
|
|
* The version of the OpenAPI document: v1
|
|
*
|
|
* NOTE: This class is auto generated by OpenAPI-Generator 7.14.0.
|
|
* https://openapi-generator.tech
|
|
* Do not edit the class manually.
|
|
*/
|
|
|
|
/*
|
|
* AiApi.h
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifndef HANZO_API_AiApi_H_
|
|
#define HANZO_API_AiApi_H_
|
|
|
|
|
|
|
|
#include "hanzo/ApiClient.h"
|
|
|
|
#include "hanzo/model/AiMCPSurface.h"
|
|
#include "hanzo/model/Ai_AnthropicResponse.h"
|
|
#include "hanzo/model/Ai_ModelList.h"
|
|
#include "hanzo/model/Ai_Ranking.h"
|
|
#include "hanzo/model/Ai_Response.h"
|
|
#include "hanzo/model/Ai_ResponsesResource.h"
|
|
#include "hanzo/model/Ai_TokenCount.h"
|
|
#include "hanzo/model/Ai_VideoStatus.h"
|
|
#include "hanzo/model/DocSearchResult.h"
|
|
#include "hanzo/model/Envelope.h"
|
|
#include "hanzo/model/Get_ai_activities_200_response.h"
|
|
#include "hanzo/model/Get_ai_articles_200_response.h"
|
|
#include "hanzo/model/Get_ai_assets_200_response.h"
|
|
#include "hanzo/model/Get_ai_chats_200_response.h"
|
|
#include "hanzo/model/Get_ai_connections_200_response.h"
|
|
#include "hanzo/model/Get_ai_connections_by_provider_authorize_200_response.h"
|
|
#include "hanzo/model/Get_ai_connections_by_provider_usage_200_response.h"
|
|
#include "hanzo/model/Get_ai_deployments_200_response.h"
|
|
#include "hanzo/model/Get_ai_files_200_response.h"
|
|
#include "hanzo/model/Get_ai_finetune_hf_datasets_200_response.h"
|
|
#include "hanzo/model/Get_ai_finetune_hf_models_200_response.h"
|
|
#include "hanzo/model/Get_ai_finetune_hf_repo_200_response.h"
|
|
#include "hanzo/model/Get_ai_finetune_jobs_200_response.h"
|
|
#include "hanzo/model/Get_ai_finetune_presets_200_response.h"
|
|
#include "hanzo/model/Get_ai_forms_200_response.h"
|
|
#include "hanzo/model/Get_ai_graphs_200_response.h"
|
|
#include "hanzo/model/Get_ai_memory_facts_200_response.h"
|
|
#include "hanzo/model/Get_ai_messages_200_response.h"
|
|
#include "hanzo/model/Get_ai_nodes_200_response.h"
|
|
#include "hanzo/model/Get_ai_providers_200_response.h"
|
|
#include "hanzo/model/Get_ai_records_200_response.h"
|
|
#include "hanzo/model/Get_ai_remote_connections_200_response.h"
|
|
#include "hanzo/model/Get_ai_router_history_200_response.h"
|
|
#include "hanzo/model/Get_ai_router_judge_panel_200_response.h"
|
|
#include "hanzo/model/Get_ai_router_stats_200_response.h"
|
|
#include "hanzo/model/Get_ai_routes_200_response.h"
|
|
#include "hanzo/model/Get_ai_scales_200_response.h"
|
|
#include "hanzo/model/Get_ai_scans_200_response.h"
|
|
#include "hanzo/model/Get_ai_signin_sessions_200_response.h"
|
|
#include "hanzo/model/Get_ai_stores_200_response.h"
|
|
#include "hanzo/model/Get_ai_tasks_200_response.h"
|
|
#include "hanzo/model/Get_ai_templates_200_response.h"
|
|
#include "hanzo/model/Get_ai_traffic_globe_200_response.h"
|
|
#include "hanzo/model/Get_ai_usages_200_response.h"
|
|
#include "hanzo/model/Get_ai_vectors_200_response.h"
|
|
#include "hanzo/model/Get_ai_videos_200_response.h"
|
|
#include "hanzo/model/Get_ai_workflows_200_response.h"
|
|
#include "hanzo/model/Get_models_providers_200_response.h"
|
|
#include "hanzo/model/Openai_AudioResponse.h"
|
|
#include "hanzo/model/Openai_ChatCompletionResponse.h"
|
|
#include "hanzo/model/Openai_EmbeddingResponse.h"
|
|
#include "hanzo/model/Openai_ImageResponse.h"
|
|
#include "hanzo/model/Post_ai_articles_200_response.h"
|
|
#include "hanzo/model/Post_ai_assets_200_response.h"
|
|
#include "hanzo/model/Post_ai_chats_200_response.h"
|
|
#include "hanzo/model/Post_ai_connections_200_response.h"
|
|
#include "hanzo/model/Post_ai_deployments_200_response.h"
|
|
#include "hanzo/model/Post_ai_feedback_200_response.h"
|
|
#include "hanzo/model/Post_ai_files_200_response.h"
|
|
#include "hanzo/model/Post_ai_finetune_cancel_200_response.h"
|
|
#include "hanzo/model/Post_ai_finetune_deploy_200_response.h"
|
|
#include "hanzo/model/Post_ai_forms_200_response.h"
|
|
#include "hanzo/model/Post_ai_graphs_200_response.h"
|
|
#include "hanzo/model/Post_ai_memory_delete_200_response.h"
|
|
#include "hanzo/model/Post_ai_memory_remember_200_response.h"
|
|
#include "hanzo/model/Post_ai_messages_200_response.h"
|
|
#include "hanzo/model/Post_ai_nodes_200_response.h"
|
|
#include "hanzo/model/Post_ai_providers_200_response.h"
|
|
#include "hanzo/model/Post_ai_rag_embed_200_response.h"
|
|
#include "hanzo/model/Post_ai_rag_ingest_200_response.h"
|
|
#include "hanzo/model/Post_ai_records_200_response.h"
|
|
#include "hanzo/model/Post_ai_remote_connections_200_response.h"
|
|
#include "hanzo/model/Post_ai_routes_200_response.h"
|
|
#include "hanzo/model/Post_ai_scales_200_response.h"
|
|
#include "hanzo/model/Post_ai_scans_200_response.h"
|
|
#include "hanzo/model/Post_ai_signin_sessions_200_response.h"
|
|
#include "hanzo/model/Post_ai_stores_200_response.h"
|
|
#include "hanzo/model/Post_ai_tasks_200_response.h"
|
|
#include "hanzo/model/Post_ai_templates_200_response.h"
|
|
#include "hanzo/model/Post_ai_tree_files_200_response.h"
|
|
#include "hanzo/model/Post_ai_vectors_200_response.h"
|
|
#include "hanzo/model/Post_ai_videos_200_response.h"
|
|
#include "hanzo/model/Post_ai_workflows_200_response.h"
|
|
#include "hanzo/model/Post_models_by_model_access_200_response.h"
|
|
#include <vector>
|
|
#include <cpprest/details/basic_types.h>
|
|
#include <boost/optional.hpp>
|
|
|
|
namespace hanzo {
|
|
namespace api {
|
|
|
|
using namespace hanzo::model;
|
|
|
|
|
|
|
|
class AiApi
|
|
{
|
|
public:
|
|
|
|
explicit AiApi( std::shared_ptr<const ApiClient> apiClient );
|
|
|
|
virtual ~AiApi();
|
|
|
|
/// <summary>
|
|
/// Tools reports what THIS PROCESS's MCP server carries: how many tools its own registry projects, optionally their names, and which subsystems this process composed.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Tools reports what THIS PROCESS's MCP server carries: how many tools its own registry projects, optionally their names, and which subsystems this process composed. It is the answer to \"is this MCP server up and does it have anything behind it\" — a question a status code cannot answer, since an empty server and a full one are both 200. What the FLEET's server carries is the fleet server's own answer: POST /v1/mcp, tools/list, which asks every subsystem and names the ones that did not reply.
|
|
/// </remarks>
|
|
/// <param name="names">Names asks for this process's tool NAMES and not only how many there are. Off by default: a list of names is a page, and the question this op exists to answer (\"is the MCP server up and does it have anything behind it\") is answered by the count. (optional, default to false)</param>
|
|
pplx::task<std::shared_ptr<AiMCPSurface>> aiMCPTools(
|
|
boost::optional<bool> names
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a article
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one article.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_articles_200_response>> deleteAiArticlesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a asset
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one asset.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_assets_200_response>> deleteAiAssetsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a chat
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one chat.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_chats_200_response>> deleteAiChatsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Disconnects a third-party AI account: it deactivates the org's row so completion resolution falls back to the global Hanzo account (no BYO), and best-effort tombstones the sealed secret.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Disconnects a third-party AI account: it deactivates the org's row so completion resolution falls back to the global Hanzo account (no BYO), and best-effort tombstones the sealed secret. Idempotent.
|
|
/// </remarks>
|
|
/// <param name="provider"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_connections_200_response>> deleteAiConnectionsByProvider(
|
|
utility::string_t provider
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a application
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one application.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_deployments_200_response>> deleteAiDeploymentsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one file.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_files_200_response>> deleteAiFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a form
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one form.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_forms_200_response>> deleteAiFormsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a graph
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one graph.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_graphs_200_response>> deleteAiGraphsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a message
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one message.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_messages_200_response>> deleteAiMessagesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Welcome (message)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> deleteAiMessagesWelcome(
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a node
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one node.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_nodes_200_response>> deleteAiNodesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiOrgSettings(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiOrgSettingsList(
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a provider
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one provider.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_providers_200_response>> deleteAiProvidersByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a record
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one record.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_records_200_response>> deleteAiRecordsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a connection
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one connection.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_remote_connections_200_response>> deleteAiRemoteConnectionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiRouterArtifactMeta(
|
|
) const;
|
|
/// <summary>
|
|
/// Router Data
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> deleteAiRouterData(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiRouterDefaults(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiRouterLedger(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiRouterPolicy(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> deleteAiRouterRewards(
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a model-route
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one model-route.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_routes_200_response>> deleteAiRoutesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a scale
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one scale.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scales_200_response>> deleteAiScalesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a scan
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one scan.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scans_200_response>> deleteAiScansByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a session
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one session.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_signin_sessions_200_response>> deleteAiSigninSessionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a store
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one store.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_stores_200_response>> deleteAiStoresByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a task
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one task.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tasks_200_response>> deleteAiTasksByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a template
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one template.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_templates_200_response>> deleteAiTemplatesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a tree-file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one tree-file.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tree_files_200_response>> deleteAiTreeFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// All (vector)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> deleteAiVectorsAll(
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a vector
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one vector.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_vectors_200_response>> deleteAiVectorsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a video
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one video.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_videos_200_response>> deleteAiVideosByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Delete a workflow
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one workflow.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_workflows_200_response>> deleteAiWorkflowsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Account
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiAccount(
|
|
) const;
|
|
/// <summary>
|
|
/// List activities
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's activities.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_activities_200_response>> getAiActivities(
|
|
) const;
|
|
/// <summary>
|
|
/// Answer
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiAnswer(
|
|
) const;
|
|
/// <summary>
|
|
/// List articles
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's articles.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_articles_200_response>> getAiArticles(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a article
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one article by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_articles_200_response>> getAiArticlesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List articles across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_articles_200_response>> getAiArticlesGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// List assets
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's assets.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_assets_200_response>> getAiAssets(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a asset
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one asset by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_assets_200_response>> getAiAssetsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List chats
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's chats.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_chats_200_response>> getAiChats(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a chat
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one chat by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_chats_200_response>> getAiChatsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List chats across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_chats_200_response>> getAiChatsGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Lists the org's connectable AI accounts and whether each is currently connected.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Lists the org's connectable AI accounts and whether each is currently connected. Never returns a key or a kms:// reference.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_connections_200_response>> getAiConnections(
|
|
) const;
|
|
/// <summary>
|
|
/// Begins an OAuth connection for the caller's org: it binds the org into a signed state and sends the caller to the provider's authorize URL.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Begins an OAuth connection for the caller's org: it binds the org into a signed state and sends the caller to the provider's authorize URL. By default it 302-redirects (a top-level browser \"connect your login\" click); a SPA/BFF that needs to drive the redirect itself passes ?format=json and gets {authorizeUrl} in the standard envelope. The org is the VERIFIED principal, so only the caller's own connection can result.
|
|
/// </remarks>
|
|
/// <param name="provider"></param>
|
|
pplx::task<std::shared_ptr<Get_ai_connections_by_provider_authorize_200_response>> getAiConnectionsByProviderAuthorize(
|
|
utility::string_t provider
|
|
) const;
|
|
/// <summary>
|
|
/// Completes OAuth: the org is recovered from the SIGNED state (not a header), the code is exchanged for a token, the token is SEALED into KMS (never the row/logs) through the same path as a BYOK key, and the org's provider row is upserted to \"connected\".
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Completes OAuth: the org is recovered from the SIGNED state (not a header), the code is exchanged for a token, the token is SEALED into KMS (never the row/logs) through the same path as a BYOK key, and the org's provider row is upserted to \"connected\". The browser is then redirected back to the console with ?ai_connected=<provider> (or ?ai_connect_error=<provider> on failure). Because the org comes from the state THIS server signed, an attacker cannot land their token in a victim org — which is why this endpoint is state-authenticated rather than credential-gated.
|
|
/// </remarks>
|
|
/// <param name="provider"></param>
|
|
pplx::task<void> getAiConnectionsByProviderCallback(
|
|
utility::string_t provider
|
|
) const;
|
|
/// <summary>
|
|
/// Imports the caller org's usage for a connected third-party account.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Imports the caller org's usage for a connected third-party account. The org is resolved from the VERIFIED principal (requireConnectionOrg), so a tenant reads only its own connection. The key is unsealed SERVER-SIDE and never returned. An unconnected account, a missing importer, or a scope-denied provider all return a 200 ProviderUsage with connected/available flags + a human note — the UI's honest-empty states — never a fabricated figure.
|
|
/// </remarks>
|
|
/// <param name="provider"></param>
|
|
pplx::task<std::shared_ptr<Get_ai_connections_by_provider_usage_200_response>> getAiConnectionsByProviderUsage(
|
|
utility::string_t provider
|
|
) const;
|
|
/// <summary>
|
|
/// Dashboards Agents
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiDashboardsAgents(
|
|
) const;
|
|
/// <summary>
|
|
/// Dashboards Vm
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiDashboardsVm(
|
|
) const;
|
|
/// <summary>
|
|
/// List deployments
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's deployments.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_deployments_200_response>> getAiDeployments(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a application
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one application by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_deployments_200_response>> getAiDeploymentsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List files
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's files.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_files_200_response>> getAiFiles(
|
|
) const;
|
|
/// <summary>
|
|
/// Active (file)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiFilesActive(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one file by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_files_200_response>> getAiFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List files across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_files_200_response>> getAiFilesGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Proxies a HuggingFace dataset search (dataset picker).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Proxies a HuggingFace dataset search (dataset picker).
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_finetune_hf_datasets_200_response>> getAiFinetuneHfDatasets(
|
|
) const;
|
|
/// <summary>
|
|
/// Proxies a HuggingFace model search (base-model picker).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Proxies a HuggingFace model search (base-model picker).
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_finetune_hf_models_200_response>> getAiFinetuneHfModels(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns a repo's detail (files, gated/private state).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns a repo's detail (files, gated/private state). ?id=&kind=model|dataset
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_finetune_hf_repo_200_response>> getAiFinetuneHfRepo(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns one job with refreshed live status.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns one job with refreshed live status. ?id=owner/name or ?name=
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_finetune_cancel_200_response>> getAiFinetuneJob(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the org's jobs, refreshing live status for active ones.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the org's jobs, refreshing live status for active ones.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_finetune_jobs_200_response>> getAiFinetuneJobs(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the new-job catalog plus, when a selection is passed (?baseModel&method&task&preset[&datasetExamples]), the recommended config so the console can render \"Recommended\" as a one-click, ready-to-run default.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the new-job catalog plus, when a selection is passed (?baseModel&method&task&preset[&datasetExamples]), the recommended config so the console can render \"Recommended\" as a one-click, ready-to-run default.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_finetune_presets_200_response>> getAiFinetunePresets(
|
|
) const;
|
|
/// <summary>
|
|
/// List forms
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's forms.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_forms_200_response>> getAiForms(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a form
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one form by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_forms_200_response>> getAiFormsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Data (form)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiFormsData(
|
|
) const;
|
|
/// <summary>
|
|
/// List forms across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_forms_200_response>> getAiFormsGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// List graphs
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's graphs.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_graphs_200_response>> getAiGraphs(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a graph
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one graph by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_graphs_200_response>> getAiGraphsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List graphs across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_graphs_200_response>> getAiGraphsGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// K8s Status
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiK8sStatus(
|
|
) const;
|
|
/// <summary>
|
|
/// List the authenticated user's stored facts
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the authenticated user's stored facts
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_memory_facts_200_response>> getAiMemoryFacts(
|
|
) const;
|
|
/// <summary>
|
|
/// List the authenticated user's memories, newest first
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the authenticated user's memories, newest first
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_memory_facts_200_response>> getAiMemoryList(
|
|
) const;
|
|
/// <summary>
|
|
/// Recall recent/relevant memories for context injection; with q it
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Recall recent/relevant memories for context injection; with q it ranks semantically, without q it returns the most recent
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_memory_facts_200_response>> getAiMemoryRecall(
|
|
) const;
|
|
/// <summary>
|
|
/// Search the authenticated user's memories (semantic, text fallback)
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Search the authenticated user's memories (semantic, text fallback)
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_memory_facts_200_response>> getAiMemorySearch(
|
|
) const;
|
|
/// <summary>
|
|
/// List messages
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's messages.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_messages_200_response>> getAiMessages(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a message
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one message by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_messages_200_response>> getAiMessagesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Answer (message)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiMessagesByOwnerByNameAnswer(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List nodes
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's nodes.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_nodes_200_response>> getAiNodes(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a node
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one node by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_nodes_200_response>> getAiNodesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Tunnel (node)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiNodesByOwnerByNameTunnel(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiOrgSettings(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiOrgSettingsList(
|
|
) const;
|
|
/// <summary>
|
|
/// Prometheus
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiPrometheus(
|
|
) const;
|
|
/// <summary>
|
|
/// List providers
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's providers.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_providers_200_response>> getAiProviders(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a provider
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one provider by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_providers_200_response>> getAiProvidersByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List providers across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_providers_200_response>> getAiProvidersGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Return every stored chunk of one file_id (full document context).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Return every stored chunk of one file_id (full document context). Consolidates the retired chat-rag-api GET /documents/{id}/context.
|
|
/// </remarks>
|
|
pplx::task<std::vector<std::shared_ptr<DocSearchResult>>> getAiRagContext(
|
|
) const;
|
|
/// <summary>
|
|
/// List records
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's records.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_records_200_response>> getAiRecords(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a record
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one record by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_records_200_response>> getAiRecordsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Query (record)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiRecordsQuery(
|
|
) const;
|
|
/// <summary>
|
|
/// Query Second (record)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiRecordsQuerySecond(
|
|
) const;
|
|
/// <summary>
|
|
/// List remote-connections
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's remote-connections.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_remote_connections_200_response>> getAiRemoteConnections(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a connection
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one connection by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_remote_connections_200_response>> getAiRemoteConnectionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiRouterArtifactMeta(
|
|
) const;
|
|
/// <summary>
|
|
/// Router Data
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiRouterData(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiRouterDefaults(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the router-improvement time-series.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the router-improvement time-series. Two scopes, one route, mirroring /v1/ai/router/stats: - ?scope=platform — PUBLIC-safe aggregate over ALL orgs, no authentication. Emits the daily reward/cost-saved/adoption series (task mix included, model ids NOT) and the retrain timeline. This is what world.hanzo.ai polls. - default (org scope) — requires a signed-in principal, scoped to the caller's OWN org (a super admin may pass ?org= to target another or \"\" for all). Window: ?days=N (default 30, capped at 90). Aggregates only.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_router_history_200_response>> getAiRouterHistory(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the LIVE Mean-Field Judge Panel state: the configured panel + dynamic judge posture (enabled/sample) resolved from the \"*\" GlobalDefaultOwner row, the live in-process per-judge calibration (weight/mean/n), and the static published benchmark.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the LIVE Mean-Field Judge Panel state: the configured panel + dynamic judge posture (enabled/sample) resolved from the \"*\" GlobalDefaultOwner row, the live in-process per-judge calibration (weight/mean/n), and the static published benchmark. PUBLIC-safe and platform-global (model ids + scalars only), so it rides the same unauthenticated, balance-exempt class as /v1/ai/router/stats?scope=platform — the world widget polls it with no auth. The judge state is a single in-process population (not per-org), so there is nothing to scope; ?scope=platform is accepted for symmetry with router-stats.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_router_judge_panel_200_response>> getAiRouterJudgePanel(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiRouterLedger(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiRouterPolicy(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> getAiRouterRewards(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the router observability aggregate.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the router observability aggregate. Two scopes, one route: - ?scope=platform — PUBLIC-safe aggregate over ALL orgs, no authentication. Emits rates, shares, per-task/per-model counts, throughput, and the cost RATIO (saved_pct) + counterfactual model id, but NEVER absolute $ levels, org identity, raw events, or feature vectors. This is what world.hanzo.ai polls. - default (org scope) — requires a signed-in principal; scoped to the caller's OWN org (a super admin may pass ?org= to target another org or \"\" for all). Carries the absolute $/MTok indices for the admin savings panel. Window: ?since= (RFC3339) or ?hours= (default 24, capped). Aggregates only.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_router_stats_200_response>> getAiRouterStats(
|
|
) const;
|
|
/// <summary>
|
|
/// List routes
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's routes.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_routes_200_response>> getAiRoutes(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a model-route
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one model-route by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_routes_200_response>> getAiRoutesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List scales
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's scales.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_scales_200_response>> getAiScales(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a scale
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one scale by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scales_200_response>> getAiScalesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List scales across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_scales_200_response>> getAiScalesGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Public (scale)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiScalesPublic(
|
|
) const;
|
|
/// <summary>
|
|
/// List scans
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's scans.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_scans_200_response>> getAiScans(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a scan
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one scan by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scans_200_response>> getAiScansByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List signin-sessions
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's signin-sessions.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_signin_sessions_200_response>> getAiSigninSessions(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a session
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one session by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_signin_sessions_200_response>> getAiSigninSessionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Duplicated (session)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiSigninSessionsDuplicated(
|
|
) const;
|
|
/// <summary>
|
|
/// List stores
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's stores.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_stores_200_response>> getAiStores(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a store
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one store by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_stores_200_response>> getAiStoresByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List stores across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_stores_200_response>> getAiStoresGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Names (store)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiStoresNames(
|
|
) const;
|
|
/// <summary>
|
|
/// Providers (store)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiStoresProviders(
|
|
) const;
|
|
/// <summary>
|
|
/// System
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiSystem(
|
|
) const;
|
|
/// <summary>
|
|
/// List tasks
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's tasks.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_tasks_200_response>> getAiTasks(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a task
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one task by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tasks_200_response>> getAiTasksByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List tasks across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_tasks_200_response>> getAiTasksGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// List templates
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's templates.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_templates_200_response>> getAiTemplates(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a template
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one template by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_templates_200_response>> getAiTemplatesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the PUBLIC live request-geo aggregate for the world.hanzo.ai \"Hanzo mode\" globe: WHERE requests to api.hanzo.ai are coming from, as country/region points with per-service-class counts, plus headline throughput rates.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the PUBLIC live request-geo aggregate for the world.hanzo.ai \"Hanzo mode\" globe: WHERE requests to api.hanzo.ai are coming from, as country/region points with per-service-class counts, plus headline throughput rates. It is AUTH-exempt and BALANCE-exempt exactly like /v1/ai/router/stats?scope=platform: - auth: the controller name \"traffic/globe\" is neither a get-/update- CRUD name nor a super-admin/present-credential endpoint, so the authz filter passes it through, and this handler requires no principal. - balance: isBalanceExempt(\"/v1/ai/traffic/...\") returns true. It exposes ONLY aggregates — counts, rates, and country/region centroids — and NEVER any IP, per-request row, org, or user dimension (see object/traffic.go). Marketing telemetry; nothing sensitive.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_traffic_globe_200_response>> getAiTrafficGlobe(
|
|
) const;
|
|
/// <summary>
|
|
/// Training Contribution
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiTrainingContribution(
|
|
) const;
|
|
/// <summary>
|
|
/// List usages
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's usages.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_usages_200_response>> getAiUsages(
|
|
) const;
|
|
/// <summary>
|
|
/// By User (usage)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiUsagesByUser(
|
|
) const;
|
|
/// <summary>
|
|
/// Cloud (usage)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiUsagesCloud(
|
|
) const;
|
|
/// <summary>
|
|
/// Range (usage)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiUsagesRange(
|
|
) const;
|
|
/// <summary>
|
|
/// User Names (usage)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiUsagesUserNames(
|
|
) const;
|
|
/// <summary>
|
|
/// List vectors
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's vectors.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_vectors_200_response>> getAiVectors(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a vector
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one vector by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_vectors_200_response>> getAiVectorsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List vectors across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_vectors_200_response>> getAiVectorsGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Version
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> getAiVersion(
|
|
) const;
|
|
/// <summary>
|
|
/// List videos
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's videos.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_videos_200_response>> getAiVideos(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a video
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one video by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_videos_200_response>> getAiVideosByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List videos across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_videos_200_response>> getAiVideosGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// List workflows
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// List the caller's workflows.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_workflows_200_response>> getAiWorkflows(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve a workflow
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Read one workflow by its (owner, name) key.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_workflows_200_response>> getAiWorkflowsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// List workflows across tenants
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Cross-tenant listing. Admin-only; a tenant caller is refused.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_workflows_200_response>> getAiWorkflowsGlobal(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the list of available models from the routing table.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the list of available models from the routing table. PUBLIC BY DESIGN, AND IT DOES NOT AUTHENTICATE — that is the whole contract, so it is stated here rather than left to be inferred. The catalogue is the same for everyone (listAvailableModels takes no principal), docs.hanzo.ai fetches it from the browser, and every policy layer around it already says so out loud: the authz filter lists \"models\" as public, filter_balance refuses to gate it (a 402 here was a console-wide outage), the rate limiter excludes it, and cloud's spend.Reachable carries /v1/models/ as \"the model catalog the shell reads for discovery\". SO THE Authorization HEADER IS NOT AN ADMISSION CHECK HERE. It is read for ONE thing — annotating gated SKUs with the caller's own access standing — and annotation degrades to nothing when there is no verified principal. It used to hold a \"require authentication\" gate that authenticated nobody: it rejected an ABSENT credential and a MALFORMED one, then accepted any string that merely looked like a key. `Bearer sk-` followed by 36 zeroes returned 200 in production; so did a JWT three days expired. It was a shape check wearing an auth check's clothes, and its cost was diagnostic: /v1/models is the natural \"is my auth working?\" probe, and answering 200 to a dead credential sent people debugging the wrong system. A public endpoint must not appear to validate. Either check the credential or ignore it — this one ignores it, deliberately and visibly. Removing that gate discloses nothing new: the catalogue was already reachable by anyone willing to type three characters, so there is no confidentiality delta, only an honesty one.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_ModelList>> getModels(
|
|
) const;
|
|
/// <summary>
|
|
/// Returns the caller's own standing for a gated model: \"granted\", \"requested\", or empty when they have never asked.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Returns the caller's own standing for a gated model: \"granted\", \"requested\", or empty when they have never asked.
|
|
/// </remarks>
|
|
/// <param name="model"></param>
|
|
pplx::task<std::shared_ptr<Get_ai_connections_by_provider_authorize_200_response>> getModelsByModelAccess(
|
|
utility::string_t model
|
|
) const;
|
|
/// <summary>
|
|
/// Public, secret-free list of the providers serving the models that GET /v1/models lists — the same source, projected.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Public, secret-free list of the providers serving the models that GET /v1/models lists — the same source, projected. Safe unauthenticated: no keys, URLs, or config are returned, and it reports a SET of names, never which provider serves which model.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_models_providers_200_response>> getModelsProviders(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements GET /v1/videos/{id} — poll a job's status.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements GET /v1/videos/{id} — poll a job's status. It authenticates the caller, verifies they OWN the job (the caller's billing subject must equal the job's), performs ONE upstream status poll, and — the first time the job is observed completed — settles the reservation with the actual cost and records the billable usage event (exactly once). Returns the OpenAI-shaped video object.
|
|
/// </remarks>
|
|
/// <param name="id"></param>
|
|
pplx::task<std::shared_ptr<Ai_VideoStatus>> getVideosById(
|
|
utility::string_t id
|
|
) const;
|
|
/// <summary>
|
|
/// Implements GET /v1/videos/{id}/content — download the finished MP4.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements GET /v1/videos/{id}/content — download the finished MP4. It authenticates + ownership-checks the caller, then proxies the upstream /content endpoint (bounded by the download concurrency ceiling) and streams the raw video bytes back inline. A successful download also bills the job once (for the client that downloads without first polling to completion) — idempotent with the poll path via job.markCompleted.
|
|
/// </remarks>
|
|
/// <param name="id"></param>
|
|
pplx::task<void> getVideosByIdContent(
|
|
utility::string_t id
|
|
) const;
|
|
/// <summary>
|
|
/// Update a article
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one article. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_articles_200_response>> patchAiArticlesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a asset
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one asset. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_assets_200_response>> patchAiAssetsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a chat
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one chat. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_chats_200_response>> patchAiChatsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a application
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one application. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_deployments_200_response>> patchAiDeploymentsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one file. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_files_200_response>> patchAiFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a form
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one form. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_forms_200_response>> patchAiFormsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a graph
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one graph. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_graphs_200_response>> patchAiGraphsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a message
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one message. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_messages_200_response>> patchAiMessagesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a node
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one node. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_nodes_200_response>> patchAiNodesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiOrgSettings(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiOrgSettingsList(
|
|
) const;
|
|
/// <summary>
|
|
/// Preferences
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> patchAiPreferences(
|
|
) const;
|
|
/// <summary>
|
|
/// Update a provider
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one provider. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_providers_200_response>> patchAiProvidersByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a record
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one record. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_records_200_response>> patchAiRecordsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a connection
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one connection. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_remote_connections_200_response>> patchAiRemoteConnectionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiRouterArtifactMeta(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiRouterDefaults(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiRouterLedger(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiRouterPolicy(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> patchAiRouterRewards(
|
|
) const;
|
|
/// <summary>
|
|
/// Update a model-route
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one model-route. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_routes_200_response>> patchAiRoutesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a scale
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one scale. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scales_200_response>> patchAiScalesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a scan
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one scan. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scans_200_response>> patchAiScansByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a session
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one session. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_signin_sessions_200_response>> patchAiSigninSessionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a store
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one store. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_stores_200_response>> patchAiStoresByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a task
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one task. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tasks_200_response>> patchAiTasksByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a template
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one template. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_templates_200_response>> patchAiTemplatesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Training Contribution
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> patchAiTrainingContribution(
|
|
) const;
|
|
/// <summary>
|
|
/// Update a tree-file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one tree-file. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tree_files_200_response>> patchAiTreeFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a vector
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one vector. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_vectors_200_response>> patchAiVectorsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a video
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one video. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_videos_200_response>> patchAiVideosByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Update a workflow
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one workflow. PATCH and PUT reach the same handler, which has always taken a whole object.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_workflows_200_response>> patchAiWorkflowsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Create a article
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one article.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_articles_200_response>> postAiArticles(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a asset
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one asset.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_assets_200_response>> postAiAssets(
|
|
) const;
|
|
/// <summary>
|
|
/// Scan (asset)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiAssetsByOwnerByNameScan(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Scan (asset)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiAssetsScan(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a chat
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one chat.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_chats_200_response>> postAiChats(
|
|
) const;
|
|
/// <summary>
|
|
/// Connects (or reconnects) a third-party AI account for the org by sealing the supplied key into KMS and upserting the org's provider row.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Connects (or reconnects) a third-party AI account for the org by sealing the supplied key into KMS and upserting the org's provider row. The raw key is sealed BEFORE the row is built and is never persisted or echoed.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_connections_200_response>> postAiConnections(
|
|
) const;
|
|
/// <summary>
|
|
/// Disconnects a third-party AI account: it deactivates the org's row so completion resolution falls back to the global Hanzo account (no BYO), and best-effort tombstones the sealed secret.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Disconnects a third-party AI account: it deactivates the org's row so completion resolution falls back to the global Hanzo account (no BYO), and best-effort tombstones the sealed secret. Idempotent.
|
|
/// </remarks>
|
|
/// <param name="provider"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_connections_200_response>> postAiConnectionsByProvider(
|
|
utility::string_t provider
|
|
) const;
|
|
/// <summary>
|
|
/// Create a application
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one application.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_deployments_200_response>> postAiDeployments(
|
|
) const;
|
|
/// <summary>
|
|
/// Deploy (application)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiDeploymentsByOwnerByNameDeploy(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Undeploy (application)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiDeploymentsByOwnerByNameUndeploy(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Attaches a per-request outcome reward to the routing decision that served request_id — the enso training loop's quality signal.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Attaches a per-request outcome reward to the routing decision that served request_id — the enso training loop's quality signal. Org-scoped via the same session-OR-Bearer principal the usage read uses (RequirePrincipal): the reward lands only on the caller's OWN org's event, so a request_id from another org (or unknown) is a 404 — cross-org writes are impossible and unknown ids are indistinguishable from foreign ones. Idempotent: a repeat overwrites. The body carries NO prompt text — only {request_id, reward|rating}.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_feedback_200_response>> postAiFeedback(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one file.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_files_200_response>> postAiFiles(
|
|
) const;
|
|
/// <summary>
|
|
/// Activate (file)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiFilesActivate(
|
|
) const;
|
|
/// <summary>
|
|
/// Vectors (file)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiFilesByOwnerByNameVectors(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Upload (file)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiFilesUpload(
|
|
) const;
|
|
/// <summary>
|
|
/// Deletes the TrainJob CR, meters the GPU-hours used so far, and marks the job cancelled.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Deletes the TrainJob CR, meters the GPU-hours used so far, and marks the job cancelled. ?id= or ?name=
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_finetune_cancel_200_response>> postAiFinetuneCancel(
|
|
) const;
|
|
/// <summary>
|
|
/// Serves a completed job's checkpoints and registers the result as a routable model on api.hanzo.ai.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Serves a completed job's checkpoints and registers the result as a routable model on api.hanzo.ai. ?id= or ?name=
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_finetune_deploy_200_response>> postAiFinetuneDeploy(
|
|
) const;
|
|
/// <summary>
|
|
/// Validates the request, resolves efficient defaults, persists the job, and submits a real TrainJob CR.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Validates the request, resolves efficient defaults, persists the job, and submits a real TrainJob CR. A submit failure (e.g. no cluster wired) is surfaced honestly: the job is saved with status \"failed\" + the reason, never faked.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_finetune_cancel_200_response>> postAiFinetuneJobs(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a form
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one form.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_forms_200_response>> postAiForms(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a graph
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one graph.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_graphs_200_response>> postAiGraphs(
|
|
) const;
|
|
/// <summary>
|
|
/// Delete one of the authenticated user's memories
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete one of the authenticated user's memories
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_memory_delete_200_response>> postAiMemoryDelete(
|
|
) const;
|
|
/// <summary>
|
|
/// Store a memory for the authenticated user
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Store a memory for the authenticated user
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_memory_remember_200_response>> postAiMemoryRemember(
|
|
) const;
|
|
/// <summary>
|
|
/// Update one of the authenticated user's memories
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Update one of the authenticated user's memories
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_memory_delete_200_response>> postAiMemoryUpdate(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a message
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one message.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_messages_200_response>> postAiMessages(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a node
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one node.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_nodes_200_response>> postAiNodes(
|
|
) const;
|
|
/// <summary>
|
|
/// Tunnel (node)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiNodesByOwnerByNameTunnel(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiOrgSettings(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiOrgSettingsList(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a provider
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one provider.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_providers_200_response>> postAiProviders(
|
|
) const;
|
|
/// <summary>
|
|
/// Mcp Tools (provider)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiProvidersMcpTools(
|
|
) const;
|
|
/// <summary>
|
|
/// Delete all chunks of one or more uploaded files (by file_id) from the owner's Search+Vector index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Delete all chunks of one or more uploaded files (by file_id) from the owner's Search+Vector index. Consolidates the retired chat-rag-api DELETE /documents.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Get_ai_finetune_presets_200_response>> postAiRagDelete(
|
|
) const;
|
|
/// <summary>
|
|
/// Parse, chunk, and embed one uploaded file under its file_id into the unified Search+Vector index, scoped to the authenticated owner.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Parse, chunk, and embed one uploaded file under its file_id into the unified Search+Vector index, scoped to the authenticated owner. Provide inline `content` or a `url` to fetch+parse (PDF/CSV/XLSX/PPTX/…). Re-embedding the same file_id replaces its chunks. Consolidates the retired chat-rag-api POST /embed and /local/embed.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_rag_embed_200_response>> postAiRagEmbed(
|
|
) const;
|
|
/// <summary>
|
|
/// Unified RAG ingest: parse + chunk + embed documents and pipe them to BOTH Hanzo Vector (semantic) AND Hanzo Search (keyword) under the tenant index {owner}-{store}-docs — the same index /v1/chat retrieval reads.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Unified RAG ingest: parse + chunk + embed documents and pipe them to BOTH Hanzo Vector (semantic) AND Hanzo Search (keyword) under the tenant index {owner}-{store}-docs — the same index /v1/chat retrieval reads. The source is pluggable: \"upload\" (inline files/documents), \"github\" (index a repo), \"crawl\" (web), or \"s3\" (the store's object-storage space). The owner is bound to the authenticated principal; the client-supplied owner is never trusted.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_rag_ingest_200_response>> postAiRagIngest(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve the top-K chunks relevant to a query, scoped to a single uploaded file (`file_id`).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Retrieve the top-K chunks relevant to a query, scoped to a single uploaded file (`file_id`). Hybrid keyword+vector retrieval over the same index. Consolidates the retired chat-rag-api POST /query.
|
|
/// </remarks>
|
|
pplx::task<std::vector<std::shared_ptr<DocSearchResult>>> postAiRagQuery(
|
|
) const;
|
|
/// <summary>
|
|
/// Retrieve the top-K chunks relevant to a query, scoped to a SET of uploaded files (`file_ids`).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Retrieve the top-K chunks relevant to a query, scoped to a SET of uploaded files (`file_ids`). Consolidates the retired chat-rag-api POST /query_multiple. Shares one retrieval path with /rag/query.
|
|
/// </remarks>
|
|
pplx::task<std::vector<std::shared_ptr<DocSearchResult>>> postAiRagQueryMultiple(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a record
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one record.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_records_200_response>> postAiRecords(
|
|
) const;
|
|
/// <summary>
|
|
/// Batch (record)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiRecordsBatch(
|
|
) const;
|
|
/// <summary>
|
|
/// Commit (record)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiRecordsCommit(
|
|
) const;
|
|
/// <summary>
|
|
/// Commit Second (record)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiRecordsCommitSecond(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a connection
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one connection.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_remote_connections_200_response>> postAiRemoteConnections(
|
|
) const;
|
|
/// <summary>
|
|
/// Start (connection)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiRemoteConnectionsByOwnerByNameStart(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Stop (connection)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiRemoteConnectionsByOwnerByNameStop(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiRouterArtifactMeta(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiRouterDefaults(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiRouterLedger(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiRouterPolicy(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> postAiRouterRewards(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a model-route
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one model-route.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_routes_200_response>> postAiRoutes(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a scale
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one scale.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_scales_200_response>> postAiScales(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a scan
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one scan.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_scans_200_response>> postAiScans(
|
|
) const;
|
|
/// <summary>
|
|
/// Signin
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiSignin(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a session
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one session.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_signin_sessions_200_response>> postAiSigninSessions(
|
|
) const;
|
|
/// <summary>
|
|
/// Signout
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiSignout(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a store
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one store.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_stores_200_response>> postAiStores(
|
|
) const;
|
|
/// <summary>
|
|
/// Vectors (store)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiStoresByOwnerByNameVectors(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Create a task
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one task.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_tasks_200_response>> postAiTasks(
|
|
) const;
|
|
/// <summary>
|
|
/// Analyze (task)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiTasksByOwnerByNameAnalyze(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Document (task)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiTasksByOwnerByNameDocument(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Create a template
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one template.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_templates_200_response>> postAiTemplates(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a tree-file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one tree-file.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_tree_files_200_response>> postAiTreeFiles(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a vector
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one vector.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_vectors_200_response>> postAiVectors(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a video
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one video.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_videos_200_response>> postAiVideos(
|
|
) const;
|
|
/// <summary>
|
|
/// Upload (video)
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> postAiVideosUpload(
|
|
) const;
|
|
/// <summary>
|
|
/// Create a workflow
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Create one workflow.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Post_ai_workflows_200_response>> postAiWorkflows(
|
|
) const;
|
|
/// <summary>
|
|
/// Serves the generative audio verbs — /v1/audio/voice (TTS), /music, /foley — that the Zen family serves natively.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Serves the generative audio verbs — /v1/audio/voice (TTS), /music, /foley — that the Zen family serves natively. It resolves the SKU and, for a Zen model, forwards to zen's matching verb billed per call at the discovered price. These verbs are Zen-native; a non-Zen model is rejected.
|
|
/// </remarks>
|
|
pplx::task<void> postAudioFoley(
|
|
) const;
|
|
/// <summary>
|
|
/// Serves the generative audio verbs — /v1/audio/voice (TTS), /music, /foley — that the Zen family serves natively.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Serves the generative audio verbs — /v1/audio/voice (TTS), /music, /foley — that the Zen family serves natively. It resolves the SKU and, for a Zen model, forwards to zen's matching verb billed per call at the discovered price. These verbs are Zen-native; a non-Zen model is rejected.
|
|
/// </remarks>
|
|
pplx::task<void> postAudioMusic(
|
|
) const;
|
|
/// <summary>
|
|
/// The OpenAI-compatible TTS endpoint (POST /v1/audio/speech).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The OpenAI-compatible TTS endpoint (POST /v1/audio/speech). It authenticates the caller, resolves `model` to its TTS provider (the SAME model-route resolution the chat/images/video endpoints use — so a BYO node registered as a TTS provider works transparently), synthesizes the audio, and streams the bytes back. This is the ONE way to synthesize speech: OpenAI-shaped, with no store or message coupling, so a caller needs no chat to speak.
|
|
/// </remarks>
|
|
pplx::task<void> postAudioSpeech(
|
|
) const;
|
|
/// <summary>
|
|
/// The OpenAI-compatible STT endpoint (POST /v1/audio/transcriptions, multipart: file + model [+ language + response_format]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The OpenAI-compatible STT endpoint (POST /v1/audio/transcriptions, multipart: file + model [+ language + response_format]). It mirrors AudioSpeech exactly: authenticate the caller, resolve `model` to its STT provider through the SAME model-route resolution (so the in-cluster speech service — or any BYO node registered as an STT provider — works transparently), transcribe, and return the OpenAI body. This is the ONE way to transcribe: OpenAI-shaped, with no store coupling, so a caller needs no chat to be heard.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_AudioResponse>> postAudioTranscriptions(
|
|
) const;
|
|
/// <summary>
|
|
/// Serves the generative audio verbs — /v1/audio/voice (TTS), /music, /foley — that the Zen family serves natively.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Serves the generative audio verbs — /v1/audio/voice (TTS), /music, /foley — that the Zen family serves natively. It resolves the SKU and, for a Zen model, forwards to zen's matching verb billed per call at the discovered price. These verbs are Zen-native; a non-Zen model is rejected.
|
|
/// </remarks>
|
|
pplx::task<void> postAudioVoice(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements the OpenAI-compatible chat completions API
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements the OpenAI-compatible chat completions API
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_ChatCompletionResponse>> postChat(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements the OpenAI-compatible chat completions API
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements the OpenAI-compatible chat completions API
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_ChatCompletionResponse>> postChatCompletions(
|
|
) const;
|
|
/// <summary>
|
|
/// Serves one completion to a caller with no account.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Serves one completion to a caller with no account.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_ChatCompletionResponse>> postChatPublic(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements the OpenAI-compatible chat completions API
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements the OpenAI-compatible chat completions API
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_ChatCompletionResponse>> postCompletions(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements POST /v1/embeddings (OpenAI-compatible).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements POST /v1/embeddings (OpenAI-compatible). Body: {\"model\": \"...\", \"input\": \"...\"|[\"...\", ...], \"encoding_format\"?, \"dimensions\"?} It authenticates the caller, resolves the model to its upstream provider via the shared routing table, rewrites the user-facing model name to the upstream id, and proxies the request to the provider's /embeddings endpoint verbatim.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_EmbeddingResponse>> postEmbeddings(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements POST /v1/images/generations (OpenAI-compatible).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements POST /v1/images/generations (OpenAI-compatible). Body: {\"model\": \"...\", \"prompt\": \"...\", \"n\"?: int, \"size\"?: \"1024x1024\", \"response_format\"?: \"url\"|\"b64_json\"} It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-image* → do-ai fal diffusion), reserves the per-image budget, generates the image(s) through the do-ai async image client, records usage for billing, and returns the OpenAI images response.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Openai_ImageResponse>> postImagesGenerations(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements the Anthropic Messages API.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements the Anthropic Messages API.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_AnthropicResponse>> postMessages(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements POST /v1/messages/count_tokens.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements POST /v1/messages/count_tokens. Claude Code calls it before a request; it returns {\"input_tokens\": N} for the given model + messages + tools.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_TokenCount>> postMessagesCountTokens(
|
|
) const;
|
|
/// <summary>
|
|
/// Records the caller's waitlist request for a gated model and answers their new standing.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Records the caller's waitlist request for a gated model and answers their new standing. Authed, idempotent, and self-scoped: the row is keyed to the caller's own org and identity, never to a body-supplied owner.
|
|
/// </remarks>
|
|
/// <param name="model"></param>
|
|
pplx::task<std::shared_ptr<Post_models_by_model_access_200_response>> postModelsByModelAccess(
|
|
utility::string_t model
|
|
) const;
|
|
/// <summary>
|
|
/// Implements POST /v1/rerank (Cohere/Jina-compatible).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements POST /v1/rerank (Cohere/Jina-compatible). Body: {\"model\": \"...\", \"query\": \"...\", \"documents\": [\"...\", ...]|[{\"text\":\"...\"}], \"top_n\"?: int, \"return_documents\"?: bool} Response: {\"object\":\"list\",\"model\":...,\"results\":[{\"index\",\"relevance_score\",\"document\"?}],\"usage\":{...}} Backend selection is provider-driven (one endpoint, one contract): - If the model routes to a native rerank provider (Jina/Cohere/Voyage) the request is proxied to that provider's /rerank endpoint. - Otherwise scores are computed as a real bi-encoder ranking: embed the query and documents through the resolved embedding model and rank by cosine similarity. No rerank-specific key required.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Ranking>> postRerank(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements POST /v1/responses.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements POST /v1/responses. The converted request is completed by the chat path, which is handed a sink saying where the answer goes: a stream is translated as it is produced, a whole body is translated entire.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_ResponsesResource>> postResponses(
|
|
) const;
|
|
/// <summary>
|
|
/// Implements POST /v1/videos/generations — the ASYNC create.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Implements POST /v1/videos/generations — the ASYNC create. Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int} It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_VideoStatus>> postVideosGenerations(
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a article
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_articles_200_response>> putAiArticlesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a asset
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_assets_200_response>> putAiAssetsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a chat
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_chats_200_response>> putAiChatsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a application
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_deployments_200_response>> putAiDeploymentsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_files_200_response>> putAiFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a form
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_forms_200_response>> putAiFormsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a graph
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_graphs_200_response>> putAiGraphsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a message
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_messages_200_response>> putAiMessagesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a node
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_nodes_200_response>> putAiNodesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiOrgSettings(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiOrgSettingsList(
|
|
) const;
|
|
/// <summary>
|
|
/// Preferences
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> putAiPreferences(
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a provider
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_providers_200_response>> putAiProvidersByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a record
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_records_200_response>> putAiRecordsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a connection
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_remote_connections_200_response>> putAiRemoteConnectionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiRouterArtifactMeta(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiRouterDefaults(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiRouterLedger(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiRouterPolicy(
|
|
) const;
|
|
/// <summary>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]). It dispatches IN-PROCESS through dispatchGateway — the SAME canonical ZAP gateway registry (zap_registry.go) that the MsgType 200 handler serves over the gateway transport. The native ZAP handler is the ONE and ONLY implementation of these routes; this is purely the api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the split-brain the router refactor removed stays removed. Why a bridge and not a twin controller method: every other migrated route (get-records, get-connections, …) carries BOTH a controller method and a ZAP handler — the exact dual-impl drift that silently NULLed customer router settings (the update-router-policy data-wipe). Routing these nouns through the ZAP handler over one adapter keeps a single source of truth. Identity is the request's own Bearer credential (Authorization header), which the native handlers resolve exactly as the gateway does — every caller (console, chat, app) already sends it. The dispatched handler returns a ZAP message whose status is field 0 and body is field 4 (BuildCloudResponse / BuildGatewayResponse layout); both are relayed verbatim. The route is mapped \"*\" (any verb) because the native handler is method-aware: /v1/ai/router/policy splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns 405 for a verb it does not own.
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Ai_Response>> putAiRouterRewards(
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a model-route
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_routes_200_response>> putAiRoutesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a scale
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scales_200_response>> putAiScalesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a scan
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_scans_200_response>> putAiScansByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a session
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_signin_sessions_200_response>> putAiSigninSessionsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a store
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_stores_200_response>> putAiStoresByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a task
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tasks_200_response>> putAiTasksByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a template
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_templates_200_response>> putAiTemplatesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Training Contribution
|
|
/// </summary>
|
|
/// <remarks>
|
|
///
|
|
/// </remarks>
|
|
pplx::task<std::shared_ptr<Envelope>> putAiTrainingContribution(
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a tree-file
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_tree_files_200_response>> putAiTreeFilesByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a vector
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_vectors_200_response>> putAiVectorsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a video
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_videos_200_response>> putAiVideosByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
/// <summary>
|
|
/// Replace a workflow
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Identical to PATCH — the handler takes a whole object either way.
|
|
/// </remarks>
|
|
/// <param name="owner"></param>
|
|
/// <param name="name"></param>
|
|
pplx::task<std::shared_ptr<Post_ai_workflows_200_response>> putAiWorkflowsByOwnerByName(
|
|
utility::string_t owner,
|
|
utility::string_t name
|
|
) const;
|
|
|
|
protected:
|
|
std::shared_ptr<const ApiClient> m_ApiClient;
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif /* HANZO_API_AiApi_H_ */
|
|
|