Files
sdk/api_tool.go

2396 lines
84 KiB
Go

/*
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/.
API version: v1
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package hanzoai
import (
"bytes"
"context"
"io"
"net/http"
"net/url"
"strings"
)
// ToolAPIService ToolAPI service
type ToolAPIService service
type ToolAPIDeleteToolMcpServersByIdRequest struct {
ctx context.Context
ApiService *ToolAPIService
id string
}
func (r ToolAPIDeleteToolMcpServersByIdRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteToolMcpServersByIdExecute(r)
}
/*
DeleteToolMcpServersById Deregisters one of the caller org's external MCP servers, so its tools leave the registry.
Deregisters one of the caller org's external MCP servers, so its
tools leave the registry. Scoped to the caller's org, so an id belonging to
another tenant is a 404 and not a delete. Answers 204 with no body; a server
this org does not have is 404. Like registering one it takes an admin of the
org or a SuperAdmin, and is on the org's audit trail before it is made.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the server to deregister, from the path.
@return ToolAPIDeleteToolMcpServersByIdRequest
*/
func (a *ToolAPIService) DeleteToolMcpServersById(ctx context.Context, id string) ToolAPIDeleteToolMcpServersByIdRequest {
return ToolAPIDeleteToolMcpServersByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *ToolAPIService) DeleteToolMcpServersByIdExecute(r ToolAPIDeleteToolMcpServersByIdRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.DeleteToolMcpServersById")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/mcp/servers/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ToolAPIDeleteToolPluginsAuthoredByIdRequest struct {
ctx context.Context
ApiService *ToolAPIService
id string
}
func (r ToolAPIDeleteToolPluginsAuthoredByIdRequest) Execute() (*ToolPluginDeleted, *http.Response, error) {
return r.ApiService.DeleteToolPluginsAuthoredByIdExecute(r)
}
/*
DeleteToolPluginsAuthoredById Removes one of the caller org's built plugins, so the runtime can no longer load it.
Removes one of the caller org's built plugins, so the
runtime can no longer load it. Scoped to the caller's org, so an id belonging
to another tenant answers 404 and is not deleted.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the plugin to remove, from the path.
@return ToolAPIDeleteToolPluginsAuthoredByIdRequest
*/
func (a *ToolAPIService) DeleteToolPluginsAuthoredById(ctx context.Context, id string) ToolAPIDeleteToolPluginsAuthoredByIdRequest {
return ToolAPIDeleteToolPluginsAuthoredByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ToolPluginDeleted
func (a *ToolAPIService) DeleteToolPluginsAuthoredByIdExecute(r ToolAPIDeleteToolPluginsAuthoredByIdRequest) (*ToolPluginDeleted, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolPluginDeleted
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.DeleteToolPluginsAuthoredById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/plugins/authored/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIDeleteToolSkillsByIdRequest struct {
ctx context.Context
ApiService *ToolAPIService
id string
}
func (r ToolAPIDeleteToolSkillsByIdRequest) Execute() (*ToolSkillDeleted, *http.Response, error) {
return r.ApiService.DeleteToolSkillsByIdExecute(r)
}
/*
DeleteToolSkillsById Removes one of the caller org's authored skills.
Removes one of the caller org's authored skills. Scoped to the
caller's org, so an id belonging to another tenant is never reached. Removing
what is not there is not an error — the caller's intent is "gone", and it is.
Like writing one it takes an admin of the org or a SuperAdmin, and is on the
org's audit trail before it is made.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the skill to remove, from the path. It is the skill's name.
@return ToolAPIDeleteToolSkillsByIdRequest
*/
func (a *ToolAPIService) DeleteToolSkillsById(ctx context.Context, id string) ToolAPIDeleteToolSkillsByIdRequest {
return ToolAPIDeleteToolSkillsByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ToolSkillDeleted
func (a *ToolAPIService) DeleteToolSkillsByIdExecute(r ToolAPIDeleteToolSkillsByIdRequest) (*ToolSkillDeleted, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolSkillDeleted
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.DeleteToolSkillsById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/skills/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolRequest struct {
ctx context.Context
ApiService *ToolAPIService
source *string
activated *string
}
// Source keeps only tools from one source — connector, function, zap-service, agent, skill or mcp. Empty keeps every source.
func (r ToolAPIGetToolRequest) Source(source string) ToolAPIGetToolRequest {
r.source = &source
return r
}
// Activated keeps only the tools activated for the caller's org and project, and only when it is exactly the string \"true\".
func (r ToolAPIGetToolRequest) Activated(activated string) ToolAPIGetToolRequest {
r.activated = &activated
return r
}
func (r ToolAPIGetToolRequest) Execute() (*ToolToolList, *http.Response, error) {
return r.ApiService.GetToolExecute(r)
}
/*
GetTool Lists every tool the caller's org and project can reach, from every source, each flagged with whether it is activated.
Lists every tool the caller's org and project can reach, from every
source, each flagged with whether it is activated. This is the discovery
surface: one flat set of names spanning connector actions, user functions,
zap-service routes, agents, skills and the org's own external MCP servers,
deduplicated by name so the highest-precedence source wins a collision. It
lists; it does not call — dispatch is POST /v1/tool/call.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolRequest
*/
func (a *ToolAPIService) GetTool(ctx context.Context) ToolAPIGetToolRequest {
return ToolAPIGetToolRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolToolList
func (a *ToolAPIService) GetToolExecute(r ToolAPIGetToolRequest) (*ToolToolList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolToolList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetTool")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.source != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "source", r.source, "form", "")
}
if r.activated != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "activated", r.activated, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolActivationRequest struct {
ctx context.Context
ApiService *ToolAPIService
}
func (r ToolAPIGetToolActivationRequest) Execute() (*ToolActivationSet, *http.Response, error) {
return r.ApiService.GetToolActivationExecute(r)
}
/*
GetToolActivation Reports which tools are switched on for the caller's org and project.
Reports which tools are switched on for the caller's org and
project. Activation is what makes a tool dispatchable and what makes it visible
to an agent, so this is the set the MCP tool list is drawn from — every other
tool in the registry is discoverable but refused at call time.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolActivationRequest
*/
func (a *ToolAPIService) GetToolActivation(ctx context.Context) ToolAPIGetToolActivationRequest {
return ToolAPIGetToolActivationRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolActivationSet
func (a *ToolAPIService) GetToolActivationExecute(r ToolAPIGetToolActivationRequest) (*ToolActivationSet, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolActivationSet
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolActivation")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/activation"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolCatalogRequest struct {
ctx context.Context
ApiService *ToolAPIService
q *string
featured *string
official *string
limit *int64
offset *int64
}
// Q matches the name, title or description, case-insensitively.
func (r ToolAPIGetToolCatalogRequest) Q(q string) ToolAPIGetToolCatalogRequest {
r.q = &q
return r
}
// Featured keeps only the listings we put on the front of the shelf, and only when it is exactly the string \"true\".
func (r ToolAPIGetToolCatalogRequest) Featured(featured string) ToolAPIGetToolCatalogRequest {
r.featured = &featured
return r
}
// Official keeps only the vendors' OWN servers — not third-party copies of them — and only when it is exactly the string \"true\".
func (r ToolAPIGetToolCatalogRequest) Official(official string) ToolAPIGetToolCatalogRequest {
r.official = &official
return r
}
// Limit bounds the page: default 50, maximum 200. A value that is not a positive integer reads as the default.
func (r ToolAPIGetToolCatalogRequest) Limit(limit int64) ToolAPIGetToolCatalogRequest {
r.limit = &limit
return r
}
// Offset skips that many listings.
func (r ToolAPIGetToolCatalogRequest) Offset(offset int64) ToolAPIGetToolCatalogRequest {
r.offset = &offset
return r
}
func (r ToolAPIGetToolCatalogRequest) Execute() (*ToolMcpCatalog, *http.Response, error) {
return r.ApiService.GetToolCatalogExecute(r)
}
/*
GetToolCatalog Lists the MCP servers the public registries publish, as we hold them: our canonical copy of registry.modelcontextprotocol.io, plus what we decided about each entry.
Lists the MCP servers the public registries publish, as we hold
them: our canonical copy of registry.modelcontextprotocol.io, plus what we
decided about each entry.
This is the SHELF an org picks from. A listing with a streamable-http endpoint
can be enabled as-is — POST /v1/tool/mcp/servers with its id — and its tools then
join the org's tool plane and the fleet's MCP server. A listing that only ships a
stdio package needs a process to run it, which is why the transports are on
every entry rather than implied.
Hidden entries are absent: they are the ones we took off the shelf. A platform
SuperAdmin sees them, because the same query answers "what is on the shelf" and
"what is in the catalog" and two queries would drift apart.
It is PAGED — 50 by default, 200 at most. The public registry publishes tens of
thousands of servers, so an unbounded answer is a twenty-megabyte response and a
storefront that renders in a minute. total is the whole match, not the page.
It needs no credential: the shelf is a copy of public registries, the same for
every org, and a storefront shows it to a visitor before anyone signs in.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolCatalogRequest
*/
func (a *ToolAPIService) GetToolCatalog(ctx context.Context) ToolAPIGetToolCatalogRequest {
return ToolAPIGetToolCatalogRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolMcpCatalog
func (a *ToolAPIService) GetToolCatalogExecute(r ToolAPIGetToolCatalogRequest) (*ToolMcpCatalog, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolMcpCatalog
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolCatalog")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/catalog"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.q != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "form", "")
}
if r.featured != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "featured", r.featured, "form", "")
}
if r.official != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "official", r.official, "form", "")
}
if r.limit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
}
if r.offset != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "offset", r.offset, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolCatalogByIdRequest struct {
ctx context.Context
ApiService *ToolAPIService
id string
}
func (r ToolAPIGetToolCatalogByIdRequest) Execute() (*ToolMCPListing, *http.Response, error) {
return r.ApiService.GetToolCatalogByIdExecute(r)
}
/*
GetToolCatalogById Returns one catalog entry in full: the publisher's description, its repository and site, every package form with the runtime that launches it, and every hosted endpoint.
Returns one catalog entry in full: the publisher's description, its
repository and site, every package form with the runtime that launches it, and
every hosted endpoint. It is what a branding page renders, and what tells a
caller whether the listing can be enabled here and now (a streamable-http
remote) or needs somewhere to run first (a stdio package).
A HIDDEN listing is not served to an org — a shelf that renders what it does
not list would be a way around the shelf — but is served to a SuperAdmin, who
is the one deciding whether to put it back. Like the shelf, it needs no
credential.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the listing, from the path. It is the publisher's reverse-DNS name with its one slash written as an underscore — \"com.stripe_mcp\".
@return ToolAPIGetToolCatalogByIdRequest
*/
func (a *ToolAPIService) GetToolCatalogById(ctx context.Context, id string) ToolAPIGetToolCatalogByIdRequest {
return ToolAPIGetToolCatalogByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ToolMCPListing
func (a *ToolAPIService) GetToolCatalogByIdExecute(r ToolAPIGetToolCatalogByIdRequest) (*ToolMCPListing, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolMCPListing
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolCatalogById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/catalog/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolKitRequest struct {
ctx context.Context
ApiService *ToolAPIService
}
func (r ToolAPIGetToolKitRequest) Execute() (*ToolKit, *http.Response, error) {
return r.ApiService.GetToolKitExecute(r)
}
/*
GetToolKit Answers the caller's kit: what their coding runs carry of the org's tool plane.
Answers the caller's kit: what their coding runs carry of the org's tool
plane. Skills are the documents of those an admin of the org activated; servers
are those an admin registered, each by its id with the tools of it an admin
activated — never an address or a credential, which stay on the plane. Both
leave out what the caller muted, and muted names it. It is the one read a run
makes, so what it answers is what the caller's runs carry.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolKitRequest
*/
func (a *ToolAPIService) GetToolKit(ctx context.Context) ToolAPIGetToolKitRequest {
return ToolAPIGetToolKitRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolKit
func (a *ToolAPIService) GetToolKitExecute(r ToolAPIGetToolKitRequest) (*ToolKit, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolKit
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolKit")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/kit"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolMcpServersRequest struct {
ctx context.Context
ApiService *ToolAPIService
}
func (r ToolAPIGetToolMcpServersRequest) Execute() (*ToolMcpServerList, *http.Response, error) {
return r.ApiService.GetToolMcpServersExecute(r)
}
/*
GetToolMcpServers Lists the external MCP servers the caller's org has registered.
Lists the external MCP servers the caller's org has registered.
Each record carries the URL and the name of the header its credential is
injected into; the credential VALUE lives only in KMS and is never returned,
so hasSecret is the whole of what this surface says about it. Each also says
whether its tools could be listed — status, a reason when they could not, and
how many there are — so a server that contributes nothing says why.
The whole URL is answered to an admin of the org or a SuperAdmin, who register
servers. A member is answered its scheme and host: which server it is, and not
a path or query an admin may have put a key in.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolMcpServersRequest
*/
func (a *ToolAPIService) GetToolMcpServers(ctx context.Context) ToolAPIGetToolMcpServersRequest {
return ToolAPIGetToolMcpServersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolMcpServerList
func (a *ToolAPIService) GetToolMcpServersExecute(r ToolAPIGetToolMcpServersRequest) (*ToolMcpServerList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolMcpServerList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolMcpServers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/mcp/servers"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolPluginsRequest struct {
ctx context.Context
ApiService *ToolAPIService
all *string
}
// All includes the configured-but-disabled subsystems too, but only when it is exactly the string \"true\". Otherwise only the running ones are reported.
func (r ToolAPIGetToolPluginsRequest) All(all string) ToolAPIGetToolPluginsRequest {
r.all = &all
return r
}
func (r ToolAPIGetToolPluginsRequest) Execute() (*ToolPluginMountList, *http.Response, error) {
return r.ApiService.GetToolPluginsExecute(r)
}
/*
GetToolPlugins Reports what this deployment actually mounted: every subsystem the composition root declared and whether it is switched on.
Reports what this deployment actually mounted: every subsystem the
composition root declared and whether it is switched on. A plugin here is
MOUNTED CODE that extends the deployment's own surface — not a tool an agent
calls — so this is an inventory and not a tool source. It is read off the same
boot snapshot every traced request resolves its subsystem label against, so it
cannot drift from what is serving. Enabled-only by default, because a caller
asking what this deployment can do wants what is running; ?all=true adds the
configured-but-off ones.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolPluginsRequest
*/
func (a *ToolAPIService) GetToolPlugins(ctx context.Context) ToolAPIGetToolPluginsRequest {
return ToolAPIGetToolPluginsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolPluginMountList
func (a *ToolAPIService) GetToolPluginsExecute(r ToolAPIGetToolPluginsRequest) (*ToolPluginMountList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolPluginMountList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolPlugins")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/plugins"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.all != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "all", r.all, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolPluginsAuthoredRequest struct {
ctx context.Context
ApiService *ToolAPIService
}
func (r ToolAPIGetToolPluginsAuthoredRequest) Execute() (*ToolAuthoredPluginList, *http.Response, error) {
return r.ApiService.GetToolPluginsAuthoredExecute(r)
}
/*
GetToolPluginsAuthored Lists the plugins the caller's org BUILT, newest first, each with the TypeScript as authored.
Lists the plugins the caller's org BUILT, newest first,
each with the TypeScript as authored. That is a different set with a different
lifecycle from GET /v1/tool/plugins, which reports the subsystems this deployment
mounted. The bundled CommonJS the runtime executes is never included, and
neither is any credential — a plugin names the connectors provider it needs and
reads the credential from ctx.auth at run time.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolPluginsAuthoredRequest
*/
func (a *ToolAPIService) GetToolPluginsAuthored(ctx context.Context) ToolAPIGetToolPluginsAuthoredRequest {
return ToolAPIGetToolPluginsAuthoredRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolAuthoredPluginList
func (a *ToolAPIService) GetToolPluginsAuthoredExecute(r ToolAPIGetToolPluginsAuthoredRequest) (*ToolAuthoredPluginList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolAuthoredPluginList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolPluginsAuthored")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/plugins/authored"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolSkillsRequest struct {
ctx context.Context
ApiService *ToolAPIService
activated *string
}
// Activated keeps only the tools activated for the caller's org and project, and only when it is exactly the string \"true\".
func (r ToolAPIGetToolSkillsRequest) Activated(activated string) ToolAPIGetToolSkillsRequest {
r.activated = &activated
return r
}
func (r ToolAPIGetToolSkillsRequest) Execute() (*ToolSourceToolList, *http.Response, error) {
return r.ApiService.GetToolSkillsExecute(r)
}
/*
GetToolSkills Lists the skills the caller's org can reach — the brand's embedded catalogue plus the org's own authored ones — with each one's activation flag.
Lists the skills the caller's org can reach — the brand's embedded
catalogue plus the org's own authored ones — with each one's activation flag.
A skill is discovery and activation metadata attached to an agent, never called
directly, so every entry here is non-dispatchable. It is GET /v1/tool narrowed
to one source, not a second store: a name a caller sees here is the same entry,
with the same activation state, that discovery reports.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolSkillsRequest
*/
func (a *ToolAPIService) GetToolSkills(ctx context.Context) ToolAPIGetToolSkillsRequest {
return ToolAPIGetToolSkillsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolSourceToolList
func (a *ToolAPIService) GetToolSkillsExecute(r ToolAPIGetToolSkillsRequest) (*ToolSourceToolList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolSourceToolList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolSkills")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/skills"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.activated != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "activated", r.activated, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIGetToolSkillsAuthoredRequest struct {
ctx context.Context
ApiService *ToolAPIService
}
func (r ToolAPIGetToolSkillsAuthoredRequest) Execute() (*ToolAuthoredSkillList, *http.Response, error) {
return r.ApiService.GetToolSkillsAuthoredExecute(r)
}
/*
GetToolSkillsAuthored Lists the caller org's OWN skills with their SKILL.md bodies.
Lists the caller org's OWN skills with their SKILL.md
bodies. GET /v1/tool/skills is the registry view — the brand's catalogue plus this
org's, with activation flags and no bodies; this is the EDITABLE set, so it
carries the content that view omits and nothing the org did not write.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIGetToolSkillsAuthoredRequest
*/
func (a *ToolAPIService) GetToolSkillsAuthored(ctx context.Context) ToolAPIGetToolSkillsAuthoredRequest {
return ToolAPIGetToolSkillsAuthoredRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolAuthoredSkillList
func (a *ToolAPIService) GetToolSkillsAuthoredExecute(r ToolAPIGetToolSkillsAuthoredRequest) (*ToolAuthoredSkillList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolAuthoredSkillList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.GetToolSkillsAuthored")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/skills/authored"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIPostToolCallRequest struct {
ctx context.Context
ApiService *ToolAPIService
toolToolCall *ToolToolCall
}
func (r ToolAPIPostToolCallRequest) ToolToolCall(toolToolCall ToolToolCall) ToolAPIPostToolCallRequest {
r.toolToolCall = &toolToolCall
return r
}
func (r ToolAPIPostToolCallRequest) Execute() (*ToolToolResult, *http.Response, error) {
return r.ApiService.PostToolCallExecute(r)
}
/*
PostToolCall Runs one of the caller's activated tools and answers with its output.
Runs one of the caller's activated tools and answers with its output.
This is the endpoint onto the tool plane's DYNAMIC half — the half no build-time
catalogue can hold, because it is per-tenant: an org's connected connector
actions, its authored skills, its agents and functions, and the tools of every
external MCP server it registered. A tool's existence, its price and its
activation are all rows, not code, so they cannot be known until the caller is.
One policy, the registry's: resolve by precedence, refuse an unactivated tool
403, settle a priced one through the x402 client or fail closed 402, then
dispatch to the winning source bound to the caller's own (org, project). One
metered unit, one audit record. A caller can only ever dispatch its own tools.
Discovery is GET /v1/tool — ?activated=true for the callable set.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIPostToolCallRequest
*/
func (a *ToolAPIService) PostToolCall(ctx context.Context) ToolAPIPostToolCallRequest {
return ToolAPIPostToolCallRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolToolResult
func (a *ToolAPIService) PostToolCallExecute(r ToolAPIPostToolCallRequest) (*ToolToolResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolToolResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.PostToolCall")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/call"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.toolToolCall == nil {
return localVarReturnValue, nil, reportError("toolToolCall is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.toolToolCall
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIPostToolMcpServersRequest struct {
ctx context.Context
ApiService *ToolAPIService
toolCreateServerReq *ToolCreateServerReq
}
func (r ToolAPIPostToolMcpServersRequest) ToolCreateServerReq(toolCreateServerReq ToolCreateServerReq) ToolAPIPostToolMcpServersRequest {
r.toolCreateServerReq = &toolCreateServerReq
return r
}
func (r ToolAPIPostToolMcpServersRequest) Execute() (*ToolMCPServer, *http.Response, error) {
return r.ApiService.PostToolMcpServersExecute(r)
}
/*
PostToolMcpServers Gives the caller's org one more external MCP server, so its tools join the org's tool plane and the fleet's MCP server.
Gives the caller's org one more external MCP server, so its tools
join the org's tool plane and the fleet's MCP server. It is the ONE way an org
gains a server, whether it typed the URL in or enabled a catalog listing: both
write the SAME record, and `source` says which it was. A second registration
path would be a second place for a server to exist, and then a second place to
forget to check the credential.
The credential VALUE is sealed in KMS under a per-org ref; the row keeps only
the URL, the header name to inject it into, and a has-secret flag — so a secret
with no KMS configured is refused 503 rather than stored in the clear. The URL
is SSRF-validated here and re-checked by the dialer at connect time, which is
the DNS-rebinding defense.
Enabling a listing the org already enabled REVISES that server rather than
adding a near-duplicate beside it, so a retried enable is the same one server.
Answers 201 with the stored record.
A server and the tools of it the org activates are carried into every agent run
in the org, so registering one — or revising one, credential included — takes
an admin of the org or a SuperAdmin; a member is refused 403. The registration
is on the org's audit trail before it is made, and one the trail cannot record
is refused 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIPostToolMcpServersRequest
*/
func (a *ToolAPIService) PostToolMcpServers(ctx context.Context) ToolAPIPostToolMcpServersRequest {
return ToolAPIPostToolMcpServersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolMCPServer
func (a *ToolAPIService) PostToolMcpServersExecute(r ToolAPIPostToolMcpServersRequest) (*ToolMCPServer, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolMCPServer
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.PostToolMcpServers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/mcp/servers"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.toolCreateServerReq == nil {
return localVarReturnValue, nil, reportError("toolCreateServerReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.toolCreateServerReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIPostToolPluginsBuildRequest struct {
ctx context.Context
ApiService *ToolAPIService
toolBuildRequest *ToolBuildRequest
}
func (r ToolAPIPostToolPluginsBuildRequest) ToolBuildRequest(toolBuildRequest ToolBuildRequest) ToolAPIPostToolPluginsBuildRequest {
r.toolBuildRequest = &toolBuildRequest
return r
}
func (r ToolAPIPostToolPluginsBuildRequest) Execute() (*ToolBuildOut, *http.Response, error) {
return r.ApiService.PostToolPluginsBuildExecute(r)
}
/*
PostToolPluginsBuild Builds and stores one plugin for the caller's org.
Builds and stores one plugin for the caller's org. The 201 carries
the bundle's size, whether a model wrote the source, and the plugin as stored.
Post `source` to build TypeScript as-is, or `spec` — an OpenAPI document or
plain prose describing the endpoints — to have one generated; the generated
source comes back in the answer, so a caller reads what will run before it
runs. Exactly one of the two, and `name` must be one lowercase path segment;
both or neither is 400.
COMPILING IS THE GATE. The source goes through the same pipeline the committed
connectors do — esbuild to one CommonJS program, then compiled in the goja
runtime that will actually execute it — and anything that fails is rejected and
NEVER stored. So a plugin in the store is one this deployment has already
loaded once, not one a model claimed was fine. A failed build answers 422
carrying the diagnostics a caller needs to fix it: the bundler's error
(`detail`), the source that failed, and whether the model wrote it.
CREDENTIALS ARE NOT PART OF A PLUGIN. A plugin names the connectors `provider`
it needs and reads that credential from `ctx.auth` at run time, under KMS
custody. Source that carries something key-shaped is REFUSED rather than
silently persisted — a scrubbed key looks like it worked.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIPostToolPluginsBuildRequest
*/
func (a *ToolAPIService) PostToolPluginsBuild(ctx context.Context) ToolAPIPostToolPluginsBuildRequest {
return ToolAPIPostToolPluginsBuildRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolBuildOut
func (a *ToolAPIService) PostToolPluginsBuildExecute(r ToolAPIPostToolPluginsBuildRequest) (*ToolBuildOut, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolBuildOut
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.PostToolPluginsBuild")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/plugins/build"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.toolBuildRequest == nil {
return localVarReturnValue, nil, reportError("toolBuildRequest is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.toolBuildRequest
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIPostToolSkillsRequest struct {
ctx context.Context
ApiService *ToolAPIService
toolSkillIn *ToolSkillIn
}
func (r ToolAPIPostToolSkillsRequest) ToolSkillIn(toolSkillIn ToolSkillIn) ToolAPIPostToolSkillsRequest {
r.toolSkillIn = &toolSkillIn
return r
}
func (r ToolAPIPostToolSkillsRequest) Execute() (*ToolSkillWritten, *http.Response, error) {
return r.ApiService.PostToolSkillsExecute(r)
}
/*
PostToolSkills Adds or revises one of the caller org's own skills, and answers 201 with the stored record.
Adds or revises one of the caller org's own skills, and answers 201
with the stored record. The id is derived from the name, so writing the same
name again REVISES that skill rather than accumulating near-duplicates that
would then collide in the registry. An org's skills are private to it by
construction — they live in a different store from the brand's embedded
catalogue and have no path into the public gallery — and a brand skill always
wins a name collision against an org's.
An activated skill is carried into every agent run in the org, so writing one
takes an admin of the org or a SuperAdmin; a member is refused 403. The write is
on the org's audit trail before it is made, and one the trail cannot record is
refused 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIPostToolSkillsRequest
*/
func (a *ToolAPIService) PostToolSkills(ctx context.Context) ToolAPIPostToolSkillsRequest {
return ToolAPIPostToolSkillsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolSkillWritten
func (a *ToolAPIService) PostToolSkillsExecute(r ToolAPIPostToolSkillsRequest) (*ToolSkillWritten, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolSkillWritten
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.PostToolSkills")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/skills"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.toolSkillIn == nil {
return localVarReturnValue, nil, reportError("toolSkillIn is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.toolSkillIn
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIPutToolActivationRequest struct {
ctx context.Context
ApiService *ToolAPIService
toolActivationReq *ToolActivationReq
}
func (r ToolAPIPutToolActivationRequest) ToolActivationReq(toolActivationReq ToolActivationReq) ToolAPIPutToolActivationRequest {
r.toolActivationReq = &toolActivationReq
return r
}
func (r ToolAPIPutToolActivationRequest) Execute() (*ToolActivationSet, *http.Response, error) {
return r.ApiService.PutToolActivationExecute(r)
}
/*
PutToolActivation Switches tools on and off for the caller's org and project, and answers with the resulting activated set.
Switches tools on and off for the caller's org and project, and
answers with the resulting activated set. It is the ONE write path that turns
skills, plugins and connectors into callable tools — an unactivated tool is
listed by discovery but refused 403 at dispatch. Activate is applied before
Deactivate, so a name in both lists ends up off. More than 256 toggles in one
request is refused 413.
Switching a skill (skill_<name>) or a tool of an MCP server the org registered
(<server>_<tool>) changes what every agent run in the org carries, so it takes
an admin of the org or a SuperAdmin: a member naming one is refused 403 and
nothing in the request is switched. Every change is on the org's audit trail
before it is made, and one the trail cannot record is refused 503.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIPutToolActivationRequest
*/
func (a *ToolAPIService) PutToolActivation(ctx context.Context) ToolAPIPutToolActivationRequest {
return ToolAPIPutToolActivationRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolActivationSet
func (a *ToolAPIService) PutToolActivationExecute(r ToolAPIPutToolActivationRequest) (*ToolActivationSet, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolActivationSet
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.PutToolActivation")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/activation"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.toolActivationReq == nil {
return localVarReturnValue, nil, reportError("toolActivationReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.toolActivationReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ToolAPIPutToolKitRequest struct {
ctx context.Context
ApiService *ToolAPIService
toolMuteReq *ToolMuteReq
}
func (r ToolAPIPutToolKitRequest) ToolMuteReq(toolMuteReq ToolMuteReq) ToolAPIPutToolKitRequest {
r.toolMuteReq = &toolMuteReq
return r
}
func (r ToolAPIPutToolKitRequest) Execute() (*ToolKit, *http.Response, error) {
return r.ApiService.PutToolKitExecute(r)
}
/*
PutToolKit Mutes and unmutes names of the org's kit for the caller's own runs, and answers the caller's kit after.
Mutes and unmutes names of the org's kit for the caller's own runs, and
answers the caller's kit after. The layer only narrows: a name the org's kit
does not carry is refused 400, since muting it would say nothing, and unmuting
never gives the caller more than an admin put in place. It is the caller's own,
so any member may write it. More than 256 names is refused 413.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ToolAPIPutToolKitRequest
*/
func (a *ToolAPIService) PutToolKit(ctx context.Context) ToolAPIPutToolKitRequest {
return ToolAPIPutToolKitRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ToolKit
func (a *ToolAPIService) PutToolKitExecute(r ToolAPIPutToolKitRequest) (*ToolKit, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ToolKit
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ToolAPIService.PutToolKit")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/tool/kit"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.toolMuteReq == nil {
return localVarReturnValue, nil, reportError("toolMuteReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.toolMuteReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}