Method callTool

pkg/tools/builtin/openapi/openapi.go:455–506

(ctx context.Context, params openAPICallArgs)

type openAPICallArgs map[string]any

func (h *openAPIHandler) callTool(ctx context.Context, params openAPICallArgs) (*tools.ToolCallResult, error) {
	resolvedPath, queryParams, bodyParams := h.classifyParams(params)

	fullURL := h.baseURL + resolvedPath
	if len(queryParams) > 0 {
		fullURL += "?" + queryParams.Encode()
	}

	var reqBody io.Reader = http.NoBody
	if len(bodyParams) > 0 {
		data, err := json.Marshal(bodyParams)
		if err != nil {
			return nil, fmt.Errorf("failed to marshal request body: %w", err)
		}
		reqBody = bytes.NewReader(data)
	}

	req, err := http.NewRequestWithContext(ctx, h.method, fullURL, reqBody)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	if len(bodyParams) > 0 {
		req.Header.Set("Content-Type", "application/json")
	}
	req.Header.Set("Accept", "application/json")

	headers := h.expander.ExpandMap(ctx, h.headers)
	setHeaders(req, headers)

	resp, err := httpclient.NewSafeClient(h.timeout, h.allowPrivateIPs).Do(req)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) // 1MB limit
	if err != nil {
		return nil, fmt.Errorf("failed to read response: %w", err)
	}

	output := limitOutput(string(body))
	if len(body) >= 1<<20 {
		output = "[WARNING: Response truncated at 1MB limit]\n" + output
	}

	if resp.StatusCode >= 400 {
		return tools.ResultError(fmt.Sprintf("HTTP %d: %s", resp.StatusCode, output)), nil
	}

	return tools.ResultSuccess(output), nil
}

// classifyParams splits tool call arguments into path replacements, query parameters,
// and body parameters based on the OpenAPI path template and "body_" prefix convention.