mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
2396 lines
84 KiB
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
|
|
}
|